软件设计模式 — 行为型模式

代码全部贴在github。因为UML图挂在processon上了,不过没有加连接。等写完全文就把链接加上。

首先是对象的行为模式:

1. 策略模式

针对一组算法,将每个算法封装到具有共同接口的独立类中,从而使得他们可以相互替换。

2. 状态模式

改变类中的状态。

策略模式和状态模式很像,不同在:状态模式解决内在状态的改变,策略模式解决内部算法的改变。感觉上没什么特别大的区别。- -。

3. 命令模式


类的行为模式:

1. 模板方法模式

软件设计模式 — 适配器模式

4该模式的目标是,通过一个代理(Adapter),在原来的类(Adaptee)和客户(Client)之间进行协调,从而达到兼容的目的。

例如:我的项目中Davinci中使用的模式,将整体的游戏类作为Adapter,把用于通讯的Server类作为成员变量(也就是ObjectAdapter)。

示意代码

package adapter;
interface Target {
    public void request();
    public void specRequest();
}
class Adaptee { //适配者
    public void specRequest() {
        System.out.println("this is specRequest.");
    }
}
class ClassAdapter extends Adaptee implements Target {
    public void request() {
        System.out.println("This is request in ClassAdapter.");
    }
}
class ObjectAdapter implements Target {
    private Adaptee adaptee = new Adaptee();
    public void request() {
        System.out.println("this. is request in ObjectAdapter.");
    }
    public void specRequest() {
        adaptee.specRequest();
    }
}
public class Client {
    private static Target ctarget = new ClassAdapter();
    private static Target otarget = new ObjectAdapter();
    public static void main(String args[]) {
        ctarget.request();
        ctarget.specRequest();
        otarget.request();
        otarget.specRequest();
    }
}

软件设计模式 — 单例模式

单例模式确保某个类只有一个实例,而且自行实例化,并向整个系统提供者个实例,提供一个访问它的全局访问点。

核心是:创造私有的构造函数

例如:只有一个实例的东西。

Singleton.java

package singleton;
public class Singleton {
    private static final Singleton singleton = new Singleton();
    private Singleton() { // 限制产生多个对象
        System.out.println("已产生对象实例");
    }
    public static Singleton getInstance() { // 通过该方法获得实例对象
        return singleton;
    }
    public static void operation() { // 类中其他方法,尽量是static
    }
}

Client

package singleton;
public class Client {
    public static void main(String[] args) {
        System.out.println("Start.");
        Singleton obj1 = Singleton.getInstance();
        Singleton obj2 = Singleton.getInstance();
        if (obj1 == obj2) {
            System.out.println("obj1和obj2是同一对象实例");
        } else {
            System.out.println("obj1和obj2并非同一对象实例");
        }
        System.out.println("End.");
    }
}

正方形是否是长方形的子类?

依据里氏代换原则,子类型必须能够替换掉它们的父类型,子类继承了父类,那么子类可以以父类的身份出现 — 在软件中,把父类都替换成它的子类,程序的行为没有变化。

所以从这个角度而言,正方形并非是长方形的子类。
举个例子,如果长方形中存在一个方法,目的是改变长宽的值,但是正方形只有一个边长,那么就可能出现问题。例如如下代码。

interface Conic {
        public long getMajor_axis();
        public long getShort_axis();
    }
    class Ellipse implements Conic {
        private long major_axis;
        private long short_axis;
        public void setMajor_axis(long major_axis) {
            this.major_axis = major_axis;
        }
        public long getMajor_axis() {
            return this.major_axis;
        }
        public void setShort_axis(long short_axis) {
            this.short_axis = short_axis;
        }
        public long getShort_axis() {
            return this.short_axis;
        }
    }
    class Circle implements Conic {
        private long radius;
        public void setRadius(long radius) {
            this.radius = radius;
        }
        public long getRadius() {
            return radius;
        }
        public long getMajor_axis() {
            return getRadius();
        }
        public long getShort_axis() {
            return getRadius();
        }
    }

上面是椭圆形的代码。可以改写成矩形来解释这个问题,不过太麻烦我还是先做后面的题目了。