23种设计模式一些随笔

23种设计模式分类

1. 适配器

聚合功能的实现

这种聚合关系的实现，一般将聚合对象(TFCard)类声明到聚合体(SDAdapterTF)中。

SDAdapterTF.java

复制代码

//声明适配者类
private TFCard mtfCard;

// 利用有参构造方法聚合TFCard接口类
public SDAdapterTF(TFCard tfCard){
    this.mtfCard = tfCard;
}

2. 装饰器模式

查看子类继承的所有方法

抽象类继承抽象类，父抽象类的抽象方法不在子抽象类中实现，子抽象类拥有父抽象类中的所有方法。子抽象类的子具体类实现父子抽象类中的所有抽象方法。

子类继承了父类，父类中的所有方法都可以直接使用不用加前缀。（下面是你继承和可以使用的所有方法）

子类调用父类的方法（二种）

• 第一种：super.父类方法
• 第二种：父类名.方法名

---

调用父类的父类中的getDesc()方法

复制代码

@Override
public String getDesc() {
    return super.getDesc();
}

有参构造方法的连续继承

父类创建了有参构造方法，子类必须也要有有参构造方法，且继承父类有参构造方法中的所有属性。

方法体（）中可以自定义几个属性，但super（）中必须全写。

如果子方法体（）没有定义属性，则super（）中要写具体的值。

祖父

复制代码

public abstract class FastFood {
    //价格
    private float price;
    //描述
    private String desc;
    // 有参构造方法
    public FastFood(float price, String desc) {
        this.price = price;
        this.desc = desc;
    }

父

复制代码

public abstract class Garnish extends FastFood{
    // 声明快餐类
    private FastFood fastFood;
    // 有参构造方法
    public Garnish(float price, String desc, FastFood fastFood) {
        super(price, desc);
        this.fastFood = fastFood;
    }

子

复制代码

public class Egg extends Garnish{
    public Egg(FastFood fastFood) {
        super(2, "鸡蛋", fastFood);
    }

3. 桥接模式

有参构造方法的应用

当父类使用了有参构造方法，则子类必须继承实现父类的有参构造方法。

父

复制代码

public abstract class OperatingSystem {
    // 聚合VideoFile接口抽象类
    protected VideoFile videoFile;
    // 创建有参构造方法
    public OperatingSystem(VideoFile videoFile) {
        this.videoFile = videoFile;
    }

子

复制代码

public class Mac extends OperatingSystem{
    //继承父类构造方法
    public Mac(VideoFile videoFile) {
        super(videoFile);
    }

4. 外观模式

contains()模糊查询方法

contains()方法，JDK内部封装的模糊查询方法。message只要有关键字就可以执行程序。

复制代码

//语言输入contains()方法相当于模糊查询
public void say(String message){
    if (message.contains("打开")){
        light.on();
    } else if (message.contains("关闭")) {
        light.off();
    }
}

5. 组合模式

两种List数组的遍历方法

item是数组里的单项，->不要忘写，这里的item是一个类所以可以调用他类里面的print()方法。

复制代码

menuComponentList.forEach(item -> item.print());

 打出menuComponentList.for出现提示，直接选for

复制代码

for (MenuComponent menuComponent : menuComponentList) {
    menuComponent.print();
}

 有参构造方法的应用

 父类并没有创建有参构造方法，但由于Menu继承了MenuComponent所以仍然可以通过构造方法给父类成员变量赋值。

复制代码

public abstract class MenuComponent {
    // 餐单名称
    protected String name;
    // 菜单等级
    protected int level;

复制代码

public class Menu extends MenuComponent {
    // 构造方法,给父类的成员变量赋值
    public Menu(String name, int level) {
        this.name = name;
        this.level = level;
    }

 构造方法的方法体主要起到获取传入数据的作用，真正得到父类成员变量的是this.name和this.level

6. 命令模式（难）

带箭头的虚线（依赖）使用场景

一般虚线所指的都是要被实例化的对象，在测试类中都要被实现。

聚合功能的作用

在这里Waitor服务员可以发出多条不同的命令，所以Command命令聚合在Waitor里。

Map和ArrayList的应用

这两种集合定义后必须声明（new）不然无法使用。

Map

Map<key, value>

// 添加元素
maps.put("A",10);
maps.put("B",10);

复制代码

Map<Integer, Integer> map = new HashMap<Integer, Integer>();
 
//遍历map中的键
for (Integer key : map.keySet()) {
    System.out.println("Key = " + key);
}
 
//遍历map中的值
for (Integer value : map.values()) {
    System.out.println("Value = " + value);
}

通过找键遍历

复制代码

Map<Integer, Integer> map = new HashMap<Integer, Integer>();
// 遍历-键
for (Integer key : map.keySet()) {
    // 通过键得到value值
    Integer value = map.get(key); 
    System.out.println("Key = " + key + ", Value = " + value);
 
}

ArrayList

//添加元素

commands.add(cmd);

//获取指定位置元素

commands.get(i)

复制代码

// 命令集合
private ArrayList<Command> commands = new ArrayList<Command>();

