【Java】纯小白的三种工厂模式基础知识学习笔记

工厂模式概念

在Java中，工厂模式是一种设计模式，用于创建对象而无需指定明确的类。工厂模式通过定义一个共同的接口或抽象类来创建对象，然后由工厂类根据特定条件或参数来实例化具体的对象。

工厂模式通常包括三种类型：简单工厂模式、工厂方法模式和抽象工厂模式。

1. 简单工厂模式 （Simple Factory Pattern）：简单工厂模式是最基本的工厂模式，它通过**++一个工厂类++**来创建对象。客户端通过传递参数给工厂类来获取特定类型的对象，而无需关心对象的创建过程。

2. 工厂方法模式 （Factory Method Pattern）：工厂方法模式通过定义一个用于创建对象的接口，但将实际创建工作延迟到子类。每个++子类++都可以实现工厂接口以提供具体的对象实例化过程。

3. 抽象工厂模式 （Abstract Factory Pattern）：抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口，而无需指定具体的类。通过使用抽象工厂模式，可以实现一组对象的一致性创建，并且可以轻松地切换++不同产品++系列的实现。

工厂模式的优点包括：

• 解耦了对象的创建和使用，使得客户端代码更加灵活和可扩展。
• 隐藏了对象的具体实现细节，使得客户端只需关心接口或抽象类。

代码示例

简单工厂模式

// Shape 抽象类
public abstract class Shape {
    public abstract void draw();
}

// Circle 类
public class Circle extends Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a circle...");
    }
}

// Square 类
public class Square extends Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a square...");
    }
}

// Triangle 类
public class Triangle extends Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a triangle...");
    }
}

// ShapeFactory 类
public class ShapeFactory {
    public static Shape getShape(String shapeType) {
        if (shapeType == null) {
            return null;
        }
        if (shapeType.equalsIgnoreCase("CIRCLE")) {
            return new Circle();
        } else if (shapeType.equalsIgnoreCase("SQUARE")) {
            return new Square();
        } else if (shapeType.equalsIgnoreCase("TRIANGLE")) {
            return new Triangle();
        }
        return null;
    }
}

// 使用示例：
Shape circle = ShapeFactory.getShape("CIRCLE");
circle.draw(); // Drawing a circle...

Shape square = ShapeFactory.getShape("SQUARE");
square.draw(); // Drawing a square...

Shape triangle = ShapeFactory.getShape("TRIANGLE");
triangle.draw(); // Drawing a triangle...

工厂方法模式

// TV 抽象类
public abstract class TV {
    public abstract void play();
}

// SamsungTV 类
public class SamsungTV extends TV {
    @Override
    public void play() {
        System.out.println("Playing Samsung TV...");
    }
}

// LGTV 类
public class LGTV extends TV {
    @Override
    public void play() {
        System.out.println("Playing LG TV...");
    }
}

// TVFactory 接口
public interface TVFactory {
    TV createTV();
}

// SamsungTVFactory 类
public class SamsungTVFactory implements TVFactory {
    @Override
    public TV createTV() {
        return new SamsungTV();
    }
}

// LGTVFactory 类
public class LGTVFactory implements TVFactory {
    @Override
    public TV createTV() {
        return new LGTV();
    }
}

// 使用示例：
TVFactory samsungFactory = new SamsungTVFactory();
TV samsungTV = samsungFactory.createTV();
samsungTV.play(); // Playing Samsung TV...

TVFactory lgFactory = new LGTVFactory();
TV lgTV = lgFactory.createTV();
lgTV.play(); // Playing LG TV...

抽象工厂模式

// TV 抽象类
public abstract class TV {
    public abstract void play();
}

// SamsungTV 类
public class SamsungTV extends TV {
    @Override
    public void play() {
        System.out.println("Playing Samsung TV...");
    }
}

// LGTV 类
public class LGTV extends TV {
    @Override
    public void play() {
        System.out.println("Playing LG TV...");
    }
}

// Phone 抽象类
public abstract class Phone {
    public abstract void call();
}

// SamsungPhone 类
public class SamsungPhone extends Phone {
    @Override
    public void call() {
        System.out.println("Making a call with Samsung phone...");
    }
}

// LGPhone 类
public class LGPhone extends Phone {
    @Override
    public void call() {
        System.out.println("Making a call with LG phone...");
    }
}

// AbstractFactory 抽象类
public abstract class AbstractFactory {
    public abstract TV createTV();
    public abstract Phone createPhone();
}

// SamsungFactory 类
public class SamsungFactory extends AbstractFactory {
    @Override
    public TV createTV() {
        return new SamsungTV();
    }

    @Override
    public Phone createPhone() {
        return new SamsungPhone();
    }
}

// LGFactory 类
public class LGFactory extends AbstractFactory {
    @Override
    public TV createTV() {
        return new LGTV();
    }

    @Override
    public Phone createPhone() {
        return new LGPhone();
    }
}

// Client 类
public class Client {
    public static void main(String[] args) {
        AbstractFactory factory1 = new SamsungFactory();
        TV samsungTV = factory1.createTV();
        Phone samsungPhone = factory1.createPhone();
        samsungTV.play(); // Playing Samsung TV...
        samsungPhone.call(); // Making a call with Samsung phone...

        AbstractFactory factory2 = new LGFactory();
        TV lgTV = factory2.createTV();
        Phone lgPhone = factory2.createPhone();
        lgTV.play(); // Playing LG TV...
        lgPhone.call(); // Making a call with LG phone...
    }
}