设计模式-面试题

一、实际应用

• 项目中使用到的设计模式

  • 模板方法模式、工厂方法模式、外观模式、建造者模式

• Spring中使用到的设计模式

  • 代理模式、单例模式、观察者模式

二、设计模式分类

设计模式（Design Pattern）是一套被反复使用、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被理解、提高代码的可靠性。

• 创建型：主要用于创建对象，包括各种工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。
• 结构型：主要用于处理类和对象的组合。包括桥接模式、适配器模式、装饰者模式、代理模式、组合模式、外观模式、享元模式等。
• 行为型：主要用于描述类或对象如何交互和怎样分配职责。包括策略模式、解释器模式、命令模式、观察者模式、迭代器模式、模板方法模式、访问者模式。

三、创建型

1、工厂方法模式(Factory Method)

• 定义一个用于创建对象的接口，让子类决定将哪一个类实例化。

//创建接口
public interface Shape {  
    void draw();  
}

//具体实体类
public class Rectangle implements Shape {  
    @Override  
    public void draw() {  
        System.out.println("Inside Rectangle::draw() method.");  
    }  
}  
  
public class Square implements Shape {  
    @Override  
    public void draw() {  
        System.out.println("Inside Square::draw() method.");  
    }  
}  

//创建工厂生成具体实例
@Component  
public class ShapeFactory {  
    private Map<String, Shape> shapeMap = new HashMap<>();  
  
    public ShapeFactory() {  
        shapeMap.put("CIRCLE", new Circle());  
        shapeMap.put("RECTANGLE", new Rectangle());  
        shapeMap.put("SQUARE", new Square());  
    }  
  
    public Shape getShape(String shapeType){  
        return shapeMap.get(shapeType);  
    }  
}

2、抽象工厂模式(Abstract Factory)

• 提供一个创建对象的接口，而无需指定它们具体的类。（创建多个工厂）

//创建接口
public interface Animal {  
    void speak();  
}

//具体实体类
public class Dog implements Animal {  
    @Override  
    public void speak() {  
        System.out.println("Woof!");  
    }  
}  
  
public class Cat implements Animal {  
    @Override  
    public void speak() {  
        System.out.println("Meow!");  
    }  
}

//抽象工厂
public abstract AnimalFactory {
    public abstract Animal createAnimal();  
}

//创建实现该抽象工厂类的具体工厂类：
public class DogFactory extends AnimalFactory {  
    @Override  
    public Animal createAnimal() {  
        return new Dog();  
    }  
}  

public class CatFactory extends AnimalFactory {  
    @Override  
    public Animal createAnimal() {  
        return new Cat();  
    }  
}

3、单例模式(Singleton)

• 确保一个类只有一个实例，并提供一个全局访问点
• 单例被破坏的场景
  • 反射、反序列化、克隆、指令重排、多线程

//饿汉式
public class Singleton {  
    private static Singleton instance = new Singleton();  
    private Singleton() {}  
    public static Singleton getInstance() {  
        return instance;  
    }  
}
//懒汉式
public class Singleton {  
    private static Singleton instance;  
    private Singleton() {}  
    public static synchronized Singleton getInstance() {  
        if (instance == null) {  
            instance = new Singleton();  
        }  
        return instance;  
    }  
}
//DCL
public class Singleton {  
    private volatile static Singleton instance;  
    private Singleton() {}  
    public static Singleton getInstance() {  
        if (instance == null) { // 第一次检查  
            synchronized (Singleton.class) {  
                if (instance == null) { // 第二次检查  
                    instance = new Singleton();  
                }  
            }  
        }  
        return instance;  
    }  
} 

保证内存可见性

volatile的作用：因为Java里创建对象，JVM指令是多条。
1、new #2：这行指令是说在堆上的某个地址处开辟了一块空间作为Object对象；