手撕四种常用设计模式（工厂，计谋，代理，单例）

工厂模式

一、工厂模式的总体长处

• 解耦：客户端与具体实现类解耦，符合“开闭原则”。
  
• 统一创建：对象创建交由工厂处置惩罚，便于会合控制。
  
• 增强可维护性：新增对象种类时不需要大改动调用代码。
  
• 便于扩展：易于管理产品族或产品等级结构。、
  

手写静态工厂模式，通过一个汽车静态工厂负责创建汽车

特点：

• 工厂类通过一个静态方法来返回差异的对象。
  
• 客户端通过传入参数决定创建哪个类。
  

✅ 长处：

• 实现简朴，结构清晰。
  
• 对客户端隐藏了对象的具体创建过程。
  

⚠️ 缺点：

• 不符合开闭原则（新增产品需修改 createCar() 方法）。
  
• 工厂职责过重，产品一多代码臃肿。
  

1. public class StaticFactoryModel {
2.    
3.     public static void main(String[] args){
4.         car car=new CarFactory.createCar("Tesla");
5. }
6. interface car{
7.     void drive();
8. }
9. class Tesla implements car{
10.     @Override
11.     public void drive(){
12.         System.out.println("drive Tesla");
13.     }
14. }
15. class toyota implements car{
16.     @Override
17.     public void drive(){
18.         System.out.println("drive toyota");
19.     }
20. }
22. class CarFactory{
23.     public static car createCar(String type){
24.         switch(type){
25.             case"Tesla": return new Tesla();
26.             case"toyota":return new toyota();
27.             default:throw new IllegalArgumentException("UnKnow Car");
28.         }
29.     }
30. }

复制代码

手写工厂方法模式

特点：

• 将创建对象的工作延迟到子类，通过差异工厂子类创建差异对象。
  

✅ 长处：

• 满意开闭原则，新增产品只需新增对应工厂。
  
• 结构清晰，职责单一，每个工厂只负责一种产品的创建。
  

⚠️ 缺点：

• 类的数目变多，增长体系复杂度。
  
• 只能生产单一类型的产品。
  

1. package com;
3. public class FactoryMethod {
4.     public static void main(String[] args) {
5.         phoneFactory factory=new iPhoneFactory();
6.         phone myphone=factory.createPhone();
7.         myphone.call();
8.     }
9. }
11. interface phone{
12.     public void call();
13. }
14. class iPhone implements phone{
15.     @Override
16.     public void call(){
17.         System.out.println("iPhone call");
18.     }
19. }
20. class Huawei implements phone{
21.     @Override
22.     public void call(){
23.         System.out.println("Huawei call");
24.     }
25. }
26. interface phoneFactory{
27.     public phone createPhone();
28. }
29. class iPhoneFactory implements phoneFactory{
30.     @Override
31.     public phone createPhone(){
32.         return new iPhone();
33.     }
34. }
35. class HuaweiFactory implements phoneFactory{
36.     @Override
37.     public phone createPhone(){
38.         return new Huawei();
39.     }
40. }

复制代码

手写抽象工厂模式

✅ 特点：

• 一个工厂可以生产多个相干的产品（如电脑 + 操作体系）。
  

✅ 长处：

• 更强的扩展本事，可以生产“产品族”（多个相干产品）。
  
• 高度封装了产品的创建细节，对客户端透明。
  

⚠️ 缺点：

• 不易新增“新产品”（好比新加一个 Printer 接口）需修改所有工厂。
  
• 抽象程度更高，明白成本稍大。
  

1. package com;
3. public class AbstractFactory {
4.     public static void main(String[] args){
5.         ShowFactory factory=new WinFactory();
6.         Computee myCom=factory.createCom();
7.         Os myOs=factory.createOs();
8.     }
9. }
11. interface Computee{
12.     public void use();
13. }
14. interface Os{
15.     public void call();
16. }
18. class hp implements  Computee{
20.     @Override
21.     public void use() {
22.         System.out.println("useing window");
23.     }
24. }
25. class AppleCom implements  Computee{
27.     @Override
28.     public void use() {
29.         System.out.println("using apple");
30.     }
31. }
33. class window implements Os{
35.     @Override
36.     public void call() {
37.         System.out.println("calling window");
38.     }
39. }
40. class AppleOS implements Os{
42.     @Override
43.     public void call() {
44.         System.out.println("calling apple");
45.     }
46. }
47. interface ShowFactory{
48.     Computee createCom();
49.     Os createOs();
50. }
51. class WinFactory implements ShowFactory{
52.     @Override
53.     public Computee createCom() {
54.         return new hp();
55.     }
56.     @Override
57.     public Os createOs() {
58.         return new window();
59.     }
60. }
61. //..另外一个工厂对应行为

复制代码

计谋模式

计谋模式
上下文负责生成具体的计谋类而且负责与客户端交互
抽象计谋类为抽象脚色，通常由一个接口大概抽象类实现，给出所有的具体计谋类需要的接口
具体计谋类：是实现接口，提供具体算法大概举动

计谋模式长处：

• 算法解耦：将举动或算法封装在独立计谋类中，便于切换和扩展。
  
• 避免多重判断：通过多态替代 if-else 或 switch，结构更清晰。
  
• 符合开闭原则：新增计谋时无需改动已有代码，只需增长新计谋类。
  
• 可复用性高：差异上下文可复用同一个计谋类，提拔代码复用率
  

1. package com;
3. public class Strategy {
4. }
5. interface paymentStragegy{
6.     public void pay();
7. }
9. class wxpayMentStragegy implements paymentStragegy{
11.     @Override
12.     public void pay() {
13.         System.out.println("useing wxpay");
14.     }
15. }
17. class ApaymentStragegy implements paymentStragegy{
19.     @Override
20.     public void pay() {
21.         System.out.println("using apay");
22.     }
23. }
25. class context{
26.     String type=System.getenv("stragegy");
27.     public paymentStragegy mypayMent=null;
28.     public context(){
29.         switch(type){
30.             case "1":mypayMent=new ApaymentStragegy();
31.             case "2":mypayMent=new wxpayMentStragegy();
32.             default:mypayMent=new wxpayMentStragegy();
33.         }
34.     }
35. }

复制代码

代理模式

代理模式（Proxy Pattern）是结构型设计模式的一种，
定义如下：
为其他对象提供一种代理以控制对这个对象的访问。

这里使用jdk代理实当代理模式
长处：

• 增强功能：在不修改原始对象的情况下增长额外逻辑（如权限校验、日记、事务等）。
  
• 解耦结构：将业务逻辑与通用功能分离，代码更清晰、职责更单一。
  
• 机动控制：可以在调用前后做一些处置惩罚，好比安全控制、延迟加载、访问控制等。
  
• 支持动态扩展：通过 JDK 动态代理可根据接口生成代理对象，运行时更机动。
  

1. package com;
3. import java.awt.*;
4. import java.lang.reflect.InvocationHandler;
5. import java.lang.reflect.Method;
6. import java.lang.reflect.Proxy;
7. import java.lang.reflect.UndeclaredThrowableException;
9. public class ProxyModel {
10. }
13. interface UserDao{
14.     public void add();
15.     public void delete();
16. }
17. class UserDaoImpl implements UserDao{
19.     @Override
20.     public void add() {
21.         System.out.println("adding");
22.     }
24.     @Override
25.     public void delete() {
26.         System.out.println("deleteling");
27.     }
28. }
29. class UserProxy implements InvocationHandler{
30.     Object object;
31.     public UserProxy(Object obb){
32.         object=obb;
33.     }
35.     public Object getProxy(){
36.         return Proxy.newProxyInstance(object.getClass().getClassLoader(),object.getClass().getInterfaces(),this);
37.     }
38.     @Override
39.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
40.         System.out.println("代理加强前");
41.         Object invoke = method.invoke(object, args);
42.         System.out.println("代理加强后");
43.         return invoke;
44.     }
45. }

