java - 23种设计模式

一、设计模式分类：

      创建型模式：单例模式、工厂模式（简单工厂模式、工厂方法模式、抽象工厂模式）、建造者模式、原型模式。
      结构型模式：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。
      行为型模式：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。
      其它：并发型模式、线程池模式。 

二、单例模式

1、懒汉式

    a）基本案例

class Singleton {
  private Singleton() {
  }
  private static Singleton singleton = null;
  public static Singleton newInstance() {
    if (singleton == null) {
      singleton = new Singleton();
    }
    return singleton;
  }
}

    b）线程安全模式

        同步方法

class Singleton {
  private Singleton() {
  }
  private static Singleton singleton = null;
  public synchronized static Singleton newInstance() {
    if (singleton == null) {
      singleton = new Singleton();
    }
    return singleton;
  }
}

        双重检查锁定

class Singleton {
  private Singleton() {
  }
  private static Singleton singleton = null;
  public static Singleton getInstance() {
    if (singleton == null) {
      synchronized (Singleton.class) {
        if (singleton == null) {
          singleton = new Singleton();
        }
      }
    }
    return singleton;
  }
}

        静态内部类（推荐）

class Singleton {
  private Singleton() {
  }
  private static class SingletonBuilder {
    private static final Singleton singleton = new Singleton();
  }
  public static final Singleton newInstance() {
    return SingletonBuilder.singleton;
  }
}

2、饿汉式

class Singleton {
  private Singleton() {
  }
  private static final Singleton singleton = new Singleton();
  public static final Singleton newInstance() {
    return singleton;
  }
}

三、工厂模式

1、简单工厂模式

public class Client {
  public static void main(String[] args) {
    CarFactory factory = new CarFactory();
    Car bus = factory.getCar("bus");
    bus.run();
    Car taxi = factory.getCar("taxi");
    taxi.run();
  }
}

interface Car {
  void run();
}

class Bus implements Car {
  @Override
  public void run() {
    System.out.println("Bus Run !");
  }
}

class Taxi implements Car {
  @Override
  public void run() {
    System.out.println("Taxi Run !");
  }
}

class CarFactory {
  public Car getCar(String carType) {
    Car car = null;
    switch (carType) {
    case "bus":
      car = new Bus();
      break;
    case "taxi":
      car = new Taxi();
      break;
    default:
      break;
    }
    return car;
  }
}

2、工厂方法模式

public class Client {
  public static void main(String[] args) {
    CarFactory busFactory = new BusFactory();
    Car bus = busFactory.buildCar();
    bus.run();
    CarFactory carFactory = new TaxiFactory();
    Car taxi = carFactory.buildCar();
    taxi.run();
  }
}

interface Car {
  void run();
}

class Bus implements Car {
  @Override
  public void run() {
    System.out.println("Bus Run !");
  }
}

class Taxi implements Car {
  @Override
  public void run() {
    System.out.println("Taxi Run !");
  }
}

interface CarFactory {
  Car buildCar();
}

class BusFactory implements CarFactory{
  @Override
  public Car buildCar() {
    return new Bus();
  }
}

class TaxiFactory implements CarFactory{
  @Override
  public Car buildCar() {
    return new Taxi();
  }
}

3、抽象工厂模式

public class Client {
  public static void main(String[] args) throws Exception {
    AbstractFactory abstractFactory = FactoryProducer.getFactory("BMWFactory");
    Car bmwCar = abstractFactory.getCar("BMW320");
    bmwCar.run();
    Car bmwCar1 = abstractFactory.getCar("BMW530");
    bmwCar1.run();
    AbstractFactory abstractFactory1 = FactoryProducer.getFactory("BenzFactory");
    Car benzCar = abstractFactory1.getCar("BenzC200");
    benzCar.run();
    Car benzCar1 = abstractFactory1.getCar("BenzE300");
    benzCar1.run();
  }
}

interface BeanMapping {
  Map<String, Class<?>> beanCache = new HashMap<>();
}

