java设计模式-----工厂模式

工厂模式:
参考: https://blog.csdn.net/wfg18801733667/article/details/60954744

为什么有工厂模式:
百度写的反而比较理解

简单的理解就是,对象由工厂生成,多用于对象比较复杂的场景
例如:你要一辆汽车,自己建造可能比较麻烦,直接问工厂要一辆你想要的就行了(虽然工厂也是我们造的)
但至少这样看起来,代码逻辑就清晰了.
先看一下 工厂模式

import static java.util.Objects.isNull;

interface Car {
    void  carName();
}

class CarA implements Car {
    @Override
    public void carName() {
        System.out.println("CarA");
    }
}

class CarB implements Car {
    @Override
    public void carName() {
        System.out.println("CarB");
    }
}

class CarC implements Car {
    @Override
    public void carName() {
        System.out.println("CarC");
    }
}


public class CarFactory {
    public Car getCar(String name) {
        if (isNull(name)) {
            return null;
        }
        if ("A".equalsIgnoreCase(name)) {
            return new CarA();
        } else if ("B".equalsIgnoreCase(name)) {
            return new CarB();
        } else if ("C".equalsIgnoreCase(name)) {
            return new CarC();
        }else{
            return null;
        }
    }

    public static void main(String[] args) {
        CarFactory carFactory = new CarFactory();
        Car a = carFactory.getCar("A");
            a.carName();
    }

}

工厂模式的优点:
1,创建产品只知道产品名称就可以了
2,扩展性,如果想增加一个产品，只要扩展一个工厂类就可以。
缺点:(耦合性太强了)每次增加一个产品时，都需要增加一个具体类和对象实现工厂，
使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。

还有一种是在工厂接口中定义方法 称为工厂方法模式

interface CarFactory  {
    Car  getCar();
}
class CarAFactory  implements CarFactory  {
    @Override
    public Car getCar() {
        return new CarA();
    }
}

工厂方法模式优点
想要增加一个产品，只要扩展一个工厂类就可以() 解耦

抽象工厂模式:
创建工厂的超级工厂
在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。
https://www.runoob.com/design-pattern/abstract-factory-pattern.html
实现:
1,创建 Shape 和 Color 接口和实现这些接口的实体类
2,创建抽象工厂类 AbstractFactory 抽象工厂包含抽象工厂方法
3,创建ShapeFactory 和 ColorFactory 这俩都继承了 AbstractFactory
4,创建一个工厂生成器类 FactoryProducer
5 利用生成器生成指定的类

interface Color {
    void fill();
}

class Red implements Color {

    @Override
    public void fill() {
        System.out.println("Inside Red::fill() method.");
    }
}

class Green implements Color {

    @Override
    public void fill() {
        System.out.println("Inside Green::fill() method.");
    }
}


interface Shape {
    void draw();
}

class Rectangle implements Shape {
    @Override
    public void draw() {
        System.out.println("Inside Rectangle::draw() method.");
    }
}
class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("Inside Circle::draw() method.");
    }
}



//抽象工厂
abstract class AbstractFactory {
    public abstract Color getColor(String color);

    public abstract Shape getShape(String shape);
}


//外形工厂类
class ShapeFactory extends AbstractFactory {
    @Override
    public Color getColor(String color) {
        return null;
    }

    @Override
    public 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;
    }
}

//颜色工厂
class ColorFactory extends AbstractFactory {

    @Override
    public Color getColor(String color) {
        if(color == null){
            return null;
        }
        if(color.equalsIgnoreCase("RED")){
            return new Red();
        } else if(color.equalsIgnoreCase("GREEN")){
            return new Green();
        }
        return null;
    }

    @Override
    public Shape getShape(String shape) {
        return null;
    }
}


public class FactoryProducer {
    public static AbstractFactory getFactory(String choice) {
        if (choice.equalsIgnoreCase("SHAPE")) {
            return new ShapeFactory();
        } else if (choice.equalsIgnoreCase("COLOR")) {
            return new ColorFactory();
        }
        return new SuperFactory();
    }


    public static void main(String[] args) {
        //使用工厂生成器生成指定的工厂
        // 生成外形工厂
        AbstractFactory shapeFactory = FactoryProducer.getFactory("SHAPE");
        //生成红色类
        Shape circle = shapeFactory.getShape("CIRCLE");
        circle.draw();
        //生成颜色工厂
        AbstractFactory colorFactory = FactoryProducer.getFactory("COLOR");
        Color red = colorFactory.getColor("RED");
        red.fill();

    }

}

好处是整个系统可以是有一个 AbstractFactory 抽象类的对象所有的产品都可以由这个生成