面试复习-设计模式

2020-06-06  本文已影响0人  Lugton
一、单例模式

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

线程不安全的单例模式

    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就使用了命令模式。

六、迭代器模式

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

七、观察者模式

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

八、状态模式

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

九、策略模式

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

十、模版方法模式

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

十一、适配器模式

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

十二、组合模式

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


节选自HeadFirst设计模式.png

十三、装饰者模式

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

十四、外观模式

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

十五、代理模式

控制对其他对象的访问。

十六、Spring中的设计模式

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

设计原则

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

猜你喜欢

热点阅读