abstract class Car {
  abstract void run();
}

abstract class BMWCar extends Car {
}

class BMW320 extends BMWCar {
  public void run() {
    System.out.println("BMW320 Run...");
  }
}

class BMW530 extends BMWCar {
  public void run() {
    System.out.println("BMW530 Run...");
  }
}

abstract class BenzCar extends Car {
}

class BenzC200 extends BenzCar {
  public void run() {
    System.out.println("BenzC200 Run...");
  }
}

class BenzE300 extends BenzCar {
  public void run() {
    System.out.println("BenzE300 Run...");
  }
}

abstract class AbstractFactory implements BeanMapping {
  public abstract Car getCar(String type) throws Exception;
}

class BenzFactory extends AbstractFactory {
  public Car getCar(String type) throws Exception {
    Class<?> cl = beanCache.get(type);
    return (BenzCar) cl.newInstance();
  }

  public BenzFactory() {
    beanCache.put(BenzCar.class.getSimpleName(), BenzCar.class);
    beanCache.put(BenzC200.class.getSimpleName(), BenzC200.class);
    beanCache.put(BenzE300.class.getSimpleName(), BenzE300.class);
  }
}

class BMWFactory extends AbstractFactory {
  public Car getCar(String type) throws Exception {
    Class<?> cl = beanCache.get(type);
    return (BMWCar) cl.newInstance();
  }

  public BMWFactory() {
    beanCache.put(BMWCar.class.getSimpleName(), BMWCar.class);
    beanCache.put(BMW320.class.getSimpleName(), BMW320.class);
    beanCache.put(BMW530.class.getSimpleName(), BMW530.class);
  }
}

class FactoryProducer implements BeanMapping {
  static {
    beanCache.put(BenzFactory.class.getSimpleName(), BenzFactory.class);
    beanCache.put(BMWFactory.class.getSimpleName(), BMWFactory.class);
  }

  public static AbstractFactory getFactory(String type) throws Exception {
    System.out.println("创建工厂" + type);
    Class<?> cl = beanCache.get(type);
    return (AbstractFactory) cl.newInstance();
  }
}

四、原型模式

  a）原型模式主要包含如下三个角色：
    Prototype：抽象原型类。声明克隆自身的接口。
    ConcretePrototype：具体原型类。实现克隆的具体操作。
    Client：客户类。让一个原型克隆自身，从而获得一个新的对象。

  b）实现 Cloneable 接口,通过调用 clone() 方法进行复制；clone() 方法一般满足如下条件：
    对任何的对象x，都有x.clone() !=x，即克隆对象与原对象不是同一个对象。
    对任何的对象x，都有x.clone().getClass()==x.getClass()，即克隆对象与原对象的类型一样。
    如果对象x的equals()方法定义恰当，那么x.clone().equals(x)应该成立。

  c）代码实现：

    浅复制（内置对象引用未复制）

public class Client {
  public static void main(String[] args) throws Exception {
    Company company = new Company("公司一", "地址一");
    User user1 = new User("张三", 0, 16, company);
    System.out.println(user1);
    User user2 = user1.clone();
    System.out.println(user2);
    System.out.println(user1.equals(user2));
  }
}

class Company {
  private String name;
  private String address;

  public Company(String name, String address) {
    this.name = name;
    this.address = address;
  }

  @Override
  public String toString() {
    return "{hashCode:" + this.hashCode() + ",name:" + name + ",address:" + address + "}";
  }
}

class User implements Cloneable {

  private String name;
  private int sex;
  private int age;
  private Company company;

  public User(String name, int sex, int age, Company company) {
    this.name = name;
    this.sex = sex;
    this.age = age;
    this.company = company;
  }

  @Override
  public User clone() {
    User user = null;
    try {
      user = (User) super.clone();
    } catch (CloneNotSupportedException e) {
      e.printStackTrace();
    }
    return user;
  }

