Java中常用的设计模式

1 单例模式

简单点说，就是一个应用程序中，某个类的实例对象只有一个，你没有办法去new，因为构造器是被private修饰的，一般通过getInstance()的方法来获取它们的实例。

getInstance()的返回值是一个对象的引用，并不是一个新的实例，所以不要错误的理解成多个对象。

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

懒汉式写法（线程安全）

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

饿汉式写法

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

静态内部类

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

枚举

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

双重校验锁

 1 public class Singleton {
 2    private volatile static Singleton singleton;
 3    private Singleton (){}
 4    public static Singleton getSingleton() {
 5    if (singleton == null) {
 6        synchronized (Singleton.class) {
 7        if (singleton == null) {
 8            singleton = new Singleton();
 9        }
10        }
11    }
12    return singleton;
13    }
14 }

2 观察者模式

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

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

 1 public class LaoWang implements Person {
 2
 3    private String name = "小王";
 4
 5    public LaoWang() {
 6    }
 7
 8    @Override
 9    public void getMessage(String s) {
10        System.out.println(name + "接到了小美打过来的电话，电话内容是：" + s);
11    }
12
13 }
14
15 public class LaoLi implements Person {
16
17    private String name = "小李";
18
19    public LaoLi() {
20    }
21
22    @Override
23    public void getMessage(String s) {
24        System.out.println(name + "接到了小美打过来的电话，电话内容是：->" + s);
25    }
26
27 }

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 public class Test {
 3    public static void main(String[] args) {
 4
 5        XiaoMei xiao_mei = new XiaoMei();
 6        LaoWang lao_wang = new LaoWang();
 7        LaoLi lao_li = new LaoLi();
 8
 9        //小王和小李在小美那里都注册了一下
10        xiao_mei.addPerson(lao_wang);
11        xiao_mei.addPerson(lao_li);
12
13        //小美向小王和小李发送通知
14        xiao_mei.notifyPerson();
15    }
16 }

3 装饰者模式

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

 1 public class Food {
 2
 3    private String food_name;
 4
 5    public Food() {
 6    }
 7
 8    public Food(String food_name) {
 9        this.food_name = food_name;
10    }
11
12    public String make() {
13        return food_name;
14    };
15 }

 1 //面包类
 2 public class Bread extends Food {
 3
 4    private Food basic_food;
 5
 6    public Bread(Food basic_food) {
 7        this.basic_food = basic_food;
 8    }
 9
10    public String make() {
11        return basic_food.make()+"+面包";
12    }
13 }
14
15 //奶油类
16 public class Cream extends Food {
17
18    private Food basic_food;
19
20    public Cream(Food basic_food) {
21        this.basic_food = basic_food;
22    }
23
24    public String make() {
25        return basic_food.make()+"+奶油";
26    }
27 }
28
29 //蔬菜类
30 public class Vegetable extends Food {
31
32    private Food basic_food;
33
34    public Vegetable(Food basic_food) {
35        this.basic_food = basic_food;
36    }
37
38    public String make() {
39        return basic_food.make()+"+蔬菜";
40    }
41
42 }

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

4 适配器模式

将两种完全不同的事物联系到一起，就像现实生活中的变压器。假设一个手机充电器需要的电压是20V，但是正常的电压是220V，这时候就需要一个变压器，将220V的电压转换成20V的电压，这样，变压器就将20V的电压和手机联系起来了。

 1 public class Test {
 2    public static void main(String[] args) {
 3        Phone phone = new Phone();
 4        VoltageAdapter adapter = new VoltageAdapter();
 5        phone.setAdapter(adapter);
 6        phone.charge();
 7    }
 8 }
 9
10 // 手机类
11 class Phone {
12
13    public static final int V = 220;// 正常电压220v，是一个常量
14
15    private VoltageAdapter adapter;
16
17    // 充电
18    public void charge() {
19        adapter.changeVoltage();
20    }
21
22    public void setAdapter(VoltageAdapter adapter) {
23        this.adapter = adapter;
24    }
25 }
26
27 // 变压器
28 class VoltageAdapter {
29    // 改变电压的功能
30    public void changeVoltage() {
31        System.out.println("正在充电...");
32        System.out.println("原始电压：" + Phone.V + "V");
33        System.out.println("经过变压器转换之后的电压:" + (Phone.V - 200) + "V");
34    }
35 }

