时间戳

首页 > 技术文章 > 23种设计模式

23种设计模式

pascall 2019-01-04 10:09 原文

一、设计模式六大原则（核心思想：开闭原则【方法抽象化】）

1、单一职责原则

描述：每个类应该实现单一的职责，否则将其拆分。

2、里氏替换原则

描述：开闭原则的补充，子类具体实现基类的抽象方法，子类不应该重写和重载父类具体方法。

3、依赖倒转原则

描述：开闭原则的基础，面向接口编程，依赖于抽象而不依赖于具体。

4、接口隔离原则

描述：每个接口中不存在子类用不到的方法，否则拆分；多个接口方法集合到一个的接口。

5、迪米特法则（最少知道原则）

描述：一个类对自己依赖的类知道的越少越好。

6、合成复用原则

描述：尽量首先使用合成/聚合的方式，而不是使用继承。

 

二、创建型设计模式

创建型模式（5）：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。

1、工厂方法模式

原理：创建一个工厂接口和创建多个工厂实现类，每个具体工厂只能创建一个具体产品类的实例。

2、抽象工厂模式

 原理：创建一个工厂接口和创建多个工厂实现类，每个具体工厂能创建多个具体产品类的实例。

 

3、单例模式

原理：保证在一个JVM中，该对象只有一个实例存在。

 3.1 简单的单例模式（线程不安全）（懒汉式）【不可用】

public class SimpleSingleton {

    private static SimpleSingleton instance = null;

    private SimpleSingleton() {
    }

    public static SimpleSingleton getInstance() {
        if(instance == null) {
            instance = new SimpleSingleton();
        }
        return instance;
    }            
}

3.2 简单的单例模式（线程安全）（饿汉式）【推荐】

public class SimpleSingleton {

    private static SimpleSingleton INSTANCE= new SimpleSingleton();

    private SimpleSingleton() {
    }

    public static SimpleSingleton getInstance() {
        return INSTANCE;
    }            
}

3.3 高效的单例模式（线程安全）（懒汉式）（双重检查）【推荐】

public class HighSingleton {

    private static HighSingleton instance = null;

    private HighSingleton() {
    }

    public static HighSingleton getInstance() {
        if(instance == null) {
            synchronized (HighSingleton.class) {
                if(instance == null) {
                       instance = new HighSingleton(); 
                }
        }
        return instance;
    }            
}

3.4 静态内部类的单例模式（线程安全）（类饿汉式）【推荐】

public class Singleton {

    private Singleton() {}

    private static class SingletonInstance {
        private static final Singleton INSTANCE = new Singleton();
    }

    public static Singleton getInstance() {
        return SingletonInstance.INSTANCE;
    }
}

4、原型模式（浅、深复制）

原理：将一个对象作为原型，对其进行复制、克隆，产生一个和原对象类似的新对象。

public class Prototype implements Cloneable, Serializable {
    
    private static final long serialVersionUID = 1L;
    private String str;
    private SerializableObject obj;

    /* 浅复制 */
    public Object clone() throws CloneNotSupportedException {
        Prototype proto = (Prototype) super.clone();
        return proto;
    }

    /* 深复制 */
    public Object deepClone() throws IOException, ClassNotFoundException {  
        ByteArrayOutputStream bos = new ByteArrayOutputStream();  
        ObjectOutputStream oos = new ObjectOutputStream(bos);  
        oos.writeObject(this);  
  
        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());  
        ObjectInputStream ois = new ObjectInputStream(bis);  
        return ois.readObject();  
    }  
}

 5、建造者模式

原理：使用多个简单的对象一步一步构建成一个复杂的对象。

public class Student {
    String name = null;
    int age = -1;
    String sex = null;

    public Student(StudentBuild builder) {
         this.name = builder.name;
         this.age = builder.age;
         this.sex = builder.sex;
    }
}
public class StudentBuilder {
    
    String name = null;
    int age = -1;
    String sex = null;

    public StudentBuilder setName(String name) {
        this.name = name;
    } 
    public StudentBuilder setAge(int age) {
        this.age = age;
    } 
    public StudentBuilder setSex(String sex) {
        this.sex = sex;
    } 
    
    // 建造出Student对象.
    public Student build() {
        return new Student(this);
    }

}

 

三、结构型设计模式

结构型模式（7）：适配器模式、装饰者模式、代理模式、外观模式、桥接模式、组合模式、享元模式。

描述：适配器模式分为类的适配器模式、对象的适配器模式、接口的适配器模式，其他的结构性设计模式依赖于是配置模式（对象的适配器模式）。

1、适配器模式

public interface ISource {
    public void mehtod();
}
// 待适配类
public class Source {
    public void methodOne(){}
}
// 目标接口
public interface ITarget {
     public void methodOne();
     public void methodTwo();
}

1.1、类的适配器模式

原理：适配器类需继承待适配类，并实现目标接口。

// 类的适配器类
public class SourceTargetAdapter extends Source implements ITarget {
    @Override
    public void methodTwo(){}
}

1.2、对象的适配器模式

原理：适配器类持有待适配类的实例对象，并且实现目标接口。

