设计模式面试准备

面试题

单例

1. 双重检查锁：

   public class SingletonDemo7 {
       private volatile static SingletonDemo7 singletonDemo7;
       private SingletonDemo7(){}
       public static SingletonDemo7 getSingletonDemo7(){
           if (singletonDemo7 == null) {
               synchronized (SingletonDemo7.class) {
                   if (singletonDemo7 == null) {
                       singletonDemo7 = new SingletonDemo7();
                   }
               }
           }
           return singletonDemo7;
       }
   }

2. 静态类成员变量

   public class SingletonDemo3 {
       private static SingletonDemo3 instance = new SingletonDemo3();
       private SingletonDemo3(){}
       public static SingletonDemo3 getInstance(){
           return instance;
       }
   }

3. 静态内部类

   public class SingletonDemo5 {
       private static class SingletonHolder{
           private static final SingletonDemo5 instance = new SingletonDemo5();
       }
       private SingletonDemo5(){}
       public static final SingletonDemo5 getInsatance(){
           return SingletonHolder.instance;
       }
   }

工厂设计模式

简单工厂模式

1. 定义：
   简单工厂模式：定义一个工厂类，它可以根据参数的不同返回不同类的实例，被创建的实例通常都具有共同的父类。因为在简单工厂模式中用于创建实例的方法是静态（static）方法，因此简单工厂模式又被称为静态工厂方法模式。

2. 角色：

   • Factory（工厂角色）：工厂角色即工厂类，它是简单工程模式的核心，负责实现创建所有产品实例的内部逻辑；工厂类可以被外界直接调用，创建所需的产品对象；在工厂类中提供了静态的工厂方法FactoryMethod()，它的返回类型为抽象产品类型Product。
   • Product（抽象产品角色）：它是工厂类所创建的所有对象的父类，封装了各种产品对象的公有方法，它的引入将提供系统的灵活性，使得在工厂类中只需要定义一个通用的工厂方法，因为所有创建的具体产品对象都是其子类对象。
   • ConcreteProduct（具体产品角色）：它是简单工厂模式的创建目标，它继承了抽象产品角色，需要实现在抽象产品中声明的抽象方法，所有被创建的对象都充当这个角色的某个具体类的实例。

3. 代码

   class Factory {  
       //静态工厂方法  
       public static Product getProduct(String arg) {  
           Product product = null;  
           if (arg.equalsIgnoreCase("A")) {  
               product = new ConcreteProductA();  
               //初始化设置product  
           }  
           else if (arg.equalsIgnoreCase("B")) {  
               product = new ConcreteProductB();  
               //初始化设置product  
           }  
           return product;  
       }  
   }
   class Client {  
       public static void main(String args[]) {  
           LoggerFactory factory;  
           Logger logger;  
           factory = new FileLoggerFactory(); //可引入配置文件实现  
           logger = factory.createLogger();  
           logger.writeLog();  
       }  
   }  

工厂方法模式

简单工厂模式的缺点：当系统中需要引入新的产品时，由于静态工厂方法通过所传入参数的不同来创建不同的产品，这必定要修改工厂类的源代码，将违背“开闭原则”。

在工厂方法模式中，我们不再提供一个统一的工厂类来创建所有的产品对象，而是针对不同的产品提供不同的工厂，系统提供一个与产品等级结构对应的工厂等级结构。

1. 定义：
   工厂方法模式：定义一个用于创建对象的接口，让子类决定将哪一个类实例化。工厂方法模式让一个类的实例化延迟到其子类。

2. 角色：

   • Product（抽象产品）：产品对象的公共父类。
   • ConcreteProduct（具体产品）：抽象产品的具体实现。
   • Factory（抽象工厂）：在抽象工厂类中，声明了工厂方法（Factory Method），用于返回一个产品。抽象工厂是工厂方法模式的核心，所有创建对象的工厂都必须实现该接口。
   • ConcreteFactory（具体工厂）：它是抽象工厂类的子类，实现了抽象工厂中定义的工厂方法，并可由客户端调用，返回一个具体产品类的实例。

3. 角色：

   //日志记录器接口：抽象产品  
   interface Logger {  
       public void writeLog();  
   }  
   //数据库日志记录器：具体产品  
   class DatabaseLogger implements Logger {  
       public void writeLog() {  
           System.out.println("数据库日志记录。");  
       }  
   }  
   //文件日志记录器：具体产品  
   class FileLogger implements Logger {  
       public void writeLog() {  
           System.out.println("文件日志记录。");  
       }  
   }  
   //日志记录器工厂接口：抽象工厂  
   interface LoggerFactory {  
       public Logger createLogger();  
   }  
   //数据库日志记录器工厂类：具体工厂  
   class DatabaseLoggerFactory implements LoggerFactory {  
       public Logger createLogger() {  
               //连接数据库，代码省略  
               //创建数据库日志记录器对象  
               Logger logger = new DatabaseLogger();   
               //初始化数据库日志记录器，代码省略  
               return logger;  
       }     
   }  
   //文件日志记录器工厂类：具体工厂  
   class FileLoggerFactory implements LoggerFactory {  
       public Logger createLogger() {  
               //创建文件日志记录器对象  
               Logger logger = new FileLogger();   
               //创建文件，代码省略  
               return logger;  
       }     
   }  
   // 客户端 使用
   class Client {  
       public static void main(String args[]) {  
           LoggerFactory factory;  
           Logger logger;  
           factory = new FileLoggerFactory(); //可引入配置文件实现  
           logger = factory.createLogger();  
           logger.writeLog();  
       }  
   }  

抽象工厂类

工厂方法模式中的每个工厂只生产一类产品，可能会导致系统中存在大量的工厂类，势必会增加系统复杂度。此时，我们就可以考虑由同一个工厂来统一生产多个产品。

1. 定义：
   抽象工厂模式：提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们的具体类。

2. 角色：

   • AbstractFactory（抽象工厂## 标题 ##）

模板设计模式

策略设计模式

代理设计模式