java中设计模式的使用(持续更新中)

概述

设计模式的目的:编写软件过程中,程序员面临着来自耦合性,内聚性以及可维护性,可扩展性,重用性,灵活性等多方面的挑战,设计模式是为了让程序(软件),具有更好的

  • 代码重用性(相同功能的代码,不用多次编写)
  • 可读性(编程规范性,便于其他程序员的阅读和理解)
  • 可扩展性(当需要增加新的功能时,非常的方便,也叫可维护性)
  • 可靠性(当我们增加新的功能后,对原来的功能没用影响)
  • 使程序呈现高内聚,低耦合的特性

设计模式的七大原则:

  1. 单一职责原则
  • 对类来说,及一个类应该只负责一项职责。如类A负责两个不同的职责:职责1,职责2。当职责1需求变更而改变A时,可能造成职责2执行错误,所以需要将类A的粒度分解为A1,A2。(例如一个UserDao,同时操作user表和order表,因此需要将UserDao拆分为UserDao和OrderDao)
  • 单一职责原则注意事项和细节
    • 降低类的复杂度,一个类只负责一项职责
    • 提高类的可读性,可维护性
    • 降低变更引起的风险
    • 通常情况下,我们应当遵守单一职责原则,只有逻辑足够简单,才可以在代码级违反单一职责原则;只有类中方法数量足够少,可以在方法级别保持单一职责原则
  1. 接口隔离原则
  • 客户端不应该依赖它不需要的接口,即一个类对另一个类的依赖应该建立在最小的接口上。
  1. 依赖倒转原则
  • 高层模块不应该依赖底层模块,二者都应该依赖其抽象
  • 抽象不应该依赖细节,细节应该依赖抽象
  • 依赖倒转的中心思想是面向接口编程
  • 依赖倒转原则是基于这样的设计理念:相对于细节的多变性,抽象的东西要稳定的多。以抽象为基础搭建的架构比以细节为基础的框架要稳定的多。在java中,抽象指的是接口或抽象类,细节就是具体的实现
  • 使用接口或抽象类的目的是制定好规范,而不涉及任何具体的操作,把展现细节的任务交给他们的实现类去完成
  1. 里氏替换原则
  • 继承包含这样一层含义:父类中凡是已经实现好的方法,实际上是在设定规范和契约,虽然它不强制要求所有的子类必须遵循这些契约,但是如果子类对这些已经实现的方法任意修改,就会对整个继承体系造成破坏。
  • 继承在给程序设计带来遍历的同时,也带来了弊端。比如使用继承会给程序带来侵入性。程序的可移植性降低,增加对象间的耦合性,如果一个类被其他的类所继承,则当这个类需要修改时,必须考虑到所有的子类,并且修改后,所有设计到子类的功能都有可能产生故障。
  1. 开闭原则ocp(开闭原则,工厂模式)
  • 开闭原则(Open Closed Principle)是编程中最基础、最重要的设计原则
  • 一个软件实体如类,模块和函数应该对扩展开放(针对提供方),对修改关闭(针对使用方)用抽象构建框架,用实现扩展细节
  • 当软件需要变化时,尽量通过扩展软件实体的行为来实现变化,而不是通过修改已有的代码来实现变化。
  • 编程中遵循其他原则,以及使用设计模式的目的就是遵循开闭原则
  1. 迪米特法则
  • 一个对象应该对其他对象保持最少的了解
  • 类与类关系越密切,耦合度越大
  • 迪米特法则,又叫最少知道原则,即一个类对自己依赖的类知道的越少越好。也就是说,对于被依赖的类不管多么的复杂,都尽量将逻辑封装在类的内部。对外除了提供的public方法,不对外泄漏任务信息
  • 迪米特法则还有哥更简单的定义:只与直接的朋友通信。(直接朋友:每个对象都会与其他对象有耦合关系,我们就说这两个对象之间是朋友关系。耦合的方式很多,依赖,关联,组合,聚合等。其中,我们称出现成员变量,方法参数,方法返回值中的类为直接的朋友,而出现在局部变量中的类不是直接的朋友。也就是说,陌生的类最好不要以局部变量的形式出现在类的内部)
  1. 合成复用原则
  • 原则是尽量使用合成/聚合的方式,而不是使用继承

设计模式分为三种类型

  • 创建型模式:单例模式、抽象工厂模式、原型模式、建造者模式、工厂模式
  • 结构型模式:适配器模式、桥接模式、装饰者模式、组合模式、外观模式、享元模式、代理模式
  • 行为型模式:模板方法模式、命令模式、访问者模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式、状态模式、策略模式、责任链模式

1.单例模式

