文章目录
- 结构型模式
- 组合模式
- 适配器模式
- 外观模式
- 桥接模式
结构型模式
什么是结构型模式
结构型模式描述如何将类或对象结合在一起，形成更大的结构，例如搭积木一样一个一个形成一个更大的结构。
结构型模式有分为两种模式：
类结构型模式：类结构型模式关心类和类之间的组合，通过继承来组合类，形成更大的结构。类结构型模式就像子承父业，儿子继承父亲的能力，在此基础上扩展自己的能力。
对象结构型模式：对象结构型模式关心对象和类之间的组合，在一个类中，应用另一个类的对象，形成更大的结构。对象型结构模式就像团队组合，借助他人的力量来完成任务。
组合模式
什么是组合模式？
组合模式是一种结构型模式，它将对象组合成树形结构，并使得客户端可以同一的对待叶子结点和组合节点。
组合模式的核心思想是将对象构建成树形结构，叶子节点是树形结构的基本元素，没有子节点，组合节点是树形结构中的容器，可以有子节点。
组合模式的角色：
- Component(组件)：定义的叶子节点和组合节点的公共接口
- Leaf(叶子节点)：树形结构的基本元素，实现了Component的接口，没有实现关于管理叶子节点的接口
- Composite(组合节点)：树形结构的容器，实现了Component的接口，实现关于管理叶子结点的接口
优点：
- 简化了客户端的代码：客户端可以统一对待叶子节点和组合节点
- 灵活性更强：组合模式可以轻松构建负责的树形结构，可以动态的删除或添加节点
- 符合开闭原则：
缺点：
- 设计复杂：如果树形结构复杂，可能导致类的数量增加
- 性能问题：如果在深度较大的树形结构中，递归影响效率
代码示例
import java.util.ArrayList;
import java.util.List;// Component：定义文件和文件夹的共同接口
abstract class FileSystemComponent {protected String name;public FileSystemComponent(String name) {this.name = name;}public abstract void display(); // 显示文件或文件夹信息public void add(FileSystemComponent component) {throw new UnsupportedOperationException("This operation is not supported.");}public void remove(FileSystemComponent component) {throw new UnsupportedOperationException("This operation is not supported.");}
}// Leaf：文件类
class File extends FileSystemComponent {public File(String name) {super(name);}@Overridepublic void display() {System.out.println("File: " + name);}
}// Composite：文件夹类
class Folder extends FileSystemComponent {private List<FileSystemComponent> components = new ArrayList<>();public Folder(String name) {super(name);}@Overridepublic void display() {System.out.println("Folder: " + name);for (FileSystemComponent component : components) {component.display(); // 递归显示子组件}}@Overridepublic void add(FileSystemComponent component) {components.add(component);}@Overridepublic void remove(FileSystemComponent component) {components.remove(component);}
}// 客户端代码
public class CompositePatternDemo {public static void main(String[] args) {// 创建文件和文件夹FileSystemComponent file1 = new File("file1.txt");FileSystemComponent file2 = new File("file2.txt");FileSystemComponent folder1 = new Folder("Folder1");FileSystemComponent folder2 = new Folder("Folder2");// 构建树形结构folder1.add(file1);folder1.add(file2);folder1.add(folder2);folder2.add(new File("file3.txt"));// 显示文件系统结构folder1.display();}
}
UML类图
适配器模式
什么是适配器模式？
适配器模式是一种结构型模式，解决由于接口不兼容，无法协同工作的问题。
适配器模式的核心是：
- 复用现有的类
- 实现接口的转换，是不能兼容的接口能够协同工作
适配器模式的两种实现方式：
类适配器模式：
- 使用继承来实现适配器
- 适配器类实现目标接口，继承被适配类，通过重写接口的方法实现适配
对象适配模式：
- 使用组合来实现适配器
- 适配器实现目标接口，持有一个配适配类对象，通过调用对象方法实现接口装换
优点
-
复用性：可以复用现有的类，而不需要修改它们的代码。
-
灵活性：对象适配器模式更灵活，可以适配多个被适配类。
-
解耦：将客户端与被适配类解耦，客户端只需要依赖目标接口。
缺点
-
复杂性：如果系统中存在大量适配器，可能会增加系统的复杂性。
-
性能问题：在某些情况下，适配器模式可能会引入额外的性能开销。
示例
假设我们有一个欧洲的电源插头（EuropeanPlug），它只能在欧洲标准的插座上使用。现在我们需要在美国的标准插座上使用这个插头，可以设计一个适配器（EuropeanToUSAdapter），将欧洲插头适配到美国插座。
目标接口（Target）
// 美国插座接口
interface USPlug {void plugInUS(); // 美国插座的接口方法
}
被适配类（Adaptee）
// 欧洲插头类
class EuropeanPlug {void plugInEurope() {System.out.println("Plugged in Europe (220V)");}
}
适配器类（Adapter）
类适配器模式
// 类适配器：通过继承实现
class EuropeanToUSAdapter extends EuropeanPlug implements USPlug {@Overridepublic void plugInUS() {System.out.println("Adapter converts European plug to US plug");plugInEurope(); // 调用被适配类的方法}
}
对象适配器模式
// 对象适配器：通过组合实现
class EuropeanToUSAdapter implements USPlug {private EuropeanPlug europeanPlug; // 持有被适配类的实例public EuropeanToUSAdapter(EuropeanPlug europeanPlug) {this.europeanPlug = europeanPlug;}@Overridepublic void plugInUS() {System.out.println("Adapter converts European plug to US plug");europeanPlug.plugInEurope(); // 调用被适配类的方法}
}
客户端代码
public class AdapterPatternDemo {public static void main(String[] args) {// 使用类适配器USPlug adapter1 = new EuropeanToUSAdapter();adapter1.plugInUS();// 使用对象适配器EuropeanPlug europeanPlug = new EuropeanPlug();USPlug adapter2 = new EuropeanToUSAdapter(europeanPlug);adapter2.plugInUS();}
}
UML类图
类适配器模式
对象适配器
外观模式
什么是外观模式
外观模式是一种结构型设计模式，为复杂的子系统提供了简单的接口，客户端通过调用接口即可操作复杂的子系统。
外观模式的角色：
- 外观类：提供简单的接口，客户端通过这些接口，和负责的子系统做交互
- 子系统类：实现系统的具体功能，外观类会调用子系统类的方法
外观模式的特点：
- 提供调用子系统的接口，简化客户端代码，让客户端和子系统解除耦合
外观模式的优点：
- 简化客户端代码，直接调用外观类接口
- 解耦客户端和子系统
- 易扩展，易维护
- 符合开闭原则
代码示例
假设我们有一个复杂的多媒体系统，包含音频播放器、视频播放器和灯光控制器。我们可以为这个系统创建一个外观类 MultimediaFacade，客户端只需要与 MultimediaFacade 交互，而不需要直接操作各个子系统。
// 子系统类：音频播放器
class AudioPlayer {public void on() {System.out.println("Audio Player is on");}public void play(String audio) {System.out.println("Playing audio: " + audio);}public void off() {System.out.println("Audio Player is off");}
}// 子系统类：视频播放器
class VideoPlayer {public void on() {System.out.println("Video Player is on");}public void play(String video) {System.out.println("Playing video: " + video);}public void off() {System.out.println("Video Player is off");}
}// 子系统类：灯光控制器
class LightController {public void dim() {System.out.println("Lights are dimmed");}public void brighten() {System.out.println("Lights are brightened");}
}// 外观类：多媒体系统
class MultimediaFacade {private AudioPlayer audioPlayer;private VideoPlayer videoPlayer;private LightController lightController;public MultimediaFacade() {this.audioPlayer = new AudioPlayer();this.videoPlayer = new VideoPlayer();this.lightController = new LightController();}public void startMovie(String audio, String video) {System.out.println("Starting the movie...");lightController.dim();audioPlayer.on();audioPlayer.play(audio);videoPlayer.on();videoPlayer.play(video);}public void endMovie() {System.out.println("Ending the movie...");audioPlayer.off();videoPlayer.off();lightController.brighten();}
}// 客户端代码
public class FacadePatternDemo {public static void main(String[] args) {MultimediaFacade multimediaFacade = new MultimediaFacade();// 开始播放电影multimediaFacade.startMovie("Background Music", "Movie Title");// 结束播放电影multimediaFacade.endMovie();}
}
uml
桥接模式
什么是桥接模式
桥接模式是一种结构型设计模式，它的特点是将抽象和实现分类，让两者能够独立，并在抽象中引用(桥接)实现，调用实现的方法完成逻辑实现。
桥接模式的核心思想：
- 实现部分：定义底层的操作逻辑，也就是我要怎么实现
- 抽象部分：定义高层的控制逻辑，也就是我要实现什么
- 桥接：通过在抽象的部分应用实现的对象，建立连接而不会是继承，使得两者可以独立扩展
实现部分只需要对自己的任务进行实现，不需要知道抽象部分的存在；抽象部分定义控制逻辑，我要实现什么样的东西，需要依赖于实现部分，但是不需要知道他的具体实现，只需要去依赖一个具体实现不需要关心它怎么实现。
什么是桥接：
- 桥接就是将抽象和实现关联起来，也就是在抽象的部分应用实现，这个引用的操作就是桥接
- 通过引用而不是继承，使得实现和抽象之间可以相互独立，独立扩展
优点：
- 将抽象和实现进行分离，两者可以独立扩展
- 避免了类爆炸，分离抽象和实现，避免了每一种组合都创建一个类
- 易维护，可扩展
- 符合开闭原则
代码示例
// 实现部分的接口：颜色
interface Color {void applyColor();
}// 具体实现类：红色
class RedColor implements Color {@Overridepublic void applyColor() {System.out.println("Applying red color");}
}// 具体实现类：绿色
class GreenColor implements Color {@Overridepublic void applyColor() {System.out.println("Applying green color");}
}// 抽象部分：形状
abstract class Shape {protected Color color; // 桥接：持有颜色的引用public Shape(Color color) {this.color = color;}abstract void draw(); // 抽象方法，子类实现
}// 具体抽象类：圆形
class Circle extends Shape {public Circle(Color color) {super(color);}@Overridevoid draw() {System.out.print("Drawing Circle. ");color.applyColor(); // 使用桥接的颜色}
}// 具体抽象类：矩形
class Rectangle extends Shape {public Rectangle(Color color) {super(color);}@Overridevoid draw() {System.out.print("Drawing Rectangle. ");color.applyColor(); // 使用桥接的颜色}
}// 客户端代码
public class BridgePatternDemo {public static void main(String[] args) {// 创建颜色对象Color red = new RedColor();Color green = new GreenColor();// 创建形状对象，并桥接颜色Shape redCircle = new Circle(red);Shape greenRectangle = new Rectangle(green);// 绘制形状redCircle.draw(); // 输出：Drawing Circle. Applying red colorgreenRectangle.draw(); // 输出：Drawing Rectangle. Applying green color}
}
uml
