Java设计模式

设计模式六大原则

• 开闭原则
  扩展开放，对修改关闭
• 里式替换原则
  基类可以出现的地方，子类一定可以出现。
• 依赖倒转原则
  依赖接口编程而不依赖具体
• 接口隔离原则
  使用多个隔离的接口，不单独依赖一个接口：降低依赖、降低耦合
• 迪米特法则
  又叫最少知道原则：一个实体应当减少与其他示例发生相互作用。
• 合成复用原则
  尽量使用合成/聚合的方式，而不是继承。

设计模式分类

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

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

行为型模式(11种)：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

创造性模式

单例设计模式

概念：生成单个对象的示例。
优点：减少内存消耗。

public class Singleton {
    /**
     * volatile保证可见性、防止指令重排，不保证原子性
     */
    private volatile static Singleton singleton;

    private Singleton() {
    }

    public static Singleton getInstance() {
        // 双端锁外层锁保证singleton实例被创建后，才会加锁，提高效率
        if (singleton == null) {
            synchronized (Singleton.class) {
                if (singleton == null) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }

}

抽象工程模式

概念：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
优点：提高了更大的扩展性。

public class Test {

    /**
     * 抽象工厂模式：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
     */
    public static void main(String[] args) {
        IAnimalFactory blackAnimalFactory = new BlackAnimalFactory();
        ICat blackCat = blackAnimalFactory.createCat();
        blackCat.eat();
        IDog blackDog = blackAnimalFactory.createDog();
        blackDog.eat();

        IAnimalFactory whiteAnimalFactory = new WhiteAnimalFactory();
        ICat whiteCat = whiteAnimalFactory.createCat();
        whiteCat.eat();
        IDog whiteDog = whiteAnimalFactory.createDog();
        whiteDog.eat();
    }
}

简单工厂模式

概念：定义一个用于创建对象的接口，让子类决定实例化哪一个类。FactoryMethod使一个类的实例化延迟到其子类。
优点：简单工厂延迟了类的加载。

建造者模式

概念：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

public class Test {

    public static void main(String[] args) {
        PersonDirector personDirector = new PersonDirector();
        Person person = personDirector.constructPerson(new ManBuilder());
        System.out.println(person.getHead());
        System.out.println(person.getBody());
        System.out.println(person.getFoot());
    }
}

原型模式

概念：用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。
优点：克隆比手工实例化可能更方便一些。

public class Test {
    public static void main(String[] args) throws CloneNotSupportedException {

        Person concretePerson = new ConcretePerson("我叫张三");
        Person clone = (ConcretePerson) concretePerson.clone();

        System.out.println(concretePerson.getName());
        System.out.println(clone.getName());
    }
}

结构性模式

适配器模式

public class Test {

    /**
     * 适配器模式
     */
    public static void main(String[] args) {
        Adaptee adaptee = new Adaptee();
        Adapter adapter = new Adapter(adaptee);
        adapter.adapteeMethod();
        adapter.adapterMethod();
    }
}

行为型模式

责任链模式

概念：使多个对象都有处理请求的机会，从而实现发送者与接受者之间解耦。
优点：解耦发送者与接受者。

public class Test {

    /**
     * 责任链模式
     */
    public static void main(String[] args) {
        HandleRequest hr = new HRHandleRequest();
        HandleRequest pm = new PMHandleRequest(hr);
        HandleRequest tl = new TLHandleRequest(pm);

        System.out.println("----");
        Request request = new Request();
        tl.handleRequest(request);
        System.out.println("----");

        request = new AddRequest();
        tl.handleRequest(request);
        System.out.println("----");

        request = new MissRequest();
        pm.handleRequest(request);

    }
}