设计模式学习纪要（一）

设计模式学习纪要（一）

一、6大设计原则

(1) 单一职责原则

思想：单一职责原则是指一个类或者一个方法只应该负责一项单一的职责。其核心是控制类的颗粒度大小，将对象解耦，提高类聚性，减少耦合性。

(2) 里氏替换原则

思想：子类可以扩展父类的功能，但不能改变原有父类的功能。这有助于增强程序的健壮性。里氏替换原则是实现开闭原则的一种重要的方式；

(3) 依赖倒置原则

思想：面向接口编程，高层模块不应依赖低层模块，两者都应依赖其抽象。抽象不应依赖细节，细节应依赖抽象。同时依赖倒置也是实现开闭原则的重要途经之一。

(4) 接口隔离原则

思想：建立单一接口，客户端不应依赖它不需要的接口。类之间依赖关系应建立在最小的接口上，即提供的接口只包含客户感兴趣的方法；

(5) 迪米特法则

思想：一个对象应尽量少地与其他对象交互。这有助于降低类与类之间的耦合，提高模块之间的相对独立性。同时由于亲和度降低，提高了类的可复用率和系统扩展性；

(6) 开闭原则

思想：软件实体应可扩展，不可修改，可以通过对代码根据作用进行抽离，通过接口或者抽象类实现规则约束，通过实现类进行实现，来控制变化，提高扩展性；

二、设计模式

（一）单例模式（创建者模式）

1. 单例模式定义

​ 某一个类在整个系统有且仅有一个实例对象提供服务；

/** 实例化对象 */
private static final SingletonService singletonService = new SingletonService();

/** 限制产生多个对象 */
private SingletonService(){}

/** 获取实例对象 */
public static SingletonService getSingletonService(){ return singletonService;}

2. 单例模式优缺点

优点：

1. 由于单例模式在内存中有且仅有一个实例对象，减少内存开销；
2. 但你模式可以避免对资源的多重占用；
3. 单例模式可以在系统设置全局的访问点，优化和共享资源访问；

缺点：

1. 单例模式中没有抽象层，因此单例模式的扩展困难；
2. 单例模式职责过重，在一定程度上违背了"单一职责原则"；

3. 单例模式适用场景

• 全局唯一序列号生成；
• 需要定义大量的静态常量和静态方法等；

4. 实现单例模式方式

• 饿汉式
• * 懒汉式（线程不安全）
  
• 懒汉式（线程安全）
  
• 双重检查模式（DCL）
  
• 静态内部类模式
  

三、工厂模式（创建者模式）

工厂模式定义

​ 通常存在一个用于创建对象的接口或抽象类，这个接口或抽象类定义了创建对象的通用方法。不同的实现类（具体产品类）负责实现这些方法，并返回具体的对象实例。这种模式使得对象的创建过程与使用过程分离，提高了系统的灵活性和可扩展性。

工厂模式优缺点

优点

• 具有良好的封装性和扩展性，将实现与调用解耦，降低了模块间的耦合性；
• 提高了代码的灵活性，支持多态和简化代码；

缺点

• 违背了开闭原则，增加了系统复杂程度，隐藏具体实现。

（一）简单工厂模式

1. 简单工厂类图

2. 代码案例

产品接口与实现类

// 产品类接口
public interface CarService {
    CarService getCreateCar();
    void getCarName();
}
// 产品类实现
public class BiYaDiCar implements CarService{
    @Override
    public CarService getCreateCar() {return new BiYaDiCar();}
    @Override
    public void getCarName(){System.out.println("This is 比亚迪 car");}
}
public class RedCar implements CarService{
    @Override
    public CarService getCreateCar() {return new RedCar();}
    @Override
    public void getCarName(){System.out.println("This is 红米 car");}
}
public class XiaoMiCar implements CarService{
    @Override
    public CarService getCreateCar() {return new XiaoMiCar();}
    @Override
    public void getCarName(){System.out.println("This is 小米 car");}
}

工厂实现与消费者