复制代码

单例模式

定义：

单例模式就是一个类只有一个实例，而且还提供这个实例的全局访问点（避免一个全局使用的类频仍创建和烧毁，耗费体系资源）
设计要素

• 一个私有的构造函数（确保只能由单例类自己创建实例）
  
• 一个私有的静态变量（确保只有一个实例）
  
• 一个公有的静态函数（给调用者提供调用方法）
  

单例类的构造方法不让其他人修改和使用；而且单例类自己只创建一个实例，这个实例，其他人也无法修改和直接使用；然后单例类提供一个调用方法，想用这个实例，只能调用。这样就确保了全局只创建了一次实例。
六种实现方式

懒汉式（线程不安全）

先不创建实例，当第一次被调用的时间再创建实例，延迟了实例化，不需要使用该类就不会实例化，节省了体系资源

线程不安全，如果多个线程同时进入了lazyd==null，此时如果还没有实例化，多个线程就会进行实例化，导致实例化了多个实例

1. package com;
3. public class LazyD {
4.     private static LazyD lazyd;
5.     private LazyD(){
6.         
7.     }
8.     public static LazyD getUniqueInstance(){
9.         if(lazyd==null){
10.             lazyd=new LazyD();
11.         }
12.         return lazyd;
13.     }
14. }

复制代码

饿汉式不管使用还是不使用这个实例，直接实例化好实例即可，然后如果需要使用的时间，直接调用方法即可

长处：提前实例化了，避免了线程不安全的问题
缺点：直接实例花了这个实例，不会再延迟实例化，如果体系没有使用这个实例，就会导致操作体系的资源浪费

1. package com;
3. public class HungryD {
4.     private static HungryD uniqueInstance=new HungryD();
5.    
6.     private HungryD(){};
7.    
8.     public static HungryD getUniqueInstance(){
9.         return uniqueInstance;
10.     }
11. }

