设计模式学习体会

【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几种常用设计模式简单示例