// 实例化工厂
public class CarFactory {
    public static CarService getInstance(Integer type){
        switch (type){
            case 1 : return new BiYaDiCar().getCreateCar();
            case 2 : return new RedCar().getCreateCar();
            case 3 : return new XiaoMiCar().getCreateCar();
        }
        return null;
    }
}
// 消费者
public class Main {
    public static void main(String[] args) {
        CarService instance = CarFactory.getInstance(1);
        instance.getCarName();
    }
}

（二）工厂模式

1. 工厂模式类图

说明：工厂模式在简单工厂模式上对于创建实例的工厂进行了抽取，抽取一个工厂接口，用于对工厂的封装，由工厂实例对工厂接口进行实现，并对指定的产品类进行实例化，降低工厂与产品类的耦合。

2. 代码案例

产品接口与实现类

// 产品类接口
public interface CarService {
    CarService getCreateCar();
    void getCarName();
}
// 产品类实现
public class BiYaDiCar implements CarService{
    @Override
    public CarService getCreateCar() {return new BiYaDiCar();}
    @Override
    public void getCarName(){System.out.println("This is 比亚迪 car");}
}
public class RedCar implements CarService{
    @Override
    public CarService getCreateCar() {return new RedCar();}
    @Override
    public void getCarName(){System.out.println("This is 红米 car");}
}
public class XiaoMiCar implements CarService{
    @Override
    public CarService getCreateCar() {return new XiaoMiCar();}
    @Override
    public void getCarName(){System.out.println("This is 小米 car");}
}

工厂接口、工厂实例与消费者

// 工厂接口
public interface BMWFactory {
    CarBMW createCarBMW();
}
// 工厂实例类
public class BMW320Factory implements BMWFactory{
    @Override
    public CarBMW createCarBMW() {return new BiYaDiCar();}
}
public class BMW502Factory implements BMWFactory{
    @Override
    public CarBMW createCarBMW() {return new XiaoMiCar();}
}
// 消费者
public class Main {
    public static void main(String[] args) {
        CarBMW carBMW = new BMW320Factory().createCarBMW();
        System.out.println(carBMW.getBMWType());
    }
}

（三）抽象工厂模式

1. 抽象工厂类图

说明：抽象工厂在工厂模式上进行了改进，通过沟通不同产品的抽象对象，对于同一相识或同一类型的产品，进行相同的工厂管理（实例化产品类），既可以实现横行的同一类型产品统一管理，同时也实现了同一产品不同类型统一管理。

2. 代码案例

产品接口与实现类

// 产品类接口
public interface CarService1 {
    CarService getCreateCar();
    void getCarName();
}
// 产品类实现
public class BiYaDiCarA implements CarService{
    @Override
    public CarService getCreateCar() {return new BiYaDiCar();}
    @Override
    public void getCarName(){System.out.println("This is 比亚迪 car");}
}
public class XiaoMiCarB implements CarService{
    @Override
    public CarService getCreateCar() {return new XiaoMiCar();}
    @Override
    public void getCarName(){System.out.println("This is 小米 car");}
}
// 产品类接口
public interface CarService2 {
    CarService getCreateCar();
    void getCarName();
}
// 产品类实现
public class BiYaDiCarA implements CarService{
    @Override
    public CarService getCreateCar() {return new BiYaDiCar();}
    @Override
    public void getCarName(){System.out.println("This is 比亚迪 car");}
}
public class XiaoMiCarB implements CarService{
    @Override
    public CarService getCreateCar() {return new XiaoMiCar();}
    @Override
    public void getCarName(){System.out.println("This is 小米 car");}
}

工厂接口、工厂实例与消费者

// 工厂接口
public interface BMWFactory {
    CarBMW createCarBMW();
}
// 工厂实例类
public class BMW320Factory implements BMWFactory{
    @Override
    public CarService1 createCarBMW1() {return new BiYaDiCarA();}
    @Override
    public CarService2 createCarBMW2() {return new BiYaDiCarA();}
}
public class BMW502Factory implements BMWFactory{
    @Override
    public CarService1 createCarBMW1() {return new XiaoMiCarB();}
    @Override
    public CarService2 createCarBMW2() {return new XiaoMiCarB();}
}
// 消费者
public class Main {
    public static void main(String[] args) {
        CarBMW carBMW = new BMW320Factory().createCarBMW();
        System.out.println(carBMW.getBMWType());
    }
}