  @Override
  public String toString() {
    return "{hashCode:" + this.hashCode() + ",name:" + name + ",sex:" + sex + ",age" + age + ",company:" + company
        + "}";
  }

}

    深复制（内置对象引用同时复制，需要内置对象同时实现 Cloneable接口）

public class Client {
  public static void main(String[] args) throws Exception {
    Company company = new Company("公司一", "地址一");
    User user1 = new User("张三", 0, 16, company);
    System.out.println(user1);
    User user2 = user1.clone();
    System.out.println(user2);
    System.out.println(user1.equals(user2));
  }
}

class Company implements Cloneable{
  private String name;
  private String address;

  public Company(String name, String address) {
    this.name = name;
    this.address = address;
  }
  @Override
  public Company clone() throws CloneNotSupportedException {
    return (Company) super.clone();
  }

  @Override
  public String toString() {
    return "{hashCode:" + this.hashCode() + ",name:" + name + ",address:" + address + "}";
  }
}

class User implements Cloneable {

  private String name;
  private int sex;
  private int age;
  private Company company;

  public User(String name, int sex, int age, Company company) {
    this.name = name;
    this.sex = sex;
    this.age = age;
    this.company = company;
  }

  @Override
  public User clone() {
    User user = null;
    try {
      user = (User) super.clone();
      user.company = company.clone();
    } catch (CloneNotSupportedException e) {
      e.printStackTrace();
    }
    return user;
  }

  @Override
  public String toString() {
    return "{hashCode:" + this.hashCode() + ",name:" + name + ",sex:" + sex + ",age" + age + ",company:" + company
        + "}";
  }

}

五、建造者模式

  a）角色分配：
    1、Builder：给出一个抽象接口，以规范产品对象的各个组成成分的建造。这个接口规定要实现复杂对象的哪些部分的创建，并不涉及具体的对象部件的创建。
    2、ConcreteBuilder：实现Builder接口，针对不同的商业逻辑，具体化复杂对象的各部分的创建。 在建造过程完成后，提供产品的实例。
    3、Director：调用具体建造者来创建复杂对象的各个部分，在指导者中不涉及具体产品的信息，只负责保证对象各部分完整创建或按某种顺序创建。
    4、Product：要创建的复杂对象。

  b）与工厂模式区别：
    工厂类模式提供的是创建单个类的模式，而建造者模式则是将各种产品集中起来进行管理，用来创建复合对象

  c）代码实现：

public class Client {
  public static void main(String[] args) throws Exception {
    PersonBuilder pb = new ManBuilder();
    PersonDirector pd = new PersonDirector();
    Person man = pd.constructPerson(pb);
    System.out.println(man);
  }
}

class Person {
  private String head;
  private String body;
  private String foot;

  public String getHead() {
    return head;
  }

  public void setHead(String head) {
    this.head = head;
  }

  public String getBody() {
    return body;
  }

  public void setBody(String body) {
    this.body = body;
  }

  public String getFoot() {
    return foot;
  }

  public void setFoot(String foot) {
    this.foot = foot;
  }

  @Override
  public String toString() {
    return "{head:" + head + ",body:" + body + ",foot:" + foot + "}";
  }
}

interface PersonBuilder {
  void buildHead();

  void buildBody();

  void buildFoot();

  Person buildPerson();// 组装
}

class ManBuilder implements PersonBuilder {

  Person person;

  public ManBuilder() {
    person = new Person();
  }

  @Override
  public void buildHead() {
    person.setHead("画个头");
  }

  @Override
  public void buildBody() {
    person.setBody("画个身子");
  }

  @Override
  public void buildFoot() {
    person.setFoot("画个脚");
  }

  @Override
  public Person buildPerson() {
    return person;
  }

}

class PersonDirector {
  public Person constructPerson(PersonBuilder pb) {
    pb.buildHead();
    pb.buildBody();
    pb.buildFoot();
    return pb.buildPerson();
  }
}

