2.1_Design_Patterns
Creational, Structural, and Behavioural Patterns
The Gang of Four’s catalog contains 23 patterns categorized into Creational, Structural, and Behavioral patterns. 根据不同的项目选择不同的设计模式
Creational Patterns 创建型模式
它们帮助一个系统独立于如何创建、组合和表示它的那些对象。
- 一个类创建型模式使用继承改变被实例化的类。
- 一个对象创建型模式将实例化委托给另一个对象。
Singleton Pattern
一个类只实例化一个对象，实现方式是将构造函数私有化，通过调用公用的getInstance来获取对象。
Factory Method Pattern
创建一个工厂，负责创建相关的对象。其他类通过调用工厂的创建函数来创建对象。这些对象的使用者不需要关心对象是如何创建的
Factory Method设计目的是定义一个创建对象的接口，让子类决定实例化哪个类
主要参与者
- Creator: factory method的父类或者接口，返回一个产品实例对象。Creator创建完产品以后，可以再执行一些默认动作。
- Concrete Creator: Creator的子类，实现了类中的factory method，创建指定类型的产品。
- Product: factory method创建出来的产品的接口或抽象类。
- Concrete Product: 具体的产品，对于Product的实现。
// Product Interface
public interface Vehicle {
void manufacture();
}
// Concrete Products
public class Car implements Vehicle {
@Override
public void manufacture() {
System.out.println("Manufacturing a Car");
}
}
public class Motorcycle implements Vehicle {
@Override
public void manufacture() {
System.out.println("Manufacturing a Motorcycle");
}
}
// Creator
public abstract class VehicleFactory {
public Vehicle orderVehicle(String type) {
Vehicle vehicle = createVehicle(type);
vehicle.manufacture();
// Other vehicle related operations
return vehicle;
}
protected abstract Vehicle createVehicle(String type);
}
// Concrete Creators
public class CarFactory extends VehicleFactory {
@Override
protected Vehicle createVehicle(String type) {
if (type.equals("car")) {
return new Car();
} else {
throw new IllegalArgumentException("Invalid vehicle type: " + type);
}
}
}
public class MotorcycleFactory extends VehicleFactory {
@Override
protected Vehicle createVehicle(String type) {
if (type.equals("motorcycle")) {
return new Motorcycle();
} else {
throw new IllegalArgumentException("Invalid vehicle type: " + type);
}
}
}
public class Main {
public static void main(String[] args) {
VehicleFactory carFactory = new CarFactory();
VehicleFactory motorcycleFactory = new MotorcycleFactory();
Vehicle vehicle1 = carFactory.orderVehicle("car");
System.out.println("Ordered: " + vehicle1.getClass().getSimpleName());
Vehicle vehicle2 = motorcycleFactory.orderVehicle("motorcycle");
System.out.println("Ordered: " + vehicle2.getClass().getSimpleName());
}
}
How It Works
Creator (VehicleFactory): Defines the orderVehicle method which uses createVehicle (the factory method) to instantiate the desired vehicle type (Car or Motorcycle).
Concrete Creators (CarFactory, MotorcycleFactory): Implement createVehicle to return specific types of vehicles (Car, Motorcycle).
Product (Vehicle) and Concrete Products (Car, Motorcycle): Define the interface (Vehicle) and concrete implementations (Car, Motorcycle) which the creators (VehicleFactory subclasses) instantiate.
Benefits
Flexibility: Allows adding new vehicle types (Car variations, Motorcycle variations) without modifying existing code (VehicleFactory).
Encapsulation: Encapsulates object creation logic, promoting code readability and maintenance.
Separation of Concerns: Separates client code from object creation, promoting single responsibility principle.
Structure Patterns 结构型模式
结构型模式关注对象之间的关系
Behavior Patterns 行为型模式
用来识别对象之间的常用交流模式并加以实现