简单介绍23种设计模式

创建型模式 工厂模式
抽象工厂模式
单例模式
建造者模式
原型模式
结构型模式 适配器模式
桥接模式
过滤器模式
组合模式
装饰其模式
外观模式
享元模式
代理模式
行为型模式 责任链模式
命令模式
解释其模式
迭代器模式
中介者模式
备忘录模式
观察者模式
状态模式
空对象模式
策略模式
模版方法
访问者模式

工厂模式和抽象工厂

简单工厂

  • 工厂类根据传入的参数，判断生产不同的实例对象。
  • 简单工厂每新增一个新的实例类型时，都要修改工厂方法。会使工厂类越来越复杂。
  • 违背了开闭原则(拓展开放，内容封闭)
  1. class Animal {
  2.     private String name;
  4.     public String getName() {
  5.         return name;
  6.     }
  8.     public void setName(String name) {
  9.         this.name = name;
  10.     }
  11. }
  13. class Factory {
  15.     public static Animal creatAnimal(String type) {
  16.         Animal animal = null;
  17.         switch (type) {
  18.             case "cat":
  19.                 animal = new Cat();
  20.                 break;
  21.             case "dog":
  22.                 animal = new Dog();
  23.                 break;
  24.             default:
  25.         }
  26.         return animal;
  27.     }
  29. }
  31. class Dog extends Animal {
  32.     public Dog() {
  33.         setName("dog");
  34.     }
  35. }
  37. class Cat extends Animal {
  38.     public Cat() {
  39.         setName("cat");
  40.     }
  41. }
  43. public class SimpleFactoryDesign {
  44.     public static void main(String[] args) {
  45.         Animal animal = Factory.creatAnimal("cat");
  46.         System.out.println(animal.getName());
  47.         animal = Factory.creatAnimal("dog");
  48.         System.out.println(animal.getName());
  49.     }
  50. }

工厂方法

  • 将工厂类的创建延迟到子类(解决了增加子类直接修改工厂方法)
  1. class Animal {
  2.     private String name;
  4.     public String getName() {
  5.         return name;
  6.     }
  8.     public void setName(String name) {
  9.         this.name = name;
  10.     }
  11. }
  13. class Dog extends Animal {
  14.     public Dog() {
  15.         setName("dog");
  16.     }
  17. }
  19. class Cat extends Animal {
  20.     public Cat() {
  21.         setName("cat");
  22.     }
  23. }
  25. abstract class AbstractFactory {
  26.     abstract Animal creatAnimal();
  28.     public void getName() {
  29.         System.out.println(creatAnimal().getName());
  30.     }
  31. }
  33. class DogFactory extends AbstractFactory {
  34.     @Override
  35.     Animal creatAnimal() {
  36.         return new Dog();
  37.     }
  38. }
  40. class CatFactory extends AbstractFactory {
  41.     @Override
  42.     Animal creatAnimal() {
  43.         return new Cat();
  44.     }
  45. }
  47. public class FactoryMethodDesign {
  48.     public static void main(String[] args) {
  49.         AbstractFactory catFactory = new CatFactory();
  50.         AbstractFactory dogFactory = new DogFactory();
  51.         catFactory.getName();
  52.         dogFactory.getName();
  53.     }
  54. }

抽象工厂

  • 工厂生产多类产品
  • 新增产品，要创建对应的工厂
  1. abstract class Animal {
  2.     private String name;
  4.     public String getName() {
  5.         return name;
  6.     }
  8.     public void setName(String name) {
  9.         this.name = name;
  10.     }
  11. }
  13. abstract class Plant  {
  14.     private String name;
  16.     public String getName() {
  17.         return name;
  18.     }
  20.     public void setName(String name) {
  21.         this.name = name;
  22.     }
  23. }
  25. class Dog extends Animal {
  26.     public Dog() {
  27.         setName("dog");
  28.     }
  29. }
  31. class Cat extends Animal {
  32.     public Cat() {
  33.         setName("cat");
  34.     }
  35. }
  37. class Pine extends Plant {
  38.     public Pine() {
  39.         setName("pine");
  40.     }
  41. }
  43. class Cypress extends Plant {
  44.     public Cypress() {
  45.         setName("cypress");
  46.     }
  47. }
  49. abstract class Factory {
  50.     abstract Animal creatAnimal();
  52.     abstract Plant creatPlant();
  53. }
  55. class Factory1 extends Factory {
  56.     @Override
  57.     Animal creatAnimal() {
  58.         return new Dog();
  59.     }
  61.     @Override
  62.     Plant creatPlant() {
  63.         return new Pine();
  64.     }
  65. }
  67. class Factory2 extends Factory {
  68.     @Override
  69.     Animal creatAnimal() {
  70.         return new Cat();
  71.     }
  73.     @Override
  74.     Plant creatPlant() {
  75.         return new Cypress();
  76.     }
  77. }
  79. public class AbstractFactoryDesign {
  80.     public static void main(String[] args) {
  81.         Factory factory1 = new Factory1();
  82.         System.out.println(factory1.creatAnimal().getName());
  83.         System.out.println(factory1.creatPlant().getName());
  85.         Factory factory2 = new Factory2();
  86.         System.out.println(factory2.creatAnimal().getName());
  87.         System.out.println(factory2.creatPlant().getName());
  88.     }
  89. }

