设计模式

设计模式的分类
总体来说设计模式分为三大类：
创建型模式，共5种： 工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。
结构型模式，共7种： 适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。
行为型模式，共11种：策略模式、*模板方法模式、观察者模式*、迭代子模式、责任链模式、命令模式、
备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。
1、单例(掌握)
概述：内存中只能存在一个该类的对象
饿汉式：对象的初始化过程在类加载的时候就已经完成
懒汉式：调用方法的时候再创建对象,需要注意线程安全问题

开发中建议使用饿汉式，面试两种都要说明

/**
 * 饿汉式:对象的初始化过程在类加载的时候就已经完成
 * 在开发中建议使用
 */
 public class Singleton{
 //直接创建对象
 public static Singleton instance = new Singleton();
 //私有化构造函数
 private Singleton(){
 }
 //返回对象实例
 public static Singleton getInstance(){
 return instance;
 }
}

/**
 * 懒汉式:调用方法的时候再创建使用
 */
public class Configuration {
       private static Configuration conf = null;
       public static synchronized Configuration getInstance(){
              if(conf ==null){
                     conf = newConfiguration();
              }
              return conf;
       }
       privateConfiguration(){
       }
}

2、工厂模式
概述
创建对象的事情，可能比较复杂的，所以创建对象的这个逻辑我们应该定义到专门的一个类里面，这个类专门负责创建各种对象实例，那么这个类就被称为工厂类

简单工厂和工厂模式的区别
简单工厂：一个工厂可以创建多个对象，如果要添加对象，那应该修改工厂.简单工厂模式中的工厂类一般是使用静态方法，通过接收的参数的不同来返回2不同的对象实例。不修改代码无法扩展
工厂模式：一个工厂对应一个对象，换句话说 一个工厂只能创建一个对象，如果我要创建这个对象，第一步应该先创建工厂对象，然后通过工厂对象来创建对象。如果要添加对象，只需要再新增一个工厂即可，更符合开闭原则

比如说，我们现在有很多动物类，猫，狗，猪 …
而这些动物有相同的行为， eat()。
抽取一个共同的父类。动物。
简单工厂模式：
Animal
|–Dog
|–Cat

  AnimalFactory
                 public static Animal createAnimal(String type){
                      if("dog".equals(type)){
                            return new Dog();
                      }else if("cat".equals(type)){
                            return new Cat();
                      }else {
                            return null;
                      }
                 }  

     工厂方法模式：
      Animal
             |--Dog
             |--Cat
             |--Pig

       AnimalFactory
             |--DogFactory
             |--CatFactory
             |--PigFactory

多个工厂模式

3、包装设计模式(掌握)
概述
对一个已知类，类的原始行为要保留住而且对于某一个方法或者给类增加一些新的内容，这种情况下使用包装设计模式
编写步骤
1、编写一个类，继承被包装类
2、在包装类中定义一个变量temp这个变量的类型是被包装类
3、定义构造方法，通过构造方法初始化temp
4、改写需要增强的方法
5、对于不需要增强的方法，调用原有对象的方法

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class MyBufferedReader extends BufferedReader{
       private BufferedReader br ;
       private int number= 1;
       public MyBufferedReader(BufferedReader br){
              super(br);
              this.br = br;
       }

       public String readLine() throws IOException{
              if(br.readLine() == null)
                     return null;
              return number+++br.readLine();
       }

       public static void main(String[] args) throws Exception {

              MyBufferedReader reader = new MyBufferedReader(new BufferedReader(new FileReader("d://giftsstore.log")));

              String line = null;
              while((line=reader.readLine()) != null){
                     System.out.println(line);
              }
       }
}

4、模板设计模式
概述：
模版设计模式中，将工作的主体架构规定好，具体类可以根据自己的需要，各自去实现
模板类最好是一个抽象类，里面包含抽象方法和非抽象方法
5.观察者模式
观察者模式类似于邮件订阅和RSS订阅，当你订阅了该文章，如果后续有更新会及时通知你。其实，简单的说就一句话：当一个对象变化时，其他依赖该对象的对象都会收到通知，并且随着变化。对象之间是一种一对多的关系。

public interface Observer{
      public void update();
    }

    //定义两个观察者实现接口
    public class Observer1 implements Observer{
        @Override
        public void update() {
            System.out.println("Observer1 has received！");
        }
    }

    public class Observer2 implements Observer{
        @Override
        public void update() {
            System.out.println("Observer2 has received！");
        }
    }

    public interface Subject{
        /*增加观察者*/
        public void add(Observer  observer);
        /*删除观察者*/
        public void del(Observer  observer);
        /*通知所有观察者*/
        public void notifyObservers();
        /*操作自身*/
        public void operation();
    }
    /*定义抽象类实现某个类*/
    public abstract class AbstractSubject implements Subject{
        //创建一个私有的 广播变量 vector
        private Vector<Observer> vector = new Vector<Observer>();

        @Override
        public void add(Observer observer) {
            vector.add(observer);
        }

        @Override
        public void del(Observer observer) {
            vector.remove(observer);
        }

        @Override
        public void notifyObservers() {
            Enumeration<Observer> enumo = vector.elements();
            while(enumo.hasMoreElements()){
                enumo.nextElement().update();
            }
        }
    }

    public class MySubject extends AbstractSubject{

        @Override
        public void operation() {
            System.out.println("更新自身");
            notifyObservers();
        }

    }

    public  class ObserverTest{
        public static void main(String[] args){
            Subject sub = new MySubject();
            sub.add(new Observer1());
            sub.add(new Observer2());
            sub.operation();
        }
    }