设计模式

1.单例模式

单例模式特点：1.单例类只能有一个实例（单例模式的构造方法是修饰符是private）

　　　　　　　2.单例类必须自己创建自己唯一的实例

　　　　　　　3.单例类必须给所有其他对象提供这一个实例

单例模式有多种写法

懒汉式：在第一次调用的时候，实例化自己

public class Singleton {
    //懒汉写法

    private static Singleton singleton;
    private Singleton(){

    }
    //线程不安全的写法
   /* public static Singleton getInstance(){
        if(singleton==null){
            Singleton singleton = new Singleton();
        }
        return singleton;
    }*/
   //线程安全的写法
    public static synchronized Singleton getInstance(){
        if(singleton==null){
            Singleton singleton = new Singleton();
        }
        return singleton;
    }

}

　　

饿汉式：对象创建的时候就被实例化，

public class SingleTonE {
    private static SingleTonE single = new SingleTonE();
    private SingleTonE(){

    }
    public static SingleTonE getInstance(){
        return single;
    }
}　　

 

　　饿汉式在类创建的同时就已经创建好一个静态的对象供系统使用，以后不再改变，所以是线程安全的。

静态内部类写法

public class Singleton {

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

}

　双重检查锁定

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;  
   }  
}

　　单例参考：https://blog.csdn.net/jason0539/article/details/23297037

　　　

2.观察者模式

     例子：瘦下来有俩个好朋友，一个是垒哥，一个是秋天，他俩时刻关注着瘦下来的状态，想要一起出去玩，瘦下来想要玩的时候，就发消息通知他们俩，通过这个接口，垒哥和秋天来接收小可爱的消息

　　

public interface Person {
     void  getMessage(String s);
}

　　垒哥和秋天来具体实现这个接口，垒哥的

public class WangLei implements Person {
    String name = "垒哥";
    public WangLei() {
        super();
    }

    @Override
    public void getMessage(String s) {
        System.out.println(name+"接到了瘦下来电话，内容是"+s);

    }
}

　　秋天的

public class QiuTian implements Person {
    String name = "秋天";
    @Override
    public void getMessage(String s) {
        System.out.println(name+"接到了瘦下来的电话，内容是"+s);
    }
}

　　瘦下来想出去玩，给好朋友发下消息

public class YaoHong {
　　　//这个是我的好朋友合集
    List<Person> peoples = new ArrayList<>();
　　　//拿个小本本把好朋友都存起来
    public void addPerson(Person p){
        peoples.add(p);
    }

　　//挨个通知他们，一起出去玩
    public void getNotifyPerson() {
        for (Person p:peoples){
            p.getMessage("我们一起去玩吧");
        }
    }
}

　　测试类

public class ViewTest {
    public static void main(String[] args) {
        QiuTian tian = new QiuTian();
        WangLei wangLei = new WangLei();
        YaoHong yaoHong = new YaoHong();
        yaoHong.addPerson(tian);
        yaoHong.addPerson(wangLei);
        yaoHong.getNotifyPerson();
    }
}

　　输出的结果为

 

 

 

通过上面栗子的介绍，来理解一下下面这段话。

观察者模式：一个被观察者管理所有相依与它的观察者物件，并且在本身的状态改变时主动发出通知，这通常通过呼叫各观察者所提供的方法来实现，此种模式通常被用来实现事件处理系统

角色：

　　抽象被观察者角色：被观察者提供一个接口，可以增加修改，删除观察者角色，一般用一个接口实现

　　抽象观察者角色：为所有具体的观察者定义一个接口，在得到主题时通知更新自己

　　具体被观察者角色：在被观察者内部状态发生改变时，给所有登记过的观察者发出通知，具体被观察者通过一个子类来实现。

　　具体观察者角色：该角色实现抽象观察者角色所需要的更新接口，以便使本身的状态与主题的状态相协调，通常用一个子类实现。如果需要，具体观察者角色可以保存一个指向具体主题的角色

在举个例子：珠宝商运送一批钻石，有黄金强盗准备抢劫，珠宝商雇佣了私人保镖，警察局也派人护送，于是当运输车上路的时候，强盗保镖警察都要观察运输车一举一动

抽象观察者：

