部分常用设计模式（更新中）

请原谅时光他是个小偷

已于 2022-11-29 16:44:44 修改

阅读量73

点赞数

文章标签：设计模式单例模式 java

于 2022-11-27 21:20:51 首次发布

本文链接：https://blog.csdn.net/weixin_45534185/article/details/128070089

版权

常用的设计模式有单例模式、简单工厂模式、工厂方法模式、抽象工厂模式、代理模式、装饰器模式、观察者模式、责任链模式。

一、单例模式

定义：单例模式就是一个类最多只能有一个实例化对象，并且会提供一个全局访问方法。

单例模式分为预加载和懒加载。预加载就是无论使用或者并不使用这个对象，类一经加载这个对象都会存在在内存中，懒加载就是刚开始这个对象是不存在内存中的，只有需要使用时才会实例化这个对象。

预加载是线程安全的，懒加载是线程不安全的。

二、简单工厂模式

简单工厂模式就是定义一个创建对象的类，由这个类封装实例化对象的行为。

三、装饰者模式（又称装饰器模式）

定义：装饰者模式是动态的将新功能附加到对象上。在对象功能的拓展方面，比继承更有弹性。装饰者模式也体现了开闭原则。

开闭原则：当软件需要扩展新功能或者需要变化时，不要通过修改已有代码来实现新功能或者变化，可以通过扩展实体类的方式来扩展新功能或者变化。

使用设计模式的目的之一就是更好的遵循开闭原则。

接下来将定义两个抽象类、四个实现类、一个测试类来体现一下装饰者模式的具体使用。（有错误或者有注释不清晰的地方可以联系本人修改，因为代码手敲，没有使用工具）

// 定义饮料抽象类
public abstract class Drink{
    public abstract double cost();
}
// 定义两个“饮料抽象类”的实现类
// 柠檬汁类，继承了饮料抽象类
public class Lemon extends Drink{
    // 柠檬汁的消费方法，一杯柠檬汁10元
    public double cost(){
        return 10;
    }
}
// 奶茶类，继承了饮料抽象类
public class MilkyTea{
    // 奶茶的消费方法，一杯奶茶20元
    public double cost(){
        return 20;
    }
}
// 定义装饰器抽象类,需要继承被装饰的类的接口
public abstract class Decorator extends Drink{
    public abstract double cost();
}
// 定义两个“装饰抽象类”的具体实现类
// 珍珠类，继承了装饰抽象类
public class Pearl extends Decorator{
    // 珍珠类的成员常量，表示添加珍珠需要多加两元
    private final static double COST = 2;
    // 珍珠类的成员变量，表示被装饰的对象
    private Drink drink;

    // 珍珠类的有参构造方法，获取被装饰的对象
    public Pearl(Drink drink){
        this.drink = drink;
    }
    
    // 珍珠类的消费方法，返回总消费值：珍珠的2元加上被装饰对象的消费
    public double cost(){
        return COST + drink.cost();
    }
}
// 布丁类，继承了装饰抽象类
public class Pudding extends Decorator{
    // 布丁类的成员常量，表示添加布丁需要多加3元
    private final static double COST = 3;
    // 布丁类的成员变量，表示被修饰的对象
    private Drink drink;

    // 布丁类的有参构造方法，获取被修饰的对象
    public Pudding(Drink drink){
        this.drink = drink;
    }

    // 布丁类的消费方法，返回总消费值：布丁的3元加上被装饰对象的消费
    public double cost(){
        return COST + drink.cost();
    }
}
// 测试类
public class Test{
    public static void main(String[] args){
        // 定义一个饮料对象，实例化柠檬汁对象
        Drink lemon = new Lemon();
        // 使用珍珠类装饰器修饰饮料对象，代表买一杯柠檬汁添加珍珠
        lemon = new Pearl(lemon);
        // 使用布丁类装饰器修饰饮料对象，代表买一杯柠檬汁添加珍珠再添加布丁
        lemon = new Pudding(lemon);
        System.out.println(lemon.cost());
    }
}

测试类输出结果为：

15

