java中23种设计模式

蔚落 2022-01-30 10:59 273阅读 0赞

### **设计模式的六大原则：** ###

开闭原则（Open Close Principle）、里氏代换原则（Liskov Substitution Principle）、依赖倒转原则（Dependence Inversion Principle）接口隔离原则（Interface Segregation Principle）、迪米特法则（最少知道原则）（Demeter Principle）、合成复用原则（Composite Reuse Principle）

### **23种设计模式：** ###

**创建型模式：**单例模式、工厂模式、抽象工厂模式、建造者模式、原型模式。

**结构型模式：**适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式。

**行为型模式：**模版方法模式、命令模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式、状态模式、策略模式、职责链模式、访问者模式。

### **最常用的设计模式：** ###

**[单例模式][Link 1]、[工厂模式][Link 2]、[适配器模式][Link 3]、[策略模式][Link 4]、[模板方法模式][Link 5]、[观察者模式][Link 6]、[外观模式][Link 7]、代理模式**

以上模式是我们最常见常用的模式，最好都要会应用。

**单例的八种写法**：懒汉——线程不安全、懒汉——线程安全（两种）、饿汉、饿汉——变种、静态内部类、枚举、双重校验锁

package com.lzw.singleton;
    
    /**
     * 饿汉式  静态常量 -- 可用
     * 优点：简单；在类装载的时候就完成实例化；避免了线程同步问题
     * 缺点：在类装载的时候就完成实例化，没有达到Lazy Loading的效果。如果从始至终从未使用过这个实例，则会造成内存的浪费
     * @author lzw
     * @Date 2019年5月23日
     */
    public class Singleton {
    
    	private final static Singleton INSTANCE = new Singleton();
    	private Singleton() {}
    	public static Singleton getInstance() {
    		return INSTANCE;
    	}	
    }
    /**
     * 饿汉式 静态代码块 -- 可用
     * 分析：同上面的方式类似，这里将类实例化的过程放在了静态代码块中，也是在类装载的时候，就执行静态代码块中的代码，初始化类的实例；所以优缺点基本相同
     * @author lzw
     * @Date 2019年5月23日
     */
    class Singleton2 {
    
        private static Singleton2 instance;
        static {
            instance = new Singleton2();
        }
        private Singleton2() {}
        
        public static Singleton2 getInstance() {
            return instance;
        }
    }
    /**
     * 懒汉式 线程不安全 -- 不可用
     * 分析：这种起到了Lazy Loading的效果，但是只能在单线程下使用。多线程环境下是可不使用的。
     * 原因：如果在多线程下，一个线程进入了if (singleton3 == null)判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。
     * @author lzw
     * @Date 2019年5月23日
     */
    class Singleton3{
    	private static Singleton3 singleton3;
    	private Singleton3(){};
    	
    	public static Singleton3 getSingleton3(){
    		if (singleton3 == null) {
    			singleton3 = new Singleton3();
    		}
    		return singleton3;
    	}
    }
    /***
     * 懒汉式 同步方法 线程安全 -- 不推荐使用
     * 缺点：缺点：效率太低了，每个线程在想获得类的实例时候，执行getInstance()方法都要进行同步。而其实这个方法只执行一次实例化代码就够了，后面的想获得该类实例，直接return就行了
     * @author lzw
     * @Date 2019年5月23日
     */
    class Singleton4 {
    
        private static Singleton4 singleton4;
        private Singleton4() {}
    
        public static synchronized Singleton4 getInstance() {
            if (singleton4 == null) {
                singleton4 = new Singleton4();
            }
            return singleton4;
        }
    }
    /**
     * 懒汉式  同步代码块  线程安全 -- 不推荐使用
     * @author lzw
     * @Date 2019年5月23日
     */
    class Singleton5 {
    
        private static Singleton5 singleton5;
        private Singleton5() {}
    
        public static Singleton5 getInstance() {
            if (singleton5 == null) {
                synchronized (Singleton.class) {
                    singleton5 = new Singleton5();
                }
            }
            return singleton5;
        }
    }
    
    /**
     * 双重检查 -- 推荐使用
     * 优点：线程安全；延迟加载；效率较高
     * @author lzw
     * @Date 2019年5月23日
     */
    class Singleton6 {
    
        private static volatile Singleton6 singleton6;
        private Singleton6() {}
    
        public static Singleton6 getInstance() {
            if (singleton6 == null) {
                synchronized (Singleton6.class) {
                    if (singleton6 == null) {
                        singleton6 = new Singleton6();
                    }
                }
            }
            return singleton6;
        }
    }
    /**
     * 静态内部类 -- 推荐使用
     * 优点：避免了线程不安全，延迟加载，效率高
     * @author lzw
     * @Date 2019年5月23日
     */
    class Singleton7 {
    
        private static volatile Singleton7 singleton7;
        private Singleton7() {}
    
        public static Singleton7 getInstance() {
            if (singleton7 == null) {
                synchronized (Singleton.class) {
                    if (singleton7 == null) {
                        singleton7 = new Singleton7();
                    }
                }
            }
            return singleton7;
        }
    }
    /**
     * 枚举 -- 可用
     * 分析：在项目用的少
     * @author lzw
     * @Date 2019年5月23日
     */
    enum Singleton8 {
        INSTANCE;
        public void whateverMethod() {
        	System.out.println("我是枚举单利模式");
        }
    }

[Link 1]: https://blog.csdn.net/weixin_42228950/article/details/90484720
[Link 2]: https://blog.csdn.net/weixin_42228950/article/details/90516609
[Link 3]: https://blog.csdn.net/weixin_42228950/article/details/90746786
[Link 4]: https://blog.csdn.net/weixin_42228950/article/details/90691355
[Link 5]: https://blog.csdn.net/weixin_42228950/article/details/90714625
[Link 6]: https://blog.csdn.net/weixin_42228950/article/details/90575402
[Link 7]: https://blog.csdn.net/weixin_42228950/article/details/90669525