Java面试题——第二篇（设计模式）

1. 工厂方法模式

1.1 普通工厂模式

建立一个工厂类，对实现了同一接口的一些类进行实例的创建。

1.2 抽象工厂模式

抽象多个工厂类，提高工厂的可扩展性

定义抽象工厂接口

java 复制代码

public interface DeviceFactory {  
    Phone createPhone();  
    Computer createComputer();  
}

实现具体工厂类

java 复制代码

// 华为工厂  
public class HuaweiFactory implements DeviceFactory {  
    @Override  
    public Phone createPhone() {  
        return new HuaweiPhone();  
    }  
    @Override  
    public Computer createComputer() {  
        // 假设华为工厂目前只生产手机  
        return null;  
    }  
}  
// 苹果工厂  
public class AppleFactory implements DeviceFactory {  
    @Override  
    public Phone createPhone() {  
        return new iPhone();  
    }  
  
    @Override  
    public Computer createComputer() {  
        return new MacComputer();  
    }  
}

客户端使用

java 复制代码

public class Client {  
    public static void main(String[] args) {  
        // 使用华为工厂  
        DeviceFactory huaweiFactory = new HuaweiFactory();  
        Phone huaweiPhone = huaweiFactory.createPhone();  
        huaweiPhone.call();  
  
        // 使用苹果工厂  
        DeviceFactory appleFactory = new AppleFactory();  
        Phone iphone = appleFactory.createPhone();  
        iphone.call();  
        Computer macComputer = appleFactory.createComputer();  
        macComputer.surfInternet();  
    }  
}

2. 单例模式

保证在一个JVM中，该对象只有一个实例存在。

使用场景：

某些类创建比较频繁，对于一些大型的对象，这是一笔很大的系统开销。

省去了new操作符，降低了系统内存的使用频率，减轻GC压力。

有些例如交易所的核心交易引擎，控制着交易流程，如果该类可以创建多个的话，系统就会乱掉，所以只有使用单例模式，才能保证核心交易服务器独立控制整个流程。

饿汉式：类初始化时创建单例，线程安全，适用于单例占内存小的场景。

java 复制代码

public class Singleton{
 
 private static Singleton instance = new Singleton();
 
 private Singleton(){}
 
 public static Singleton newInstance(){
  return instance;
 }
}

懒汉式：需要创建单例实例的时候在创建，需要考虑线程安全

java 复制代码

public class Singleton{

 private static Singleton instance = null;
 
 private Singleton(){}
 
 public static synchronized Singleton newInstance(){
  if(null == instance){
    instance = new Singleton();
  }
  return instance;
 }
}

双重校验锁定

解决问题：假如两个线程A执行了if(null == instance)语句，会认为单例对象没有创建，此时线程切到B也执行了同样语句，B也认为单例对象没有创建，然后两个线程依次执行同步代码块，分别创建了一个对象。

java 复制代码

public class Singleton {  
	// 持有私有静态实例，防止被引用
    private static volatile Singleton instance;  
    // 私有构造方法，防止被实例化
    private Singleton() {}  

    //静态工厂方法，创建实例
    public static Singleton getInstance() {  
        if (instance == null) {  
            synchronized (Singleton.class) {  
                if (instance == null) {  
                    instance = new Singleton();  
                }  
            }  
        }  
        return instance;  
    }  
}

静态内部类方法：可以同时保证延迟加载和线程安全

java 复制代码

public class Singleton {  
    private Singleton() {}  
    private static class SingletonHolder {  
        private static final Singleton INSTANCE = new Singleton();  
    }  
    public static final Singleton getInstance() {  
        return SingletonHolder.INSTANCE;  
    }  
}