七大设计模式原则

1、开闭原则(Open-closed Principle)

开闭原则,是面向设计中最基础的设计原则。
一个软件实体类、模块、函数应该对扩展开放、对修改关闭
强调的是用抽象构建框架,用实现扩展细节。可以提高软件系统的可复用性和可维护性。

实例:

public interface ICourse {

    Integer getId();

    String getName();

    Double getPrice();

}
public class JavaCourse implements ICourse{

    private Integer id;

    private String name;

    private Double price;

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

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

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

    public JavaCourse(Integer id, String name, Double price) {
        this.id = id;
        this.name = name;
        this.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();
    }

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

}

2、本末倒置原则(Dependence Inversion Principle)

高层模块不应该依赖底层模块,二者都应该依赖其抽象。
抽象不应该依赖细节,细节应该依赖抽象。
本末倒置可以减少类与类之间的耦合性,提高系统的稳定性,提高代码的可读性和可维护性,降低修改程序造成的风险。

实例:

public interface ICourse {

    void study();

}
public class JavaCourse implements ICourse{

    @Override
    public void study() {
        System.out.println("学习Java");
    }

}
public class PythonCourse implements ICourse{

    @Override
    public void study() {
        System.out.println("学习Python");
    }

}
/**
 * 方式一:依赖注入,每次学习一个新课程就多创建一个类
 */
public class PersonOne {

    public void study(ICourse iCourse){
        iCourse.study();
    }

    public static void main(String[] args) {
        PersonOne personOne = new PersonOne();
        personOne.study(new JavaCourse());
        personOne.study(new PythonCourse());
    }
}
/**
 * 方式二:构造器注入,调用时每次都要创建实例
 */
public class PersonTwo {

    private ICourse iCourse;

    public PersonTwo(ICourse iCourse) {
        this.iCourse = iCourse;
    }

    public void study() {
        iCourse.study();
    }

    public static void main(String[] args) {
        PersonTwo personTwo = new PersonTwo(new JavaCourse());
        personTwo.study();
    }
}
/**
 * 方式三:Setter方式注入
 */
public class PersonThree {

    private ICourse iCourse;

    public void setCourse(ICourse iCourse) {
        this.iCourse = iCourse;
    }

    public void study() {
        iCourse.study();
    }

    public static void main(String[] args) {
        PersonThree personTwo = new PersonThree();
        personTwo.setCourse(new JavaCourse());
        personTwo.study();
    }
}

3、单一职责(Simple Responsibility Principle)

不要存在多于一个导致类变更的原因
一个对象应该只包含单一的职责,并且该职责被完整地封装在一个类中。

/**
 * course存在两种处理逻辑,这个地方修改代码
 */
public class Course {
    public void study(String name){
        if("直播".equals(name)){
            System.out.println("不能快进");
        }else {
            System.out.println("2xx倍速");
        }
    }

    public static void main(String[] args) {
        Course course = new Course();
        course.study("直播");
    }

}

修改下的代码,这样把两个课程给分开控制。

public class LiveCourse {
    public void study(String name){
        System.out.println("不能快进");
    }
}
public class ReplayCourse {
    public void study(String name){
        System.out.println("2xx倍速");
    }
}
public class Test {

    public static void main(String[] args) {
        LiveCourse liveCourse = new LiveCourse();
        liveCourse.study("直播");

        ReplayCourse replayCourse = new ReplayCourse();
        replayCourse.study("测试");
    }

}`在这里插入代码片`

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

用多个专门的接口,而不使用单一的接口,客户端不应该依赖它不需要的接口

  • 一个类对一类的依赖应该建立在最小的接口上
  • 建立单一接口,不要建立庞大的接口
  • 尽量细化接口,接口中的方法尽量少

实例:

public interface Animal {
    void eat();
    
    void fly();
    
    void swimming();
}
public class Bird implements Animal{
    @Override
    public void eat() {

    }

    @Override
    public void fly() {

    }

    @Override
    public void swimming() {

    }
}
public class Dag implements Animal{
    @Override
    public void eat() {

    }

    @Override
    public void fly() {

    }

    @Override
    public void swimming() {

    }
}

当dog不能飞,鸟儿不能游泳的时候,这个方法就会空,这时候需要根据动物行为设计不同的接口

public interface EatAnimal {

    void eat();

}
public interface FlyAnimal {

    void fly();

}
public interface SwimmingAnimal {

    void swimming();

}
public class Dog implements SwimmingAnimal, EatAnimal{
    @Override
    public void eat() {

    }

    @Override
    public void swimming() {

    }
}

5、迪米特法则(Law of demeter LoD)

一个对象应该对其他对象保持最少的了解。只和朋友交流,不喝陌生人说话。
出现在成员变量、方法的输入、输出参数中的类都可以称为成员朋友类,出现在方法体内内部的类不属于朋友类。

实例:

public class Course {
}
public class Employee {
    public void checkNumOfCourse(List<Course> courseList) {
        System.out.println("课程数量" + courseList.size());
    }
}
public class Leader {

