工厂模式-简单工厂,工厂方法,抽象工厂

一.简单工厂模式

抽象工厂模式为:根据用户传入参数创建不同对象

简单工厂类图:

首先,定义一个车类产品对象抽象类

public abstract class Car {

    public abstract void driver();
}

再分别定义其两个子类,一类为宝马车类,一类为奔驰车类,并实现其抽象方法driver()

public class BenzCar extends Car {

    private String brand = "Benz";

    private String color = "white";

    private String enegy = "oil";

    public void driver() {
        System.out.println("I driver the car of "+this.color+" "+this.brand+" with "+this.enegy);
    }
}

public class BMWCar extends Car {

    private String brand = "BMW";

    private String color = "red";

    private String enegy = "oil";

    public void driver() {
        System.out.println("I driver the car of "+color+" "+brand+" with "+enegy);
    }

}

在定义一个车类工厂,根据用户传入的参数(商标名称),生产不同的车类对象,返回给用户

public class CarFactory {

    public Car createCar(String brand){
        switch(brand){
            case "BMW":
                return  new BMWCar();
            case "Benz":
                return new BenzCar();
            default:
                return null;
        }
    }
}

在定义一个测试类,进行测试

public class Test {

    public static void main(String[] args) {
        CarFactory factory = new CarFactory();
        Car bmw = factory.createCar("BMW");
        bmw.driver();

        System.out.println("====================");
        Car benz = factory.createCar("Benz");
        benz.driver();
    }
}

当用户传入"BMW"生产宝马车,用户传入"Benz"生产奔驰车

简单工厂:

优点:可以根据用户的传参,来决定生产出那种对象,来满足用户接下来的业务逻辑使用

缺点:当我们每增加一种不同的产品时,就需要修改源码逻辑,不符合开闭原则

>>>>>>>>>>但可以根据反射+简单工厂,来改造简单工厂模式<<<<<<<<<<<

这样就可以,工厂生产对象时,不用修改源码了

二.工厂方法模式

工厂方法模式:为用户不需要通过传参去获取对象,而是通过new不同的对象工厂,去获取不同的对象

就是将创建对象的工厂更"细致化"

工厂方法模式类图:

首先,定义一个车类产品对象抽象类

public abstract class Car {

    public abstract void driver();
}

再分别定义其两个子类,一类为宝马车类,一类为奔驰车类,并实现其抽象方法driver()

public class BenzCar extends Car {

    private String brand = "Benz";

    private String color = "white";

    private String enegy = "oil";

    public void driver() {
        System.out.println("I driver the car of "+this.color+" "+this.brand+" with "+this.enegy);
    }
}

public class BMWCar extends Car {

    private String brand = "BMW";

    private String color = "red";

    private String enegy = "oil";

    public void driver() {
        System.out.println("I driver the car of "+color+" "+brand+" with "+enegy);
    }

}

定义一个车工厂接口

public interface ICarFactory {

    public Car createCar();

}

再分别定义两个车工厂类实现该接口

奔驰车工厂-专门生产奔驰车

public class BenzCarFactory implements  ICarFactory{
    @Override
    public Car createCar() {
        return new BenzCar();
    }
}

宝马车工厂-专门生产宝马车

public class BMWCarFactory implements ICarFactory {
    @Override
    public Car createCar() {
        return new BMWCar();
    }
}

再定义一个测试类

public class Test {

    public static void main(String[] args) {
        Car bmw = new BMWCarFactory().createCar();
        bmw.driver();

        System.out.println("====================");
        Car benz = new BenzCarFactory().createCar();
        benz.driver();
    }
}

测试结果:

工厂方法模式:

优点:

1.不需要用户传入参数,去进行不同对象的选择,而可以直接使用对应的工厂,就能生产对应的对象.

2.符合开闭原则,就是当我需要增加一个车类时,只需要扩展增加就行了,不用修改源代码

缺点:

1.需要维护的类增加了.

2.当我每增加一种车类时,不仅要增加产品类,还要增加产品工厂类,使用时也要new对应的工厂去生产对应的产品对象

三.抽象工厂模式

抽象工厂模式:多产品簇中的每系列产品,组合生产一个"新"的产品---关键词"组合"

抽象工厂类图:

定义一个车类抽象类

public abstract class Car {

    public abstract void driver();
}

定义奔驰车类-需要的能源为-"油能"

public class BenzCar extends Car {

    private String brand = "Benz";

    private String color = "white";

    private String needEnergy = "oil";

    public void driver() {
        System.out.println("I driver the car of " + this.color + " " + this.brand + " with " + this.needEnergy);
    }
}

定义宝马车类-需要能源为-"电能"

public class BMWCar extends Car {

    private String brand = "BMW";

    private String color = "red";

    private String needEnergy = "elc";

    public void driver() {
        System.out.println("I driver the car of " + color + " " + brand + " with " + needEnergy);
    }


}

定义一个能源抽象类

public abstract class Energy {

    abstract void use();

}

定义电能类

public class ElcEnergy extends Energy {

    private String energy = "elc";

    @Override
    void use() {
        System.out.println("use " + this.energy);
    }
}

定义油能类

public class OilEnergy extends Energy {

    private String energy = "oil";

    @Override
    void use() {
        System.out.println("use " + this.energy);
    }
}

定义一个抽象工厂-创建车类方法,创建能源类方法

public abstract class AbstractCarFactory {

    abstract Car createCar();

    abstract Energy createEnergy();

}

定义一个生产电能车类工厂

public class ElcCarFactory extends AbstractCarFactory {
    @Override
    Car createCar() {
        return new BMWCar();
    }

    @Override
    Energy createEnergy() {
        return new ElcEnergy();
    }

}

定义一个生产油能车类工厂

public class OilCarFactory extends AbstractCarFactory {
    @Override
    Car createCar() {
        return new BenzCar();
    }

    @Override
    Energy createEnergy() {
        return new OilEnergy();
    }
}

再定义测试类

public class Test {

    public static void main(String[] args) {
        AbstractCarFactory acf = new ElcCarFactory();
        Car car = acf.createCar();
        car.driver();
        Energy eng = acf.createEnergy();
        eng.use();
        System.out.println("======================");
        acf = new OilCarFactory();
        car = acf.createCar();
        car.driver();
        eng = acf.createEnergy();
        eng.use();
    }
}

测试结果:

当我们用电能车类工厂-创建的是,需要电能的宝马车,以及电能--这样宝马车就可以"跑"起来了

当我们用油能车类工厂-创建的是,需要油能的奔驰车,以及油能--这样奔驰车就可以"跑"起来了

抽象工厂模式:

优点:

1.为用户实现,通过不同产品簇的组合,生成不同的产品,比如 车由 品牌 颜色 能源 组合,那么我们可以抽象出 2条产品簇 品牌簇 和 能源簇 通过其不同的子类去实现 宝马电动车  奔驰油能车

2.符合开闭原则

缺点:

1.需要维护的类,过多.

2.生产出的产品,必须增加一层校验,不然油能车类工厂,如果创建出需要电能的宝马车,以及油能,那宝马车就"跑"不起来了~

抽象工厂-应用于当我们需要一系列相关类,去满足我们的业务需求时,但我们又不想维护类与类中间的关联关系时,可以采用,抽象工厂模式,去进行管理.我们只需要知道,通过油能车类工厂生产出来的,就是油能车,以及可以让油能车跑起来的油类能源(注重"组合")