文章目录
结构型模式
适配器模式
一、概述
将一个类的接口转换成客户希望的另外一个接口。Adapter
模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。
二、适用性
- 使用一个已经存在的类,而它的接口不符合你的需求。
- 创建一个可以复用的类,该类可以与其他不相关的类或不可预见的类(即那些接口 可能不一定兼容的类)协同工作。
- (仅适用于对象
Adapter
)使用一些已经存在的子类,但是不可能对每一个都进行 子类化以匹配它们的接口。对象适配器可以适配它的父类接口。
三、参与者
Target
定义Client
使用的与特定领域相关的接口。Client
与符合Target
接口的对象协同。Adaptee
定义一个已经存在的接口,这个接口需要适配。Adapter
对Adaptee
的接口与Target
接口进行适配
四、类图
五、示例
- Target
package com.cz.Adaptermode.adapter;
/**
* @Author: zhang
* @Date: 2021/3/30 - 16:00
* @Descripetion: 定义Target接口
**/
public interface Target {
void adapteeMethod();
void adapterMethod();
}
- Adaptee
package com.cz.Adaptermode.adapter;
/**
* @Author: zhang
* @Date: 2021/3/30 - 16:01
* @Descripetion: 适配器类
**/
public class Adaptee {
public void adapteeMethod(){
System.out.println("Adaptee method!");
}
}
- Adapter
package com.cz.Adaptermode.adapter;
/**
* @Author: zhang
* @Date: 2021/3/30 - 16:02
* @Descripetion: Target的实现类
**/
public class Adapter implements Target {
private Adaptee adaptee;
public Adapter(Adaptee adaptee) {
this.adaptee = adaptee;
}
@Override
public void adapteeMethod() {
adaptee.adapteeMethod();
}
@Override
public void adapterMethod() {
System.out.println("Adapter method!");
}
}
- Client
package com.cz.Adaptermode.adapter;
/**
* @Author: zhang
* @Date: 2021/3/30 - 16:06
* @Descripetion: 测试类
**/
public class Test {
public static void main(String[] args) {
Target target = new Adapter(new Adaptee());
target.adapteeMethod();
target.adapterMethod();
}
}
- 运行结果:
装饰模式
一、概述
动态地给一个对象添加一些额外的职责。就增加功能来说,Decorator
模式相比生成子类更为灵活。
二、适用性
- 在不影响其他对象的情况下,以动态、透明的方式给单个对象添加职责。
- 处理那些可以撤消的职责。
- 当不能采用生成子类的方法进行扩充时。
三、参与者
Component
定义一个对象接口,可以给这些对象动态地添加职责。ConcreteComponent
定义一个对象,可以给这个对象添加一些职责。Decorator
维持一个指向Component
对象的指针,并定义一个与Component
接口一致的接口。ConcreteDecorator
向组件添加职责。
四、类图
五、示例
- Component
package com.cz.Adaptermode.decorator;
/**
* @Author: zhang
* @Date: 2021/3/30 - 16:10
* @Descripetion: 定义Component接口Person
**/
public interface Person {
void eat();
}
- ConcreteComponent
package com.cz.Adaptermode.decorator;
/**
* @Author: zhang
* @Date: 2021/3/30 - 16:11
* @Descripetion: Person接口的实现类Man
**/
public class Man implements Person {
public void eat(){
System.out.println("男人在吃");
}
}
- Decorator
package com.cz.Adaptermode.decorator;
/**
* @Author: zhang
* @Date: 2021/3/30 - 16:12
* @Descripetion: Decorator抽象类实现Person接口
**/
public abstract class Decorator implements Person {
protected Person person;
public void setPerson(Person person){
this.person = person;
}
@Override
public void eat() {
person.eat();
}
}
- ConcreteDecorator
package com.cz.Adaptermode.decorator;
/**
* @Author: zhang
* @Date: 2021/3/30 - 16:14
* @Descripetion: Decorator的子类
**/
public class ManDecoratorA extends Decorator {
public void eat(){
super.eat();
reEat();
System.out.println("ManDecoratorA类");
}
public void reEat(){
System.out.println("再吃一顿饭");
}
}
package com.cz.Adaptermode.decorator;
/**
* @Author: zhang
* @Date: 2021/3/30 - 16:16
* @Descripetion: Decorator的子类
**/
public class ManDecoratorB extends Decorator {
public void eat(){
super.eat();
System.out.println("=====================");
System.out.println("ManDecoratorB类");
}
}
- Test
package com.cz.Adaptermode.decorator;
/**
* @Author: zhang
* @Date: 2021/3/30 - 16:17
* @Descripetion: 测试类
**/
public class Test {
public static void main(String[] args) {
Man man = new Man();
ManDecoratorA mdA = new ManDecoratorA();
ManDecoratorB mdB = new ManDecoratorB();
mdA.setPerson(man);
mdB.setPerson(mdA);
mdB.eat();
}
}
- 运行结果:
外观模式
一、概述
为子系统中的一组接口提供一个一致的界面,Facade
模式定义了一个高层接口,这个接口使得这一子系统更加容易使用。
二、适用性
- 当要为一个复杂子系统提供一个简单接口时。子系统往往因为不断演化而变得越来越 复杂。大多数模式使用时都会产生更多更小的类。这使得子系统更具可重用性,也更容 易对子系统进行定制,但这也给那些不需要定制子系统的用户带来一些使用上的困难。
Facade
可以提供一个简单的缺省视图,这一视图对大多数用户来说已经足够,而那些需 要更多的可定制性的用户可以越过facade层。 - 客户程序与抽象类的实现部分之间存在着很大的依赖性。引入
facade
将这个子系统与客 户以及其他的子系统分离,可以提高子系统的独立性和可移植性。 - 当需要构建一个层次结构的子系统时,使用
facade
模式定义子系统中每层的入口点。 如果子系统之间是相互依赖的,你可以让它们仅通过facade进行通讯,从而简化了它们 之间的依赖关系。
三、参与者
Facade
知道哪些子系统类负责处理请求。 将客户的请求代理给适当的子系统对象。Subsystemclasses
实现子系统的功能。 处理由Facade
对象指派的任务。 没有facade的任何相关信息;即没有指向facade
的指针。
四、类图
五、示例
- Facade
package com.cz.Adaptermode.facade;
import com.sun.xml.internal.ws.wsdl.writer.document.Service;
import java.awt.*;
/**
* @Author: zhang
* @Date: 2021/3/30 - 18:26
* @Descripetion: hapeFacede当做Shape各个子系统(Circle/Rectangle/Square)的门面
**/
public class Facade {
/**
* 画圆子系统
*/
private Shape circle;
/**
* 画矩形子系统
*/
private Shape rectangle;
/**
* 画正方形子系统
*/
private Shape square;
public Facade() {
circle = new Circle();
rectangle = new Rectangle();
square = new Square();
}
/**
* 画圆
*/
public void drawCircle(){
circle.drawShape();;
}
/**
* 画矩形
*/
public void drawRectangle(){
rectangle.drawShape();;
}
/**
* 画正方形
*/
public void drawSquare(){
square.drawShape();;
}
}
Subsystemclasses
package com.cz.Adaptermode.facade;
/**
* @Author: zhang
* @Date: 2021/3/30 - 18:57
* @Descripetion: Shape系统
**/
public abstract class Shape {
abstract void drawShape();
}
class Circle extends Shape {
@Override
void drawShape() {
System.out.println("Circle:Shape");
}
}
class Rectangle extends Shape {
@Override
void drawShape() {
System.out.println("Rectangle:Shape");
}
}
class Square extends Shape {
@Override
void drawShape() {
System.out.println("Square:Shape");
}
}
- Test
package com.cz.Adaptermode.facade;
/**
* @Author: zhang
* @Date: 2021/3/30 - 18:34
* @Descripetion: 测试类
**/
public class Test {
public static void main(String[] args) {
/*使用门面和各个子系统交互*/
Facade facade = new Facade();
facade.drawCircle();
facade.drawRectangle();
facade.drawSquare();
}
}
- 运行结果:
代理模式
一、概述
为其他对象提供一种代理以控制对这个对象的访问。
二、适用性
- 远程代理(
RemoteProxy
)为一个对象在不同的地址空间提供局部代表。 - 虚代理(
VirtualProxy
)根据需要创建开销很大的对象。 - 保护代理(
ProtectionProxy
)控制对原始对象的访问。智能指引(SmartReference
)取代了简单的指针,它在访问对象时执行一些附加操作。
三、参与者
Proxy
保存一个引用使得代理可以访问实体。若RealSubject
和Subject
的接口相同,Proxy
会引用Subject
。 提供一个与Subject
的接口相同的接口,这样代理就可以用来替代实体。 控制对实体的存取,并可能负责创建和删除它。 其他功能依赖于代理的类型:RemoteProxy
负责对请求及其参数进行编码,并向不同地址空间中的实体发送已编码的请求。VirtualProxy
可以缓存实体的附加信息,以便延迟对它的访问。ProtectionProxy
检查调用者是否具有实现一个请求所必需的访问权限。Subject
定义RealSubject
和Proxy
的共用接口,这样就在任何使用RealSubject
的地方都可以使用Proxy
。RealSubject
定义Proxy
所代表的实体
四、类图
五、示例
- Proxy
package com.cz.Adaptermode.proxy;
/**
* @Author: zhang
* @Date: 2021/3/30 - 19:04
* @Descripetion: Proxy
**/
public class ProxyObject implements Object {
Object object;
public ProxyObject(){
System.out.println("这是代理类");
object = new ObjectImpl();
}
public void action(){
System.out.println("代理开始");
object.action();
System.out.println("代理结束");
}
}
- Subject
package com.cz.Adaptermode.proxy;
/**
* @Author: zhang
* @Date: 2021/3/30 - 19:07
* @Descripetion: Subject
**/
public interface Object {
void action();
}
- RealSubject
package com.cz.Adaptermode.proxy;
/**
* @Author: zhang
* @Date: 2021/3/30 - 19:08
* @Descripetion: RealSubject
**/
public class ObjectImpl implements Object {
@Override
public void action() {
System.out.println("================");
System.out.println("================");
System.out.println("这是被代理的类");
System.out.println("================");
System.out.println("================");
}
}
- Test
package com.cz.Adaptermode.proxy;
/**
* @Author: zhang
* @Date: 2021/3/30 - 19:09
* @Descripetion: 测试类
**/
public class Test {
public static void main(String[] args) {
Object object = new ProxyObject();
object.action();
}
}
- 运行结果:
桥接模式
一、概述
将抽象部分与它的实现部分分离,使它们都可以独立地变化。
二、适用性
- 不希望在抽象和它的实现部分之间有一个固定的绑定关系。 例如这种情况可能是因为,在程序运行时刻实现部分应可以被选择或者切换。
- 类的抽象以及它的实现都应该可以通过生成子类的方法加以扩充。 这时Bridge模式使你可以对不同的抽象接口和实现部分进行组合,并分别对它们进行扩充。
- 对一个抽象的实现部分的修改应对客户不产生影响,即客户的代码不必重新编译。
- 正如在意图一节的第一个类图中所示的那样,有许多类要生成。 这样一种类层次结构说明你必须将一个对象分解成两个部分。
- 在多个对象间共享实现(可能使用引用计数),但同时要求客户并不知道这一点。
三、参与者
Abstraction
定义抽象类的接口。 维护一个指向Implementor类型对象的指针。RefinedAbstraction
扩充由Abstraction
定义的接口。Implementor
定义实现类的接口,该接口不一定要与Abstraction
的接口完全一致。 事实上这两个接口可以完全不同。 一般来讲,Implementor
接口仅提供基本操作,而Abstraction
则定义了基于这些基本操作的较高层次的操作。ConcreteImplementor
实现Implementor
接口并定义它的具体实现。
四、类图
五、示例
- Abstraction
package com.cz.Adaptermode.bridge;
/**
* @Author: zhang
* @Date: 2021/3/30 - 19:15
* @Descripetion: 定义Abstraction Person类
**/
public abstract class Person {
private Clothing clothing;
private String type;
public Clothing getClothing(){
return clothing;
}
public void setClothing(Clothing clothing){
this.clothing = clothing;
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
public abstract void dress();
}
- RefinedAbstraction
package com.cz.Adaptermode.bridge;
/**
* @Author: zhang
* @Date: 2021/3/30 - 19:18
* @Descripetion: 定义RefinedAbstraction类Man
**/
public class Man extends Person {
public Man(){
setType("猛男");
}
public void dress(){
Clothing clothing = getClothing();
clothing.personDressCloth(this);
}
}
package com.cz.Adaptermode.bridge;
/**
* @Author: zhang
* @Date: 2021/3/30 - 19:20
* @Descripetion: 定义RefinedAbstraction类Lady
**/
public class Lady extends Person {
public Lady(){
setType("美女");
}
public void dress(){
Clothing clothing = getClothing();
clothing.personDressCloth(this);
}
}
- Implementor
package com.cz.Adaptermode.bridge;
/**
* @Author: zhang
* @Date: 2021/3/30 - 19:22
* @Descripetion: 定义Implementor 类Clothing
**/
public abstract class Clothing {
public abstract void personDressCloth(Person person);
}
- ConcreteImplementor
package com.cz.Adaptermode.bridge;
/**
* @Author: zhang
* @Date: 2021/3/30 - 19:23
* @Descripetion: 定义ConcreteImplementor类Jacket
**/
public class Jacket extends Clothing {
@Override
public void personDressCloth(Person person) {
System.out.println(person.getType() + "是西装暴徒");
}
}
package com.cz.Adaptermode.bridge;
/**
* @Author: zhang
* @Date: 2021/3/30 - 19:25
* @Descripetion: 定义ConcreteImplementor类 Trouser
**/
public class Trouser extends Clothing {
@Override
public void personDressCloth(Person person) {
System.out.println(person.getType() + "劫富济贫");
}
}
- Test
package com.cz.Adaptermode.bridge;
/**
* @Author: zhang
* @Date: 2021/3/30 - 19:26
* @Descripetion: 测试类
**/
public class Test {
public static void main(String[] args) {
Person man = new Man();
Person lady = new Lady();
Clothing jacket = new Jacket();
Clothing trouser = new Trouser();
jacket.personDressCloth(man);
trouser.personDressCloth(man);
jacket.personDressCloth(lady);
trouser.personDressCloth(lady);
}
}
- 运行结果:
组合模式
一、概述
将对象组合成树形结构以表示"部分-整体”的层次结构。"Composite使得用户对单个对象和组合对象的使用具有一致性。
二、适用性
- 表示对象的部分-整体层次结构。
- 希望用户忽略组合对象与单个对象的不同,用户将统一地使用组合结构中的所有对象。
三、参与者
Component
为组合中的对象声明接口。 在适当的情况下,实现所有类共有接口的缺省行为。 声明一个接口用于访问和管理Component
的子组件。 (可选)在递归结构中定义一个接口,用于访问一个父部件,并在合适的情况下实现它。Leaf
在组合中表示叶节点对象,叶节点没有子节点。 在组合中定义节点对象的行为。Composite
定义有子部件的那些部件的行为。 存储子部件。 在Component
接口中实现与子部件有关的操作。Client
通过Component
接口操纵组合部件的对象。
四、类图
五、示例
- Component
package com.cz.Adaptermode.composite;
import java.util.List;
/**
* @Author: zhang
* @Date: 2021/3/30 - 19:31
* @Descripetion: 定义Component 类Employer
**/
public abstract class Employer {
private String name;
public String getName() {
return this.name;
}
public void setName(String name) {
this.name = name;
}
public abstract void add(Employer employer);
public abstract void delete(Employer employer);
public List<Employer> employers;
public void printInfo(){
System.out.println(name);
}
public List<Employer> getEmployers(){
return this.employers;
}
}
- Leaf
package com.cz.Adaptermode.composite;
/**
* @Author: zhang
* @Date: 2021/3/30 - 19:36
* @Descripetion: 定义Leaf类Programmer
**/
public class Programmer extends Employer {
public Programmer(String name){
setName(name);
employers = null;//程序员, 表示没有下属了
}
@Override
public void add(Employer employer) {
}
@Override
public void delete(Employer employer) {
}
}
package com.cz.Adaptermode.composite;
/**
* @Author: zhang
* @Date: 2021/3/30 - 19:38
* @Descripetion: 定义Leaf类ProjectAssistant
**/
public class ProjectAssistant extends Employer {
public ProjectAssistant(String name){
setName(name);
employers = null;//项目助理, 表示没有下属了
}
@Override
public void add(Employer employer) {
}
@Override
public void delete(Employer employer) {
}
}
- Composite
package com.cz.Adaptermode.composite;
import java.util.ArrayList;
/**
* @Author: zhang
* @Date: 2021/3/30 - 19:39
* @Descripetion: 定义Composite类ProjectManager类
**/
public class ProjectManager extends Employer{
public ProjectManager(String name){
setName(name);
employers = new ArrayList<Employer>();
}
@Override
public void add(Employer employer) {
employers.add(employer);
}
@Override
public void delete(Employer employer) {
employers.remove(employer);
}
}
- Client
package com.cz.Adaptermode.composite;
import java.util.List;
/**
* @Author: zhang
* @Date: 2021/3/30 - 19:41
* @Descripetion: 测试类
**/
public class Test {
public static void main(String[] args) {
Employer pm = new ProjectManager("项目经理");
Employer pa = new ProjectAssistant("项目助理");
Employer programmer1 = new Programmer("程序员一");
Employer programmer2 = new Programmer("程序员二");
pm.add(pa);//为项目经理添加项目助理
pm.add(programmer2);//为项目经理添加程序员
List<Employer> ems = pm.getEmployers();
for (Employer em :ems){
System.out.println(em.getName());
}
}
}
- 运行结果:
享元模式
一、概述
运用共享技术有效地支持大量细粒度的对象。
二、适用性
当都具备下列情况时,使用Flyweight模式:
- 一个应用程序使用了大量的对象。
- 完全由于使用大量的对象,造成很大的存储开销。
- 对象的大多数状态都可变为外部状态。
- 如果删除对象的外部状态,那么可以用相对较少的共享对象取代很多组对象。
- 应用程序不依赖于对象标识。由于Flyweight对象可以被共享,对于概念上明显有别的对象,标识测试将返回真值。
三、参与者
Flyweight
描述一个接口,通过这个接口flyweight
可以接受并作用于外部状态。ConcreteFlyweight
实现Flyweight
接口,并为内部状态(如果有的话)增加存储空间。ConcreteFlyweight
对象必须是可共享的。它所存储的状态必须是内部的;即,它必须独立于ConcreteFlyweight
对象的场景。UnsharedConcreteFlyweight
并非所有的Flyweight
子类都需要被共享。Flyweight
接口使共享成为可能,但它并不强制共享。 在Flyweight对象结构的某些层次,UnsharedConcreteFlyweight
对象通常将ConcreteFlyweight
对象作为子节点。FlyweightFactory
创建并管理flyweight
对象。 确保合理地共享flyweight
。当用户请求一个flyweight
时,FlyweightFactory
对象提供一个已创建的实例或者创建一个(如果不存在的话)。
四、类图
五、示例
- Flyweight
package com.cz.Adaptermode.flyweight;
/**
* @Author: zhang
* @Date: 2021/3/30 - 19:48
* @Descripetion: Flyweight
**/
public interface Flyweight {
void action(int arg);
}
- ConcreteFlyweight
package com.cz.Adaptermode.flyweight;
/**
* @Author: zhang
* @Date: 2021/3/30 - 19:48
* @Descripetion: ConcreteFlyweight
**/
public class FlyweightImpl implements Flyweight {
@Override
public void action(int arg) {
System.out.println("参数值: " + arg);
}
}
- FlyweightFactory
package com.cz.Adaptermode.flyweight;
import java.util.HashMap;
import java.util.Map;
/**
* @Author: zhang
* @Date: 2021/3/30 - 19:49
* @Descripetion: FlyweightFactory
**/
public class FlyweightFactory {
private static Map flyweights = new HashMap();
public FlyweightFactory(String arg){
flyweights.put(arg, new FlyweightImpl());
}
public static Flyweight getFlyweight(String key){
if (flyweights.get(key) == null){
flyweights.put(key, new FlyweightImpl());
}
return (Flyweight) flyweights.get(key);
}
public static int getSize(){
return flyweights.size();
}
}
- Test
package com.cz.Adaptermode.flyweight;
/**
* @Author: zhang
* @Date: 2021/3/30 - 19:53
* @Descripetion: 测试类
**/
public class Test {
public static void main(String[] args) {
Flyweight fly1 = FlyweightFactory.getFlyweight("a");
fly1.action(1);
Flyweight fly2 = FlyweightFactory.getFlyweight("a");
System.out.println(fly1 == fly2);
Flyweight fly3 = FlyweightFactory.getFlyweight("b");
fly3.action(2);
Flyweight fly4 = FlyweightFactory.getFlyweight("c");
fly4.action(3);
Flyweight fly5 = FlyweightFactory.getFlyweight("d");
fly4.action(4);
System.out.println(FlyweightFactory.getSize());
}
}
- 运行结果: