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

软件设计七大准则

开闭准则

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

代码示例

接口：

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();    }}