设计模式学习体会

【1】适配器模式

体会：

适配器模式就是在实体类与接口之间，增加一个抽象类，以此作为缓冲，使得实现类不必要实现接口所有的方法。

（原理就是接口的实现类必须实现接口的所有方法，但是子类不一定覆盖父类的方法。）

interface Window {// 定义Window窗口接口，表示窗口操作
	public void open();// 窗口打开

	public void close();// 窗口关闭

	public void iconified();// 窗口最小化

	public void deiconified();// 窗口恢复

	public void activated();// 窗口活动
}

// 定义抽象类实现接口，在此类中覆写方法，但是所有的方法体为空
abstract class WindowAdapter implements Window {
	public void open() {
	};// 窗口打开

	public void close() {
	};// 窗口关闭

	public void iconified() {
	};// 窗口最小化

	public void deiconified() {
	};// 窗口恢复

	public void activated() {
	};// 窗口活动
}

// 子类继承WindowAdapter抽象类，选择性实现需要的方法
class WindowImpl extends WindowAdapter {
	public void open() {
		System.out.println("窗口打开");// 实现open()方法
	}

	public void close() {
		System.out.println("窗口关闭");// 实现close()方法
	}
}

public class AdapterDemo {
	public static void main(String args[]) {
		Window win = new WindowImpl(); // 实现接口对象
		// 调用方法
		win.open();
		win.close();
	}
}

【2】观察者模式

体会：

通过被观察者父类Observable中的notifyObservers()方法，自动调用观察者所实现接口中唯一的方法update()，以此来告诉所有已注册的观察者，然后在观察者update()方法中实现需要观察的事情。

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

class House extends Observable {
    private float price;

    public void setPrice(float price) {
        this.setChanged();// 设置变化点
        this.notifyObservers(price);// 通知所有观察者价格改变(自动调用了观察者的update()方法)
        this.price = price;
    }

    public float getPrice() {
        return this.price;
    }

    public House(float price) {
        this.price = price;
    }

    public String toString() {
        return "房子价格为: " + this.price;
    }
}

class HousePriceObserver implements Observer {
    private String name;

    public HousePriceObserver(String name) {
        super();
        this.name = name;
    }

    @Override
    public void update(Observable o, Object arg) {// 只要改变了 observable 对象就调用此方法
        if (arg instanceof Float) {
            System.out.println(this.name + "观察的价格更改为:" + ((Float) arg).floatValue());
        }
    }
}

public class ObserDemo {
    public static void main(String[] args) {
        House h = new House(1000000);
        HousePriceObserver hpo1 = new HousePriceObserver("购房者A");
        HousePriceObserver hpo2 = new HousePriceObserver("购房者B");
        HousePriceObserver hpo3 = new HousePriceObserver("购房者C");
        h.addObserver(hpo1);// 给房子注册观察者
        h.addObserver(hpo2);// 给房子注册观察者
        h.addObserver(hpo3);// 给房子注册观察者
        // 修改房子价格，会触发update(Observable o, Object arg)方法通知购房者新的房价信息
        h.setPrice(2222222);//
        System.out.println(h);// 再次输出房子价格
    }
}

【3】代理模式

体会：

在实现类和接口之间，增加一个实现了同一个接口的代理类，代理类实现与实现类相同的方法，该方法不仅直接调用原实现类的同一个方法，而且添加上一些额外想加入的操作，实例化的时候，只需要将实现类的实例对象也传进去就可以了。

interface Interf {  // 定义接口
    public void method(); // 定义抽象方法
}

class Imppl implements Interf { // 实现类
    public void method() { // 覆写抽象方法
        System.out.println("implementation!");
    }
}

class Proxy implements Interf { // 代理类
    private Interf interf;

    public Proxy(Interf interf) {
        this.interf = interf; // 将需要被代理的实现类的实例对象传进来
    }

    public void method() {  // 与需要代理的方法相同的方法
        System.out.println("代理类额外操作1");
        this.interf.method(); // 调用原来实现类的实现方法
        System.out.println("代理类额外操作2");
    }
}

