Java设计模式-工厂方法模式（4）

大家好，我是馆长！从今天开始馆长开始对java设计模式的创建型模式中的单例模式、原型模式、工厂方法、抽象工厂、建造者的工厂方法模式进行讲解和说明。

工厂方法模式（Factory Method）

定义

工厂方法（FactoryMethod）模式的定义：定义一个创建产品对象的工厂接口，将产品对象的实际创建工作推迟到具体子工厂类当中。这满足创建型模式中所要求的“创建与使用相分离”的特点。工厂方法模式基本分为：简单工厂模式与工厂方法模式。

解决问题

类的实例化延迟：工厂方法模式通过将对象的实例化推迟到其子类，使得客户端代码可以与抽象类接口交互，而不依赖具体的实现类。这种灵活性允许系统更容易扩展和修改。

解耦客户端和具体类：客户端通过工厂方法创建对象，而不需要知道具体的实现类。这种解耦使得客户端代码不受具体类的影响，可以轻松切换或添加新的实现类，而不影响客户端代码的稳定性。

符合开闭原则：工厂方法模式使得系统更容易符合开闭原则，即对扩展开放，对修改关闭。通过添加新的具体工厂和产品类，而不需要修改现有的代码，实现了系统的可扩展性

结构

工厂模式包含角色：

抽象产品（Abstract Product）：定义了产品的共同接口或抽象类。它可以是具体产品类的父类或接口，规定了产品对象的共同方法。

具体产品（Concrete Product）：实现了抽象产品接口，定义了具体产品的特定行为和属性。

抽象工厂（Abstract Factory）：声明了创建产品的抽象方法，可以是接口或抽象类。它可以有多个方法用于创建不同类型的产品。

具体工厂（Concrete Factory）：实现了抽象工厂接口，负责实际创建具体产品的对象。

简单工厂模式：

   注意的是，简单工厂模式不是GOF设计模式中的模式，它是工厂模式的一种变形。是对有限个数的产品，或者固定不变，或者已经确定的产品进行创建。它只有一个工厂。

代码实现

//抽象产品 Shape
public interface Shape {
void draw();
}
//具体产品 Circle
public class Circle implements Shape {

@Override
public void draw() {
System.out.println(" Circle --> draw() method.");
}
}
//具体产品 Rectangle
public class Rectangle implements Shape {

@Override
public void draw() {
System.out.println("Rectangle --> draw() method.");
}
}
//具体产品 Square
public class Square implements Shape {

@Override
public void draw() {
System.out.println("Square --> draw() method.");
}
}
//产品类型枚举，
public enum ShapType {
CIRCLE("C"), RECTANGLE("R"), SQUARE("S");
private String type;

ShapType(String type) {
this.type = type;
}
}
//单一工厂
public class ShapeFactory {

//使用 getShape 方法获取形状类型的对象
public Shape getShape(ShapType type) {

switch (type) {
case CIRCLE:
return new Circle();
case RECTANGLE:
return new Rectangle();
case SQUARE:
return new Square();
default:
return null;
}
}
}
//模拟客户端
public class ClientDemo {

public static void main(String[] args) {
ShapeFactory shapeFactory = new ShapeFactory();

//获取 Circle 的对象，并调用它的 draw 方法
Shape circle = shapeFactory.getShape(ShapType.CIRCLE);

//调用 Circle 的 draw 方法
circle.draw();

//获取 Rectangle 的对象，并调用它的 draw 方法
Shape rectangle = shapeFactory

.getShape(ShapType.RECTANGLE);

//调用 Rectangle 的 draw 方法
rectangle.draw();

//获取 Square 的对象，并调用它的 draw 方法
Shape square = shapeFactory.getShape(ShapType.SQUARE);

//调用 Square 的 draw 方法
square.draw();
}
}

工厂方法模式

工厂模式属于创建型模式，它在创建对象时提供了一种封装机制，将实际创建对象的代码与使用代码分离。让其具体工厂实现抽象工厂接口，返回的也是一个抽象的产品。具体产品在具体工厂中体现。

优点：如果存在新增的产品，可以通过添加新的具体工厂和产品类，而不需要修改现有的代码，实现了系统的可扩展性。

代码实现

//抽象产品 Shape
public interface Shape {
void draw();
}
//具体产品 Circle
public class Circle implements Shape {

@Override
public void draw() {
System.out.println(" Circle --> draw() method.");
}
}
//具体产品 Rectangle
public class Rectangle implements Shape {

@Override
public void draw() {
System.out.println("Rectangle --> draw() method.");
}
}
//具体产品 Square
public class Square implements Shape {

@Override
public void draw() {
    System.out.println("Square --> draw() method.");
}

}
//ShapeFactory 抽象工厂
public interface ShapeFactory {
//使用 getShape 方法获取形状类型的对象
Shape shape();
}
//CircleFactory工厂
public class CircleFactory implements ShapeFactory{

//使用 getShape 方法获取形状类型的对象
@Override
public Shape shape() {
    return new Circle();
}

}
//RectangleFactory工厂
public class RectangleFactory implements ShapeFactory{
//使用 getShape 方法获取形状类型的对象
@Override
public Shape shape() {
return new Rectangle();
}
}
//SquareFactory工厂
public class SquareFactory implements ShapeFactory{

//使用 getShape 方法获取形状类型的对象
@Override
public Shape shape() {
    return new Square();
}

}
//模拟客户端
public class ClientDemo {

public static void main(String[] args) {
    //获取 CircleFactory 的对象，并调用它的 draw 方法
    ShapeFactory circleFactory = new CircleFactory();
    Shape circle = circleFactory.shape();
    circle.draw();


    //获取 RectangleFactory 的对象，并调用它的 draw 方法
    ShapeFactory rectangleFactory = new RectangleFactory();
    Shape rectangle = rectangleFactory.shape();
    rectangle.draw();

    //获取 Square 的对象，并调用它的 draw 方法
    ShapeFactory squareFactory = new SquareFactory();
    Shape square = squareFactory.shape();
    square.draw();

}

}

好了，关于工厂方法模式的说明，馆长就先讲到这里。谢谢各位看官！！

23 种设计模式不是孤立存在的，很多模式之间存在一定的关联关系，在大的系统开发中常常同时使用多种设计模式，或者模式与模式之间的组合进行生成更加强大的程序功能。