设计模式-工厂方法原型模板方法外观
设计模式概述 - 工厂方法 & 原型 & 模板方法 & 外观
工厂方法模式简述
工厂方法模式（Factory Method Pattern）是一种创建型设计模式，它定义了一个用于创建对象的接口，但由子类决定实例化哪个类。工厂方法将类的实例化推迟到子类。
角色
- 产品接口（Product）：定义产品的接口。
- 具体产品（ConcreteProduct）：实现产品接口的具体类。
- 工厂接口（Creator）：定义创建产品的工厂方法。
- 具体工厂（ConcreteCreator）：实现工厂接口，返回具体产品的实例。
优点
- 解耦：客户端不需要知道具体产品的类，只需依赖于产品接口。
- 扩展性：增加新产品时只需新增具体产品和具体工厂，而不需要修改已有代码。
缺点
- 类的数量增加：每增加一种产品，就需要增加一个具体产品和一个具体工厂，可能导致类的数量增加。
- 复杂性：对于简单的场景，使用工厂方法模式可能显得过于复杂。
示例代码
// 产品接口
interface Product {void use();
}// 具体产品A
class ConcreteProductA implements Product {@Overridepublic void use() {System.out.println("Using ConcreteProductA.");}
}// 具体产品B
class ConcreteProductB implements Product {@Overridepublic void use() {System.out.println("Using ConcreteProductB.");}
}// 工厂接口
abstract class Creator {public abstract Product factoryMethod();
}// 具体工厂A
class ConcreteCreatorA extends Creator {@Overridepublic Product factoryMethod() {return new ConcreteProductA();}
}// 具体工厂B
class ConcreteCreatorB extends Creator {@Overridepublic Product factoryMethod() {return new ConcreteProductB();}
}// 客户端代码
public class Client {public static void main(String[] args) {Creator creatorA = new ConcreteCreatorA();Product productA = creatorA.factoryMethod();productA.use();Creator creatorB = new ConcreteCreatorB();Product productB = creatorB.factoryMethod();productB.use();}
}
原型模式简述
原型模式（Prototype Pattern）是一种创建型设计模式，它通过复制现有的实例来创建新对象，而不是通过实例化一个新的对象。这种模式适用于创建相似对象的场景，尤其是在创建对象的成本较高时。
角色
- 原型接口（Prototype）：定义克隆方法。
- 具体原型（ConcretePrototype）：实现原型接口，提供具体的克隆方法。
- 客户端（Client）：使用原型对象来创建新的对象。
优点
- 性能提升：通过复制现有对象来创建新对象，避免了重复的初始化过程。
- 简化创建过程：可以通过克隆现有对象来简化对象的创建过程。
缺点
- 复杂性：实现克隆方法可能会增加代码的复杂性，尤其是在对象包含复杂的成员时。
- 深拷贝与浅拷贝：需要关注对象的拷贝方式，深拷贝和浅拷贝的选择可能会影响对象的状态。
示例代码
// 原型接口
interface Prototype {Prototype clone();
}// 具体原型
class ConcretePrototype implements Prototype {private String name;public ConcretePrototype(String name) {this.name = name;}public String getName() {return name;}@Overridepublic Prototype clone() {return new ConcretePrototype(this.name);}
}// 客户端代码
public class Client {public static void main(String[] args) {ConcretePrototype original = new ConcretePrototype("Original");ConcretePrototype clone = (ConcretePrototype) original.clone();System.out.println("Original Name: " + original.getName());System.out.println("Cloned Name: " + clone.getName());}
}
模板方法模式简述
模板方法模式（Template Method Pattern）是一种行为型设计模式，它定义了一个算法的骨架，并允许子类在不改变算法结构的情况下重新定义某些特定步骤。通过这种方式，模板方法模式可以实现代码复用和算法的灵活性。
角色
- 抽象类（AbstractClass）：定义模板方法和一些基本操作的接口。
- 具体类（ConcreteClass）：实现抽象类中的某些操作，完成特定的算法步骤。
优点
- 代码复用：通过将算法的公共部分放在抽象类中，减少了代码重复。
- 灵活性：子类可以根据需要重写某些步骤，灵活定制算法的具体实现。
缺点
- 增加复杂性：模板方法模式可能会导致类的数量增加，从而增加系统的复杂性。
- 限制扩展：子类只能重写抽象类中定义的方法，可能会限制某些灵活性。
示例代码
// 抽象类
abstract class AbstractClass {// 模板方法public final void templateMethod() {stepOne();stepTwo();stepThree();}// 基本方法protected abstract void stepOne();protected abstract void stepTwo();// 钩子方法protected void stepThree() {System.out.println("Default Step Three Implementation.");}
}// 具体类A
class ConcreteClassA extends AbstractClass {@Overrideprotected void stepOne() {System.out.println("ConcreteClassA: Step One Implementation.");}@Overrideprotected void stepTwo() {System.out.println("ConcreteClassA: Step Two Implementation.");}
}// 具体类B
class ConcreteClassB extends AbstractClass {@Overrideprotected void stepOne() {System.out.println("ConcreteClassB: Step One Implementation.");}@Overrideprotected void stepTwo() {System.out.println("ConcreteClassB: Step Two Implementation.");}@Overrideprotected void stepThree() {System.out.println("ConcreteClassB: Custom Step Three Implementation.");}
}// 客户端代码
public class Client {public static void main(String[] args) {AbstractClass classA = new ConcreteClassA();classA.templateMethod();System.out.println();AbstractClass classB = new ConcreteClassB();classB.templateMethod();}
}
外观模式简述
外观模式（Facade Pattern）是一种结构型设计模式，它为复杂的子系统提供一个统一的接口，使得子系统更易使用。通过外观模式，客户端可以通过一个简单的接口与复杂的系统进行交互，从而降低系统的复杂性。
角色
- 外观类（Facade）：提供一个简单的接口，封装了复杂的子系统。
- 子系统类（Subsystem）：实现具体的功能，通常由多个类组成。
优点
- 简化接口：通过提供统一的接口，简化了子系统的使用。
- 降低耦合：客户端与子系统之间的依赖关系减少，提高了系统的可维护性。
- 提高可读性：外观模式使得代码的结构更加清晰，易于理解。
缺点
- 可能导致功能膨胀：外观类可能会变得过于复杂，承担过多的责任。
- 不符合开放-封闭原则：如果子系统发生变化，可能需要修改外观类的实现。
示例代码
// 子系统类A
class SubsystemA {public void operationA() {System.out.println("SubsystemA: Operation A");}
}// 子系统类B
class SubsystemB {public void operationB() {System.out.println("SubsystemB: Operation B");}
}// 子系统类C
class SubsystemC {public void operationC() {System.out.println("SubsystemC: Operation C");}
}// 外观类
class Facade {private SubsystemA subsystemA;private SubsystemB subsystemB;private SubsystemC subsystemC;public Facade() {subsystemA = new SubsystemA();subsystemB = new SubsystemB();subsystemC = new SubsystemC();}public void simpleOperation() {subsystemA.operationA();subsystemB.operationB();subsystemC.operationC();}
}// 客户端代码
public class Client {public static void main(String[] args) {Facade facade = new Facade();facade.simpleOperation();}
}