5 工厂模式

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

 1 // 抽象产品类
 2 abstract class Car {
 3    public void run();
 4
 5    public void stop();
 6 }
 7
 8 // 具体实现类
 9 class Benz implements Car {
10    public void run() {
11        System.out.println("Benz开始启动了。。。。。");
12    }
13
14    public void stop() {
15        System.out.println("Benz停车了。。。。。");
16    }
17 }
18
19 class Ford implements Car {
20    public void run() {
21        System.out.println("Ford开始启动了。。。");
22    }
23
24    public void stop() {
25        System.out.println("Ford停车了。。。。");
26    }
27 }
28
29 // 工厂类
30 class Factory {
31    public static Car getCarInstance(String type) {
32        Car c = null;
33        if ("Benz".equals(type)) {
34            c = new Benz();
35        }
36        if ("Ford".equals(type)) {
37            c = new Ford();
38        }
39        return c;
40    }
41 }
42
43 public class Test {
44
45    public static void main(String[] args) {
46        Car c = Factory.getCarInstance("Benz");
47        if (c != null) {
48            c.run();
49            c.stop();
50        } else {
51            System.out.println("造不了这种汽车。。。");
52        }
53
54    }
55
56 }

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

 1 // 抽象产品角色
 2 public interface Moveable {
 3    void run();
 4 }
 5
 6 // 具体产品角色
 7 public class Plane implements Moveable {
 8    @Override
 9    public void run() {
10        System.out.println("plane....");
11    }
12 }
13
14 public class Broom implements Moveable {
15    @Override
16    public void run() {
17        System.out.println("broom.....");
18    }
19 }
20
21 // 抽象工厂
22 public abstract class VehicleFactory {
23    abstract Moveable create();
24 }
25
26 // 具体工厂
27 public class PlaneFactory extends VehicleFactory {
28    public Moveable create() {
29        return new Plane();
30    }
31 }
32
33 public class BroomFactory extends VehicleFactory {
34    public Moveable create() {
35        return new Broom();
36    }
37 }
38
39 // 测试类
40 public class Test {
41    public static void main(String[] args) {
42        VehicleFactory factory = new BroomFactory();
43        Moveable m = factory.create();
44        m.run();
45    }
46 }

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

 1 //抽象工厂类
 2 public abstract class AbstractFactory {
 3    public abstract Vehicle createVehicle();
 4    public abstract Weapon createWeapon();
 5    public abstract Food createFood();
 6 }
 7 //具体工厂类，其中Food,Vehicle，Weapon是抽象类，
 8 public class DefaultFactory extends AbstractFactory{
 9    @Override
10    public Food createFood() {
11        return new Apple();
12    }
13    @Override
14    public Vehicle createVehicle() {
15        return new Car();
16    }
17    @Override
18    public Weapon createWeapon() {
19        return new AK47();
20    }
21 }
22 //测试类
23 public class Test {
24    public static void main(String[] args) {
25        AbstractFactory f = new DefaultFactory();
26        Vehicle v = f.createVehicle();
27        v.run();
28        Weapon w = f.createWeapon();
29        w.shoot();
30        Food a = f.createFood();
31        a.printName();
32    }
33 }

6 代理模式之静态代理

整个流程大概是这样的：家里人催婚->男女双方家庭商定结婚的黄道即日->找一家靠谱的婚庆公司->在约定的时间举行结婚仪式->结婚完毕

1 //代理接口
2 public interface ProxyInterface {
3 //需要代理的是结婚这件事，如果还有其他事情需要代理，比如吃饭睡觉上厕所，也可以写
4 void marry();
5 //代理吃饭(自己的饭，让别人吃去吧)
6 //void eat();
7 //代理拉屎，自己的屎，让别人拉去吧
8 //void shit();
9 }

 1 public class WeddingCompany implements ProxyInterface {
 2
 3 private ProxyInterface proxyInterface;
 4
 5 public WeddingCompany(ProxyInterface proxyInterface) {
 6  this.proxyInterface = proxyInterface;
 7 }
 8
 9 @Override
10 public void marry() {
11  System.out.println("我们是婚庆公司的");
12  System.out.println("我们在做结婚前的准备工作");
13  System.out.println("节目彩排...");
14  System.out.println("礼物购买...");
15  System.out.println("工作人员分工...");
16  System.out.println("可以开始结婚了");
17  proxyInterface.marry();
18  System.out.println("结婚完毕，我们需要做后续处理，你们可以回家了，其余的事情我们公司来做");
19 }
20
21 }

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

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