六、适配器模式

1、类适配模式

public class Client {
  public static void main(String[] args) {
    Target adapter = new Adapter();
    adapter.request();
  }
}

class Adaptee {
  public void specificRequest() {
    System.out.println("适配执行...");
  }
}

interface Target {
  public void request();
}

class Adapter extends Adaptee implements Target {
  public void request() {
    super.specificRequest();
  }
}

2、对象适配器模式

public class Client {
  public static void main(String[] args) {
    Target adapter = new Adapter(new Adaptee());
    adapter.request();
  }
}

class Adaptee {
  public void specificRequest() {
    System.out.println("适配执行...");
  }
}

interface Target {
  public void request();
}

class Adapter implements Target {
  
  private Adaptee adaptee;
  
  public Adapter(Adaptee adaptee) {
    this.adaptee = adaptee;
  }
  
  public void request() {
    if(adaptee != null) {
      adaptee.specificRequest();
    }
  }
}

七、装饰器模式

与适配器区别（适配器使用不同方法[request/specificRequest]，装饰器使用相同的方法[eat]）

public class Test {
  public static void main(String[] args) {
    Person person = new NewPerson(new OldPerson());
    person.eat();
  }
}

interface Person {
  void eat();
}

class OldPerson implements Person {
  @Override
  public void eat() {
    System.out.println("吃饭");
  }
}
class NewPerson implements Person {
  private OldPerson op;
  public NewPerson(OldPerson op) {
    this.op = op;
  }
  @Override
  public void eat() {
    System.out.println("生火");
    System.out.println("做饭");
    op.eat();
    System.out.println("刷碗");
  }
}

八、代理模式

静态代理（怎么跟适配器模式一样）

public class Test {
  public static void main(String[] args) {
    UserInfo userInfo = new UserProxy(new UserImpl());
    userInfo.queryUser();
    userInfo.updateUser();
  }
}

interface UserInfo {
  public void queryUser();

  public void updateUser();
}

class UserImpl implements UserInfo{
  @Override
  public void queryUser() {
    System.out.println("query user...");
  }
  @Override
  public void updateUser() {
    System.out.println("update user...");
  }
}

class UserProxy implements UserInfo{
  private UserInfo userInfo;
  public UserProxy(UserInfo userInfo) {
    this.userInfo = userInfo;
  }
  @Override
  public void queryUser() {
    System.out.println("after query user...");
    userInfo.queryUser();
    System.out.println("before query user...");
  }
  @Override
  public void updateUser() {
    System.out.println("after update user...");
    userInfo.updateUser();
    System.out.println("before update user...");
  }
}

动态代理

public class Test {
  public static void main(String[] args) {
    UserInfo userImpl = new UserImpl();
    UserHandler handler = new UserHandler(userImpl);
    UserInfo proxy = (UserInfo)Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(), new Class[] {UserInfo.class}, handler);
    proxy.queryUser();
    proxy.updateUser();
  }
}

interface UserInfo {
  public void queryUser();
  public void updateUser();
}

class UserImpl implements UserInfo{
  @Override
  public void queryUser() {
    System.out.println("query user...");
  }
  @Override
  public void updateUser() {
    System.out.println("update user...");
  }
}

class UserHandler implements InvocationHandler{
  private UserInfo userInfo;
  public UserHandler(UserInfo userInfo) {
    this.userInfo = userInfo;
  }
  @Override
  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    System.out.println("after...");
    Object obj = method.invoke(userInfo, args);
    System.out.println("before...");
    return obj;
  }
}

九、外观模式

public class Test {
  public static void main(String[] args) {
    Computer computer = new Computer();
    computer.start();
    computer.shutdown();
  }
}