所谓类得单例设计模式、就是采取一定得方法保证在整个的软件系统中,对某个类只能存在一个对象实例,并且该类只提供一个取得对象实例的方法(一般静态方法)。

  • 单例模式保证了系统内存中该类只存在一个对象,节省了系统资源,对于一些需要频繁创建销毁的对象,使用单例模式可以提高系统性能
  • 当想实例化一个单例类时候,必须要记住使用相应的获取对象的方法,而不是使用new
  • 单例模式使用的场景:需要频繁的进行创建和销毁的对象,创建对象时耗时过多或消耗资源过多(即:重量级对象),但又经常用到的对象,工具类对象、频繁访问数据库或文件的对象(比如数据源、session工厂等)

单例模式有八种方式:

  • 饿汉式(静态常量)
  • 饿汉式(静态代码块)
  • 懒汉式(线程不安全)
  • 懒汉式(线程安全,同步方法)
  • 懒汉式(线程安全,同步代码块)
  • 双重检查
  • 静态内部类
  • 枚举

步骤:构造方法私有化,提供一个公共的方法供外部获取对象

饿汉式(静态常量)

优点:在类装载的时候就完成实例化,避免了线程同步问题

缺点:从未使用过这个实例,造成内存浪费

public class Singleton {

    private static final Singleton instance = new Singleton();
    //构造方法私有化
    private Singleton(){}
    //公共方法获取实例
    public static Singleton getInstance(){
        return instance;
    }
}
饿汉式(静态代码块)
public class Singleton {

    private static Singleton instance;
    
    static {
        instance = new Singleton();
    }

    private Singleton(){}

    public static Singleton getInstance(){
        return instance;
    }
}
懒汉式(线程不安全)

在多线程环境下,一个线程进入了if判断语句块,还未来得及往下执行,另外一个线程获得cpu的时间片往下执行,会创建多个实例。

public class Singleto {
    private static Singleto instance;
    
    private Singleto(){}
    
    public static Singleto getInstance(){
        if(instance == null){
            instance = new Singleto();
        }
        return instance;
    }
}
懒汉式(线程安全,同步方法)

解决线程不安全问题,但是效率低,当对象已经被创建后,所有线程都还是会去竞争锁,还是会去进入判断

public class Singleto {
    
    private static Singleto instance;
    
    private Singleto(){}
    
    public static synchronized  Singleto getInstance(){
        if(instance == null){
            instance = new Singleto();
        }
        return instance;
    }
}
懒汉式(线程安全,同步代码块)
public class Singleto {
    private static Singleto instance;
    
    private Singleto(){}
    
    public static  Singleto getInstance(){
        synchronized (Singleto.class) {
            if (instance == null) {
                instance = new Singleto();
            }
            return instance;
        }
    }
}
双重检查

又叫双重校验锁,解决线程安全问题,同时解决竞争锁性能问题,并且满足懒加载

public class Singleto {
    private static Singleto instance;

    private Singleto() {
    }

    public static Singleto getInstance() {

        if (instance == null) {
            synchronized (Singleto.class) {
                if (instance == null) {
                    instance = new Singleto();
                }
            }
        }
        return instance;

    }
}
静态内部类

SingletonHolder在Singleto装载时不会被加载,在调用getInstance时才被加载,达到懒加载模式。并且jvm加载类时是线程安全的。

public class Singleto {
    
    private Singleto(){
        
    }
    
    private static class SingletonHolder{
        private static final Singleto INSTANCE = new Singleto();
    }
    
    public static Singleto getInstance(){
        return SingletonHolder.INSTANCE;
    } 
}
枚举
public enum Singleton {
    INSTANCE;
    public void doSomething() {

    }
}

2.工厂模式

  • 工厂模式的意义:将实例化对象的代码提取出来,放到一个类中统一管理和维护,达到和主项目的依赖关系的解耦。从而提高项目的扩展和维护性
  • 三种工厂模式(简单工厂模式,工厂方法模式,抽象工厂模式)
  • 创建对象实例时,不要直接new,而是吧这个new类的动作放在一个工厂的方法中,并返回,变量不要直接持有具体类的引用。
  • 不要让类继续具体类,而是继承抽象类或者是实现接口
  • 不要覆盖基类中已经实现的方法
2.1简单工厂模式

简单工厂模式又叫静态工厂模式,原理就是将需要创建的对象抽取到一个工厂类中。使用的时候通过调用工厂获取对象,这样可以将对象的创建等细节抽取到一处,发生变更时只用更改工厂类即可,满足ocp原则。

披萨基类

public abstract class Pizza {
    String name;

    public abstract void prepare();
    public abstract void bake();
    public abstract void cut();
    public abstract void box();
}

创建两种披萨

/**
 * 芝士披萨
 *
 * @author 
 * @date 2024-11-06
 */
public class CheesePizza extends Pizza {

    public CheesePizza() {
        super.name = "奶酪披萨";
    }

