学习笔记（设计模式--工厂模式）

工厂模式

1、普通工厂模式

        工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

        在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

        优点：

        1、一个调用者想创建一个对象，只要知道其名称就可以了。

        2、扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。

        3、屏蔽产品的具体实现，调用者只关心产品的接口。

        缺点：每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。

使用场景

1、日志记录器：记录可能记录到本地硬盘、系统事件、远程服务器等，用户可以选择记录日志到什么地方。

2、数据库访问，当用户不知道最后系统采用哪一类数据库，以及数据库可能有变化时。

3、设计一个连接服务器的框架，需要三个协议，"POP3"、"IMAP"、"HTTP"，可以把这三个作为产品类，共同实现一个接口。

普通工厂模式实现步骤

1.创建接口和创建实现这个接口的实体类。

2.创建一个工厂，可以基于给定信息生成实体类的对象。

创建一个接口：

public interface Car {
    void build();
}

创建实现接口的实体类：

Audi.java

public class Audi implements Car{
    @Override
    public void build() {
        System.out.println("This is a Audi car！");
    }
}

Benz.java

public class Benz implements Car{
    @Override
    public void build() {
        System.out.println("This is a Benz car！");
    }
}

创建一个工厂，生成基于给定信息的实体类的对象。

public class CarFactory {
    public Car getCar(String carName){
        if(carName == null){
            return null;
        }
        if (carName.equalsIgnoreCase("Audi")){
            return new Audi();
        }else if (carName.equalsIgnoreCase("Benz")){
            return new Benz();
        }
        return null;
    }
}

使用该工厂，通过传递信息来获取实体类的对象。

public class CarDemo {
    public static void main(String[] args) {
        CarFactory carFactory = new CarFactory();
        Car audi = carFactory.getCar("Audi");
        audi.build();//This is a Audi car！
    }
}

2、抽象工厂模式

通过一个超级工厂创建其他工厂。在抽象工厂模式中，不需要指定产出产品工厂的类。每个生成的工厂按照工厂模式提供对象。

实现步骤

1.创建 Car和 Motorcycle 接口和实现这些接口的实体类。

2.创建抽象工厂类 AbstractFactory。

3.定义工厂类 CarFactory 和 MotorFactory，这两个工厂类都是扩展了 AbstractFactory。

4.创建一个工厂创造器/生成器类 FactoryProducer。

代码

为汽车创建一个接口

public interface Car {
    void build();
}

创建实现汽车接口的实体类 Audi.java

public class Audi implements Car{
    @Override
    public void build() {
        System.out.println("This is a Audi car！");
    }
}

Benz.java

public class Benz implements Car{
    @Override
    public void build() {
        System.out.println("This is a Benz car！");
    }
}

为摩托车创建一个接口

public interface Motorcycle {
    void makeMotorcycle();
}

创建实现摩托车接口的实体类 Honda.java

public class Honda implements Motorcycle {
    @Override
    public void makeMotorcycle() {
        System.out.println("造一个本田摩托");
    }
}

创建实现摩托接口的实体类 Spring.java。

public class Spring implements Motorcycle {
    @Override
    public void makeMotorcycle() {
        System.out.println("造一个春风摩托");
    }
}

为Car和Color对象创建抽象类获取工厂。

public abstract class AbstracFactory {
    public abstract Motorcycle getMotor(String color);
    public abstract Car getCar(String car);
}

创建Motor工厂类集成工厂抽象类。基于给定的信息生成实体类对象。

public class MotorFactory extends AbstracFactory{

    @Override
    public Motorcycle getMotor(String color) {
        if (color == null){
            return null;
        }
        if (color.equalsIgnoreCase("Spring")){
            return new Spring();
        }else if (color.equalsIgnoreCase("Honda")){
            return new Honda();
        }
        return null;
    }

    @Override
    public Car getCar(String car) {
        return null;
    }
}

创建car工厂类集成工厂抽象类。基于给定的信息生成实体类对象。

public class CarFactory extends AbstracFactory{
    @Override
    public Motorcycle getMotor(String color) {
        return null;
    }
    @Override
    public Car getCar(String carName){
        if(carName == null){
            return null;
        }
        if (carName.equalsIgnoreCase("Audi")){
            return new Audi();
        }else if (carName.equalsIgnoreCase("Benz")){
            return new Benz();
        }
        return null;
    }
}

创建一个工厂创造类，通过给定条件获取工厂。

public class FactoryProducer {
    public static AbstracFactory getFactory(String choice){
        if (choice.equalsIgnoreCase("Car")){
            return new CarFactory();
        }else if (choice.equalsIgnoreCase("Motor")){
            return new MotorFactory();
        }
        return null;
    }
}

使用 FactoryProducer 来获取 AbstractFactory，通过传递类型信息来获取实体类的对象。

public class AbstractFactoryPatternDemo {
    public static void main(String[] args) {
        AbstracFactory motorFactory = FactoryProducer.getFactory("Motor");
        Motorcycle motor = motorFactory.getMotor("Spring");
        motor.makeMotorcycle();//造一个春风摩托
        AbstracFactory carFactory = FactoryProducer.getFactory("CAR");
        Car audi = carFactory.getCar("Audi");//This is a Audi car！
        audi.build();
    }
}

若要增加新的产品，只需要在AbstracFactory中增加创建产品的接口，并在具体工厂中实现新加产品的创建。