设计模式

分为四大类

1.创建型模式 工厂 单例
2.结构型模式 适配器 装饰器 代理
3.行为型模式 观察者
4.J2EE 设计模式 MVC 模式

工厂模式

1.在超类和多个子类之间的情况，这种模式将创建对象的责任转移到工厂类
2.超类可以是接口、抽象类、父类
3.有了多个子类和超类，接下来可以创建工厂类
4.工厂类的方法，基于相同的参数类型返回了不同的对象；
5.工厂类的方法可以是静态的,根据传如参数的值不同，创造不同的对象。
传送门

抽象工厂模式

超级工厂创建其他工厂

单例模式

意图：保证一个类仅有一个实例，并提供一个访问它的全局访问点。
主要解决：一个全局使用的类频繁地创建与销毁。
何时使用：当您想控制实例数目，节省系统资源的时候。
如何解决：判断系统是否已经有这个单例，如果有则返回，如果没有则创建。
关键代码：构造函数是私有的。
几种实现方式

懒汉式，线程不安全
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() {  //加锁synchronized 
    if (instance == null) {  
        instance = new Singleton();  
    }  
    return instance;  
    }  
}

饿汉式,线程安全
public class Singleton {  
    private static Singleton instance = new Singleton();  //instance 在类装载时就实例化
    private Singleton (){}  
    public static Singleton getInstance() {  
    return instance;  
    }  
}

双锁机制,线程安全
public class Singleton {  
    private volatile static Singleton singleton;  //volatile 内存可见
    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() {  
    }  
}

一般情况下，不建议使用第 1 种和第 2 种懒汉方式，建议使用第 3 种饿汉方式。
只有在要明确实现 lazy loading 效果时，才会使用第 5 种登记方式。
如果涉及到反序列化创建对象时，可以尝试使用第 6 种枚举方式。
如果有其他特殊的需求，可以考虑使用第 4 种双检锁方式。

适配器模式

读卡器是作为内存卡和笔记本之间的适配器。您将内存卡插入读卡器，再将读卡器插入笔记本，这样就可以通过笔记本来读取内存卡。
1.先创建一个SD卡的接口
2.创建内存接口的实现类，模拟SD卡的功能
3.创建计算机接口，计算机提供读取SD卡方法：
4.创建一个计算机实例，实现计算机接口，并实现其读取SD卡方法
5.这时候就可以模拟计算机读取SD卡功能.调用计算机读取SD卡方法就OK
接下来在不改变计算机读取SD卡接口的情况下，通过适配器模式读取TF卡：
6.创建TF卡接口
7.创建TF卡实例
8.创建SD适配TF （也可以说是SD兼容TF，相当于创建读卡器）
实现SD卡接口，并将要适配的对象TF卡private TFCard tfCard;作为适配器的属性引入。

装饰器模式

向一个现有的对象添加新的功能
1.创建一个 Shape 接口
2.创建实现了 Shape 接口的实体类
3.创建一个实现了 Shape 接口的抽象装饰类 ShapeDecorator，并把 Shape 对象作为它的实例变量。protected Shape decoratedShape; 里面添加新的功能
4.创建实现了 ShapeDecorator 的实体类。

代理模式

创建具有现有对象的对象为其他对象提供一种代理以控制对这个对象的访问
实现与被代理类组合，我也实现代理对象实现的接口，然后我把代理对象作为我的内部变量。

观察者模式

当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。
关键代码：在抽象类里有一个 ArrayList 存放观察者们。
拍卖的时候，拍卖师观察最高标价，然后通知给其他竞价者竞价。
1.创建 Subject 类。被观察的一个对象

public class Subject {
   
   private List<Observer> observers 
      = new ArrayList<Observer>();//一个List数组，存放依赖它的对象，他们继承观察者类所以List类型为观察者。
   private int state;//改变的值
 
   public int getState() {
      return state;
   }
 
   public void setState(int state) {
      this.state = state;
      notifyAllObservers();
   }
 //添加一个依赖它的对象
   public void attach(Observer observer){
      observers.add(observer);      
   }
 //通知更新
   public void notifyAllObservers(){
      for (Observer observer : observers) {
         observer.update();
      }
   }  
}

2.创建 Observer 类。里面包含被观察对象

public abstract class Observer {
   protected Subject subject;//里面包含被观察对象
   public abstract void update();
}

3.创建实体观察者类。

public class BinaryObserver extends Observer{
 
   public BinaryObserver(Subject subject){
      this.subject = subject;
      this.subject.attach(this);
   }

   @Override
   public void update() {
      System.out.println( "Binary String: " 
      + Integer.toBinaryString( subject.getState() ) ); 
   }
}

public class OctalObserver extends Observer{
 
   public OctalObserver(Subject subject){
      this.subject = subject;
      this.subject.attach(this);
   }
 
   @Override
   public void update() {
     System.out.println( "Octal String: " 
     + Integer.toOctalString( subject.getState() ) ); 
   }
}

4.使用 Subject 和实体观察者对象。

 Subject subject = new Subject();
 
      new OctalObserver(subject);
      new BinaryObserver(subject);

      System.out.println("First state change: 15");   
      subject.setState(15);
      System.out.println("Second state change: 10");  
      subject.setState(10);
/*
First state change: 15
Octal String: 17
Binary String: 1111
Second state change: 10
Octal String: 12
Binary String: 1010
*/

MVC模式

我们将创建一个作为模型的 Student 对象。
StudentView 是一个把学生详细信息输出到控制台的视图类，
StudentController 是负责存储数据到 Student 对象中的控制器类，并相应地更新视图 StudentView。
创建模型

public class Student {
   private String rollNo;
   private String name;
   public String getRollNo() {
      return rollNo;
   }
   public void setRollNo(String rollNo) {
      this.rollNo = rollNo;
   }
   public String getName() {
      return name;
   }
   public void setName(String name) {
      this.name = name;
   }
}

创建视图。

public class StudentView {
   public void printStudentDetails(String studentName, String studentRollNo){
      System.out.println("Student: ");
      System.out.println("Name: " + studentName);
      System.out.println("Roll No: " + studentRollNo);
   }
}

创建控制器

public class StudentController {
   private Student model;
   private StudentView view;
 
   public StudentController(Student model, StudentView view){
      this.model = model;
      this.view = view;
   }
 
   public void setStudentName(String name){
      model.setName(name);    
   }
 
   public String getStudentName(){
      return model.getName();    
   }
 
   public void setStudentRollNo(String rollNo){
      model.setRollNo(rollNo);      
   }
 
   public String getStudentRollNo(){
      return model.getRollNo();     
   }
 
   public void updateView(){           
      view.printStudentDetails(model.getName(), model.getRollNo());
   }  
}

使用 StudentController 方法来演示 MVC 设计模式的用法。

public class MVCPatternDemo {
   public static void main(String[] args) {
 
      //从数据库获取学生记录
      Student model  = retrieveStudentFromDatabase();
 
      //创建一个视图：把学生详细信息输出到控制台
      StudentView view = new StudentView();
 
      StudentController controller = new StudentController(model, view);
 
      controller.updateView();
 
      //更新模型数据
      controller.setStudentName("John");
 
      controller.updateView();
   }
 
   private static Student retrieveStudentFromDatabase(){
      Student student = new Student();
      student.setName("Robert");
      student.setRollNo("10");
      return student;
   }
}