关于设计模式:软件设计的七大原则

软件设计七大准则

开闭准则

• 定义：一个软件实体如类、模块和函数应该对扩大凋谢，对批改敞开。
• 用形象构建框架，用实现扩大细节。
• 长处：进步软件系统的可复用性及可维护性。

代码示例

接口：

public interface ICourse {Integer getId();
    String getName();
    Double getPrice();}

基类：

public class JavaCourse implements ICourse{
    private Integer id;
    private String name;
    private Double price;

    public JavaCourse(Integer id, String name, Double price) {
        this.id = id;
        this.name = name;
        this.price = price;
    }

    @Override
    public Integer getId() {return this.id;}

    @Override
    public String getName() {return this.name;}

    @Override
    public Double getPrice() {return this.price;}

    @Override
    public String toString() {
        return "JavaCourse{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", price=" + price +
                '}';
    }
}

扩大类（子类）：

public class JavaDiscountCourse extends JavaCourse{public JavaDiscountCourse(Integer id, String name, Double price) {super(id, name, price);
    }

    public Double getOriginPrice(){return super.getPrice();
    }

    @Override
    public Double getPrice() {return super.getPrice()*0.8;
    }
    
}

测试：

public class OpenCloseTest {
    @Test
    public void openCloseTest(){ICourse iCourse = new JavaDiscountCourse(99, "Java 从零到企业级开发", 348d);
        JavaDiscountCourse javaDiscountCourse = (JavaDiscountCourse) iCourse;
        System.out.println("课程 ID:"+javaDiscountCourse.getId()+"课程名称:"+javaDiscountCourse.getName()+
                "价格:"+javaDiscountCourse.getPrice() + "初始价格:"+javaDiscountCourse.getOriginPrice());
    }
}

准则剖析

利用场景：打折销售

需要：须要减少网站的网课打折 性能。

实现：间接在“应用层”上扩大（继承）了基类，而不是间接对“底层”的接口或者基类进行批改。

起因：如果接口的办法较多，基类实现的逻辑比较复杂，对其进行间接批改会存在 危险扩散，容易引起 Bug。越低层次的模块（或越根底的模块）的批改，影响的范畴越大；相同越高层次的模块的批改，影响的范畴越小。

举例：如果 Dao 层中的一个模块被多个 Service 层模块应用，对 Dao 层的该模块进行批改会影响到多个 Service 层模块，甚至影响到 Controller 层。

依赖倒置准则

• 定义：高层模块不应该依赖低层模块，二者都应该依赖其形象。
• 形象不应该依赖细节；细节应该依赖形象。
• 针对接口编程，不要针对实现编程。
• 长处：能够缩小类间的耦合性、进步零碎稳定性，进步代码可读性和可维护性，可升高批改程序所造成的危险。

代码示例

实体类：

public class Feyl {
    private ICourse icourse;

    public void setICourse(ICourse icourse) {this.icourse = icourse;}

    public void studyCourse(){icourse.studyCourse();
    }
}

接口：

public interface ICourse {void studyCourse();
}

实现类:

public class ArithmeticCourse implements ICourse{
    @Override
    public void studyCourse() {System.out.println("Feyl is learning Arithmetic course!");
    }
}

public class JavaCourse implements ICourse{
    @Override
    public void studyCourse() {System.out.println("Feyl is learning Java course!");
    }
}

public class FECourse implements ICourse{
    @Override
    public void studyCourse() {System.out.println("Feyl is learning FECourse!");
    }
}

测试类：

public class DependencyInversionTest {    
    @Test
    public void DependencyInversionTest(){Feyl feyl = new Feyl();
        feyl.setICourse(new ArithmeticCourse());
        feyl.studyCourse();
        feyl.setICourse(new JavaCourse());
        feyl.studyCourse();
        feyl.setICourse(new FECourse());
        feyl.studyCourse();}
}

准则剖析

利用场景：减少学习的课程

需要：减少实体类（人）学习的课程 性能。

实现：通过 ICourse 接口将实体类（人）与具体学习的课程相分割。减少具体课程时，让减少的课程间接实现接口，此过程不须要对具体的实体类（人）进行批改。

繁多职责准则

• 定义：不要存在多于一个导致类变更的起因
• 一个类 / 接口 / 办法只负责一项职责
• 长处：升高类的复杂度、进步类的可读性、进步零碎的可维护性、升高变更引起的危险

代码示例

类的繁多职责：

public class ICourse {}

public interface ICourseManager {void studyCourse();
    void refundCourse();}

public interface ICourseContent {String courseName();
    byte[] courseVideo();
}

public class ICourseImpl implements ICourseManager,ICourseContent{
    @Override
    public String courseName() {return null;}

    @Override
    public byte[] courseVideo() {return new byte[0];
    }

