java中23种设计模式

 

设计模式的六大原则：

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

23种设计模式：

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

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

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

最常用的设计模式：

单例模式、工厂模式、适配器模式、策略模式、模板方法模式、观察者模式、外观模式、代理模式

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

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

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("我是枚举单利模式");
    }
}