设计模式总结

常见设计模式

• 单例模式
• 工厂模式
• 观察者模式
• 适配器模式
• 装饰者模式

单例模式

 /** 
 * 线程安全，但是效率非常低 
 * @author vanceinfo 
 * 
 */ 
public class SingletonTest {  
    private SingletonTest() {  
    }  
   
    private static SingletonTest instance;  
   
    public static synchronized SingletonTest getInstance() {  
        if (instance == null)  
            instance = new SingletonTest();  
        return instance;  
    }  
} 

/** 
 * 线程安全  并且效率高 
 * 
 */ 
public class SingletonTest {  
    private static SingletonTest instance;  
   
    private SingletonTest() {  
    }  
   
    public static SingletonTest getIstance() {  
        if (instance == null) {  
            synchronized (SingletonTest.class) {  
                if (instance == null) {  
                    instance = new SingletonTest();  
                }  
            }  
        }  
        return instance;  
    }  
} 

工厂模式

定义一个创建对象的接口，但由子类决定要实例化的类是哪一个。工厂方法模式把类实例化的过程推迟到子类。

interface Animal { // 定义一个动物的接口 
    public void say(); // 说话方法 
}  
   
class Cat implements Animal { // 定义子类Cat 
    @Override 
    public void say() { // 覆写say()方法 
        System.out.println("我是猫咪，喵呜！");  
    }  
}  
   
class Dog implements Animal { // 定义子类Dog 
   
    @Override 
    public void say() { // 覆写say()方法 
        System.out.println("我是小狗，汪汪！");  
    }  
}  
   
class Factory { // 定义工厂类 
    public static Animal getInstance(String className) {  
        Animal a = null; // 定义接口对象 
        if ("Cat".equals(className)) { // 判断是哪个子类的标记 
            a = new Cat(); // 通过Cat子类实例化接口 
        }  
        if ("Dog".equals(className)) { // 判断是哪个子类的标记 
            a = new Dog(); // 通过Dog子类实例化接口 
        }  
        return a;  
    }  
}  
   
public class FactoryDemo {  
   
    public static void main(String[] args) {  
        Animal a = null; // 定义接口对象 
        a = Factory.getInstance(args[0]); // 通过工厂获取实例 
        if (a != null) { // 判断对象是否为空 
            a.say(); // 调用方法  
        }  
    }  
} 

发布-订阅模式 和 观察者模式【细微区别】

【丰声消息发布事件属于观察者模式；kafka推送属于发布-订阅模式】

在观察者模式中，观察者是知道Subject的，Subject一直保持对观察者进行记录。
然而在发布-订阅模式，消息的发送方，叫做发布者（publishers），消息不会直接发送给特定的接收者（订阅者）。
它们只有通过（调度中心）消息代理进行通信。

package observer;

import java.util.ArrayList;
import java.util.List;

public class MagazineSubject implements Subject{
    //存放订阅者
    private List<Observer> observers=new ArrayList<Observer>();
    //期刊版本
    private int version;

    @Override
    public void addObserver(Observer obj) {
        observers.add(obj);
    }

    @Override
    public void deleteObserver(Observer obj) {
        int i = observers.indexOf(obj);
        if(i>=0){
            observers.remove(obj);
        }
    }

    @Override
    public void notifyObserver() {
        for(int i=0;i<observers.size();i++){
            Observer o=(Observer)observers.get(i);
            o.update(version);
        }
    }

    //该杂志发行了新版本
    public void publish(){
        //新版本
        this.version++;
        //信息更新完毕，通知所有观察者
        notifyObserver();
    }
}

（4）观察者实现类

package observer;

public class CustomerObserver implements Observer{
    //订阅者名字
    private String name;
    private int version;

    public CustomerObserver(String name){
        this.name = name;
    }

    @Override
    public void update(int version) {
        this.version=version;
        System.out.println("该杂志出新版本了");
        this.buy();
    }

    public void buy(){
        System.out.println(name+"购买了第"+version+"期的杂志!");
    }

}
--------------------- 
原文：https://blog.csdn.net/chengyuqiang/article/details/79222294 

适配器模式（适配性） inputStreamReader IO流

定义：将一个类的接口转换成客户期望的另一个接口，适配器让原本接口不兼容的类可以相互合作。

以充电器为实例: 手机充电器一般都是5V左右吧，咱天朝的家用交流电压220V，所以手机充电需要一个适配器（降压器）


最后测试：给手机冲个电：

Mobile mobile = new Mobile();
V5Power v5Power = new V5PowerAdapter(new V200Power());
mobile.inputPower(v5Power);

原文：https://blog.csdn.net/wmq880204/article/details/75106848 

装饰器模式（增加功能）

装饰器模式又称为包装（Wrapper）模式。装饰器模式以多客户端透明的方式扩展对象的功能，是继承关系的一个替代方案。装饰器模式在Java体系中的经典应用是Java I/O，如输入流InputStream，字符输入流Reader