public class ProxyDemo {
    public static void main(String args[]) {
        Interf interf = null; // 定义接口对象
        interf = new Proxy(new Imppl()); // 实例化代理，同时传入原来实现类的实例对象
        interf.method(); // 调用代理类的实现方法
    }
}

【4】单例模式

体会：

单例模式的目的，无非就是不让外部随意生成本类的实例对象，实现方式主要是两个：

1、禁止外部调用本类的构造方法（将构造方法私有化）

2、在类内部维护一个全局的实例变量，通过提供一个统一的接口，给外部直接调用。

class Singleton {
    private static Singleton instance = new Singleton();// 在内部产生本类的实例化对象

    public static Singleton getInstance() { // 通过静态方法返回instance对象
        return instance;
    }

    private Singleton() { // 将构造方法封装为私有化
    }

    public void print() {
        System.out.println("Hello World!!!");
    }
}

public class SingletonDemo {
    public static void main(String args[]) {
        Singleton s1 = null; // 声明对象
        Singleton s2 = null; // 声明对象
        Singleton s3 = null; // 声明对象
        s1 = Singleton.getInstance(); // 取得实例化对象
        s2 = Singleton.getInstance(); // 取得实例化对象
        s3 = Singleton.getInstance(); // 取得实例化对象
        s1.print(); // 调用方法
        s2.print(); // 调用方法
        s3.print(); // 调用方法
    }
}

【5】工厂模式

体会：

工厂模式，就是个生产不同实例的工厂，就是根据不同的条件“生产”出各种所需要的实例，从而把这个判断的过程交给工厂，省去用户不断进行判断的过程。

interface Animal { // 定义一个动物的接口
    public void say(); // 说话方法
}

class Cat implements Animal { // 定义子类Cat
    @Override
    public void say() { // 覆写say()方法
        System.out.println("我是猫咪，喵呜！");
    }
}

class Dog implements Animal { // 定义子类Dog

    @Override
    public void say() { // 覆写say()方法
        System.out.println("我是小狗，汪汪！");
    }
}

class Factory { // 定义工厂类
    public static Animal getInstance(String className) {
        Animal a = null; // 定义接口对象
        if ("Cat".equals(className)) { // 判断是哪个子类的标记
            a = new Cat(); // 通过Cat子类实例化接口
        }
        if ("Dog".equals(className)) { // 判断是哪个子类的标记
            a = new Dog(); // 通过Dog子类实例化接口
        }
        return a;
    }
}

public class FactoryDemo {

    public static void main(String[] args) {
        Animal a = null; // 定义接口对象
        a = Factory.getInstance(args[0]); // 通过工厂获取实例
        if (a != null) { // 判断对象是否为空
            a.say(); // 调用方法
        }
    }
}

【6】命令模式

体会：

命令模式的目的就是达到命令的发出者和执行者之间解耦，实现请求和执行分开，

就是将命令接受者的实例对象交到命令接口的实现类中去，

这样，命令发出者只需要发出接口命令，即可与命令接收者实现操作。

interface Command {
    public void exe();
}

class Invoker {
    private Command command;

    public Invoker(Command command) {
        this.command = command;
    }

    public void action() {
        command.exe();
    }
}

class MyCommand implements Command {
    private Receiver receiver;

    public MyCommand(Receiver receiver) {
        this.receiver = receiver;
    }

    @Override
    public void exe() {
        receiver.action("MyCommand");
    }
}

class Receiver {
    public void action(String command) {
        System.out.println(command + " received!");
    }
}

public class CommandDemo {
    public static void main(String[] args) {
        Receiver receiver = new Receiver();
        // MyCommand实现了Command接口并持有接收对象
        Command command = new MyCommand(receiver);
        // 发出命令（可以看到实现了调用者Invoker和被调用者Receiver的解耦）
        Invoker invoker = new Invoker(command);
        invoker.action();
    }
}

ref：

http://youyouyl.iteye.com/blog/1830930 java几种常用设计模式简单示例