    public void prepare() {
        System.out.println("开始制作" + name);
    }

    public void bake() {
        System.out.println(name + "烘烤中");
    }

    public void cut() {
        System.out.println(name + "切割中");
    }

    public void box() {
        System.out.println(name + "打包中");
    }
}
/**
 * 牛肉披萨
 *
 * @author 
 * @date 2024-11-06
 */
public class BeefPizza extends Pizza{
    public BeefPizza() {
        super.name = "牛肉披萨";
    }

    public void prepare() {
        System.out.println("开始制作" + name);
    }

    public void bake() {
        System.out.println(name + "烘烤中");
    }

    public void cut() {
        System.out.println(name + "切割中");
    }

    public void box() {
        System.out.println(name + "打包中");
    }
}

创建一个披萨订单

/**
 * 订一个披萨
 *
 * @author 
 * @date 2024-11-06
 */
public class OrderPizza {
    String type;

    public OrderPizza(String type) {
        this.type = type;
    }

    public void submitOrder() {
        String orderType;
        orderType = getType();
        Pizza pizza = PizzaFactory.createPizza(orderType);
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
    }

    private String getType() {
        return this.type;
    }
}

创建披萨工厂

/**
 * 披萨工厂
 *
 * @author 
 * @date 2024-11-06
 */
public class PizzaFactory {
    public static Pizza createPizza(String orderType) {
        Pizza pizza = null;
        if (orderType.equals("cheese")) {
            pizza = new CheesePizza();
        } else if (orderType.equals("beef")) {
            pizza = new BeefPizza();
        } else {
            System.out.println("没有该类型");
        }
        return pizza;
    }
}

披萨店订购披萨

/**
 * 披萨店
 *
 * @author 
 * @date 2024-11-06
 */
public class PizzaStore {
    public static void main(String[] args) {
        OrderPizza orderPizza = new OrderPizza("beef");
        orderPizza.submitOrder();
    }
}

这样的好处就是扩展性强,以后有其他的披萨类型,只用创建一个新的披萨类,然后再工厂中添加新的披萨,其他使用工厂的创建即可,不用关心对象的创建。不使用工厂模式,新添加一个类型时,所有创建披萨的地方都要更改。

2.2工厂方法模式

工厂方法模式:定义一个创建对象的抽象方法,由子类决定要实例化的类。工厂方法模式将对象的实例化推迟到子类。

披萨基类

public abstract class Pizza {
    String name;

    public abstract void prepare();
    public abstract void bake();
    public abstract void cut();
    public abstract void box();
}

不同区域和口味的披萨

public class BJBeefPizza extends Pizza {
    public BJBeefPizza() {
        super.name = "北京牛肉披萨";
    }

    public void prepare() {
        System.out.println("开始制作" + name);
    }

    public void bake() {
        System.out.println(name + "烘烤中");
    }

    public void cut() {
        System.out.println(name + "切割中");
    }

    public void box() {
        System.out.println(name + "打包中");
    }
}

public class BJCheesePizza extends Pizza {

    public BJCheesePizza() {
        super.name = "北京奶酪披萨";
    }

    public void prepare() {
        System.out.println("开始制作" + name);
    }

    public void bake() {
        System.out.println(name + "烘烤中");
    }

    public void cut() {
        System.out.println(name + "切割中");
    }

    public void box() {
        System.out.println(name + "打包中");
    }
}


public class CDBeefPizza extends Pizza {
    public CDBeefPizza() {
        super.name = "成都牛肉披萨";
    }

    public void prepare() {
        System.out.println("开始制作" + name);
    }

    public void bake() {
        System.out.println(name + "烘烤中");
    }

    public void cut() {
        System.out.println(name + "切割中");
    }

    public void box() {
        System.out.println(name + "打包中");
    }
}


public class CDCheesePizza extends Pizza {

    public CDCheesePizza() {
        super.name = "成都奶酪披萨";
    }

    public void prepare() {
        System.out.println("开始制作" + name);
    }

    public void bake() {
        System.out.println(name + "烘烤中");
    }

    public void cut() {
        System.out.println(name + "切割中");
    }

    public void box() {
        System.out.println(name + "打包中");
    }
} 

抽象工厂方法类

public abstract class OrderPizza {
    protected String orderType;

    abstract Pizza createPizza(String orderType);

    public OrderPizza(String type) {
        orderType = type;
    }

    public void submitOrder() {
        Pizza pizza = createPizza(orderType);
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
    }
}

具体的工厂实现

public class BJOrderPizza extends OrderPizza {
    public BJOrderPizza(String type) {
        super(type);
    }

    Pizza createPizza(String orderType) {
        Pizza pizza = null;
        if (orderType.equals("cheese")) {
            pizza = new BJCheesePizza();
        } else if (orderType.equals("beef")) {
            pizza = new BJBeefPizza();
        }
        return pizza;
    }
}


