Java常用的设计模式

一.单例模式

Singleton是一种创建型模式，指某个类使用了Singleton模式，则这个类被创建后，只能产生一个实例供外部访问，并且提供一个全局的访问点。单例设计模式指的就是无论程序如何运行，采用单例设计模式的类（Singleton）永远都只会有一个实例化对象产生。

具体实现步骤::

1).在其内部产生该类的实例化对象，并将其封装成private static类型；

2).将采用单例设计模式的类的构造方法私有化；

3).定义一个静态方法返回该类的实例。

---

（1）懒汉式写法（线程不安全）：

public class Singleton {
	private static Singleton singleton;

	private Singleton() {
	}

	public static Singleton getInstance() {
 		if (singleton == null) {
 			 singleton = new Singleton();
 		}
 		return singleton;
	}
}

上面的是最基本的单例模式（懒汉写法）的写法，线程不安全版本，下面我再公布几种单例模式的写法：

（2）懒汉式写法（线程安全）

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

synchronized保证了安全性

（3）饿汉式写法

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

（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 method() {  
   }  
}

（6）双重校验锁

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

二.观察者模式

对象间一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。
观察者设计模式，比如：现在许多购房者都密切观察者房价的变化，当房价变化时，所有的购房者都能观察到，以上的购房者属于观察者，这就是观察者设计模式

举个栗子：假设有三个人，小美，小王和小李。小美很漂亮，小王和小李是两个程序猿，时刻关注着小美的一举一动。有一天，小美说了一句：“谁来陪我打游戏啊。”这句话被小王和小李听到了，结果乐坏了，蹭蹭蹭，没一会儿，小王就冲到小美家门口了，在这里，小美是被观察者，小王和小李是观察者，被观察者发出一条信息，然后观察者们进行相应的处理，看代码：

public interface Person {
   //小王和小李通过这个接口可以接收到小美发过来的消息
   void getMessage(String s);
}

小王和小李的代码：

public class LaoWang implements Person {
   private String name = "小王";

   public LaoWang() {
   }

   @Override
   public void getMessage(String s) {
       System.out.println(name + "接到了小美打过来的电话，电话内容是：" + s);
   }
}

public class LaoLi implements Person {
   private String name = "小李";

   public LaoLi() {
   }

   @Override
   public void getMessage(String s) {
       System.out.println(name + "接到了小美打过来的电话，电话内容是：->" + s);
   }
}

小美的代码：

public class XiaoMei {
    List<Person> list = new ArrayList<>();
    
    public XiaoMei(){
    }

    public void addPerson(Person person){
        list.add(person);
    }

    //遍历list，把自己的通知发送给所有暗恋自己的人
    public void notifyPerson() {
        for(Person person:list){
            person.getMessage("你们过来吧，谁先过来谁就能陪我一起玩儿游戏!");
        }
    }
}

测试类：

public class Test {
   public static void main(String[] args) {
       XiaoMei xiao_mei = new XiaoMei();
       LaoWang lao_wang = new LaoWang();
       LaoLi lao_li = new LaoLi();

       //把小王和小李添加到暗恋小美的列表
       xiao_mei.addPerson(lao_wang);
       xiao_mei.addPerson(lao_li);

       //小美向小王和小李发送通知
       xiao_mei.notifyPerson();
   }
}

结果正确

三.装饰者模式

对已有的业务逻辑更进一步的封装，使其增加额外的功能。如Java中的IO流就使用了装饰者模式，用户在使用的时候，可以任意组装，达到自己想要的效果。

举个栗子：
我想吃三明治，首先我需要一根大大的香肠，我喜欢吃奶油，在香肠上面加一点奶油，再放一点蔬菜，最后再用两片面包夹一下，就是一个三明治了。

首先，我们需要写一个Food类，让其他所有食物都来继承这个类，看代码：

public class Food {
   private String food_name;

   public Food() {
   }

   public Food(String food_name) {
       this.food_name = food_name;
   }

   public String make() {
       return food_name;
   };
}

蔬菜相关的类：

//面包类
public class Bread extends Food {
   private Food basic_food;

   public Bread(Food basic_food) {
       this.basic_food = basic_food;
   }

   public String make() {
       return basic_food.make()+"+面包";
   }
}

//奶油类
public class Cream extends Food {
   private Food basic_food;

   public Cream(Food basic_food) {
       this.basic_food = basic_food;
   }

   public String make() {
       return basic_food.make()+"+奶油";
   }
}

//蔬菜类
public class Vegetable extends Food {
   private Food basic_food;

   public Vegetable(Food basic_food) {
       this.basic_food = basic_food;
   }

   public String make() {
       return basic_food.make()+"+蔬菜";
   }

}