 数组遍历

复制代码

// 遍历list集合
for (Command command : commands) { }

 7. 职责链模式

职责链的体现

client.java

复制代码

// 创建一个请假条对象
LeaveRequest leaveRequest = new LeaveRequest("i坤",9,"要出国学习唱、跳、rap");

// 创建各级领导对象
GroupLeader groupLeader = new GroupLeader();
Manager manager = new Manager();
GeneralManager generalManager = new GeneralManager();

// 创建处理者链
generalManager.setNextHandle(manager);
manager.setNextHandle(generalManager);

// i坤提交请假申请,从小组长开始传递
generalManager.submit(leaveRequest);

public/private/protected

「包访问权限：」 没有任何修饰符的权限就是「包访问权限」，意味着当前包的所有类都可以访问这个成员，对于本包之外的类，这个成员就变成了「private」，访问不了

「public：」 被public修饰的成员对任意一个类都是可用的，任何一个类都可以访问到，通过操作该类的对象随意访问「public」成员

「protected：」 在相同的class内部，同一个包内和其他包的子类中能被访问。要理解「protected」权限，就需要了解「继承」，因为这个权限处理的就是继承相关的概念，继承而来的子类可以访问「public、protected」，

「private：」 除了包含这个成员的类之外，所有类都无法访问这个成员，相当于自我封闭，防止其他类改变或删除这个方法

static静态方法

要想不new新的实例化对象就像引用属性或方法，必须加上static静态方法。

使用方法：类名.属性名/方法名

复制代码

public GroupLeader() {
    super(Handler.NUM_THREE, Handler.NUM_ONE);
}

8. 命令模式

核心

复制代码

private int state;

@Override
public void setState(int state) {
    this.state = state;
}

@Override
public void open() {
    switch (state){
        case OPENING_STATE : break;
        case CLOSING_STATE :
            System.out.println("电梯打开了。。。");
            setState(OPENING_STATE);
            break;
        case RUNNING_STATE : break;
        case STOPPING_STATE:
            System.out.println("电梯打开了。。。");
            setState(OPENING_STATE);
            break;
    }
}

9. 状态模式2（复杂）

10. 观察者模式

聚合的另一种实现

以数组的形式出现

复制代码

public class SubscriptionSubject implements Subject{
    private List<Observer> weiXinUserList = new ArrayList<Observer>();

关键代码

复制代码

@Override
public void update(String message) {
    System.out.println(name+"："+message);
}

复制代码

@Override
public void notify(String message) {
    for (Observer users : weiXinUserList) {
        // 调用观察者对象中的Update方法
        users.update(message);
    }
}

11. 中介者模式（不懂）

有参构造方法的继承super（）

super（）中是所继承的父类构造方法中的参数，里面的参数可以直接使用，相当于参数的传递。

例如下图中的： mediator.constact(message,this);

 

constact()方法间的关联（不懂）

Tenant.java & HouseOwner.java

复制代码

public class Tenant extends Person{

    public Tenant(String name, Mediator mediator) {
        super(name, mediator);
    }
    // 和中介联系（沟通）
    public void contact(String message){
        mediator.constact(message,this);
    }

MediatorStructure.java

复制代码

@Override
public void constact(String message, Person person) {
    if (person == houseOwner){
        tenant.getMessage(message);
    }else {
        houseOwner.getMessage(message);
    }
}

 测试类

复制代码

public class Client {
    public static void main(String[] args) {
        // 创建中介者对象
        MediatorStructure mediatorStructure = new MediatorStructure();
        // 创建租房者对象
        Tenant tenant = new Tenant("小云",mediatorStructure);
        // 创建房主对象
        HouseOwner houseOwner = new HouseOwner("老王",mediatorStructure);

        // 中介知道具体房主和租客
        mediatorStructure.setTenant(tenant);
        mediatorStructure.setHouseOwner(houseOwner);

        // 这里房主和房客没有任何关联，通过中介者传递消息
        tenant.contact("我要租三室一厅的房子。");
        houseOwner.contact("我这里有三室一厅的房子，你要租吗？");
    }
}

12. 访问者模式

静态分派

。。。

动态分派

。。。

双分派

大概用法是子类调用父类方法（动态分派一），然后在调用的父类方法中将本身对象（this）传出去（动态分派二）。

实现动态绑定

复制代码

public interface Animal {
    // 接受访问
    public void accept(Person person);
}

复制代码

public class Cat implements Animal{
    @Override
    public void accept(Person person) {
        person.feed(this);
        System.out.println("好好吃，喵喵喵~");
    }

复制代码

public interface Person {
    // 喂猫
    public void feed(Cat cat);
    // 喂狗
    public void feed(Dog dog);
}

13. 备忘录模式

黑箱模式

下图划红线的意思是，将RoleStateMemento类写在GameRole中。在此设计模式中（黑箱）RoleStateMemento类要设为私有。

14. 解释器模式

在“”里的模板字符串写法

复制代码

public String toString() {
    return "("+left.toString()+"+"+right.toString()+")";
}