public class CDOrderPizza extends OrderPizza{
    public CDOrderPizza(String type) {
        super(type);
    }

    Pizza createPizza(String orderType) {
        Pizza pizza = null;
        if (orderType.equals("cheese")) {
            pizza = new CDCheesePizza();
        } else if (orderType.equals("beef")) {
            pizza = new CDBeefPizza();
        }
        return pizza;
    }
}

演示


public class PizzaStore {
    public static void main(String[] args) {
        new BJOrderPizza("cheese").submitOrder();
        new CDOrderPizza("beef").submitOrder();
    }
}
2.3抽象工厂模式
  • 抽象工厂模式:定义了一个interface用于创建相关或有依赖关系的对象簇,而无需指明具体的类
  • 抽象工厂模式可以将简单工厂模式和工厂方法模式进行整合
  • 从设计层面看,抽象工厂模式就是对简单工厂模式的改进(或者称为进一步的抽象)
  • 将工厂抽象成两层,AbsFactory(抽象工厂)和具体实现的工厂子类。程序员可以根据创建对象类型使用相应的工厂子类。这样将单个的简单工厂类变成了工厂簇,更利于代码的维护和扩展。

抽象工厂

public interface AbsFactory {
    Pizza createPizza(String type);
}

具体的工厂

public class BJFactory implements AbsFactory{
    public Pizza createPizza(String type) {
        Pizza pizza = null;
        if (type.equals("cheese")) {
            pizza = new BJCheesePizza();
        } else if (type.equals("beef")) {
            pizza = new BJBeefPizza();
        }
        return pizza;
    }
}

public class CDFactory implements AbsFactory{
    public Pizza createPizza(String type) {
        Pizza pizza = null;
        if (type.equals("cheese")) {
            pizza = new CDCheesePizza();
        } else if (type.equals("beef")) {
            pizza = new CDBeefPizza();
        }
        return pizza;
    }
}

工厂的使用

public class OrderPizza {
    AbsFactory factory;

    public OrderPizza(AbsFactory factory){
        this.factory = factory;
    }
    public void submitOrder(String orderType) {
        Pizza pizza = factory.createPizza(orderType);
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
    }
}

结果展示


public class PizzaStore {
    public static void main(String[] args) {
        OrderPizza orderPizza = new OrderPizza(new BJFactory());
        orderPizza.submitOrder("cheese");
    }
}

3.原型模式

  • 原型模式(prototype)是指:用原型实例指定创建对象的种类。并且通过拷贝这些原型,创建新的对象。
  • 原型模式是一种创建型设计模式,允许一个对象再创建另外一个可定制的对象,无需指定如何创建的细节
  • 工作原理是通过将一个原型对象传给那个要发动创建的对象,这个要发动创建的对象通过请求原型对象拷贝它们自己来实施创建,即,对象.clone()
3.1代码实现

原型类实现Cloneable接口,覆写clone方法

public class Sheep implements Cloneable{
    private String name;
    private int age;
    private String color;

