策略模式-观察者模式-装饰者模式-工厂模式-单例模式

算是最近学设计模式（HEAD FIRST设计模式）的一个总结吧，力求用最精简的代码说明其设计本质。

第一个模式：策略模式

代码：

interface refuel {
    public void fuelUp();
}


class car {
    refuel fuelType;

    public void setFuelType(refuel type) {
        this.fuelType = type;
    }

    public void fuelUp() {
        fuelType.fuelUp();
    }

}


class fuelUpWith_93 implements refuel {

    @Override
    public void fuelUp() {
        System.out.println("Fueled up with No.93 gasoline");
    }

}


class fuelUpWith_97 implements refuel {

    @Override
    public void fuelUp() {
        System.out.println("Fueled up with No.97 gasoline");
    }

}

说明：汽车都需要加油，但是不同汽车加不同的油，通过让汽车持有一个具体实现加油算法的对象（通常向上转型为其接口），在汽车加油的时候直接调用这个接口，让其自己实现这种汽车加油的相关算法。

设计思想：解耦合，这个设计模式最大的优点是：能保证复用所有相同的代码（只要你的汽车持有了其使用的汽油类型），又能保证当你需要一种新的实现的时候可以快速加入进去（写一种实现基础接口的算法实现）而不需要修改原有代码。

第二个设计模式：观察者模式

代码(JAVA内置实现)：

import java.util.Observable;
import java.util.Observer;

public class Main {

    public static void main(String[] args) {
        School highSchool = new School();
        Student Jack = new Student("Jack");
        Student Tom = new Student("Tom");
        Jack.register(highSchool);
        Tom.register(highSchool);
        highSchool.termBegins();
    }
}


class School extends Observable {

    public void termBegins() {
        this.setChanged();
        this.notifyObservers();
    }

}


class Student implements Observer {

    Observable o;
    String name;

    public Student(String name) {
        this.name = new String(name);
    }

    public void register(Observable o) {
        this.o = o;
        o.addObserver(this);
    }

    @Override
    public void update(Observable o, Object arg) {
        if (o instanceof School) {
            System.out.println(name + " go to schoole");
        }
    }

}

代码（手动实现）：

import java.util.ArrayList;

public class Main {

    public static void main(String[] args) {
        Student Jack = new Student("Jack");
        Student Tom = new Student("Tom");
        School highSchool = new School();
        highSchool.register(Jack);
        highSchool.register(Tom);
        highSchool.termBegins();
    }
}


class School {

    ArrayList<Student> stuList = new ArrayList<Student>();

    public void register(Student stu) {
        stuList.add(stu);
    }

    public void termBegins() {
        this.notifyObservers();
        System.out.println("Welcome to school!");
    }

    private void notifyObservers() {
        for (Student stu : stuList) {
            stu.update();
        }
    }
}


class Student {

    String name;

    public Student(String name) {
        this.name = new String(name);
    }

    public void update() {
        System.out.println(name + " go to school");
    }

}

说明：把学生（观察者）对象交给学校（被观察者）。当学校开学时，一个一个去“通知”，让其持有的学生对象作出对应的反应。

设计思想：当需要变化的时候通知观察者们。Swing组件中大量用到（反应鼠标点击消息等等）。其他没啥很特别的东西。

第三个设计模式：装饰者模式
代码：

public class Main {

    public static void main(String[] args) {
        coffee myCoffee = new Mocha(new Milk(new regularCoffee()));
        System.out.println(myCoffee.getName());
    }
}


interface coffee {

    public int getCost();

    public String getName();

}


class regularCoffee implements coffee {

    @Override
    public int getCost() {
        return 5; // 最最普通的一杯咖啡底价5元
    }

    @Override
    public String getName() {
        return "咖啡"; // 最最普通的咖啡
    }

}


abstract class coffeeDecorator implements coffee {

    coffee oriCoffee;

}


class Milk extends coffeeDecorator { // 牛奶，加牛奶的修饰器

    public Milk(coffee c) {
        this.oriCoffee = c;
    }

    @Override
    public int getCost() {
        return oriCoffee.getCost() + 3; // 加一份牛奶再加3元
    }

    @Override
    public String getName() {
        return "牛奶" + oriCoffee.getName(); // 加一份牛奶的话，名字上也要加一份牛奶前缀
    }

}


class Mocha extends coffeeDecorator { // 摩卡，加巧克力的修饰器

    public Mocha(coffee c) {
        this.oriCoffee = c;
    }

    @Override
    public int getCost() {
        return oriCoffee.getCost() + 4; // 加一份巧克力再叫4元
    }

    @Override
    public String getName() {
        return "摩卡" + oriCoffee.getName(); // 加一份巧克力的话，名字也加一个前缀
    }

}

说明：每一次新建一个装饰者（Mocha或者Milk或者你写的别的什么），都依赖于一个传入的参数（目前的咖啡），在这个基础上继续添加装饰。

设计思想：一些类可能有*组合的可能（比如咖啡），你很难一次把他们写全（从设计上也不应该如此），于是便应该用装饰者模式让使用者自己去搭配。每一次经过修饰就在传入参数的基础上进行修改。

第四个设计模式：工厂模式

首先要说的是工厂模式这个名字让人迷惑，因为很多模式好像都和工厂模式有关系：

1，静态工厂模式 ： 一般是说用静态方法写的简单工厂模式。

2，简单工厂模式 ：就是一个类，里面封装了某个类的构造方法，不仅调配构造参数，也许还有别的工作要做。

3，工厂方法模式 ：在工厂中定义一个创建对象的接口，但是让子类去实现（通过Abstract）具体的创建过程。（和模板方法模式有点像）

4，抽象工厂模式 ：提供一个接口，用来创建相关或依赖对象的家族。

关于工厂方法模式和抽象工厂模式可以看：看这篇文章

 

第五个设计模式：单例模式
代码（饿汉模式）：

class Singleton {

    private static Singleton instance = new Singleton();

    private Singleton() {

    }

    public static Singleton getInstance() {
        return instance;
    }

}

 

说明：饿汉模式就是直接在类的静态字段中写上一个实例对象。由<clinit>方法自动在类加载结束的时候进行创建。JVM会保证类的加载线程安全，所以这种情况基本上不需要考虑多线程情况下的线程安全。但是问题还是有：生命周期不可以控制，这个类一加载就存在一个实例对象。

代码（懒汉模式,双重检查模式+volatile）：

class Singleton {

    private volatile static Singleton instance;

    private Singleton() {

    }

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

说明：看这篇文章的说明

设计思想：很多类只需要有一个实例，也许只能有一个实例，当尝试获取多个实例时会返回相同一个实例对象（或者返回null或者报错）。