java中设计模式的使用（持续更新中）

概述

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

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

设计模式的七大原则：

单一职责原则

对类来说，及一个类应该只负责一项职责。如类A负责两个不同的职责：职责1，职责2。当职责1需求变更而改变A时，可能造成职责2执行错误，所以需要将类A的粒度分解为A1，A2。（例如一个UserDao,同时操作user表和order表，因此需要将UserDao拆分为UserDao和OrderDao）
单一职责原则注意事项和细节

- 降低类的复杂度，一个类只负责一项职责
- 提高类的可读性，可维护性
- 降低变更引起的风险
- 通常情况下，我们应当遵守单一职责原则，只有逻辑足够简单，才可以在代码级违反单一职责原则；只有类中方法数量足够少，可以在方法级别保持单一职责原则

接口隔离原则

客户端不应该依赖它不需要的接口，即一个类对另一个类的依赖应该建立在最小的接口上。

依赖倒转原则

高层模块不应该依赖底层模块，二者都应该依赖其抽象
抽象不应该依赖细节，细节应该依赖抽象
依赖倒转的中心思想是面向接口编程
依赖倒转原则是基于这样的设计理念：相对于细节的多变性，抽象的东西要稳定的多。以抽象为基础搭建的架构比以细节为基础的框架要稳定的多。在java中，抽象指的是接口或抽象类，细节就是具体的实现
使用接口或抽象类的目的是制定好规范，而不涉及任何具体的操作，把展现细节的任务交给他们的实现类去完成

里氏替换原则

继承包含这样一层含义：父类中凡是已经实现好的方法，实际上是在设定规范和契约，虽然它不强制要求所有的子类必须遵循这些契约，但是如果子类对这些已经实现的方法任意修改，就会对整个继承体系造成破坏。
继承在给程序设计带来遍历的同时，也带来了弊端。比如使用继承会给程序带来侵入性。程序的可移植性降低，增加对象间的耦合性，如果一个类被其他的类所继承，则当这个类需要修改时，必须考虑到所有的子类，并且修改后，所有设计到子类的功能都有可能产生故障。

开闭原则ocp（开闭原则，工厂模式）

开闭原则（Open Closed Principle）是编程中最基础、最重要的设计原则
一个软件实体如类，模块和函数应该对扩展开放（针对提供方），对修改关闭（针对使用方）用抽象构建框架，用实现扩展细节
当软件需要变化时，尽量通过扩展软件实体的行为来实现变化，而不是通过修改已有的代码来实现变化。
编程中遵循其他原则，以及使用设计模式的目的就是遵循开闭原则

迪米特法则

一个对象应该对其他对象保持最少的了解
类与类关系越密切，耦合度越大
迪米特法则，又叫最少知道原则，即一个类对自己依赖的类知道的越少越好。也就是说，对于被依赖的类不管多么的复杂，都尽量将逻辑封装在类的内部。对外除了提供的public方法，不对外泄漏任务信息
迪米特法则还有哥更简单的定义：只与直接的朋友通信。（直接朋友：每个对象都会与其他对象有耦合关系，我们就说这两个对象之间是朋友关系。耦合的方式很多，依赖，关联，组合，聚合等。其中，我们称出现成员变量，方法参数，方法返回值中的类为直接的朋友，而出现在局部变量中的类不是直接的朋友。也就是说，陌生的类最好不要以局部变量的形式出现在类的内部）

合成复用原则

原则是尽量使用合成/聚合的方式，而不是使用继承

设计模式分为三种类型

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

1.单例模式

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

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

单例模式有八种方式：

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

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

饿汉式（静态常量）

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

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

java">public class Singleton {private static final Singleton instance = new Singleton();//构造方法私有化private Singleton(){}//公共方法获取实例public static Singleton getInstance(){return instance;}
}

饿汉式（静态代码块）

java">public class Singleton {private static Singleton instance;static {instance = new Singleton();}private Singleton(){}public static Singleton getInstance(){return instance;}
}

懒汉式（线程不安全）

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

java">public class Singleto {private static Singleto instance;private Singleto(){}public static Singleto getInstance(){if(instance == null){instance = new Singleto();}return instance;}
}

懒汉式（线程安全，同步方法）

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

java">public class Singleto {private static Singleto instance;private Singleto(){}public static synchronized  Singleto getInstance(){if(instance == null){instance = new Singleto();}return instance;}
}

懒汉式（线程安全，同步代码块）

java">public class Singleto {private static Singleto instance;private Singleto(){}public static  Singleto getInstance(){synchronized (Singleto.class) {if (instance == null) {instance = new Singleto();}return instance;}}
}

双重检查

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

java">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加载类时是线程安全的。

java">public class Singleto {private Singleto(){}private static class SingletonHolder{private static final Singleto INSTANCE = new Singleto();}public static Singleto getInstance(){return SingletonHolder.INSTANCE;} 
}

枚举

java">public enum Singleton {INSTANCE;public void doSomething() {}
}

2.工厂模式

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

2.1简单工厂模式

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

披萨基类

java">public abstract class Pizza {String name;public abstract void prepare();public abstract void bake();public abstract void cut();public abstract void box();
}

