创建型设计模式
创建型设计模式主要关注对象的创建过程，旨在使系统独立于对象的创建、组合和表示。这类模式通过抽象实例化过程，帮助我们在系统中灵活地创建对象，而不必依赖于具体的类。创建型设计模式包括以下几种：
单例模式（Singleton Pattern）
工厂方法模式（Factory Method Pattern）
抽象工厂模式（Abstract Factory Pattern）
建造者模式（Builder Pattern）
原型模式（Prototype Pattern）
1. 单例模式
单例模式就像是一个国家的总统，无论你在哪里访问总统，你访问的都是同一个人。总统是唯一的，且全局可访问。
单例模式确保一个类只有一个实例，并提供一个全局访问点。
public class President {
// 私有静态实例，确保唯一性
private static President instance;
// 私有构造函数，防止外部实例化
private President() {}
// 全局访问点
public static President getInstance() {
if (instance == null) {
instance = new President();
}
return instance;
}
public void speak() {
System.out.println("I am the President.");
}
}
// 使用单例模式
public class Main {
public static void main(String[] args) {
President president = President.getInstance();
president.speak(); // 输出: I am the President.
}
}2. 工厂方法模式
工厂方法模式就像是一个汽车制造厂，不同的工厂生产不同的汽车型号。你不需要知道具体的制造过程，只需要告诉工厂你需要什么类型的汽车。
工厂方法模式定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个。工厂方法模式使类的实例化推迟到子类。
// 产品接口
interface Car {
void drive();
}
// 具体产品
class Sedan implements Car {
@Override
public void drive() {
System.out.println("Driving a Sedan.");
}
}
class SUV implements Car {
@Override
public void drive() {
System.out.println("Driving an SUV.");
}
}
// 工厂接口
interface CarFactory {
Car createCar();
}
// 具体工厂
class SedanFactory implements CarFactory {
@Override
public Car createCar() {
return new Sedan();
}
}
class SUVFactory implements CarFactory {
@Override
public Car createCar() {
return new SUV();
}
}
// 使用工厂方法模式
public class Main {
public static void main(String[] args) {
CarFactory sedanFactory = new SedanFactory();
Car sedan = sedanFactory.createCar();
sedan.drive(); // 输出: Driving a Sedan.
CarFactory suvFactory = new SUVFactory();
Car suv = suvFactory.createCar();
suv.drive(); // 输出: Driving an SUV.
}
}3. 抽象工厂模式
抽象工厂模式就像一个家具厂，它可以生产一系列相关的产品，比如椅子、桌子和沙发。你不需要关心具体的生产过程，只需要选择你想要的家具风格（现代、古典等）。
抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
// 产品接口
interface Chair {
void sitOn();
}
interface Table {
void putOn();
}
// 具体产品
class ModernChair implements Chair {
@Override
public void sitOn() {
System.out.println("Sitting on a Modern Chair.");
}
}
class ModernTable implements Table {
@Override
public void putOn() {
System.out.println("Putting something on a Modern Table.");
}
}
class ClassicChair implements Chair {
@Override
public void sitOn() {
System.out.println("Sitting on a Classic Chair.");
}
}
class ClassicTable implements Table {
@Override
public void putOn() {
System.out.println("Putting something on a Classic Table.");
}
}
// 抽象工厂接口
interface FurnitureFactory {
Chair createChair();
Table createTable();
}
// 具体工厂
class ModernFurnitureFactory implements FurnitureFactory {
@Override
public Chair createChair() {
return new ModernChair();
}
@Override
public Table createTable() {
return new ModernTable();
}
}
class ClassicFurnitureFactory implements FurnitureFactory {
@Override
public Chair createChair() {
return new ClassicChair();
}
@Override
public Table createTable() {
return new ClassicTable();
}
}
// 使用抽象工厂模式
public class Main {
public static void main(String[] args) {
FurnitureFactory modernFactory = new ModernFurnitureFactory();
Chair modernChair = modernFactory.createChair();
Table modernTable = modernFactory.createTable();
modernChair.sitOn(); // 输出: Sitting on a Modern Chair.
modernTable.putOn(); // 输出: Putting something on a Modern Table.
FurnitureFactory classicFactory = new ClassicFurnitureFactory();
Chair classicChair = classicFactory.createChair();
Table classicTable = classicFactory.createTable();
classicChair.sitOn(); // 输出: Sitting on a Classic Chair.
classicTable.putOn(); // 输出: Putting something on a Classic Table.
}
}4. 建造者模式
建造者模式就像是一个建筑工地的项目经理，他负责协调各个工人（如木工、电工、水管工）来建造一栋房子。项目经理不需要知道每个工人的具体工作细节，只需要确保房子按照设计图纸一步步建造完成。
建造者模式将一个复杂对象的构建与其表示分离，使得同样的构建过程可以创建不同的表示。
// 产品类
class House {
private String foundation;
private String structure;
private String roof;
public void setFoundation(String foundation) {
this.foundation = foundation;
}
public void setStructure(String structure) {
this.structure = structure;
}
public void setRoof(String roof) {
this.roof = roof;
}
@Override
public String toString() {
return "House [foundation=" + foundation + ", structure=" + structure + ", roof=" + roof + "]";
}
}
// 抽象建造者
interface HouseBuilder {
void buildFoundation();
void buildStructure();
void buildRoof();
House getHouse();
}
// 具体建造者
class ConcreteHouseBuilder implements HouseBuilder {
private House house;
public ConcreteHouseBuilder() {
this.house = new House();
}
@Override
public void buildFoundation() {
house.setFoundation("Concrete Foundation");
}
@Override
public void buildStructure() {
house.setStructure("Concrete Structure");
}
@Override
public void buildRoof() {
house.setRoof("Concrete Roof");
}
@Override
public House getHouse() {
return this.house;
}
}
// 导演类
class ConstructionEngineer {
private HouseBuilder houseBuilder;
public ConstructionEngineer(HouseBuilder houseBuilder) {
this.houseBuilder = houseBuilder;
}
public House constructHouse() {
houseBuilder.buildFoundation();
houseBuilder.buildStructure();
houseBuilder.buildRoof();
return houseBuilder.getHouse();
}
}
// 使用建造者模式
public class Main {
public static void main(String[] args) {
HouseBuilder builder = new ConcreteHouseBuilder();
ConstructionEngineer engineer = new ConstructionEngineer(builder);
House house = engineer.constructHouse();
System.out.println(house); // 输出: House [foundation=Concrete Foundation, structure=Concrete Structure, roof=Concrete Roof]
}
}5. 原型模式
原型模式就像是一个复印机，你可以通过复印机复制一份已经存在的文档，而不需要重新手写一遍。复印机通过复制现有的文档来生成新的文档。
原型模式通过复制现有的实例来创建新的实例，而不是通过新建类的方式。它通常用于创建成本较高的对象。
// 原型接口
interface Prototype {
Prototype clone();
}
// 具体原型
class Document implements Prototype {
private String content;
public Document(String content) {
this.content = content;
}
public void setContent(String content) {
this.content = content;
}
public String getContent() {
return content;
}
@Override
public Prototype clone() {
return new Document(this.content);
}
@Override
public String toString() {
return "Document [content=" + content + "]";
}
}
// 使用原型模式
public class Main {
public static void main(String[] args) {
Document original = new Document("Original Content");
Document copy = (Document) original.clone();
copy.setContent("Copied Content");
System.out.println(original); // 输出: Document [content=Original Content]
System.out.println(copy); // 输出: Document [content=Copied Content]
}
}评论