public interface Watcher {
    public void update();
}

抽象被观察者：

public interface Watched {
    public void addWatcher(Watcher watcher);
    public void removeWatcher(Watcher watcher);
    public void notifyWatcher();

}　　

具体的观察者警察：

public class Police implements Watcher {
    @Override
    public void update() {
        System.out.println("运输车有行动，警察保护安全");
    }
}

具体的观察者强盗：

public class Thief implements Watcher {
    @Override
    public void update() {
        System.out.println("运输车有行动，强盗准备动手");
    }
}

具体的观察者保镖：

public class Security implements Watcher{
    @Override
    public void update() {
        System.out.println("运输车有行动，保镖保护安全");
    }
}

具体的被观察者钱：

public class Money implements Watched {
    List<Watcher> watcherList = new ArrayList<Watcher>();

    @Override
    public void addWatcher(Watcher watcher) {
        watcherList.add(watcher);

    }

    @Override
    public void removeWatcher(Watcher watcher) {
        watcherList.remove(watcher);
    }

    @Override
    public void notifyWatcher() {
        for (Watcher watcher:watcherList){
            watcher.update();
        }


    }
}

测试类：

public class test {
    public static void main(String[] args) {
        Money money = new Money();
        Police p = new Police();
        Security s = new Security();
        Thief t = new Thief();
        money.addWatcher(p);
        money.addWatcher(s);
        money.addWatcher(t);
        money.notifyWatcher();

    }
}

　　

参考链接：https://blog.csdn.net/jason0539/article/details/45055233

3.工厂模式

　　（1）工厂模式主要是为创建对象提供过渡接口，以便将创建对象的具体过程屏蔽隔离起来，达到提高灵活性的目的

　　工厂模式可以分为三类：　　

　　　　（1）简单工厂模式（Simple Factory）

　　　　（2）工厂方法模式（Factory Method）

　　　　（3）抽象工厂模式（Abstract Factory）

　　这三种模式从上到下逐步抽象，并且更具有一般性

　　(2)引言

　　　　1.还没有工厂时代：假如还没有工业革命，如果一个客户要一款宝马车，一般的做法是客户去创建一款宝马车，然后拿来用

　　　　2.简单工厂模式：后来出现了工业革命，用户不用去创建宝马车了，因为客户有一个工厂来帮他创建宝马，想要什么车，这个工厂就可以建。比如想要320i系列车，工厂就创建这个系列的车，即工厂可以创建产品。

　　　　3.工厂方法模式时代：为了满足客户，宝马系列越来越多，比如320i，523i，301i等系列一个工厂无法创建所有的宝马系列，于是由单独分出来多个具体的工厂，每个具体工厂创建一种系列。即具体工厂类只能创建一个具体产品。但是宝马工厂还是个抽象。你需要具体指定某个具体的工厂才能生产车出来

　　　　4.抽象工厂模式时代：随着客户的要求越来越高，宝马车必须配置空调，于是这个工厂开始生产宝马车和需要的空调

　　　　最终客户只要对宝马的销售人员说：我要523i空调车，销售人员就直接给他523i空调车了，而不用自己去创建523i空调宝马车了。

简单工厂模式又称为静态工厂模式。重命名上就可以看出这个模式一定很简单，它存在的目的很简单：定义一个用于创建对象的接口

 

参考链接：https://blog.csdn.net/jason0539/article/details/23020989

4.代理模式

5.策略模式

6.模板方法模式

（1）AbstractClass抽象类，类中实现了模板方法，定义了算法的骨架，聚体子类需要去实现其他的抽象方法。

（2）ConcreteClass实现抽象方法，以完成算法中特点子类的步骤

以顾客需要喝到不同口味的豆浆为例

抽象类

public abstract class soya {
    //模板方法
    public void make(){
        select();
        if (customWant()){
            addCondition();
        }
        solk();
        beat();
    }
    //选材
    public void select(){
        System.out.println("选择新鲜的黄豆");
    }
    public abstract void addCondition();
    public void solk(){
        System.out.println("开始浸泡");
    }
    public void beat(){
        System.out.println("开始打磨");
    }
    public boolean customWant(){
        return true;
    }
}

　喝红豆味的豆浆