    public Sheep(String name, int age, String color) {
        this.name = name;
        this.age = age;
        this.color = color;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {}

    @Override
    public String toString() {
        return "Sheep{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", color='" + color + '\'' +
                '}';
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
3.2深拷贝和浅拷贝问题

浅拷贝

  • 对于数据类型是基本数据类型的成员变量,浅拷贝会直接进行值传递,也就是将该属性值复制一份给新的对象
  • 对于数据类型是引用数据类型的成员变量,比如说成员变量是某个数组、某个类的对象等,那么浅拷贝会进行引用传递,也就是只是将该成员变量的引用值(内存地址)复制一份给新的对象。因为实际上两个对象的该成员变量都指向同一个实例。在这种情况下,在一个对象中修改该成员变量会影响到另一个对象的该成员变量值
  • 浅拷贝则是使用默认的clone()方法来实现

深拷贝

  • 复制对象的所有基本数据类型的成员变量值
  • 为所有引用数据类型的成员变量申请存储空间,并复制每个引用数据类型成员变量所引用的对象,直到该对象可达的所有对象。也就是说,对象进行深拷贝要对整个对象进行拷贝
  • 深拷贝实现方式1:重写clone方法来实现深拷贝
  • 深拷贝实现方式2:通过对象序列化实现深拷贝(推荐)
package com.demo.design_pattern.prototype;

import java.io.Serializable;

public class Beef implements Cloneable, Serializable {
    private String name;

    public Beef(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Beef{" +
                "name='" + name + '\'' +
                '}';
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
package com.demo.design_pattern.prototype;

import java.io.*;

public class Sheep implements Cloneable , Serializable {
    private String name;
    private int age;
    private String color;

    private Beef friend;

    public Sheep(String name, int age, String color) {
        this.name = name;
        this.age = age;
        this.color = color;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {}

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public Beef getFriend() {
        return friend;
    }

    public void setFriend(Beef friend) {
        this.friend = friend;
    }

    @Override
    public String toString() {
        return "Sheep{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", color='" + color + '\'' +
                ", friend=" + friend +
                '}';
    }

    /*
    * 方式一:完成深拷贝
    * */
    @Override
    protected Object clone() throws CloneNotSupportedException {
        Object clone = super.clone();
        Sheep sheep = (Sheep) clone;
        sheep.friend = (Beef) this.friend.clone();
        return clone;
    }
    /*
     * 方式二:完成深拷贝
     * */
    public Object deepClone(){
        Sheep sheep = null;
        ByteArrayOutputStream bos = null;
        ObjectOutputStream oos = null;
        ByteArrayInputStream bis =null;
        ObjectInputStream ois =null;
        //创建流对象
        try {
            bos = new ByteArrayOutputStream();
            oos = new ObjectOutputStream(bos);
            // 序列号,写入当前对象的二进制流
            oos.writeObject(this);

            bis = new ByteArrayInputStream(bos.toByteArray());
            ois = new ObjectInputStream(bis);
            // 反序列化,从二进制流产生当前对象
            sheep = (Sheep) ois.readObject();
        } catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
                assert bos != null;
                bos.close();
                assert oos != null;
                oos.close();
                assert bis != null;
                bis.close();
                assert ois != null;
                ois.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return sheep;
    }
}

代码演示


  Sheep sheep = new Sheep("肖恩", 12, "白色");
        sheep.setFriend(new Beef("小黑"));
//        Sheep sheep1 = (Sheep) sheep.clone();
        Sheep sheep1 = (Sheep) sheep.deepClone();
        System.out.println(sheep1.getFriend() == sheep.getFriend());
        System.out.println(sheep1);
        System.out.println(sheep);

原型模式的注意事项和细节:

  • 创建新的对象比较复杂时,可以利用原型模式简化对象的创建过程,同时也能提高效率
  • 不用重新初始化对象,而是动态地获得运行时的状态
  • 如果原始对象发生改变(增加或减少属性),其它克隆对象也会发生相应的变化,而无需修改代码
  • 缺点:需要为每一个类配备一个克隆方法,对全新的类来说不是很难,但对已有的类进行改造时,需要修改其源代码,违背了opc原则。

4.建造者模式

4.1概念
  • 建造者模式(Builder Pattern)又叫生成器模式,是一种对象构建模式。它可以将复杂对象的建造过程抽象出来(抽象类别),使这个抽象过程的不同实现方法可以构造出不同表现(属性)的对象
  • 建造者模式使一步一步创建一个复杂的对象,它允许用户只通过指定复杂对象的类型和内容就可以构建它们,用户不需要知道内部的具体构建细节。
4.2核心角色
  • Product(产品角色):一个具体的产品对象
  • Builder(抽象建造者):创建一个Product对象的各个部件指定的接口/抽象类。
  • ConcreteBuilder(具体建造者):实现接口,构建和装配各个部件。
  • Director(指挥者):构建一个使用Builder接口的对象。它主要是用于创建一个复杂的对象。它主要又两个作用,一是:隔离了客户与对象的生产过程,二是负责控制产品对象的生产过程。
4.3代码实现

4.3.1建造的产品
/**
 * 房子 --- 对应product
 *
 * @author 
 * @date 2024-11-11
 */
public class House {
    private String basic;
    private String wall;
    private String roofed;

    public String getBasic() {
        return basic;
    }

    public void setBasic(String basic) {
        this.basic = basic;
    }

    public String getWall() {
        return wall;
    }

    public void setWall(String wall) {
        this.wall = wall;
    }

    public String getRoofed() {
        return roofed;
    }

    public void setRoofed(String roofed) {
        this.roofed = roofed;
    }

}
4.3.2抽象建造者-定义建造的方法
/**
 * 房屋建造者 --- 对应抽象的建造者
 *
 * @author 
 * @date 2024-11-11
 */
public abstract class HouseBuilder {
    protected House house = new House();

    /*
    * 定义房子建造的步骤
    * */
    public abstract void buildBasic();

    public abstract void buildWall();

    public abstract void roofed();

    public House buildHouse() {
        return house;
    }
}
4.3.3具体的建造执行者--实现具体的建造方法
public class HigBuilding extends HouseBuilder{
    @Override
    public void buildBasic() {
        System.out.println("高楼房子打地基50米");
        house.setBasic("高楼房子打地基50米");
    }

    @Override
    public void buildWall() {
        System.out.println("高楼房子砌墙80cm");
        house.setWall("高楼房子砌墙80cm");
    }

    @Override
    public void roofed() {
        System.out.println("高楼房子封顶");
        house.setRoofed("高楼房子封顶");
    }
}
4.3.4指挥者 --- 定义建造的流程(控制方法的执行流程)
/**
 * 房子建造指挥者
 *
 * @author 
 * @date 2024-11-11
 */
public class HouseDirector {
    private HouseBuilder houseBuilder;

    public HouseDirector(HouseBuilder houseBuilder) {
        this.houseBuilder = houseBuilder;
    }

     /**
     * 建造房子,定义产品的创建过程
     *
     * @return 
     */
    public House constructHouse() {
        // 调用建造者中的方法,完成产品的创建
        houseBuilder.buildBasic();
        houseBuilder.buildWall();
        houseBuilder.roofed();
        return houseBuilder.buildHouse();
    }
}
4.3.5使用
public class Client {
    public static void main(String[] args) {
        HigBuilding higBuilding = new HigBuilding();
        HouseDirector houseDirector = new HouseDirector(higBuilding);
        House house = houseDirector.constructHouse();
        System.out.println(house);
    }
}
4.3.6建造者模式的注意事项和细节
  • 建造者模式所创建的产品一般具有较多的共同点,其组成部分相似,如果产品之间的差异性很大,则不适合使用建造者模式,因此其使用范围受到一定的限制
  • 如果产品的内部变化复杂,可能会导致需要定义很多具体建造者类来实现这种变化,导致系统变得很庞大,因此在这种情况下,要考虑是否选择建造者模式

抽象工厂模式 vs 建造者模式

抽象工厂模式实现对产品家族的创建,一个产品家族是这样的一系列产品:具有不同分类维度的产品组合,采用抽象工厂模式不需要关心构建过程,只关心什么产品由什么工厂生产即可。而建造者模式则是要去按照指定的蓝图建造产品,它的主要目的是通过组装零配件而产生一个新产品

5.适配器模式

5.1概述
  • 适配器模式(Adapter Pattern)将某个类的接口转换成客户端期望的另一个接口表示,主的目的是兼容性,让原本因接口不匹配不能一起工作的两个类可以协同工作。其别名为包装器(Wrapper)
  • 适配器模式属于结构型模式
  • 主要分为三类:类适配器模式、对象适配器模式、接口适配器模式
5.2工作原理
  • 将一个类的接口转换成另一种接口,让原本接口不兼容的类可以兼容
  • 从用户的角度看不到被适配者,是解耦的
  • 用户调用适配器转化出来的目标接口方法,适配器再调用被适配者的相关接口方法
  • 用户收到反馈结果,感觉只是和目标接口交互
5.3类适配器模式

基本介绍:Adapter类,通过继承src类,实现dst类接口,完成src->dst的适配。

/**
 * 电源220v
 * src
 *
 * @author
 * @date 2024-11-19
 */
public class Voltage220V {
    public int output220V(){
        int src = 220;
        System.out.println("电压="+src+"伏");
        return src;
    }
}
/**
 * 5v 电压接口
 * dist
 *
 * @author 
 * @date 2024-11-19
 */
public interface IVoltage5V {
    int output5V();
}
/**
 * 电压适配器
 *
 * @author
 * @date 2024-11-19
 */
public class VoltageAdapter extends Voltage220V implements IVoltage5V {

    @Override
    public int output5V() {
        int output220V = super.output220V();
        int dst = output220V / 44;
        System.out.println("适配完成,电压="+dst+"伏");
        return dst;
    }
}
/**
 * 电话
 *
 * @author
 * @date 2024-11-19
 */
public class Phone {
    public void charge(IVoltage5V iVoltage5V){
        if(iVoltage5V.output5V()==5){
            System.out.println("手机充电中。。。");
        }else{
            System.out.println("电压不匹配,无法充电");
        }
    }
}
public class Client {
    public static void main(String[] args) {
        VoltageAdapter adapter = new VoltageAdapter();
        new Phone().charge(adapter);
    }
}

类适配器模式注意事项和细节

  • java是单继承机制,所以类适配器需要继承src类这一点算是一个缺点,因为这要求dst必须是接口,有一定局限性
  • src类的方法在Adapter中都会暴露出来,也增加使用的成本
  • 由于其继承了src类,所以它可以根据需求重写src类的方法,使得Adapter的灵活性增强了。
5.4对象适配器模式
  • 基本思路和类的适配器模式相同,只是将Adapter类作修改,不是继承src类,而是持有src类的实例,以解决兼容性的问题。即:持有src类,实现dst类接口,完成src->dst的适配
  • 根据“合成复用原则”,在系统中尽量使用关联关系来替代继承关系。
  • 对象适配器模式是适配器模式常用的一种
/**
 * 电源220v
 * src
 *
 * @author
 * @date 2024-11-19
 */
public class Voltage220V {
    public int output220V(){
        int src = 220;
        System.out.println("电压="+src+"伏");
        return src;
    }
}
/**
 * 5v 电压接口
 * dist
 *
 * @author
 * @date 2024-11-19
 */
public interface IVoltage5V {
    int output5V();
}
/**
 * 电话
 *
 * @author
 * @date 2024-11-19
 */
public class Phone {
    public void charge(IVoltage5V iVoltage5V){
        if(iVoltage5V.output5V()==5){
            System.out.println("手机充电中。。。");
        }else{
            System.out.println("电压不匹配,无法充电");
        }
    }
}
/**
 * 电压适配器
 *
 * @author
 * @date 2024-11-19
 */
public class VoltageAdapter implements IVoltage5V {
    private Voltage220V voltage220V;

    public VoltageAdapter(Voltage220V voltage220V) {
        this.voltage220V = voltage220V;
    }

    @Override
    public int output5V() {
        int output220V = voltage220V.output220V();
        int dst = output220V / 44;
        System.out.println("适配完成,电压="+dst+"伏");
        return dst;
    }
}
public class Client {
    public static void main(String[] args) {
        Voltage220V voltage220V = new Voltage220V();
        IVoltage5V voltage5V = new VoltageAdapter(voltage220V);
        new Phone().charge(voltage5V);
    }
}

对象适配器模式注意事项和细节

  • 对象适配器和类适配器其实算是同一种思想,只不过实现方式不同。根据合成复用原则,使用组合代替继承,所以它解决了类适配器必须继承src的局限性问题,也不再要求dst必须是接口。
  • 使用成本更低,更灵活
5.5接口适配器模式
  • 适配器模式或缺省适配器模式
  • 当不需要全部实现接口提供的方法时,可先设计一个抽象类实现接口,并为该接口中每个方法提供给一个默认实现(空方法),那么该抽象类的子类可有选择地覆盖父类的某些方法来实现需求
  • 适用于一个接口不想使用其所有的方法的情况

举例:springMVC中的拦截器实现,HandlerInterceptor和HandlerInterceptorAdapter

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:/a/919145.html

如若内容造成侵权/违法违规/事实不符,请联系我们进行投诉反馈qq邮箱809451989@qq.com,一经查实,立即删除!

相关文章

【计算机网络实验】之静态路由配置

【计算机网络实验】之静态路由配置 实验题目实验目的实验任务实验设备实验环境实验步骤路由器配置设置静态路由测试路由器之间的连通性配置主机PC的IP测试 实验题目 静态路由协议的配置 实验目的 熟悉路由器工作原理和机制;巩固静态路由理论;设计简单…

【PS】矢量绘图技巧

1、先使用钢笔工具结合ctrl和alt建将苹果大致扣出来。 任意选择一个颜色进行填充 新建一个图层,使用渐变工具为图层添加渐变颜色 选择剪切蒙版,将图层颜色填入苹果,得最终结果。 内容二、麦当劳 与内容一类似的,使用钢笔工具将M形…

【HCIP]——OSPF综合实验

题目 实验需求 根据上图可得,实验需求为: 1.R5作为ISP:其上只能配置IP地址;R4作为企业边界路由器,出口公网地址需要通过PPP协议获取,并进行CHAP认证。(PS:因PPP协议尚未学习&#…

django启动项目报错解决办法

在启动此项目报错: 类似于: django.core.exceptions.ImproperlyConfigured: Requested setting EMOJI_IMG_TAG, but settings are not c启动方式选择django方式启动,以普通python方式启动会报错 2. 这句话提供了对遇到的错误的一个重要线索…

【GeekBand】C++设计模式笔记12_Singleton_单件模式

1. “对象性能” 模式 面向对象很好地解决了 “抽象” 的问题, 但是必不可免地要付出一定的代价。对于通常情况来讲,面向对象的成本大都可以忽略不计。但是某些情况,面向对象所带来的成本必须谨慎处理。典型模式 SingletonFlyweight 2. Si…

计算机网络 (1)互联网的组成

一、互联网的边缘部分 互联网的边缘部分由所有连接在互联网上的主机组成,这些主机又称为端系统(end system)。端系统可以是各种类型的计算机设备,如个人电脑、智能手机、网络摄像头等,也可以是大型计算机或服务器。端系…

电商行业客户服务的智能化:构建高效客户服务知识库

在电商行业,客户服务是提升用户体验和品牌忠诚度的关键。随着数字化转型的深入,构建一个高效的客户服务知识库变得尤为重要。本文将探讨电商行业如何构建客户服务知识库,并分析其在提升服务质量中的作用。 客户服务知识库的重要性 客户服务…

CentOS 9 无法启动急救方法

方法一:通过单用户安全模式启动 开机按上下方向键,选择需要启动的内核,按e键进入配置模式 修改配置 ro 改 rw 删除 rhgb quiet 末尾增加 init/bin/bash 按 Ctrlx 启动单用户模式 如果想重新启动,重启电脑 执行 exec /sbin/in…

数字后端零基础入门系列 | Innovus零基础LAB学习Day11(Function ECO流程)

###LAB 20 Engineering Change Orders (ECO) 这个章节的学习目标是学习数字IC后端实现innovus中的一种做function eco的flow。对于初学者,如果前面的lab还没掌握好的,可以直接跳过这节内容。有时间的同学,可以熟悉掌握下这个flow。 数字后端…

SAM-Med2D 训练完成后boxes_prompt没有生成mask的问题

之前对着这这篇文章去微调SAM_Med2D(windows环境),发现boxes_prompt空空如也。查找了好长时间问题SAM-Med2D 大模型学习笔记(续):训练自己数据集_sam训练自己数据集-CSDN博客 今天在看label2image_test.json文件的时候发现了一些端倪: 官方…

java ssm 同仁堂药品管理系统 在线药品信息管理 医药管理源码jsp

一、项目简介 本项目是一套基于SSM的同仁堂药品管理系统,主要针对计算机相关专业的和需要项目实战练习的Java学习者。 包含:项目源码、数据库脚本、软件工具等。 项目都经过严格调试,确保可以运行! 二、技术实现 ​后端技术&…

使用阿里云快速搭建 DataLight 平台

使用阿里云快速搭建 DataLight 平台 本篇文章由用户 “闫哥大数据” 分享,B 站账号:https://space.bilibili.com/357944741?spm_id_from333.999.0.0 注意:因每个人操作顺序可能略有区别,整个部署流程如果出现出入,以…

如何解决VS Code的Live Share会话中Guest无法看到共享的文件夹?

在 VS Code 的 Live Share 会话中,如果 Guest 无法看到共享的文件夹,如图所示: 可能是因为权限设置、浏览器限制或 Live Share 的配置问题。以下是逐步排查和解决问题的方法: 1. 确保正确共享了文件夹 在主机(Host&a…

.NET 9 运行时中的新增功能

本文介绍了适用于 .NET 9 的 .NET 运行时中的新功能和性能改进。 文章目录 一、支持修剪的功能开关的属性模型二、UnsafeAccessorAttribute 支持泛型参数三、垃圾回收四、控制流实施技术.NET 安装搜索行为性能改进循环优化感应变量加宽Arm64 上的索引后寻址强度降低循环计数器可…

深入解析TK技术下视频音频不同步的成因与解决方案

随着互联网和数字视频技术的飞速发展,音视频同步问题逐渐成为网络视频播放、直播、编辑等过程中不可忽视的技术难题。尤其是在采用TK(Transmission Keying)技术进行视频传输时,由于其特殊的时序同步要求,音视频不同步现…

MongoDB:数据迁移

业余人员学习 第一种:通过MongoDB命令 参考链接: MongoDB的备份(mongodump)与恢复(mongorestore)_MongoDB_脚本之家 MongoDB数据库管理:全面掌握mongodump和mongorestore的备份与恢复技巧_8055096的技术博客_51CTO博客 1.1、首先进入操作命令行,都不需要进入MongoDB […

网络安全练习之 ctfshow_web

文章目录 VIP题目限免(即:信息泄露题)源码泄露前台JS绕过协议头信息泄露robots后台泄露phps源码泄露源码压缩包泄露版本控制泄露源码(git)版本控制泄露源码2(svn)vim临时文件泄露cookie泄露域名txt记录泄露敏感信息公布内部技术文档泄露编辑器…

【俄罗斯方块】

【俄罗斯方块】 C语言实现C实现Java实现Python实现 💐The Begin💐点点关注,收藏不迷路💐 首先把经典的俄罗斯方块简化一下:方块有顺序地从屏幕顶端掉下至底部,当碰到障碍物或底部时停下,同时变成…

优化装配,提升品质:虚拟装配在汽车制造中的关键作用

汽车是各种零部件的有机结合体,因此汽车的装配工艺水平和装配质量直接影响着汽车的质量与性能。在汽车装配过程中,经常会发生零部件间干涉或装配顺序不合理等现象,且许多零部件制造阶段产生的质量隐患要等到实际装配阶段才能显现出来&#xf…

【算法】日期问题(C/C++)

目录 日期问题概述 一、闰年判断 问题描述: 解决方法: 代码实现: 二、回文日期 问题描述: 链接:2867. 回文日期 - AcWing题库 解决方法: 代码实现: 三、日期差值 问题描述&#xff1…