总结

  • 首先从简单工厂进化到工厂方法，是因为工厂方法弥补了简单工厂对修改开放的弊端，即简单工厂违背了开闭原则。
  • 从工厂方法进化到抽象工厂，是因为抽象工厂弥补了工厂方法只能创造一个系列的产品的弊端。

单例模式

懒汉式

  • 比较懒嘛，所以用的时候才创建实例对象
  1. public class LazySingleton {
  2.     private static LazySingleton singleton;
  4.     private LazySingleton() {
  5.     }
  7.     public static LazySingleton getInstance() {
  8.         if (singleton == null) {
  9.             synchronized (LazySingleton.class) {
  10.                 if (singleton == null) {
  11.                     singleton = new LazySingleton();
  12.                 }
  13.             }
  14.         }
  15.         return singleton;
  16.     }
  17. }

饿汉式

  • 饿汉，等不及了，所以是提前创建对象
  1. public class HungrySingleton {
  2.     private HungrySingleton singleton = new HungrySingleton();
  4.     private HungrySingleton() {
  5.     }
  7.     public HungrySingleton getSingleton(){
  8.         return singleton;
  9.     }
  10. }

静态内部类

  1. public class InnerClassSingleton {
  3.     private InnerClassSingleton() {
  4.     }
  6.     private static class Inner {
  7.         private static final InnerClassSingleton singleton = new InnerClassSingleton();
  8.     }
  10.     public static InnerClassSingleton getInstance() {
  11.         return Inner.singleton;
  12.     }
  14. }

枚举

  • 枚举默认构造方法私有
  1. public enum SingletonEnum {
  2.     ONE,
  3.     TWO,
  4.     THREE;
  7.     public static SingletonEnum getOne(){
  8.         return ONE;
  9.     }
  11.     public static SingletonEnum getTwo(){
  12.         return TWO;
  13.     }
  15.     public static SingletonEnum getThree(){
  16.         return THREE;
  17.     }
  18. }

建造者模式

将一个复杂的对象的构建与它的表示分离，使

得同样的构建过程可以创建不同的表示。创建者模式隐藏了复杂对象的创建过程，它把复杂对象的创建过程加以抽象，通过子类继承或者重载的方式，动态的创建具有复合属性的对象。

经典模式

  1. @Data
  2. class Computer {
  4.     private String cup;
  5.     private String gpu;
  6.     private String disk;
  7.     private String ram;
  8. }
  10. @Data
  11. abstract class ComputerBuilder {
  12.     abstract void setCup();
  14.     abstract void setGpu();
  16.     abstract void setDisk();
  18.     abstract void setRam();
  20.     abstract Computer getComputer();
  21. }
  23. class HigherComputerBuilder extends ComputerBuilder {
  25.     private Computer computer;
  27.     public HigherComputerBuilder() {
  28.         this.computer = new Computer();
  29.     }
  31.     @Override
  32.     void setCup() {
  33.         computer.setCup("8G");
  34.     }
  36.     @Override
  37.     void setGpu() {
  38.         computer.setGpu("4G");
  39.     }
  41.     @Override
  42.     void setDisk() {
  43.         computer.setDisk("1T");
  44.     }
  46.     @Override
  47.     void setRam() {
  48.         computer.setRam("16G");
  49.     }
  51.     @Override
  52.     Computer getComputer() {
  53.         return computer;
  54.     }
  55. }
  57. class TowerComputerBuilder extends ComputerBuilder {
  59.     private Computer computer;
  61.     public TowerComputerBuilder() {
  62.         this.computer = new Computer();
  63.     }
  65.     @Override
  66.     void setCup() {
  67.         computer.setCup("4G");
  68.     }
  70.     @Override
  71.     void setGpu() {
  72.         computer.setGpu("2G");
  73.     }
  75.     @Override
  76.     void setDisk() {
  77.         computer.setDisk("500G");
  78.     }
  80.     @Override
  81.     void setRam() {
  82.         computer.setRam("8G");
  83.     }
  85.     @Override
  86.     Computer getComputer() {
  87.         return computer;
  88.     }
  89. }
  91. class Director {
  93.     private ComputerBuilder computerBuilder;
  95.     public Director(ComputerBuilder computerBuilder) {
  96.         this.computerBuilder = computerBuilder;
  97.     }
  99.     public Computer createComputerBuilder() {
  100.         computerBuilder.setCup();
  101.         computerBuilder.setDisk();
  102.         computerBuilder.setGpu();
  103.         computerBuilder.setRam();
  104.         return computerBuilder.getComputer();
  105.     }
  106. }
  109. public class Main {
  111.     public static void main(String[] args) {
  112.         Computer computer = new Director(new HigherComputerBuilder()).createComputerBuilder();
  113.         System.out.println("高配：" + computer);
  114.         computer = new Director(new TowerComputerBuilder()).createComputerBuilder();
  115.         System.out.println("低配：" + computer);
  116.     }
  117. }

