java补充知识点(2)——设计模式

23种设计模式

总体来说设计模式分为三大类：

创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。

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

行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

其实还有两类：并发型模式和线程池模式。

设计模式六大原则：
https://blog.csdn.net/weixin_45044097/article/details/99285995

二十三种设计模式 参考博客：
https://blog.csdn.net/jason0539/article/details/44956775
https://www.cnblogs.com/welan/p/9005019.html
http://c.biancheng.net/design_pattern/

1 单例模式

该类只能有一个实例，为了实现这一功能，必须隐藏类的构造函数，即把构造函数声明为private，并提供一个创建对象的方法（getInstance），由于构造对象被声明为private，外界无法直接创建这个类型的对象，只能通过该类提供的方法来获取类的对象，要达到这样的目的只能把创建对象的方法声明为static。
单例应用场景：
这个对象想让整个应用程序访问并且访问同一个对象，这个时候就可以用单例模式。

1 懒汉式

一开始不赋值，在要这个对象的时候，先看看有没有这个对象，没有再创建。

1.1 线程不安全

不支持多线程，线程不安全。
这种方式是最基本的实现方式，这种实现最大的问题就是不支持多线程。因为没有加锁 synchronized，所以严格意义上它并不算单例模式。

public class SingleLazyModel {
	private static SingleLazyModel singleLazyModel;
	private SingleLazyModel() {}
	// 提供一个共有的方法来获得对象
	public static SingleLazyModel getSingleLazyModel() {//getIntaneace
		if(singleLazyModel == null){
            singleLazyModel = new SingleLazyModel();//只会运行一次
            System.out.println("-----------------");
        }
        return  singleLazyModel;		
	}	
}

1.2 线程安全

能够在多线程中很好的工作，但是，效率很低，99% 情况下不需要同步。
优点：第一次调用才初始化，避免内存浪费。
缺点：必须加锁 synchronized 才能保证单例，但加锁会影响效率。
getInstance() 的性能对应用程序不是很关键（该方法使用不太频繁）

public class Singleton {  
    private static Singleton instance;  
    private Singleton (){}  
    public static synchronized Singleton getInstance() {  
	    if (instance == null) {  
	        instance = new Singleton();  
	    }  
	    return instance;  
    }  
}

2 饿汉式

一开始就赋值
这种方式比较常用，但容易产生垃圾对象。
优点：没有加锁，执行效率会提高。
缺点：类加载时就初始化，浪费内存。
它基于 classloader 机制避免了多线程的同步问题，不过，instance 在类装载时就实例化，虽然导致类装载的原因有很多种，在单例模式中大多数都是调用 getInstance 方法， 但是也不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化 instance 显然没有达到 lazy loading 的效果。

public class SingleHungryModel {
	private static SingleHungryModel singleHungryModel = new SingleHungryModel();
    private  SingleHungryModel(){}

    //提供一个公有的方法来获得对象
    public static SingleHungryModel getSingleHungryModel(){//getIntaneace
    	if(singleHungryModel == null){
            singleHungryModel = new SingleHungryModel();//只会运行一次
            System.out.println("-----------------");
        }
        return singleHungryModel;
    }
}

3 扩展：双重检查锁定

双检锁/双重校验锁（DCL，即 double-checked locking）
采用双锁机制，安全且在多线程情况下能保持高性能。

public class Singleton {  
    private volatile static Singleton singleton;  
    private Singleton (){}  
    public static Singleton getSingleton() {  
	    if (singleton == null) {  
	        synchronized (Singleton.class) {  
		        if (singleton == null) {  
		            singleton = new Singleton();  
		        }  
	        }  
	    }  
	    return singleton;  
    }  
}

4 扩展：登记式/静态内部类

能达到双检锁方式一样的功效，但实现更简单。对静态域使用延迟初始化，应使用这种方式而不是双检锁方式。这种方式只适用于静态域的情况，双检锁方式可在实例域需要延迟初始化时使用。