class Cpu {
  public void start() {
    System.out.println("Cpu start...");
  }
  public void shutdown() {
    System.out.println("Cpu shutdown...");
  }
}
class Disk {
  public void start() {
    System.out.println("Disk start...");
  }
  public void shutdown() {
    System.out.println("Disk shutdown...");
  }
}
class Memory {
  public void start() {
    System.out.println("Memory start...");
  }
  public void shutdown() {
    System.out.println("Memory shutdown...");
  }
}
class Computer{
  private Cpu cpu;
  private Disk disk;
  private Memory memory;
  public Computer() {
    cpu = new Cpu();
    disk = new Disk();
    memory = new Memory();
  }
  public void start() {
    cpu.start();
    disk.start();
    memory.start();
  }
  public void shutdown() {
    cpu.shutdown();
    disk.shutdown();
    memory.shutdown();
  }
}

十、桥接模式

public class Client {
  public static void main(String[] args) {
    RefinedAbstraction ra = new RefinedAbstraction(new ConcreteImplementorA());
    ra.operation();
    ra.otherOperation();
    RefinedAbstraction rb = new RefinedAbstraction(new ConcreteImplementorB());
    rb.operation();
    rb.otherOperation();
  }
}

interface Implementor {
  public void operationImpl();
}

abstract class Abstraction {
  private Implementor implementor;

  public Abstraction(Implementor implementor) {
    this.implementor = implementor;
  }

  public void operation() {
    implementor.operationImpl();
  }
}

class ConcreteImplementorA implements Implementor {
  @Override
  public void operationImpl() {
    System.out.println("具体实现A");
  }
}

class ConcreteImplementorB implements Implementor {
  @Override
  public void operationImpl() {
    System.out.println("具体实现B");
  }
}

class RefinedAbstraction extends Abstraction {
  public RefinedAbstraction(Implementor implementor) {
    super(implementor);
  }

  public void otherOperation() {
    // 实现一定的功能，可能会使用具体实现部分的实现方法,
    // 但是本方法更大的可能是使用 Abstraction 中定义的方法，
    // 通过组合使用 Abstraction 中定义的方法来完成更多的功能。
  }
}

十一、组合模式

  组成部分：
    Component: 为参加组合的对象声明一个公共接口，不管是组合还是叶结点。
    Leaf: 在组合中表示叶子结点对象，叶子结点没有子结点。
    Composite: 表示参加组合的有子对象的对象，并给出树枝购件的行为。

public class Test {
  public static void main(String[] args) {
    final FolderComponent leaf = new FileLeaf("runnable file");
    leaf.display();

    final FolderComponent folder = new FolderComposite("new folder");
    folder.add(new FileLeaf("content1 in new folder"));
    folder.add(new FileLeaf("content2 in new folder"));
    folder.display();
  }
}

abstract class FolderComponent {
  private String name;

  public String getName() {
    return name;
  }

  public void setName(final String name) {
    this.name = name;
  }

  public FolderComponent() {
  }

  public FolderComponent(final String name) {
    this.name = name;
  }

  public abstract void add(FolderComponent component);

  public abstract void remove(FolderComponent component);

  public abstract void display();
}

class FileLeaf extends FolderComponent {
  public FileLeaf(final String name) {
    super(name);
  }

  @Override
  public void add(final FolderComponent component) {
    // ...
  }

  @Override
  public void remove(final FolderComponent component) {
    // ...
  }

  @Override
  public void display() {
    System.out.println("FileLeaf:" + this.getName());
  }
}

class FolderComposite extends FolderComponent {
  private final List<FolderComponent> components;

  public FolderComposite(final String name) {
    super(name);
    this.components = new ArrayList<FolderComponent>();
  }

  public FolderComposite() {
    this.components = new ArrayList<FolderComponent>();
  }

  @Override
  public void add(final FolderComponent component) {
    this.components.add(component);
  }

  @Override
  public void remove(final FolderComponent component) {
    this.components.remove(component);
  }

  @Override
  public void display() {
    System.out.println("FolderComposite---name:" + this.getName());
    for (final FolderComponent component : components) {
      System.out.println("FolderComposite---component-name:" + component.getName());
    }
  }
}