// 对象的适配器类
public class SourceTargetWrapper implements ITarget {
    private Source source;

    public SourceTargetWrapper (Source source){
         this.source = source;
    }
    @Override
    public void methodOne(){
        source.methodOne();
    };
    @Override
    public void methodTwo(){}
}

1.3、接口的适配器模式

原理：抽象适配器类实现目标接口，其子类实现具体方法。

// 抽象适配器类
public abstract class TargetWrapper implements Target {
    @Override
    public void methodOne(){}
    @Override
    public void methodTwo(){}
}
public class SourceSub extends TargetWrapper {
    @Override
    public void methodOne(){}
}

2、装饰者模式

原理：在原方法的基础上添加新功能。

// 待装饰类
public class Source implements ISource {
    @Override
    public void mehtod(){}
}
// 装饰类
public SourceDecorator implements ISource {
    private ISource source;

    public  SourceDecorator (ISource source) {
        this.source = source;
    }
    @Override
    public void method(){
        // 新增方法
        this.newMethod();
        // 原始方法
        source.method();
    }
    private void newMethod(){}
}

3、代理模式

原理：使用代理类间接调用待代理类方法。

// 待代理类
public class Source implements ISource {
    @Override
    public void mehtod(){}
}
// 代理类
public SourceProxy implements ISource {
    private ISource source;

    public  SourceDecorator (ISource source) {
        this.source = source;
    }
    @Override
    public void method(){
        source.method();
    }
}

4、外观模式

原理：外观类用于管理类与类之间的依赖关系。

public class CPU {
    public void startUp() {}
    public void shutDown() {}
}
public class Memory {
    public void startUp() {}
    public void shutDown() {}
}
// 外观类
public class ComputerFacade {
    private CPU cpu;
    private Memory memoty;

    public ComputerFacade (CPU cpu, Memory memoty) {
        this.cpu = cpu;
        this.memory = memory;
    }
    public void startUp() {
        cpu.startUp();
        memory.startUp();
    }
    public void shutDown() {
        cpu.shutDown();
        memory.shutDown();
    }
}

5、桥接模式

原理：把事物和具体实现分开。

public class SourceSubOne implements ISource {
    @Override
    public void mehtod(){}
}
public class SourceSubTwo implements ISource {
    @Override
    public void mehtod(){}
}
// 桥接抽象类
public abstract class SourceBridge {
    private ISource source;
    public ISource getSource(){
        return source;
    }
    public void setSource(ISource source){
        this.source = source;
    }
   
    public void mehtod(){
        source.mehtod();
    }
}
// 桥接类
public abstract class SourceBridgeSub extends SourceBridge {
    public void mehtod(){
        source.mehtod();
    }
}

6、组合模式

原理：。

7、享元模式

原理：。

四、关系型设计模式

关系型模式（11）：策略模式、模板方法模式；观察者模式、迭代子模式、责任链模式、命令模式；备忘录模式、状态模式；访问者模式、中介者模式、解释器模式。

描述：关系型模式分为父类与子类关系、两个类关系、类的状态关系、通过中间类关系。

public interface ICalcutor {
    public int calcute(String exp);  
}

1、策略模式（父类与子类关系）

原理：定义了一系列算法，并将每个算法封装起来，使他们可以相互替换，且算法的变化不会影响到使用算法的客户；即定义一个抽象类或者类，其中定义多个方法，由子类来调用父类方法。

public abstract class ICalculator {
    public  int[] split(String exp,String opt){  
        String array[] = exp.split(opt);  
        int arrayInt[] = new int[2];  
        arrayInt[0] = Integer.parseInt(array[0]);  
        arrayInt[1] = Integer.parseInt(array[1]);  
        return arrayInt;  
    }
}
// 加运算
public class PlusCalculator implements ICalcutor{
    @Override
    public  int calcute(String exp){  
        String array[] = split(opt, "\\+");   
        return array[0] + array[1];
    }
}

2、模板方法模式（父类与子类关系）

原理：一个抽象类中，有一个主方法，再定义多个方法（可抽象），定义一个该抽象类子类，重写抽象方法，通过调用抽象类方法，实现对子类的调用。

public abstract class AbstractCalculator {  
    /*主方法，实现对本类其它方法的调用，不可修改*/  
    public final int calculate(String exp,String opt){  
        int array[] = split(exp,opt);  
        return calculate(array[0],array[1]);  
    }
    /*被子类重写的方法*/  
    abstract public int calculate(int num1,int num2);  
      
    public int[] split(String exp,String opt){  
        String array[] = exp.split(opt);  
        int arrayInt[] = new int[2];  
        arrayInt[0] = Integer.parseInt(array[0]);  
        arrayInt[1] = Integer.parseInt(array[1]);  
        return arrayInt;  
    }  
}  
// 加运算
public class PlusCalculator implements ICalcutor{
    @Override
    public  int calculate(int num1, int num2){   
        return num1 + num2;
    }
}

 

 未完。。。。

 

 

 文章摘自-23种设计模式全解析（codeTao）

推荐阅读