    public void CommandCheckNumber(Employee employee){
        List<Course> courseList = new ArrayList<Course>();
        for (int i = 0; i < 20; i++) {
            courseList.add(new Course());
        }
        employee.checkNumOfCourse(courseList);
    }

    public static void main(String[] args) {
        Leader leader = new Leader();
        Employee employee = new Employee();
        leader.CommandCheckNumber(employee);
    }
}

根据迪米特法则,Leader只想要结果,不需要和Course有直接的接触,所以这个地方修改

public class EmployeeCp {
    public void checkNumOfCourse() {
        List<Course> courseList = new ArrayList<Course>();
        for (int i = 0; i < 20; i++) {
            courseList.add(new Course());
        }
        System.out.println("课程数量" + courseList.size());
    }
}
public class LeaderCp {

    public void CommandCheckNumber(EmployeeCp employee){
        employee.checkNumOfCourse();
    }

    public static void main(String[] args) {
        LeaderCp leader = new LeaderCp();
        EmployeeCp employee = new EmployeeCp();
        leader.CommandCheckNumber(employee);
    }
}

6、里氏替换原则(Liskov Substitution Priciple)

如果针对一个类型为T1的对象O1,都有类型T2的对象O2,使得以T1定义的所有程序P在所有的对象O1都替换成O2时,程序P的行为没有发生变化,那么类型T2还是类型T1的子类型。
1)子类可以实现父类的抽象方法,但不能覆盖父类的非抽象方法
2)子类仲可以增加自己特有的方法
3)当子类的方法重载父类的方法时,方法的前置条件(入参)要比父类方法的输入参数更宽松
4)当子类的方法实现
父类的方法时,方法的后置条件(输出/返回值)要比父类更严格或相等

优点:
1)约束继承泛滥,开闭原则的一种体现
2)加签程序的健壮性,同时变更也可以做到好的兼容,提高程序的维护性、扩展性,降低需求变更时的风险

实例:

public class Rectangle {

    private Long height;
    private Long width;

    public Long getHeight() {
        return height;
    }

    public Long getWidth() {
        return width;
    }

    public void setHeight(Long height) {
        this.height = height;
    }

    public void setWidth(Long width) {
        this.width = width;
    }
}
public class Square extends Rectangle {

    private Long length;

    public Long getLength() {
        return length;
    }

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

    @Override
    public Long getHeight() {
        return getLength();
    }

    @Override
    public void setHeight(Long height) {
        setLength(height);
    }

    @Override
    public Long getWidth() {
        return getLength();
    }

    @Override
    public void setWidth(Long width) {
        setLength(width);
    }

}
public class Test {
    public static void resize(Rectangle rectangle){
        while (rectangle.getWidth() >= rectangle.getHeight()){
            rectangle.setHeight(rectangle.getHeight()+1);
            System.out.printf("width: %s, height:%s", rectangle.getWidth(), rectangle.getHeight());
        }
        System.out.printf("width: %s, height:%s", rectangle.getWidth(), rectangle.getHeight());
    }

    public static void main(String[] args) {
        Rectangle rectangle = new Rectangle();
        rectangle.setWidth(20L);
        rectangle.setHeight(10L);
        resize(rectangle);

		//死循环
        Square square = new Square();
        square.setLength(10L);
        resize(square);
    }
}

当是正方形的时候,陷入死循环,违背里氏替换原则,父类替换成子类后结果不是预期。
修改代码,创建一个抽象四边形

public interface QuadRectangle {
    Long getWidth();

    Long getHeight();
}
public class RectangleCp implements QuadRectangle{

    private Long height;
    private Long width;

    public Long getHeight() {
        return height;
    }

    public Long getWidth() {
        return width;
    }

    public void setHeight(Long height) {
        this.height = height;
    }

    public void setWidth(Long width) {
        this.width = width;
    }
}
public class SquareCp implements QuadRectangle {

    private Long length;

    public Long getLength() {
        return length;
    }

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

    @Override
    public Long getHeight() {
        return getLength();
    }

    @Override
    public Long getWidth() {
        return getLength();
    }

}

7、合成复用原则(Composite Reuse Principle)

尽量使用对象组合(has-a)/聚合(contain-a),而不是继承达到软件复用的目的。
继承叫做“白箱复用”,把所有的实现细节暴露给子类
组合/聚合称为“黑箱复用”,对类以外的对象是无法获取到实现细节的

实例:

public class DBConnection {
    public String getConnection() {
        return "MySql连接";
    }
}
public class ProductDao {

    private DBConnection dbConnection;

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

    public void addProduct(){
        String conn = dbConnection.getConnection();
        System.out.println("创建商品");
    }

}

如果这时候不只是mysql还有其他类型的数据库,违反开闭原则
修改代码:

public abstract class DBConnectionCp {
    public abstract String getConnection();
}
public class MysqlConnection extends DBConnection{
    @Override
    public String getConnection() {
        return "mysql";
    }
}
public class OracleConnection extends DBConnection{
    @Override
    public String getConnection() {
        return "Oracle";
    }
}

你可能感兴趣的:(设计模式,java)