Java核心之设计原则和设计模式

使用基于tcp协议的编程模型实现将Message类型对象由客户端发送给服务器:

服务器接收到对象后判断用户对象信息是否为"admin"和"123456"，若是则将Message对象中的类型改为"sucess"，否则将类型改为"failed"并回发给客户端.

客户端接收到服务器发来的对象后判断并给出提示。

其中Message类的特征有：类型(字符串类型) 和用户对象(User类型)。

其中User类的特征有：用户名、密码(字符串类型)。

import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.ServerSocket;
import java.net.Socket;
public class ServerObjectTest {
  public static void main(String[] args) {
    try {
      // 1.创建ServerSocket类型的对象并提供端口号
      ServerSocket ss = new ServerSocket(8888);
      // 2.等待客户端的连接请求，调用accept方法
      System.out.println("等待客户端的连接请求...");
      Socket s = ss.accept();
      System.out.println("客户端连接成功！");

      // 3.使用输入输出流进行通信
      // 接收客户端发来的Message类型的对象，使用ObjectInputStream类
      ObjectInputStream ois = new ObjectInputStream(
        s.getInputStream());
      Message m = (Message) ois.readObject();
      //System.out.println("客户端发来的内容是：" + m);
      // 判断接收到用户信息的用户名和密码是否正确，并修改类型
      if("admin".equals(m.getMu().getUserName()) &&
          "123456".equals(m.getMu().getPassWord())) {
        m.setType("sucess");
      } else {
        m.setType("fail");
      }
      // 向客户端回发校验的结果
      ObjectOutputStream oos = new ObjectOutputStream(
        s.getOutputStream());
      oos.writeObject(m);
      //System.out.println("服务器发送校验结果成功！");

      // 4.关闭Socket
      oos.close();
      ois.close();
      s.close();
      ss.close();
    } catch(Exception e) {
      e.printStackTrace();
    }
  }
}

import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.Socket;
public class ClientObjectTest {
  public static void main(String[] args) {
    try {
      // 1.构造Socket类型的对象并提供服务器的IP地址和端口号
      Socket s = new Socket("192.168.30.200", 8888);
      System.out.println("连接服务器成功！");

      // 2.使用输入输出流通信
      // 实现将Message类型的对象使用对象流发送给服务器
      Message tm = new Message("check", new User("admin", "123456"));
      ObjectOutputStream oos = new ObjectOutputStream(
        s.getOutputStream());
      oos.writeObject(tm);
      //System.out.println("客户端发送数据成功！");
      // 接收服务器发来的校验结果并给出对应的提示
      ObjectInputStream ois = new ObjectInputStream(
        s.getInputStream());
      Message m = (Message) ois.readObject();
      //System.out.println("服务器发来的内容是：" + m);
      // 判断接收到的校验结果给出提示
      if("sucess".equals(m.getType())) {
        System.out.println("登录成功，欢迎使用！");
      } else {
        System.out.println("用户名或密码错误！");
      }

      // 3.关闭Socket
      ois.close();
      oos.close();
      s.close();
    } catch(Exception e) {
      e.printStackTrace();
    }
  }
}

软件开发的流程

需求分析文档 => 概要设计文档 => 详细设计文档 => 编码和测试 => 安装和调试=> 维护和升级

常用的设计原则

开闭原则

对扩展开放，对修改关闭。

public class Person {
  private String name;
  ... ...
}
public class SubPerson extends Person {
  private int age;
}

里氏代换原则

任何父类可以出现的地方，子类一定可以出现。

子类is a父类，建议多使用多态。

public static void printShape(Shape s) {
  s.show();
}
printShape(new Rect(1, 2, 3, 4));
printShape(new Circle(5, 6, 7));

依赖倒转原则

尽量多依赖于抽象类和接口而不是具体实现类。抽象类对子类具有强制性和规范性。

public abstract class Account {
  public abstract double getLixi();
}
public class FixedAccount extends Account {
  @Override
  public double getLixi() {  }
}

接口隔离原则

尽量多依赖于小接口而不是大接口,避免接口的污染。

public interface RunAnimal {
  public abstract void run();
}
public interface FlyAnimal {
  public abstract void fly();
}
public class Dog implements RunAnimal {
  @Override
  public void run() {}
}

迪米特法则(最少知道原则)

一个实体(模块)应当少于其它实体之间发生关联。

高内聚，低耦合

所谓高内聚就是指一个实体应该有的功能应当尽量高度聚集于该实体的内部。

所谓低耦合就是指一个实体应当减少与其它实体之间的关联度。

合成复用原则

尽量多使用合成的方式，而不是继承的方式。

public class A {
  public void show() {  ... }
}
public class B extends A{   - 不推荐
  public void test() {
    // 调用类A的show方法
    show();
  }
}
public class B {   - 推荐
  private A a;
  public B(A a) {
    this.a = a;
  }
  public void test() {
    // 调用类A的show方法
    a.show();
  }
}

设计模式

基本概念

设计模式就是多年代码经验的总结，主要用于固定的场合中。
常用的设计模式

单例设计模式、模板设计模式、工厂方法模式、抽象工厂模式

普通工厂方法模式

public interface Sender {
  // 自定义抽象方法
  public abstract void send();
}

public class MailSender implements Sender {
  @Override
  public void send() {
    System.out.println("正在发送邮件...");
  }
}

public class SmsSender implements Sender {
  @Override
  public void send() {
    System.out.println("正在发送短信...");
  }
}

public class SendFactory {
  // 自定义描述生产的行为
  public Sender produce(String type) {
    //System.out.println("你不就是向折腾一下我们程序员吗？但我不惧哦！");
    if("mail".equals(type)) {
      return new MailSender();
    }
    if("sms".equals(type)) {
      return new SmsSender();
    }
    return null;
  }
}

public class SendFactoryTest{
  public static void main(String[] args){
    SendFactory factory = new SendFactory();
    /* 调用SmsSender的Send()方法
    Sender sender = factory.produce("sms");
    sender.Send();
    */
    // 调用Mailender的Send()方法
    Sender sender = factory.produce("mail");
    sender.Send();
  }
}