面试复习-设计模式

一、单例模式

确保一个类只有一个实例，并提供一个全局访问点。

线程不安全的单例模式

懒汉式

    private static Singleton uniqueLH;

    public static Singleton getUniqueInstanceLanhan(){

        if (uniqueLH==null){
            uniqueLH=new Singleton();
        }

        return uniqueLH;

    }

线程安全的单例模式：

饿汉式

private static Singleton uniqueEH=new Singleton();

懒汉式

    private static Singleton uniqueLH;
    public static synchronized Singleton getUniqueInstanceLanhanSafe(){

        if (uniqueLH==null){
            uniqueLH=new Singleton();
        }

        return uniqueLH;

    }

双重校验锁

public class Singleton {


    //加volatile是为了防止指令重排序
    //uniqueInstance=new Singleton()分三步
    //1.分配内存空间
    //2.初始化
    //3.将对象指向分配的内存空间
    //如果没有禁止指令重排序 可能会出现先1 3 后 2
    // 这样uniqueInstance不为null，但返回的对象还未被初始化

    private volatile static Singleton uniqueInstance;

    private Singleton(){

    }

    public static Singleton getUniqueInstance(){

        if (uniqueInstance==null){
            synchronized (Singleton.class){
                if (uniqueInstance==null){
                    uniqueInstance=new Singleton();
                }
            }
        }

        return uniqueInstance;

    }

}

枚举类

public enum SingletonEnum {

    INSTANCE;
    
}

二、简单工厂模式

创建一个对象时不向客户暴露内部细节，并提供一个创建对象的通用接口。

public interface Product{
}

public class Product1 implements Product{
}

public class Product2 implements Product{
}

三、工厂方法模式

定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个，工厂方法让类把实例化推迟到子类。

public interface Factory {

    Product createProduct();
    
}

public class FactoryA implements Factory {
    @Override
    public Product createProduct() {
        return new Product1();
    }
}

public class FactoryB implements Factory {
    @Override
    public Product createProduct() {
        return new Product2();
    }
}

四、抽象工厂模式

提供一个接口，用于创建相关或依赖对象的家族，而不需要明确具体类。例如上述产品要增加相对应的配件。

public interface Tool {
}

public class ToolA implements Tool {
}

public class ToolB implements Tool {
}

public interface Factory {

    Product createProduct();
    Tool createTool();

}

public class FactoryA implements Factory {
    @Override
    public Product createProduct() {
        return new Product1();
    }

    @Override
    public Tool createTool() {
        return new ToolA();
    }
}

public class FactoryB implements Factory {
    @Override
    public Product createProduct() {
        return new Product2();
    }

    @Override
    public Tool createTool() {
        return new ToolB();
    }
}

五、命令模式

将命令封装成对象，可以使用命令来参数化其他对象，可以将命令放入队列中进行排队，将命令操作可以记录到日志中，支持撤销的操作。Java.lang.Runnable就使用了命令模式。

六、迭代器模式

提供一种顺序访问聚合对象元素的方法，并且不暴露聚合对象的内部表示。

七、观察者模式

定义对象之间的一对多依赖，当一个对象状态改变时，它的所有依赖都会收到通知并自动更新状态。

八、状态模式

允许对象在内部状态改变时改变它的行为，对象看起来好像修改了它所属的类。

九、策略模式

定义一系列算法，封装每个算法，并使它们可以互换。

状态模式是通过状态转移来改变Context所组合的State对象
策略模式是通过Context本身的决策来改变组合的Strategy对象
Comparator是策略模式，就是在不改变对象自身，而用一种策略对象来改变它的行为，将算法和数据分离。

十、模版方法模式

定义算法框架，并将一些步骤的实现延迟到子类。通过模版方法，子类可以重新定义算法的某些步骤，而不用改变算法结构。

十一、适配器模式

把一个类接口转换成另一个用户需要的接口。

Arrays.asList()

十二、组合模式

将对象组合成树形结构来表示“整体/部分”层次关系，允许用户以相同的方式处理单独对象和组合对象。

节选自HeadFirst设计模式.png

十三、装饰者模式

为对象动态添加功能。所谓装饰，就是把这个装饰者套在被装饰者上，从而动态扩展被装饰者的功能。

java.io.BufferedInputStream
java.io.BufferedOnputStream

十四、外观模式

提供了一个统一的接口，用来访问子系统中的一群接口，从而让子系统更容易使用。

十五、代理模式

控制对其他对象的访问。

远程代理：控制对远程对象（不同地址空间）的访问，它负责将请求及其参数进行编码，并向不同地址空间中的对象发送已经编码的请求。
虚拟代理：根据需要创建开销很大的对象，它可以缓存实体的附加信息，以便延迟对它的访问，例如在网站加载一个很大的图片时，不能马上完成，可以用虚拟代理缓存图片的大小信息，然后生成一张临时图片代替原始图片。
保护代理：按权限控制对象的访问，它负责检查调用者是否具有实现一个请求所必须的访问权限。
智能代理：取代了简单的指针，它在访问对象时执行一些附加操作：记录对象的引用次数；第一次引用一个对象时，将它装入内存；在访问一个实际对象前，检查是否已经锁定了它，以确保其他对象不能改变它。

十六、Spring中的设计模式

1.简单工厂：Spring中的beanFactory
2.单例模式：Spring下默认的bean均为singleton
3.代理模式：AOP的动态代理
4.观察者模式：ApplicationListener

设计原则

单一责任原则（S）
让一个类只负责一个事，当这个类需要做过多的事情的时候，就需要分解这个类
开放封闭原则（O）
类应该对扩展开放，对修改关闭。该原则要求在添加新功能时不需要修改代码
里氏替换原则（L）
子类对象必须能够替换掉所有父类对象。子类需要能够当成父类来使用，并且需要比父类更特殊。如果不满足这个原则，那么各个子类的行为上就会有很大差异，增加继承体系的复杂度。
接口分离原则（O）
不应该强迫客户依赖于他们不用的方法。因此使用多个专门的接口比使用单一的接口要好。
依赖倒置原则（D）
高层模块不应该依赖于低层模块，二者都应该依赖于抽象。抽象不应该依赖于细节，细节依赖于抽象。