常用设计模式说明_class food { string foodname; public: food(string

常用设计模式汇总

一、单例模式

简言之，一个应用程序中，某个类的实例对象只有一个，你没办法去new，因为构造器是被private修饰的，一般通过getInstance()的方法来获取它们的实例。getInstance()的返回值是一个对象的引用，并不是一个新的实例，所以不要错误的理解成多个对象。

• 懒汉式（线程不安全）

public class Singleton {
 
 	private static Singleton singleton;

 	private Singleton() {}

 	public static Singleton getInstance() {
  		if (singleton == null) {
   			singleton = new Singleton();
  		}
  		return singleton;
 	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13

• 懒汉式（线程安全）

public class Singleton {  
    private static Singleton instance;  
    private Singleton (){}  
    public static synchronized Singleton getInstance() {  
    	if (instance == null) {  
        	instance = new Singleton();  
    	}  
    	return instance;  
    }  
}  
1
2
3
4
5
6
7
8
9
10

• 饿汉式写法

public class Singleton {  
    private static Singleton instance = new Singleton();  
    private Singleton (){}  
    public static Singleton getInstance() {  
    	return instance;  
    }  
}  
1
2
3
4
5
6
7

• 静态内部类

public class Singleton {  
    private static class SingletonHolder {  
    	private static final Singleton INSTANCE = new Singleton();  
    }  
    private Singleton (){}  
    public static final Singleton getInstance() {  
    	return SingletonHolder.INSTANCE;  
    }  
}  
1
2
3
4
5
6
7
8
9

• 枚举

public enum Singleton {  
    INSTANCE;  
    public void whateverMethod() {}  
} 
1
2
3
4

这种方式是Effective Java作者Josh Bloch提倡的方式，它不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象。

• 双重校验锁

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;  
    }  
} 
1
2
3
4
5
6
7
8
9
10
11
12
13
14

二、观察者模式

对象间一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。


假设有三个人，小美（女，28），老王和老李。小美很漂亮，很风骚，老王和老李是两个中年男屌丝，时刻关注着小美的一举一动。有一天，小美说了一句：我老公今天不在家，一个人好无聊啊～～～，这句话被老王和老李听到了，结果乐坏了，蹭蹭蹭，没一会儿，老王就冲到小美家门口了，于是进门了……啪～嘿嘿嘿～~ 在这里，小美是被观察者，老王和老李是观察者，被观察者发出一条信息，然后观察者们进行相应的处理，示例代码：

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

这个接口相当于老王和老李的电话号码，小美发送通知的时候就会拨打getMessage()这个电话，拨打电话就是调用接口

// 老王
public class LaoWang implements Person {

    private String name = "老王";

    public LaoWang() {}

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

}
1
2
3
4
5
6
7
8
9
10
11
12
13

// 老李
public class LaoLi implements Person {

    private String name = "老李";

    public LaoLi() {}

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

}
1
2
3
4
5
6
7
8
9
10
11
12
13

// 小美
public class XiaoMei {

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

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

     //遍历list，把自己的通知发送给所有暗恋自己的人
     public void notifyPerson() {
         for(Person person:list){
             person.getMessage("今天家里就我一个人，你们过来吧，谁先追到我我就跟谁嘿嘿嘿~");
         }
     }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

// 测试代码
public class Test {
    public static void main(String[] args) {
        XiaoMei xiaoMei = new XiaoMei();
        LaoWang laoWang = new LaoWang();
        LaoLi laoLi = new LaoLi();

        //老王和老李在小美那里都注册了一下
        xiaoMei.addPerson(laoWang);
        xiaoMei.addPerson(laoLi);

        //小美向老王和老李发送通知
        xiaoMei.notifyPerson();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

运行结果：

老王接到了小美打过来的电话，电话内容是：今天家里就我一个人，你们过来吧，谁先追到我我就跟谁嘿嘿嘿~
老李接到了小美打过来的电话，电话内容是–>今天家里就我一个人，你们过来吧，谁先追到我我就跟谁嘿嘿嘿~

三、装饰者模式

对已有的业务逻辑进一步的封装，使其增加额外的功能，如Java中的IO流就使用了装饰者模式，用户在使用的时候，可以任意组装，达到自己想要的效果。
举个栗子，我想吃汉堡，首先我需要一块肉，我喜欢吃奶油，在肉片上面加一点奶油，再放一点蔬菜，最后再用两片面包夹起来。那我们应该怎么来写代码呢？ 首先，我们需要写一个Food类，让其他所有食物都来继承这个类，看代码：

public class Food {

    private String foodName;

    public Food() {
    }

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

    public String make() {
        return foodName;
    };
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

然后我们写几个子类继承它：

// 面包类
public class Bread extends Food {

    private Food basicFood;

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

    public String make() {
        return basicFood.make()+" + 面包";
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

// 奶油类
public class Cream extends Food {

    private Food basicFood;

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

    public String make() {
        return basicFood.make()+" + 奶油";
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

//蔬菜类
public class Vegetable extends Food {

    private Food basicFood;

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

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

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

这几个类都是差不多的，构造方法传入一个Food类型的参数，然后在make方法中加入一些自己的逻辑，如果你还是看不懂为什么这么写，不急，你看看我的Test类是怎么写的，一看你就明白了

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

看到没有，一层一层封装，我们从里往外看：最里面我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();
    }
}
1
2
3
4
5
6
7
8

// 手机类
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;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

// 变压器
class VoltageAdapter {
    // 改变电压的功能
    public void changeVoltage() {
        System.out.println("正在充电...");
        System.out.println("原始电压：" + Phone.V + "V");
        System.out.println("经过变压器转换之后的电压：" + (Phone.V - 200) + "V");
    }
}
1
2
3
4
5
6
7
8
9

正在充电…
原始电压：220V
经过变压器转换之后的电压：20V

五、工厂模式

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

// 抽象产品类
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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

工厂方法模式：有四个角色，抽象工厂模式，具体工厂模式，抽象产品模式，具体产品模式。不再是由一个工厂类去实例化具体的产品，而是由抽象工厂的子类去实例化产品。

// 抽象产品角色
public interface Moveable {
    void run();
}

// 具体产品角色
public class Plane implements Moveable {
    @Override
    public void run() {
        System.out.println("plane....");
    }
}

public class Broom implements Moveable {
    @Override
    public void run() {
        System.out.println("broom.....");
    }
}

// 抽象工厂
public abstract class VehicleFactory {
    abstract Moveable create();
}

// 具体工厂
public class PlaneFactory extends VehicleFactory {
    public Moveable create() {
        return new Plane();
    }
}

public class BroomFactory extends VehicleFactory {
    public Moveable create() {
        return new Broom();
    }
}

// 测试类
public class Test {
    public static void main(String[] args) {
        VehicleFactory factory = new BroomFactory();
        Moveable m = factory.create();
        m.run();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

抽象工厂模式：与工厂方法模式不同的是，工厂方法模式中的工厂只生产单一的产品，而抽象工厂模式中的工厂生产多个产品

//抽象工厂类
public abstract class AbstractFactory {
    public abstract Vehicle createVehicle();
    public abstract Weapon createWeapon();
    public abstract Food createFood();
}

//具体工厂类，其中Food,Vehicle，Weapon是抽象类，
public class DefaultFactory extends AbstractFactory{
    @Override
    public Food createFood() {
        return new Apple();
    }
    @Override
    public Vehicle createVehicle() {
        return new Car();
    }
    @Override
    public Weapon createWeapon() {
        return new AK47();
    }
}

//测试类
public class Test {
    public static void main(String[] args) {
        AbstractFactory f = new DefaultFactory();
        Vehicle v = f.createVehicle();
        v.run();
        Weapon w = f.createWeapon();
        w.shoot();
        Food a = f.createFood();
        a.printName();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

六、代理模式（proxy）

有两种，静态代理和动态代理。
先说静态代理，很多理论性的东西我不讲，直接举例：
到了一定的年龄，我们就要结婚，结婚是一件很麻烦的事情，（包括那些被父母催婚的）。有钱的家庭可能会找司仪来主持婚礼，显得热闹，洋气～好了，现在婚庆公司的生意来了，我们只需要给钱，婚庆公司就会帮我们安排一整套结婚的流程。整个流程大概是这样的：家里人催婚->男女双方家庭商定结婚的黄道即日->找一家靠谱的婚庆公司->在约定的时间举行结婚仪式->结婚完毕
婚庆公司打算怎么安排婚礼的节目，在婚礼完毕以后婚庆公司会做什么，我们一概不知。。。别担心，不是黑中介，我们只要把钱给人家，人家会把事情给我们做好。所以，这里的婚庆公司相当于代理角色，现在明白什么是代理角色了吧。
代码实现请看：

//代理接口
public interface ProxyInterface {
 	//需要代理的是结婚这件事，如果还有其他事情需要代理，比如吃饭睡觉上厕所，也可以写
 	void marry();
}
1
2
3
4
5

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("结婚完毕，我们需要做后续处理，你们可以回家了，其余的事情我们公司来做");
 	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

看到没有，婚庆公司需要做的事情很多，我们再看看结婚家庭的代码:

public class NormalHome implements ProxyInterface{

 	@Override
 	public void marry() {
  		System.out.println("我们结婚啦～");
 	}
}
1
2
3
4
5
6
7

这个已经很明显了，结婚家庭只需要结婚，而婚庆公司要包揽一切，前前后后的事情都是婚庆公司来做，听说现在婚庆公司很赚钱的，这就是原因，干的活多，能不赚钱吗？
来看看测试类代码：

public class Test {
 	public static void main(String[] args) {
  		ProxyInterface proxyInterface = new WeddingCompany(new NormalHome());
  		proxyInterface.marry();
 	}
}
1
2
3
4
5
6

运行结果如下：

在我们预料中，结果正确，这就是静态代理。

关于静态代理和动态代理的区别，个人观点：
静态代理：是在java文件编译前，手动写好代理类对象。这样只能代理一类对象，即一类接口的类型。
动态代理：是通过反射原理，在程序运行的时候动态的生成的代理对象，所以可以代理任意的类对象。

动态代理
举例：我是周杰伦的歌迷。一直想点歌给周杰伦唱。要怎么办？直接找他，估计没时间搭理我，最有希望的就是找他的经纪人，通过经纪人，传达我想点的歌。这个时候这个经纪人就是代理。
代码示例：
1，周杰伦是一个歌手，我们首先创建一个Singer接口类，并声明一个点歌和告别的方法；

public interface Singer {
    /**
     * 根据歌名点歌
     * @param songName
     */
    public void orderSong(String songName);
    /**
     * 向观众告别
     * @param audienceName
     */
    public void sayGoodBye(String audienceName);
}
1
2
3
4
5
6
7
8
9
10
11
12

2，接下来创建周杰伦类并实现歌手接口；

public class Jay implements Singer {

    @Override
    public void orderSong(String songName) {
        System.out.println("演唱歌曲：" + songName);
    }

    @Override
    public void sayGoodBye(String audienceName) {
        System.out.println("再见：" + audienceName);
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13

3，就算我找到了经纪人（代理），那我也不能随便就叫经纪人通知（调用）周杰伦（目标对象）唱歌（的方法），我还要准备一个感人肺腑的故事，但是我又不会讲故事，这个时候，经纪人就提供给了我一个模板（调用处理类，一个接口），让我按照模板编写故事（实现invoke方法）；

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class MyStoryInvocationHandler implements InvocationHandler {

    private Object object;
    
    public MyStoryInvocationHandler(Object o) {
        this.object = o;
    }
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    
        System.out.println("Jay，我是你代理经纪人：" + proxy.getClass().getName());
        //处理业务
        System.out.println("巴拉巴拉......(讲了一个故事)");
        
        for(Object arg:args) {
            System.out.println("传入的参数：" + arg);
        }
        
        //通过反射机制，通知力宏做事情
        method.invoke(object, args);
        
        //处理业务
        System.out.println("巴拉巴拉，感谢......");
        
        return null;
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

代码中的method.invoke()方法使用到了反射机制。

4，OK，到这里所有的准备工作就完成了，接下来就开始吧。

import java.lang.reflect.Proxy;

public class MyPorxy {
    public static void main(String[] args) {
        //实例化目标对象（创造一个Jay）
        Jay jay = new Jay();
        //实例化调用处理类（编好的故事）
        MyStoryInvocationHandler handler = new MyStoryInvocationHandler(jay);
        
        //接下来创建代理（经纪人）
        
        //准备一个类加载器
        ClassLoader loader =   MyPorxy.class.getClassLoader();
        //获取目标对象的接口类对象数组
        Class<?>[] interfaces = jay.getClass().getInterfaces();
        
        //创建代理
        Singer proxy = (Singer) Proxy.newProxyInstance(loader, interfaces, handler);
        
        //开始点歌
        proxy.orderSong("告白气球");
        System.out.println("****** 歌唱中......********");
        //歌唱完了，say goodBye吧
        proxy.sayGoodBye("我的粉丝");
       
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

运行结果：
【CSDN编辑器的锅，我的省略号变短了…】

Jay，我是你代理经纪人：com.sun.proxy.$ Proxy0
巴拉巴拉…(讲了一个故事)
传入的参数：告白气球
演唱歌曲：告白气球
巴拉巴拉，感谢…
****** 歌唱中…********
Jay，我是你代理经纪人：com.sun.proxy.$ Proxy0
巴拉巴拉…(讲了一个故事)
传入的参数：我的粉丝
再见：我的粉丝
巴拉巴拉，感谢…

代理模式源码分析及详细角色等介绍各位可以百度其他作者作品~