1.工厂模式

简单工厂模式（Simple Factory Pattern）属于创建型模式，是指由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类的对象，而被创建的对象通常都具有共同的父类或接口，这种模式又叫做静态工厂方法模式。

简单工厂模式包含三个角色：

1. 工厂类（Factory）：负责创建所有产品的静态工厂方法，根据传入的参数创建不同的产品；
2. 抽象产品类（Product）：定义所有产品的公共接口；
3. 具体产品类（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();
}

工厂模式的应用场景主要是在对象的创建过程中，对类的实例化进行隔离。在使用工厂模式的时候，客户端不需要知道具体的类的类型，只需要知道具体类型对应的参数即可得到所需的对象。因此，工厂模式可以在不暴露具体类的内部实现的情况下，通过规定好的接口来创建对象。工厂模式在软件开发中广泛应用。

应用场景：

1. 系统的初始化需要创建大量的对象；
2. 系统中的对象种类较多，用工厂方法将客户端和具体类解耦；
3. 创建对象需要进行大量的重复性工作，如数据库查询，通过工厂模式统一管理；
4. 需要动态地配置创建对象的种类。

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();
    }
}

应用场景

抽象工厂模式的应用场景主要有以下几点：

1. 系统中有多个产品族，每个具体工厂创建同一族但属于不同等级结构的产品。
2. 系统提供一个产品类的库，所有的产品以同样的接口出现，从而使客户端不依赖于具体实现。
3. 隔离多个产品族，让客户端不需要关心创建细节。
4. 强调一系列相关的产品对象（属于同一产品族）一起使用创建对象需要大量重复的代码。
5. 提供一个产品类的库，所有的产品以同样的接口出现，从而使客户端不依赖于具体实现。

因此，抽象工厂模式适用于以下场景：

1. 创建多个产品族，产品等级高于单个产品。
2. 一个系统不应当依赖于产品类实例如何被创建、组合和表达的细节，这对于所有类型的工厂模式都是重要的。
3. 系统中有多于一个的产品族，而每次只使用其中某一产品族。
4. 属于同一个产品族的产品将在一起使用，这一约束必须在系