测试类：

public class Test {
   public static void main(String[] args) {
       Food food = new Bread(new Vegetable(new Cream(new Food("香肠"))));
       System.out.println(food.make());
   }
}

一层一层封装，我们从里往外看：最里面我new了一个香肠，在香肠的外面我包裹了一层奶油，在奶油的外面我又加了一层蔬菜，最外面我放的是面包。

运行结果：香肠+奶油+蔬菜+面包

四.适配器模式

将两种完全不同的事物联系到一起，就像现实生活中的变压器。

举一个例子：
假设一个手机充电器需要的电压是20V，但是正常的电压是220V，这时候就需要一个变压器，将220V的电压转换成20V的电压进行充电，这样，变压器就将20V的电压和手机联系起来了。

public class Test {
   public static void main(String[] args) {
       Phone phone = new Phone();
       VoltageAdapter adapter = new VoltageAdapter();
       phone.setAdapter(adapter);
       phone.charge();
   }
}

// 手机类
class Phone {
   public static final int V = 220;// 正常电压220v，是一个常量
   private VoltageAdapter adapter;

   // 充电
   public void charge() {
       adapter.changeVoltage();
   }

   public void setAdapter(VoltageAdapter adapter) {
       this.adapter = adapter;
   }
}

// 变压器
class VoltageAdapter {

   // 改变电压的功能
   public void changeVoltage() {
       System.out.println("正在充电...");
       System.out.println("原始电压：" + Phone.V + "V");
       System.out.println("经过变压器转换之后的电压:" + (Phone.V - 200) + "V");
   }
}

五.工厂模式

主要用来实例化有共同接口的类，工厂模式可以动态决定应该实例化那一个类。具体做法即程序在接口和子类之间加入了一个过渡端，通过此过渡端可以动态取得实现了共同接口的子类实例化对象。

工厂模式主要有以下几种形态：

1）简单工厂（SimpleFactory）；

2）工厂方法（FactoryMethod）；

3）抽象工厂（AbstractFactory）；

---

（1）简单工厂模式：一个抽象的接口，多个抽象接口的实现类，一个工厂类，用来实例化抽象的接口

// 抽象产品类
abstract class Car {
   public void run();

   public void stop();
}

// 具体实现类
class Benz implements Car {
   public void run() {
       System.out.println("Benz开始启动了。。。。。");
   }

   public void stop() {
       System.out.println("Benz停车了。。。。。");
   }
}

class Ford implements Car {
   public void run() {
       System.out.println("Ford开始启动了。。。");
   }

   public void stop() {
       System.out.println("Ford停车了。。。。");
   }
}

// 工厂类
class Factory {
   public static Car getCarInstance(String type) {
       Car c = null;
       if ("Benz".equals(type)) {
           c = new Benz();
       }
       if ("Ford".equals(type)) {
           c = new Ford();
       }
       return c;
   }
}

public class Test {

   public static void main(String[] args) {
       Car c = Factory.getCarInstance("Benz");
       if (c != null) {
           c.run();
           c.stop();
       } else {
           System.out.println("造不了这种汽车。。。");
       }

   }

}

六.代理模式：静态代码和动态代理

1.什么叫代理?

举一个栗子：
到了一定的年龄，我们就要结婚，婚庆公司就会帮我们安排一整套结婚的流程。
婚庆公司打算怎么安排婚礼的节目，在婚礼完毕以后婚庆公司会做什么，我们一概不知。。这里的婚庆公司就相当于代理角色。

（1）静态代理

//代理接口
public interface ProxyInterface {
	//需要代理的是结婚这件事
	void marry();
}

婚庆公司代码：

public class WeddingCompany implements ProxyInterface {
	private ProxyInterface proxyInterface;

	public WeddingCompany(ProxyInterface proxyInterface) {
 		this.proxyInterface = proxyInterface;
	}

	@Override
	public void marry() {
 		System.out.println("我们是婚庆公司的");
 		System.out.println("我们在做结婚前的准备工作");
 		System.out.println("节目彩排...");
 		System.out.println("礼物购买...");
 		System.out.println("工作人员分工...");
 		System.out.println("可以开始结婚了");
 		
 		proxyInterface.marry();
 		
 		System.out.println("结婚完毕，我们需要做后续处理，你们可以回家了，其余的													事情我们公司来做");
}

}

结婚家庭代码：

public class NormalHome implements ProxyInterface{

	@Override
	public void marry() {
 		System.out.println("我们结婚啦～");
	}
}

测试类：

public class Test {
	public static void main(String[] args) {
 		ProxyInterface proxyInterface = new WeddingCompany(new NormalHome());
 		proxyInterface.marry();
	}
}

（2）动态代理

与反射知识有关！