因为测试类中买了一杯柠檬汁，添加了珍珠和布丁，计算公式就是10+2+3=15，故总消费15元。

以上代码，就可以根据顾客需要选择性的挑选一种饮料并且可以任意添加配料。添加配料的功能就是使用装饰器来实现的，如果商店中新添加了一种配料，只需要再写一个新的装饰抽象类的实现类即可。

这也正是装饰者模式符合开闭原则的原因，在以上例子中添加新配料只需要添加实现类，而不需要修改原来的代码，即使新加的代码有bug也不会影响原来代码的操作和使用。

四、观察者模式

定义：对象间的一种一对多依赖关系，使得每当一个对象状态发生转变时，其相关依赖对象皆得到通知并被自动更新。

观察者模式的优点：

1.降低了观察者和被观察者之间的耦合关系，两者之间是抽象耦合关系。符合依赖倒置原则。

2.被观察者和观察者之间建立了一套触发机制。

依赖倒置原则：依赖倒置原则是程序要依赖于抽象接口，不要依赖于具体实现。简单来说就是要求对抽象进行编程，不要对实现进行编程，这样就降低了客户与实现模块间的耦合。

例如：B站UP主和其关注者之间，UP主不定时发布一些视频，关注UP主就可以收到推送的视频，取消关注就收不到推送消息。类似的还有抖音博主和其关注者、公众号和其关注者等等。

接下来将定义两个抽象类、三个实现类、一个测试类来体现一下观察者模式的具体使用。

// 定义B站用户接口，即观察者接口
public abstract User{
    public void notice(String videoMessage);
}
// 定义B站用户具体实现类1，实现B站用户接口
public class User1 extends User{
    // B站用户类的私有成员变量，表示用户名称
    private String  name;
    // B站用户类的私有成员变量，表示用户收到的视频信息
    private String videoMessage;
    
    // 构造方法，获取用户姓名
    public User1(Strin name){
        this.name = name;
    }
    
    // 通知方法，获取关注UP主的推送视频信息
    public void notice(String videoMessage){
        // 给成员变量赋值
        this.videoMessage = videoMessage;
        // 调用观看方法
        watch();
    }
    
    // 观看方法，在控制台打印当前用户获取的视频信息
    public void watch(){
        System.out.println(name + "观看视频：" + videoMessage);
    }
}
// 定义B站用户具体实现类2，实现B站用户接口
public class User2 extends User{
    // B站用户类的私有成员变量，表示用户名称
    private String  name;
    // B站用户类的私有成员变量，表示用户收到的视频信息
    private String videoMessage;
    
    // 构造方法，获取用户姓名
    public User2(Strin name){
        this.name = name;
    }
    
    // 通知方法，获取关注UP主的推送视频信息
    public void notice(String videoMessage){
        // 给成员变量赋值
        this.videoMessage = videoMessage;
        // 调用观看方法
        watch();
    }
    
    // 观看方法，在控制台打印当前用户获取的视频信息
    public void watch(){
        System.out.println(name + "观看视频：" + videoMessage);
    }
}
// 定义B站UP主接口，即被观察者接口
public abstract Up{
    // 创建用户集合（即观察者集合）
    private ArrayList<User> array = new ArrayList<User>();
    // Up主要推送的视频信息
    private String videoMessage;

    // 设置视频信息的方法
    public void set(String videoMessage){
        this.videoMessage = videoMessage;
    }
    
    // 增加观察者的方法
    public void add(User user){
        array.add(user);
    }

    // 删除观察者的方法
    public void remove(User user){
        array.remove(user);
    }

    // 通知用户的方法（即通知观察者的方法）
    public abstract void notify();
}
// 定义B站UP主具体实现类，实现B站UP主接口
public class Up1 extends Up{
    public void notify(){
        for(User user : array){
            user.notice(videoMessage);
        }
    }
}
// 测试类
public class Test{
    public static void main(String[] args{
        Up up = new Up1();
        User user1 = new User1("小明");
        User user2 = new User2("小红");
        up.add(user1);
        up.add(user2);
        up.set("B站周年庆");
        up.notify();
    }
}

测试类输出结果为：