2.1_Design_Patterns

Abner Zhou 收录于 Coursera Software Design and Architecture

2024-06-23 约 736 字预计阅读 2 分钟

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 行为型模式

用来识别对象之间的常用交流模式并加以实现

目录