设计模式 - 《Java 笔记》

1.工厂模式
简而言之，就是创建一个工厂来产生对象。
步骤：

定义一个接口
```
public interface Shape {
void draw();
}
```

定义接口的实现

public class Rectangle implements Shape {
@Override
public void draw() {
   System.out.println("Inside Rectangle::draw() method.");
}
}

public class Square implements Shape {
@Override
public void draw() {
   System.out.println("Inside Square::draw() method.");
}
}

public class Circle implements Shape {
@Override
public void draw() {
   System.out.println("Inside Circle::draw() method.");
}
}

创建工厂来生成实体对象

public class ShapeFactory {
//使用 getShape 方法获取形状类型的对象
public Shape getShape(String shapeType){
   if(shapeType == null){
      return null;
   }        
   if(shapeType.equalsIgnoreCase("CIRCLE")){
      return new Circle();
   } else if(shapeType.equalsIgnoreCase("RECTANGLE")){
      return new Rectangle();
   } else if(shapeType.equalsIgnoreCase("SQUARE")){
      return new Square();
   }
   return null;
}
}

使用工厂来返回实体类对象

public class FactoryPatternDemo {
public static void main(String[] args) {
   ShapeFactory shapeFactory = new ShapeFactory();
   //获取 Circle 的对象，并调用它的 draw 方法
   Shape shape1 = shapeFactory.getShape("CIRCLE");
   //调用 Circle 的 draw 方法
   shape1.draw();
   //获取 Rectangle 的对象，并调用它的 draw 方法
   Shape shape2 = shapeFactory.getShape("RECTANGLE");
   //调用 Rectangle 的 draw 方法
   shape2.draw();
   //获取 Square 的对象，并调用它的 draw 方法
   Shape shape3 = shapeFactory.getShape("SQUARE");
   //调用 Square 的 draw 方法
   shape3.draw();
}
}

2. 抽象工厂模式
通过一个抽象工厂，来创造工厂，再通过创造出来的工厂生成对象，例子略。

3.单例模式
步骤：

构造方法私有化
创建当前类的一个静态成员变量
创建一个获取成员变量的方法

public class SingleObject {
   //创建 SingleObject 的一个对象
   private static SingleObject instance = new SingleObject();
   //让构造函数为 private，这样该类就不会被实例化
   private SingleObject(){}
   //获取唯一可用的对象
   public static SingleObject getInstance(){
      return instance;
   }
   public void showMessage(){
      System.out.println("Hello World!");
   }
}

懒汉式，线程不安全：

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

懒汉式，线程安全：

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

饿汉式，线程安全，但容易产生垃圾对象：

public class Singleton {  
  private static Singleton instance = new Singleton();  
  private Singleton (){}  
  public static Singleton getInstance() {  
  return instance;  
  }  
}

双检锁/双重校验锁，线程安全且在多线程下能保持高性能：

volatile关键字参考这篇博客：https://www.cnblogs.com/zhengbin/p/5654805.html

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

登记式/静态内部类，这种方式与双检锁功效一致，实现更简单，应使用这种方式而不是双检锁方式。

静态内部类在使用时才会加载
静态代码块在类加载的时候加载
一般顺序：

先执行父类的静态代码块和静态变量初始化，并且静态代码块和静态变量的执行顺序只跟代码中出现的顺序有关
执行子类的静态代码块和静态变量初始化
执行父类的实例变量初始化
执行父类的构造函数
执行子类的实例变量初始化
执行子类的构造函数

如果类已经被加载：
则静态代码块和静态变量就不用重复执行，在创建类对象时，只执行与实例相关的变量初始化和构造方法。

public class Singleton {  
    private static class SingletonHolder {  
    private static final Singleton INSTANCE = new Singleton();  
    }  
    private Singleton (){}  
    public static final Singleton getInstance() {  
    return SingletonHolder.INSTANCE;  
    }  
}

枚举，线程安全，实现容易

这种实现方式还没有被广泛采用，但这是实现单例模式的最佳方法。它更简洁，自动支持序列化机制，绝对防止多次实例化。

public enum Singleton {  
    INSTANCE;  
    public void whateverMethod() {  
    }  
}

4.建造者模式
使用简单的对象一步一步构建成一个复杂的对象，这种类型的设计模式属于创建型模式，他提供了以重创建对象的最佳方式。

5.适配器模式