复制代码

懒汉式（线程安全）

和基本的懒汉式的区别就是在get方法上 加了一把 锁。如此一来，多个线程访问，每次只有拿到锁的的线程可以或许进入该方法，避免了多线程不安全问题的出现。

1. package com;
3. public class Singletion {
4.    
5.     private static Singletion uniqueInstance;
6.    
7.     private Singletion(){};
8.    
9.     public static synchronized Singletion getUniqueInstance(){
10.         if(uniqueInstance==null){
11.             uniqueInstance=new Singletion();
12.         }
13.         return uniqueInstance;
14.     }
15. }

复制代码

双重校验锁实现（线程安全）

双重查抄锁定（Double-Check Locking）是一种对线程安全的懒汉式单例模式的优化。传统的线程安全懒汉式存在性能问题——即使单例已经创建，每次调用仍旧需要获取锁，导致性能下降。
而双重查抄锁定通过在加锁前先判断实例是否已存在，避免了不必要的锁开销：

• 如果实例已创建，直接返回实例，不进入加锁代码块，提拔了服从。
  
• 如果实例未创建，多个线程同时进入时，由于加锁机制，只有一个线程可以或许进入锁内创建实例，保证线程安全。
  

因此，只有在首次实例化时会发生线程壅闭，之后的调用都不会再产生锁竞争，从而实现了高效且安全的延迟初始化。
焦点就是对比懒汉式的线程安全版本有性能提拔
还有就是使用volatile关键字修饰uniqueInstance实例变量的缘故原由如下
实验 uniqueInstance = new Singleton(); 时，实际上分为三步：

• 为 uniqueInstance 分配内存
  
• 初始化 uniqueInstance
  
• 将 uniqueInstance 指向分配的内存所在
  

虽然正常顺序是 1 → 2 → 3，但 JVM 可能因指令重排导致实验顺序变为 1 → 3 → 2。
在单线程环境中这不会有问题，但在多线程环境下可能导致安全隐患：例如线程 A 实验了步骤 1 和 3，还未完成初始化（步骤 2），线程 B 看到 uniqueInstance 非空后直接使用它，结果是使用了未初始化的实例。
为避免这种情况，使用 volatile 关键字修饰 uniqueInstance，可以克制指令重排，确保多线程环境下实例的准确初始化和可见性，保证线程安全。

1. package com;
3. public class Singletion {
4.    
5.     private volatile static Singletion uniqueInstance;
6.    
7.     private Singletion(){};
8.    
9.     public static Singletion getUniqueInstance(){
10.         if(uniqueInstance==null){
11.             synchronized (Singletion.class){
12.                 if(uniqueInstance==null){
13.                     uniqueInstance=new Singletion();
14.                 }
15.             }
16.         }
17.         return uniqueInstance;
18.     }
19. }

复制代码

静态内部类实现（线程安全）

• 延迟加载机制
  

• 
  
  
  
  • 静态内部类 SingletonHolder 不会在类加载时初始化，只有在首次调用 getUniqueInstance() 方法并访问 SingletonHolder.INSTANCE 时才会被加载。
    
  • 此时 JVM 会保证 INSTANCE 的初始化过程是线程安全的，而且 仅实验一次。
    
  
  

• 线程安全保证
  

• 
  
  
  
  • 由于类加载机制的特性，JVM 会通过 类初始化锁（Class Initialization Lock） 确保 INSTANCE 的唯一性，无需额外同步代码。
    
  
  

• 优势总结
  

• 
  
  
  
  • 懒加载：实例仅在需要时创建，节省资源。
    
  • 线程安全：依赖 JVM 的类加载机制，无需双重查抄锁（DCL）或 synchronized。
    
  • 高性能：无锁竞争，访问服从高
    
  
  

1. package com;
3. public class Singletion {
4.     private Singletion(){};
5.     private static class SingletionHolder{
6.         private static final Singletion INSTANCE=new Singletion()l
7.     }
8.     public static Singletion getUniqueInstance(){
9.         return SingletionHolder.INSTANCE;
10.     }
11. }

复制代码

枚举类实现（线程安全）

枚举类的创建就是线程安全的，任何情况下都是单例的
枚举实现单例时，其实例的创建由 JVM 保证线程安全，且天然是单例。
长处

• 写法简便
  
• 天然线程安全
  
• 主动防止反射和反序列化攻击
  

关于反序列化问题

• 序列化：将 Java 对象转换为字节序列
  
• 反序列化：根据字节序列重建 Java 对象
  

通例单例模式在反序列化时可能会创建新的实例，破坏单例性。
为了避免这一问题，通常需要重写 readResolve() 方法来确保反序列化返回同一个实例：

1. package com;
3. public enum Singletion {
4.     INSTANCE;
5.     // 添加业务逻辑方法
6.     public void using() {
7.         // 实际功能逻辑写在这里
8.     }
9. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。