    @Override
    public void studyCourse() {}

    @Override
    public void refundCourse() {}
}

办法的繁多职责：

public class Method {public void updateUserInfo(String username, String address){
        username = "Feyl";
        address = "HeNan";
    }

    public void updateUserInfo(String username, String... properties){
        username = "Feyl";
//        properties = ;
    }
    public void updateUsername(String username){username = "Feyl";}

    public void updateAddress(String address){address = "HeNan";}
}

接口隔离准则

• 定义：用多个专门的接口，而不应用繁多的总接口，客户端不应该依赖它不须要的接口
• 一个类对一个类的依赖应该建设在最小的接口上
• 建设繁多接口，不要建设宏大臃肿的接口
• 尽量细化接口，接口中的办法尽量少
• 留神适度准则，肯定要适度
• 长处：合乎咱们常说的高内聚低耦合的设计思维，从而使得类具备很好的可读性、可扩展性和可维护性。

代码示例

反例：

public interface IAnimalAction {void eat();
    void fly();
    void swim();}

public class Bird implements IAnimalAction{
    @Override
    public void eat() {}

    @Override
    public void fly() {}

    @Override
    public void swim() {}
}

范例：

public interface IEatAnimalAction {void eat();
}

public interface IFlyAnimalAction {void fly();
}

public interface ISwimAnimalAction {void swim();
}

public class Dog implements ISwimAnimalAction,IEatAnimalAction{
    @Override
    public void eat() {}

    @Override
    public void swim() {}
}

迪米特准则

• 定义：一个对象应该对其余对象放弃起码的理解。又叫起码晓得准则
• 尽量升高类与类之间的耦合
• 长处：升高类之间的耦合
• 强调只和敌人交换, 不和陌生人谈话
• 敌人：呈现在成员变量、办法的输出、输入参数中的类称为成员敌人类，而呈现在办法体外部的类不属于敌人类。

代码示例

反例：

public class Course {}

public class TeamLeader {public void checkNumberOfCourse(List<Course> courses){System.out.println("在线课程的数量："+courses.size());
    }
}

public class Boss {void commandCheckNumber(TeamLeader teamLeader) {List<Course> list = new ArrayList<Course>();
        for (int i = 0; i < 20; i++) {list.add(new Course());
        }
        teamLeader.checkNumberOfCourse(list);
    }
}

测试类：

public class DemeterTest {
    @Test
    public void demeterTest() {new Boss().commandCheckNumber(new TeamLeader());
    }
}

范例：

public class TeamLeader {public void checkNumberOfCourse(){List<Course> courses = new ArrayList<Course>();
        for (int i = 0; i < 20; i++) {courses.add(new Course());
        }
        System.out.println("在线课程的数量："+courses.size());
    }
}

public class Boss {public void commandCheckNumber(TeamLeader teamLeader) {teamLeader.checkNumberOfCourse();
    }
}

里氏替换准则

定义：如果对每一个类型为 T1 的对象 o1，都有类型为 T2 的对象 o2，使得以 T1 定义的所有程序 P 在所有的对象 o1 都替换成 o2 时，程序 P 的行为没有发生变化，那么类型 T2 是类型 T1 的子类型。

定义扩大：一个软件实体如果实用一个父类的话，那肯定实用于其子类，所有援用父类的中央必须能通明地应用其子类的对象，子类对象可能替换父类对象，而程序逻辑不变。

引申意义：子类能够扩大父类的性能，但不能扭转父类原有的性能。

含意 1：子类能够实现父类的形象办法，但不能笼罩父类的非形象办法。

含意 2：子类中能够减少本人特有的办法。

含意 3：当子类的办法重载父类的办法时，办法的前置条件（即办法的输出 / 入参）要比父类办法的输出参数更宽松。

含意 4：当子类的办法实现父类的办法时（重写 / 重载或实现形象办法），办法的后置条件（即办法的输入 / 返回值）要比父类更严格或相等。

长处 1：束缚继承泛滥，开闭准则的一种体现。

长处 2：增强程序的健壮性，同时变更时也能够做到十分好的兼容性，进步程序的维护性、扩展性。升高需要变更时引入的危险。

对开闭准则代码批改使其符和里氏替换准则：

// ICourse 接口、JavaCourse 类放弃不变

public class JavaDiscountCourse extends JavaCourse{public JavaDiscountCourse(Integer id, String name, Double price) {super(id, name, price);
    }

    public Double getDiscountPrice(){return super.getPrice()*0.8;
    }
}

测试类：

