1.工厂模式
简单工厂模式（Simple Factory Pattern）属于创建型模式，是指由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类的对象，而被创建的对象通常都具有共同的父类或接口，这种模式又叫做静态工厂方法模式。
简单工厂模式包含三个角色：
- 工厂类（Factory）：负责创建所有产品的静态工厂方法，根据传入的参数创建不同的产品；
- 抽象产品类（Product）：定义所有产品的公共接口；
- 具体产品类（Concrete Product）：实现抽象产品类的接口，是被工厂创建的对象。
以下是一个简单的以汽车工厂为主题的示例代码，演示了如何使用工厂模式创建汽车对象。
定义一个汽车工厂接口，它包含一个用于创建汽车对象的方法
public interface CarFactory {
Car createCar();
}定义一个具体的汽车工厂，它实现了CarFactory接口。这个工厂根据不同的汽车类型来创建不同的汽车对象：
public class SimpleCarFactory implements CarFactory {
@Override
public Car createCar() {
return new SimpleCar();
}
public Car createSUV() {
return new SUVCar();
}
}上面代码中，定义了两个方法，createCar方法用于创建普通轿车对象，createSUV方法用于创建SUV类型的汽车对象。SimpleCar和SUVCar是两个具体的汽车类。
最后，定义一个汽车接口和两个具体的汽车类，它们实现了汽车接口：
public interface Car {
void drive();
}
public class SimpleCar implements Car {
@Override
public void drive() {
System.out.println("Driving a simple car");
}
}
public class SUVCar implements Car {
@Override
public void drive() {
System.out.println("Driving an SUV car");
}
}这样，就可以使用工厂模式创建汽车对象了。下面是一个示例代码，演示如何使用工厂模式创建汽车对象：
public static void main(String[] args) {
CarFactory factory = new SimpleCarFactory();
Car car1 = factory.createCar();
Car car2 = factory.createSUV();
car1.drive();
car2.drive();
}工厂模式的应用场景主要是在对象的创建过程中，对类的实例化进行隔离。在使用工厂模式的时候，客户端不需要知道具体的类的类型，只需要知道具体类型对应的参数即可得到所需的对象。因此，工厂模式可以在不暴露具体类的内部实现的情况下，通过规定好的接口来创建对象。工厂模式在软件开发中广泛应用。
应用场景：
扫描二维码关注公众号，回复：
16641120 查看本文章
- 系统的初始化需要创建大量的对象；
- 系统中的对象种类较多，用工厂方法将客户端和具体类解耦；
- 创建对象需要进行大量的重复性工作，如数据库查询，通过工厂模式统一管理；
- 需要动态地配置创建对象的种类。
2.抽象工厂模式
interface Shape {
void draw();
}
class Rectangle implements Shape {
@Override
public void draw() {
System.out.println("Drawing Rectangle");
}
}
class Circle implements Shape {
@Override
public void draw() {
System.out.println("Drawing Circle");
}
}
interface Color {
void fill();
}
class Red implements Color {
@Override
public void fill() {
System.out.println("Filling Red");
}
}
class Green implements Color {
@Override
public void fill() {
System.out.println("Filling Green");
}
}
abstract class AbstractFactory {
abstract Shape getShape(String shapeType);
abstract Color getColor(String colorType);
}
class ShapeFactory extends AbstractFactory {
@Override
Shape getShape(String shapeType) {
if (shapeType == null) {
return null;
}
if (shapeType.equalsIgnoreCase("CIRCLE")) {
return new Circle();
} else if (shapeType.equalsIgnoreCase("RECTANGLE")) {
return new Rectangle();
}
return null;
}
@Override
Color getColor(String colorType) {
return null;
}
}
class ColorFactory extends AbstractFactory {
@Override
Shape getShape(String shapeType) {
return null;
}
@Override
Color getColor(String colorType) {
if (colorType == null) {
return null;
}
if (colorType.equalsIgnoreCase("RED")) {
return new Red();
} else if (colorType.equalsIgnoreCase("GREEN")) {
return new Green();
}
return null;
}
}
class FactoryProducer {
static AbstractFactory getFactory(String choice) {
if (choice.equalsIgnoreCase("SHAPE")) {
return new ShapeFactory();
} else if (choice.equalsIgnoreCase("COLOR")) {
return new ColorFactory();
}
return null;
}
}
public class AbstractFactoryPatternDemo {
public static void main(String[] args) {
AbstractFactory shapeFactory = FactoryProducer.getFactory("SHAPE");
Shape shape1 = shapeFactory.getShape("CIRCLE");
shape1.draw();
Shape shape2 = shapeFactory.getShape("RECTANGLE");
shape2.draw();
AbstractFactory colorFactory = FactoryProducer.getFactory("COLOR");
Color color1 = colorFactory.getColor("RED");
color1.fill();
Color color2 = colorFactory.getColor("GREEN");
color2.fill();
}
}应用场景
抽象工厂模式的应用场景主要有以下几点：
- 系统中有多个产品族，每个具体工厂创建同一族但属于不同等级结构的产品。
- 系统提供一个产品类的库，所有的产品以同样的接口出现，从而使客户端不依赖于具体实现。
- 隔离多个产品族，让客户端不需要关心创建细节。
- 强调一系列相关的产品对象（属于同一产品族）一起使用创建对象需要大量重复的代码。
- 提供一个产品类的库，所有的产品以同样的接口出现，从而使客户端不依赖于具体实现。
因此，抽象工厂模式适用于以下场景：
- 创建多个产品族，产品等级高于单个产品。
- 一个系统不应当依赖于产品类实例如何被创建、组合和表达的细节，这对于所有类型的工厂模式都是重要的。
- 系统中有多于一个的产品族，而每次只使用其中某一产品族。
- 属于同一个产品族的产品将在一起使用，这一约束必须在系