设计模式

java IO
常见IO类有哪些
涉及到哪些设计模式
设计模式：单例模式，观察者模式，使用场景？
观察者模式如何实现
装饰者模式，他问装饰者模式是什么原理
写个工厂模式
适配器模式
用过什么设计模式；单例模式怎么实现的；怎么保证是单一的；
饿汉模式；懒汉模式；线程安全的写法；
知道什么设计模式
单例设计模式有几种哪种不安全
设计模式（手写饿汉懒汉单例模式）
学习过哪些设计模式，用过哪些设计模式

15. 生产者消费者模式讲一讲
16. 了解什么设计模式呢，说一下代理设计模式 --> 我说了动态代理的Proxy和CGLib的两种代理实现方式
17. Java的I/O使用到了什么设计模式（有装饰者模式，FilterInputStream聚合了InputStream）
    常见设计模式
    装饰者，模板方法，策略，工厂，状态
    设计模式，动态代理

• 设计模式分类
  
• 设计模式原则：
  开闭原则：对扩展开放，对修改关闭，当对程序进行扩展时，不能修改代码
  迪米特原则：一个实体尽量不和其他实体相互作用，使模块隔离
  接口隔离原则：尽量使用多个接口，而不是单个接口
  依赖倒转原则：高层次模块不应该依赖于低层次模块，他们都应该依赖于抽象，另外，抽象不应该依赖于具体实现，具体实现应该依赖于抽象。
  合成复用原则：尽量使用合成的方式，少使用依赖
  里氏代换原则：任何基类出现的地方，子类都可以出现
• 单例模式：
  单例模式主要有三种，懒汉式加载、饿汉式加载和双检锁模式
  懒汉式加载：

package designmodle;
//懒汉式加载：懒汉式加载的特点是类加载时不会对单例实例化，只有第一次调用getInstance()时才会实例化单例。
public class lazySingleton {
    private static volatile lazySingleton instance = null; //采用volatile的目的是为了保证多线程环境下的同步
    private lazySingleton(){} //采用private的目的是为了防止类在外部被实例化
    public static synchronized lazySingleton getInstance(){ //采用synchronize的目的是为了多线程环境下同步
        if(instance == null){
            System.out.println("the lazy singleton is not created");
            instance = new lazySingleton();
        }
        System.out.println("the lazy singleton is created");
        return instance;
    }

    public static void main(String[] args) {
        new lazySingleton().getInstance();
        new lazySingleton().getInstance();
    }
}

饿汉式加载：

package designmodle;
//饿汉式单例：饿汉式单例模式的特点是类加载的时候实例化单例对象，在调用getInstance()之前单例对象就已经存在。
public class hungrySingleton {
    private static final hungrySingleton Instance = new hungrySingleton();
    private hungrySingleton(){
    }

    public static hungrySingleton getInstance() {
        System.out.println("This hungry singleton is created.");
        return Instance;
    }
    public static void main(String[] args) {
        new hungrySingleton().getInstance();
        new hungrySingleton().getInstance();

    }
}

双检锁模式：

package designmodle;

import javax.management.InstanceAlreadyExistsException;

public class doubleCheckSingleton {
    private static volatile doubleCheckSingleton Instance;
    private doubleCheckSingleton(){}

    public static doubleCheckSingleton getInstance() {
        if(Instance == null)
        {
            synchronized (doubleCheckSingleton.class){
                if(Instance == null){
                    System.out.println("the doubleCheck singleton is not created");
                    Instance = new doubleCheckSingleton();
                }
            }
        }
        System.out.println("the doubleCheck singleton is created");
        return Instance;
    }
    public static void main(String[] args) {
        new doubleCheckSingleton().getInstance();
        new doubleCheckSingleton().getInstance();

    }
}

reference1
reference2

• 模板方法模式：
  在抽象类中的模板方法中定义一个操作的结构或者执行步骤；将一些子类相同的基本方法放在抽象类中定义，不同的子类对抽象类中的抽象方法进行不同的实现。模板方法的好处是可以将基本方法放在抽象类中，去除了子类中重复的代码，缺点是对不同的实现需要定义不同的子类，可能造成类太多，更加抽象。
  示例如下：

public abstract class AbstractClass {
    protected abstract void doAnything();
    protected abstract void doSomething();
    public final void templateMethod(){
        /*
         * 调用基本方法，完成相关的逻辑
         */
        this.doAnything();
        this.doSomething();
    }
}
public class ConcreteClass1 extends AbstractClass {

    @Override
    protected void doAnything() {
        // TODO Auto-generated method stub
        //子类实现具体
    }

    @Override
    protected void doSomething() {
        // TODO Auto-generated method stub    
    }
}
public class ConcreteClass2 extends AbstractClass {

    @Override
    protected void doAnything() {
        // TODO Auto-generated method stub
        //子类实现具体
    }

    @Override
    protected void doSomething() {
        // TODO Auto-generated method stub    
    }
}

• 观察者模式：
  观察者模式是指多个对象之间存在一对多的关系，当一个对象发生变化时，其他依赖于它的对象会受到事件通知，进行各自的更新，所以这种模式也叫发布-订阅模式
  观察者模式中有抽象目标类、具体目标类、抽象观察者和具体观察者，其中目标类负责增加和删除观察者对象，并实现对通知观察者的方法，观察者负责实现更新自己的方法，当收到目标类的事件通知后调用更新方法进行更新。
  观察者模式属于行为型模式。
  zookeeper中采用了这种模式。
  reference1
  reference2

• 装饰者模式：
  对原有对象的功能进行动态的扩展和加强，相比继承，更具弹性，无须通过继承增加子类就能扩展对象的新功能。采用继承，可能会出现子类爆炸的情况。
  装饰着模式中有：抽象组件、具体组件、装饰角色和具体装饰角色
  具体组件和抽象装饰者有相同的接口，装饰对象中拥有被装饰对象的引用。
  装饰着的典型应用：IO流中：inputStream作为抽象组件，fileinputStream是具体组件，filterInputStream是装饰角色，而buffedInputStream是具体装饰角色。
  继承会出现类爆炸的情况, 比如一个顶级接口有5个具体的实现组件,同时每一个组件都需要三种不同的装饰 如果是继承去实现 就是 5*3 = 15 个类 而装饰者模式则是 5+3=8个类。
  reference1

• 工厂模式
  特点:工厂方法让类把实例化推迟到子类，让子类决定要实例化的类是哪个类。
  工厂模式可以通过使用一个共同的接口来指向新创建的对象，我们只需要将想要创建的不同参数传入工厂，就可以实例化出不同的对象。
  在工厂方法模式中，工厂父类负责定义创建产品对象的公共接口，而工厂子类则负责生成具体的产品对象，这样做的目的是将产品类的实例化操作延迟到工厂子类中完成，即通过工厂子类来确定究竟应该实例化哪一个具体产品类。
  reference1