public class Singleton {  
    private static class SingletonHolder {  
    	private static final Singleton INSTANCE = new Singleton();  
    }  
    private Singleton (){}  
    public static final Singleton getInstance() {  
    	return SingletonHolder.INSTANCE;  
    }  
}

5 枚举

public enum Singleton {  
    INSTANCE;  
    public void whateverMethod() {  
    }  
}

经验之谈：一般情况下，不建议使用第 1 种和第 2 种懒汉方式，建议使用饿汉方式。只有在要明确实现 lazy loading 效果时，才会使用登记方式。如果涉及到反序列化创建对象时，可以尝试使用枚举方式。如果有其他特殊的需求，可以考虑使用双检锁方式。

23种设计模式参考博客：
https://blog.csdn.net/jason0539/article/details/44956775

2 工厂模式

2.1 原生工厂模式

public class PaiZhaoFactory {
    private static  PaiZhao paiZhao;
	public void setPaiZhao(String name) {
		if(name != null) {
			if(name.equals("手机")) {
				this.paiZhao = new ShouJi();
            } else if(name.equals("照相机")) {
            	this.paiZhao = new ZhaoXiangJi();
        }
    }
}

<bean name="shouji" class="other.ShouJi"></bean>
<bean name="zhaoxiangji" class="other.ZhaoXiangJi"></bean>

<bean name="paizhao" class="other.PaiZhaoFactory" >
	<property name="paiZhao"  ref="zhaoxiangji"></property>
</bean>

修改ref，很麻烦，每个都要配置！so，有了以下方法…

2.2 Spring工厂模式

在实际的项目中，工厂模式是开发必备的处理规则，而我们原始的工厂模式前面已经讲述过，代码之间的依赖度太高，耦合性太强，并不利于项目后期的升级、维护和优化，那么我们来看看spring怎样完成工厂模式的注入。
什么是耦合、解耦，参考博客：https://blog.csdn.net/shenwansangz/article/details/82284957
我们需要创建一个父接口，创建一个子实现类，然后还需要一个控制器，最后通过spring的xml配置完成工厂模式：
父接口：

public interface PaiZhao {
    public void pic();
}

子实现类

public class ShouJi implements PaiZhao {
    @Override
    public void pic() {
        System.out.println("---像素4800w--");
    }
}

public class ZhaoXiangJi  implements PaiZhao {
    @Override
    public void pic() {
        System.out.println("-------16000w像素----");
    }
}

工厂类：

public class PaiZhaoFactory {
    private static  PaiZhao paiZhao;
    public PaiZhao setShouJi() {
        return new ShouJi();
    }
    public ZhaoXiangJi setZhaoXiangJi(){
        return new ZhaoXiangJi();
    }
}

spring.xml配置：

<bean name="factoryName" class="static_factory.PaiZhaoFactory"></bean>

<bean name="shouji1" factory-bean="factoryName" factory-method="setShouJi"></bean>

<bean name="zhaoxiangji" factory-bean="factoryName" factory-method="setZhaoXiangJi"></bean>

测试类：

public class TestFactory {
    static ApplicationContext context;
    @BeforeClass
    static public void getXMl() {
        context = new ClassPathXmlApplicationContext("spring2.xml");
    }
    @AfterClass
    static public void close() {
        System.out.println("---测试结束---");
    }
    @Test
    public void getObject(){
        //向上转型
        PaiZhao paiZhao = context.getBean("zhaoxiangji",PaiZhao.class);
        paiZhao.pic();
        //其本身的类型
        ZhaoXiangJi zhaoXiangJi = context.getBean("zhaoxiangji",ZhaoXiangJi.class);
        zhaoXiangJi.pic();
    }
    //  service  interface   impl
    //  userService = new UserServiceImpl  对接口开发
}

3 抽象工厂模式

参考博客：https://www.runoob.com/design-pattern/abstract-factory-pattern.html

4 代理模式

点击这儿跳转查看相关：
https://blog.csdn.net/weixin_45044097/article/details/107283429

5 观察者模式

这是学到android的时候延伸出来的，所以案例也是android的。
观察者模式参考：https://blog.csdn.net/weixin_45044097/article/details/107283493