变种模式

  2. @Data
  3. class Person {
  4.     private String name;
  5.     private String gender;
  6.     private int age;
  7.     private double money;
  8.     private String house;
  9. }
  11. class PersonBuilder {
  12.     private String name;
  13.     private String gender;
  14.     private int age;
  15.     private double money;
  16.     private String house;
  18.     public PersonBuilder(String name, String gender) {
  19.         this.name = name;
  20.         this.gender = gender;
  21.     }
  23.     public PersonBuilder age(int age) {
  24.         this.age = age;
  25.         return this;
  26.     }
  28.     public PersonBuilder money(double money) {
  29.         this.money = money;
  30.         return this;
  31.     }
  33.     public PersonBuilder house(String house) {
  34.         this.house = house;
  35.         return this;
  36.     }
  38.     public Person build() {
  39.         Person person = new Person();
  40.         person.setName(name);
  41.         person.setAge(age);
  42.         person.setGender(gender);
  43.         person.setMoney(money);
  44.         person.setHouse(house);
  45.         return person;
  46.     }
  47. }
  50. public class VarietyBuilder {
  51.     public static void main(String[] args) {
  52.         System.out.println(new PersonBuilder("小明", "man")
  53.                 .age(11).house("big")
  54.                 .money(1111111111).build());
  55.     }
  56. }

原型模式

对象拷贝

  • 浅拷贝
    只复制基本类型，非基本类型需要自定义实现
  • 深拷贝
    所有对象

代码实现

  1. @Data
  2. class Persion implements Cloneable {
  3.     private String name;
  4.     private int age;
  5.     private HashMap<String, String> propertis;
  7.     @Override
  8.     protected Persion clone() throws CloneNotSupportedException {
  9.         Persion persion = (Persion) super.clone();
  10.           //非基本类型自定义拷贝
  11.         persion.propertis = (HashMap<String, String>) this.propertis.clone();
  12.         return persion;
  13.     }
  14. }
  16. public class Prototype {
  18.     public static void main(String[] args) throws CloneNotSupportedException {
  19.         Persion persion = new Persion();
  20.         persion.setAge(11);
  21.         persion.setName("小明");
  22.         HashMap<String, String> propertis = new HashMap<>();
  23.         propertis.put("money", "20亿");
  24.         propertis.put("gender", "man");
  25.         persion.setPropertis(propertis);
  27.         Persion persion1 = persion.clone();
  29.         System.out.println(persion);
  30.         System.out.println(persion1);
  32.         System.out.println(persion.getPropertis() == persion1.getPropertis());
  33.     }
  34. }

结果：

  1. 我是构造方法
  2. Persion(name=小明, age=11, propertis={money=20亿, gender=man})
  3. Persion(name=小明, age=11, propertis={money=20亿, gender=man})
  4. false

总结

  • clone方法创建对象不会调用其构造方法。
  • 被clone对象要实现Cloneable接口
  • 默认super.clone只能复制基本类型，非基本类型需要自定义实现
  • 原型模式可以用来快速创建复杂对象

适配器模式

类适配器

  1. interface Player {
  2.     void action();
  3. }
  5. interface Mp4 {
  6.     void play();
  7. }
  9. class ExpensiveMp4 implements Mp4 {
  10.     @Override
  11.     public void play() {
  12.         System.out.println("play mp4");
  13.     }
  14. }
  16. public class PlayerAdapter extends ExpensiveMp4 implements Player {
  17.     @Override
  18.     public void action() {
  19.         play();
  20.     }
  21. }

接口适配器

  1. interface Player {
  2.     void action();
  3. }
  5. interface Mp4 {
  6.     void play();
  7. }
  9. class ExpensiveMp4 implements Mp4 {
  10.     @Override
  11.     public void play() {
  12.         System.out.println("play mp4");
  13.     }
  14. }
  16. public class PlayerAdapter implements Player {
  17.     private Mp4 mp4;
  19.     public PlayerAdapter(Mp4 mp4) {
  20.         this.mp4 = mp4;
  21.     }
  23.     @Override
  24.     public void action() {
  25.         mp4.play();
  26.     }
  27. }

总结

  • 提高代码复用
  • 灵活性非常好
  • 适配器其实是对目标类/接口的包装，实际工作只有目标类/接口