public class OpenCloseTest {
    @Test
    public void openCloseTest(){ICourse iCourse = new JavaDiscountCourse(99, "Java 从零到企业级开发", 348d);
        JavaDiscountCourse javaDiscountCourse = (JavaDiscountCourse) iCourse;
        System.out.println("课程 ID:"+javaDiscountCourse.getId()+"课程名称:"+javaDiscountCourse.getName()+
                "价格:"+javaDiscountCourse.getDiscountPrice() + "初始价格:"+javaDiscountCourse.getPrice());
    }
}

代码示例

反例：

public class Rectangle {
    private long length;

    public long getLength() {return length;}

    public void setLength(long length) {this.length = length;}

    public long getWidth() {return width;}

    public void setWidth(long width) {this.width = width;}

    private long width;
}

public class Square extends Rectangle{
    private long sideLength;

    public long getSideLength() {return sideLength;}

    public void setSideLength(long sideLength) {this.sideLength = sideLength;}

    @Override
    public long getLength() {return getSideLength();
    }

    @Override
    public void setLength(long length) {setSideLength(length);
    }

    @Override
    public long getWidth() {return getSideLength();
    }

    @Override
    public void setWidth(long width) {setSideLength(width);
    }
}

测试类：

public class Test {public static void resize(Rectangle rectangle){while(rectangle.getWidth() <= rectangle.getLength()){rectangle.setWidth(rectangle.getWidth()+1);
            System.out.println("Width:" + rectangle.getWidth()+"\t Length:"+rectangle.getLength());
        }
        System.out.println("resize 办法完结: Width:"+rectangle.getWidth()+"\tLength:"+rectangle.getLength());
    }

    public static void main(String[] args) {/*Rectangle rectangle = new Rectangle();
        rectangle.setWidth(10);
        rectangle.setLength(20);
        resize(rectangle);*/
        Square square = new Square();
        square.setLength(10);
        resize(square);
    }
}

范例：

public interface Quadrangle {long getWidth();
    long getLength();}

public class Rectangle implements Quadrangle{
    private long width;
    private long length;

    @Override
    public long getWidth() {return 0;}

    @Override
    public long getLength() {return 0;}

    public void setWidth(long width) {this.width = width;}

    public void setLength(long length) {this.length = length;}
}

public class Square implements Quadrangle{
    private long sideLength;

    @Override
    public long getWidth() {return sideLength;}

    @Override
    public long getLength() {return sideLength;}

    public long getSideLength() {return sideLength;}

    public void setSideLength(long sideLength) {this.sideLength = sideLength;}
}

Test 测试类中的
//        square.setLength(10);
//        resize(square);
会抛异样。若将 resize(Rectangle rectangle) 改为 resize(Quadrangle quadrangle)，办法中的 set 办法也不能满足要求。由此看来，反例中的继承关系违反了里氏替换准则。

办法重载（入参）：

public class Base {public void method(HashMap map){System.out.println("父类的 HashMap 办法被执行。");
    }
}

public class Child extends Base {
/*    @Override
    public void method(HashMap map) {System.out.println("子类的 HashMap 入参办法被调用了!");
    }*/

    public void method(Map map){System.out.println("子类的 Map 入参办法被调用了!");
    }
}

办法重载（返回值）：

public abstract class Base {public abstract Map method();
}

public class Child extends Base{
    @Override
    public HashMap method() {HashMap<String,String> hashMap = new HashMap<>();
        System.out.println("子类的 HashMap 被调用!");
        hashMap.put("msg","子类的 HashMap 被调用!");
        return hashMap;
    }
}

合成(组合)/ 聚合复用准则

• 定义：尽量应用对象组合 / 聚合，而不是继承关系达到软件复用的目标
• 聚合 has- A 和组合 contains-A
• 长处：能够使零碎更加灵便, 升高类与类之间的耦合度，一个类的变动对其余类造成的影响绝对较少
• 何时应用合成 / 聚合、继承
• 聚合 has-A、组合 contains-A 继承 is-A

代码示例

public abstract class DBConnection {/*public String getConnection(){return "Mysql 数据库连贯";}*/
    public abstract String getDBConnection();}

public class MySQLConnection extends DBConnection{
    @Override
    public String getDBConnection() {return "MySQL 数据库连贯";}
}

public class PostgreSQLConnection extends DBConnection{
    @Override
    public String getDBConnection() {return "PostgreSQL 数据库连贯";}
}

public class ProductDao{
    private DBConnection dbConnection;

    public void setDbConnection(DBConnection dbConnection) {this.dbConnection = dbConnection;}

    public void addProduct(){String conn = dbConnection.getDBConnection();
        System.out.println("应用"+conn+"减少产品");
    }
}

测试代码：

public class CompositionAggregationTest {
    @Test
    public void compositionAggregationTest(){ProductDao productDao = new ProductDao();
//        productDao.setDbConnection(new MySQLConnection());
        productDao.setDbConnection(new PostgreSQLConnection());
        productDao.addProduct();}
}