JDK中常见的设计模式

JDK中常见的设计模式

单例模式（Singleton pattern）用于 Runtime，Calendar 和其他的一些类中。
工厂模式（Factory pattern）被用于各种不可变的类如 Boolean，像 Boolean.valueOf。
观察者模式（Observer pattern）被用于 Swing 和很多的事件监听中。
装饰器设计模式（Decoratordesign pattern）被用于多个 Java IO 类中。

单例模式

单例模式重点在于在整个系统上共享一些创建时较耗资源的对象。整个应用中只维护一个特定类实例，它被所有组件共同使用。Java.lang.Runtime 是单例模式的经典例子。从 Java5 开始你可以使用枚举（enum）来实现线程安全的单例。

代码

//懒汉  线程不安全(多线程不能正常运行)
public class SingletonOne {
   
    private static SingletonOne singletonOne;

    private SingletonOne(){
   }

    public static SingletonOne getInstance(){
   
        if(singletonOne == null){
   
            singletonOne = new SingletonOne();
        }
        return singletonOne;
    }
}
//懒汉  线程安全  效率很低  能在多线程很好的工作
public class SingletonTwo {
   
    private static SingletonTwo instance;

    private SingletonTwo(){
   }

    public static synchronized  SingletonTwo getInstance(){
   
        if(instance == null){
   
            instance = new SingletonTwo();
        }
        return instance;
    }
}
//饿汉
/**
 *  这种方式基于classloder机制避免了多线程的同步问题，不过，instance在类装载时就实例化，虽然导致类装载的原因有很多种，
 *  在单例模式中大多数都是调用getInstance方法， 但是也不能确定有其他的方式（或者其他的静态方法）导致类装载，
 *  这时候初始化instance显然没有达到lazy loading的效果。
 * */
public class SingletonThree {
   
    private static  SingletonThree instance = new SingletonThree();

    private SingletonThree(){
   }

    public static  SingletonThree getInstance(){
   
        return  instance;
    }
}
//双重锁校验
public class SingletonFive {
   
    private volatile  static SingletonFive instance;

    private  SingletonFive(){
   }

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

观察者模式

定义：在软件系统中，对象不是孤立存在的，一个对象行为的改变可能会导致一个或多个其他与之存在依赖关系的对象行为发生改变。

应用实例场景：

在多人联机对战的游戏中，多个玩家可以加入同一个战队组成联盟，当战队中的某一成员受到敌人攻击时将给所有其它盟友发送通知，盟友收到通知后做出响应。

结构图：

代码：

AllyControlCenter：指挥部类

package 设计模式.观察者模式;

import java.util.LinkedList;
import java.util.List;

abstract class AllyControlCenter {
   

    protected  String allyName;  //战队名称
    protected List<IObserver> players = new LinkedList<IObserver>();
    public String getAllyName() {
   
        return allyName;
    }
    public void setAllyName(String allyName) {
   
        this.allyName = allyName;
    }
    //注册方法
    public void Join(IObserver obs){
   
        System.out.println(obs.getName() + "加入" + this.allyName + "战队！");
        players.add(obs);
    }
    //注销方法
    public void Quit(IObserver obs){
   
        System.out.println(obs.getName() + "退出" + this.allyName + "战队！");
    }
    //声明抽象通知方法
    public abstract  void NotifyObserver(String name);
}

ConcreteAllyControlCenter：具体指挥部类

package 设计模式.观察者模式;
public class ConcreteAllyControlCenter extends AllyControlCenter {
   
    public ConcreteAllyControlCenter(String allyName){
   
        System.out.println(allyName + "战队组建成功！");
        System.out.println("-------------------------");
        this.allyName = allyName;
    }
    //实现通知方法
    @Override
    public void NotifyObserver(String name) {
   
        System