创建两种披萨

java">/*** 芝士披萨** @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 + "打包中");}
}

java">/*** 牛肉披萨** @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 + "打包中");}
}

创建一个披萨订单

java">/*** 订一个披萨** @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;}
}

创建披萨工厂

java">/*** 披萨工厂** @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;}
}

披萨店订购披萨

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

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

2.2工厂方法模式

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

披萨基类

java">public abstract class Pizza {String name;public abstract void prepare();public abstract void bake();public abstract void cut();public abstract void box();
}

不同区域和口味的披萨

java">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 + "打包中");}
}

抽象工厂方法类

java">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();}
}

具体的工厂实现

java">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;}
}

演示

java">
public class PizzaStore {public static void main(String[] args) {new BJOrderPizza("cheese").submitOrder();new CDOrderPizza("beef").submitOrder();}
}

2.3抽象工厂模式

抽象工厂模式：定义了一个interface用于创建相关或有依赖关系的对象簇，而无需指明具体的类
抽象工厂模式可以将简单工厂模式和工厂方法模式进行整合
从设计层面看，抽象工厂模式就是对简单工厂模式的改进（或者称为进一步的抽象）
将工厂抽象成两层，AbsFactory（抽象工厂）和具体实现的工厂子类。程序员可以根据创建对象类型使用相应的工厂子类。这样将单个的简单工厂类变成了工厂簇，更利于代码的维护和扩展。

抽象工厂

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

具体的工厂

java">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;}
}

工厂的使用

java">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();}
}

结果展示

java">
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方法

java">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) {}@Overridepublic String toString() {return "Sheep{" +"name='" + name + '\'' +", age=" + age +", color='" + color + '\'' +'}';}@Overrideprotected Object clone() throws CloneNotSupportedException {return super.clone();}
}

3.2深拷贝和浅拷贝问题

浅拷贝

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

深拷贝

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

java">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;}@Overridepublic String toString() {return "Beef{" +"name='" + name + '\'' +'}';}@Overrideprotected Object clone() throws CloneNotSupportedException {return super.clone();}
}

java">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;}@Overridepublic String toString() {return "Sheep{" +"name='" + name + '\'' +", age=" + age +", color='" + color + '\'' +", friend=" + friend +'}';}/** 方式一：完成深拷贝* */@Overrideprotected 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;}
}

代码演示


java">  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建造的产品

java">/*** 房子 --- 对应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抽象建造者-定义建造的方法

java">/*** 房屋建造者 --- 对应抽象的建造者** @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具体的建造执行者--实现具体的建造方法

java">public class HigBuilding extends HouseBuilder{@Overridepublic void buildBasic() {System.out.println("高楼房子打地基50米");house.setBasic("高楼房子打地基50米");}@Overridepublic void buildWall() {System.out.println("高楼房子砌墙80cm");house.setWall("高楼房子砌墙80cm");}@Overridepublic void roofed() {System.out.println("高楼房子封顶");house.setRoofed("高楼房子封顶");}
}

4.3.4指挥者 --- 定义建造的流程（控制方法的执行流程）

java">/*** 房子建造指挥者** @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使用

java">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的适配。

java">/*** 电源220v* src** @author* @date 2024-11-19*/
public class Voltage220V {public int output220V(){int src = 220;System.out.println("电压="+src+"伏");return src;}
}

java">/*** 5v 电压接口* dist** @author * @date 2024-11-19*/
public interface IVoltage5V {int output5V();
}

java">/*** 电压适配器** @author* @date 2024-11-19*/
public class VoltageAdapter extends Voltage220V implements IVoltage5V {@Overridepublic int output5V() {int output220V = super.output220V();int dst = output220V / 44;System.out.println("适配完成，电压="+dst+"伏");return dst;}
}

java">/*** 电话** @author* @date 2024-11-19*/
public class Phone {public void charge(IVoltage5V iVoltage5V){if(iVoltage5V.output5V()==5){System.out.println("手机充电中。。。");}else{System.out.println("电压不匹配，无法充电");}}
}

java">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的适配
根据“合成复用原则”，在系统中尽量使用关联关系来替代继承关系。
对象适配器模式是适配器模式常用的一种

java">/*** 电源220v* src** @author* @date 2024-11-19*/
public class Voltage220V {public int output220V(){int src = 220;System.out.println("电压="+src+"伏");return src;}
}

java">/*** 5v 电压接口* dist** @author* @date 2024-11-19*/
public interface IVoltage5V {int output5V();
}

java">/*** 电话** @author* @date 2024-11-19*/
public class Phone {public void charge(IVoltage5V iVoltage5V){if(iVoltage5V.output5V()==5){System.out.println("手机充电中。。。");}else{System.out.println("电压不匹配，无法充电");}}
}

java">/*** 电压适配器** @author* @date 2024-11-19*/
public class VoltageAdapter implements IVoltage5V {private Voltage220V voltage220V;public VoltageAdapter(Voltage220V voltage220V) {this.voltage220V = voltage220V;}@Overridepublic int output5V() {int output220V = voltage220V.output220V();int dst = output220V / 44;System.out.println("适配完成，电压="+dst+"伏");return dst;}
}

java">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