JavaSE：常用的设计原则

1.　　软件开发的流程

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

2.　　常用的设计原则

　　　　<1>　　开闭原则 (Open Close Principle)

　　　　　　　　　　对扩展开放，对修改关闭，为了使程序的扩展性好，易于维护和升级

　　　　　　　　　　代码示例：　　　　　

public abstract class Person {
    private String name;
    //private int age;    客户新增需求： 添加年龄 （将代码直接添加在Person.java中的缺点： "牵一发而动全身"）
    // 建议： <1> 尽量不要修改 （对修改关闭）
　　 //       <2> 对拓展开放 （见SubPerson.java）

    public Person() {
    }

    public Person(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public abstract void show();
}

运用开闭原则 (Open Close Principle)：  

public class SubPerson extends Person {
    private int age;

    @Override
    public void show() {

    }
}

　　　　<2>　　里氏代换原则 （Liskov Substitution Principle）

　　　　　　　　　　任何基类（父类）可以出现的地方，子类一定可以出现，多使用多态（父类的引用指向子类的对象）的方式

　　　　<3>　　依赖倒转原则 (Dependence Inversion Principle)

　　　　　　　　　　尽量多依赖于抽象类或接口，而不是具体实现类。

　　　　　　　　　　原因：抽象类 / 接口 对子类具有强制性和规范性

　　　　　　　　　　例子：

public abstract class Person {
    private String name;

    public Person() {
    }

    public Person(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public abstract void show();
}

public class SubPerson extends Person {
    private int age;

　　 // 必须重写抽象方法，或者将类声明为抽象类 
    // 体现了强制性和规范性

    @Override
    public void show() {

    }
}

　　　　<4>　　接口隔离原则 (Interface Segregation Principle)

　　　　　　　　　　尽量多使用小接口，而不是大接口，避免接口的污染，降低类之间耦合（关联）度

 　　　　　　　　　  例子：

public interface Animal {

    void run(); // 用于描述奔跑行为的抽象方法
    void fly(); // 用于描述飞行行为的抽象方法
}

public class Dog implements {
    @Override
    public void run() {

    }

　　 // 不足： Dog.java 需要重写Animal接口中的所有抽象方法，包括 fly() 方法
　　  
　　　　

    @Override
    public void run() {

    }

　　// 改进： 需要使用小接口 （RunAnimal）    

}

====================================================================================================================

// 小接口一
public interface RunAnimal {

    void run(); // 用于描述奔跑行为的抽象方法
}

// 小接口二
public interface FlyAnimal {

    void fly(); // 用于描述飞行行为的抽象方法
}

// 使用小接口
public class Dog implements RunAnimal {
    @Override
    public void run() {

    }
}

　　　　<5>　　迪米特法则（最少知道原则） （Demeter Principle）

　　　　　　　　　　一个实体，应当尽量少与其他实体之间发生相互作用，使系统功能模块相对独立

　　　　　　　　　　高内聚（聚集于该实体的内部），低耦合（关联度）

　　　　　　　　　　比如： 一个Java讲师，应该高度聚集Java的技术，而降低与行政工作的关联度

                                                （高耦合：一个既修水龙头，又讲Java的讲师）

　　　　<6>　　合成复用原则 （Composite Reuse Principle)

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

　　　　　　　　　　代码：

 public class A {
 
     public void show() {
         System.out.println("这是A类中的show方法！");
     }
 }

public class B/* <2> 方法一，继承：extends A*/ {
　　 // <2> 使用继承的缺点： Java中只支持单继承

    // <3> 方法二： 合成复用原则

    // 1. 声明一个其他类类型的引用，作为这个类的成员变量

    private A a;  

    // 2. 通过构造方法，初始化这个成员变量

    public B(A a) {
        this.a = a;
    }

    public void test() {
        // <1> 调用A类中的show方法，请问如何实现？
        a.show();
    }
}