设计模式-Java开发中常用和常见的设计模式总结归纳

持续更新中…
参考：
（Java_GOF23设计模式全解） 尚学堂 百战程序员 2018 Java300集教学视频！

1. 单例模式

1.1. 静态内部类方式

public class ThreadPoolUtil {
    
    

    private ThreadPoolUtil() {
    
    
    }

    private static class Singleton {
    
    
        private static final String threadNamePrefix = "global-unique-thread-";
        private static final ThreadPoolExecutor INSTANCE = new ThreadPoolExecutor(
                Integer.parseInt(PropsUtil.sysProps.get(Constants.CORE_POOL_SIZE)),
                "0".equals(PropsUtil.sysProps.get(Constants.MAXIMUM_POOL_SIZE)) ?
                        (Runtime.getRuntime().availableProcessors() << 1) :
                        Integer.parseInt(PropsUtil.sysProps.get(Constants.MAXIMUM_POOL_SIZE)),
                Long.valueOf(PropsUtil.sysProps.get(Constants.KEEP_ALIVE_TIME)),
                TimeUnit.MILLISECONDS,
                new ArrayBlockingQueue<>(Integer.parseInt(PropsUtil.sysProps.get(Constants.ARRBLOCK_QUEUE_SIZE))),
                r -> {
    
    
                    Thread thread = new Thread(r);
                    thread.setName(threadNamePrefix + thread.getId());
                    return thread;
                });
    }

    public static ThreadPoolExecutor getInstance() {
    
    
        return Singleton.INSTANCE;
    }
}

2. 工厂模式

核心本质/思想：

1. 实例化对象不需要new，用工厂方法代替
2. 将选择实现类、创建对象统一管理和控制，从而将调用者和我们的实现类解耦。

2.1. 简单/静态工厂（不符合开闭原则，但常用）

1. 思想：

2. 实现：

   公共部分的接口和类：

   // 实现类对应的接口
   public interface IBike {
         
         
       void name();
   }
   
   // 实例1
   public class Mobai implements IBike {
         
         
       @Override
       public void name() {
         
         
           System.out.println("Mobai");
       }
   }
   
   // 实例2
   public class Ofo implements IBike {
         
         
       @Override
       public void name() {
         
         
           System.out.println("ofo");
       }
   }
   

   简单工厂模式核心类：

   public class BikeFactory {
         
         
       public IBike getBike(String name){
         
         
           if ("Mobai".equalsIgnoreCase(name)) {
         
         
               return new Mobai();
           } else if ("Ofo".equalsIgnoreCase(name)) {
         
         
               return new Ofo();
           } else {
         
         
               return null;
           }
       }
   }
   

   测试类：

   public class Test {
         
         
       public static void main(String[] args) {
         
         
           // 简单/静态工厂模式.
           System.out.println("简单工厂：");
           BikeFactory bikeFactory = new BikeFactory();
           IBike mobai = bikeFactory.getBike("Mobai");
           mobai.name();
           IBike ofo = bikeFactory.getBike("Ofo");
           ofo.name();
           // 工厂方法模式
           System.out.println("工厂方法：");
           MobaiFactory mobaiFactory = new MobaiFactory();
           mobaiFactory.getBike().name();
           OfoFactory ofoFactory = new OfoFactory();
           ofoFactory.getBike().name();
       }
   }
   

2.2. 工厂方法（符合开闭原则，但是会创建许多工厂类）

1. 思想：

2. 实现：

2.3. 抽象工厂（符合开闭原则，但是会创建许多工厂类）

1. 思想：
2. 实现：

3. 适配器模式

核心本质/思想：

3.1. 对象适配器

3.2. 类适配器

4. 责任链模式

核心本质/思想：