public class RedSoya extends soya {
    @Override
    public void addCondition() {
        System.out.println("添加红豆");
    }
}

　　花生味豆浆

public class PeanuaSoya extends soya {
    @Override
    public void addCondition() {
        System.out.println("添加花生");
    }
}

　　纯豆浆

public class onlySoya extends soya{

    @Override
    public void addCondition() {
        return;
    }

    @Override
    public boolean customWant() {
        return false;
    }
}

　　

　测试

public class test {
    public static void main(String[] args) {
        soya redsoya = new RedSoya();
        redsoya.make();
        soya PeaunaSoya = new PeanuaSoya();
        PeaunaSoya.make();
        soya only = new onlySoya();
        only.make();
    }
}

　　测试结果

选择新鲜的黄豆
添加红豆
开始浸泡
开始打磨
选择新鲜的黄豆
添加花生
开始浸泡
开始打磨
选择新鲜的黄豆
开始浸泡
开始打磨

　　

7.装饰者模式 

　　对已有的业务逻辑的封装，增加额外的属性和功能，装饰者与被装饰者拥有共同的超类，继承的目的是继承类型而不是行为

　

//定义被装饰者
public interface Human {
	public void wearClothes();
 
	public void walkToWhere();
}
 
//定义装饰者
public abstract class Decorator implements Human {
	private Human human;
 
	public Decorator(Human human) {
		this.human = human;
	}
 
	public void wearClothes() {
		human.wearClothes();
	}
 
	public void walkToWhere() {
		human.walkToWhere();
	}
}
 
//下面定义三种装饰，这是第一个，第二个第三个功能依次细化，即装饰者的功能越来越多
public class Decorator_zero extends Decorator {
 
	public Decorator_zero(Human human) {
		super(human);
	}
 
	public void goHome() {
		System.out.println("进房子。。");
	}
 
	public void findMap() {
		System.out.println("书房找找Map。。");
	}
 
	@Override
	public void wearClothes() {
		// TODO Auto-generated method stub
		super.wearClothes();
		goHome();
	}
 
	@Override
	public void walkToWhere() {
		// TODO Auto-generated method stub
		super.walkToWhere();
		findMap();
	}
}
 
public class Decorator_first extends Decorator {
 
	public Decorator_first(Human human) {
		super(human);
	}
 
	public void goClothespress() {
		System.out.println("去衣柜找找看。。");
	}
 
	public void findPlaceOnMap() {
		System.out.println("在Map上找找。。");
	}
 
	@Override
	public void wearClothes() {
		// TODO Auto-generated method stub
		super.wearClothes();
		goClothespress();
	}
 
	@Override
	public void walkToWhere() {
		// TODO Auto-generated method stub
		super.walkToWhere();
		findPlaceOnMap();
	}
}
 
public class Decorator_two extends Decorator {
 
	public Decorator_two(Human human) {
		super(human);
	}
 
	public void findClothes() {
		System.out.println("找到一件D&G。。");
	}
 
	public void findTheTarget() {
		System.out.println("在Map上找到神秘花园和城堡。。");
	}
 
	@Override
	public void wearClothes() {
		// TODO Auto-generated method stub
		super.wearClothes();
		findClothes();
	}
 
	@Override
	public void walkToWhere() {
		// TODO Auto-generated method stub
		super.walkToWhere();
		findTheTarget();
	}
}
 
//定义被装饰者，被装饰者初始状态有些自己的装饰
public class Person implements Human {
 
	@Override
	public void wearClothes() {
		// TODO Auto-generated method stub
		System.out.println("穿什么呢。。");
	}
 
	@Override
	public void walkToWhere() {
		// TODO Auto-generated method stub
		System.out.println("去哪里呢。。");
	}
}
//测试类，看一下你就会发现，跟java的I/O操作有多么相似
public class Test {
	public static void main(String[] args) {
		Human person = new Person();
		Decorator decorator = new Decorator_two(new Decorator_first(
				new Decorator_zero(person)));
		decorator.wearClothes();
		decorator.walkToWhere();
	}
}
 

　　运行结果

 

 

參考：https://blog.csdn.net/jason0539/article/details/22713711

8.适配器模式

9.生产者消费者模式