工厂模式

定义

“Define an interface for creating an object, but let subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclasses.”(在基类中定义创建对象的一个接口，让子类决定实例化哪个类。工厂方法让一个类的实例化延迟到子类中进行。)

• 简单工厂（Simple Factory）模式，又称静态工厂方法模式（Static Factory Method Pattern）。
• 工厂方法（Factory Method）模式，又称多态性工厂（Polymorphic Factory）模式或虚拟构造子（Virtual Constructor）模式；
• 抽象工厂（Abstract Factory）模式，又称工具箱（Kit 或Toolkit）模式。

为什么要用工厂模式

1. 解耦 ：把对象的创建和使用的过程分开;
2. 降低代码重复: 如果创建某个对象的过程都很复杂，需要一定的代码量，而且很多地方都要用到，那么就会有很多的重复代码。
3. 降低维护成本 ：由于创建过程都Simple Factory）
   创建图形实例：
   首先是图形接口

public interface Shape {
    void draw();
}

创建实现类

public class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("draw a circle");
    }
}

public class Rectangle implements Shape {
    @Override
    public void draw() {
        System.out.println("draw an Rectangle");
    }
}

创建图形工厂

public class Factory {
    public static Shape getShape(Class<? extends Shape> clazz){
        Shape shape = null;
        try {
            shape = (Shape) Class.forName(clazz.getName()).newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return shape;
    }
}

测试类

public class Test {
    public static void main(String[] args) {
        Shape circle = Factory.getShape(Circle.class);
        circle.draw();

        Shape rectangle = Factory.getShape(Rectangle.class);
        rectangle.draw();
    }
}

输出

draw a circle
draw an Rectangle

工厂方法(Factory Method)

工厂方法模式是简单工厂的仅一步深化， 在工厂方法模式中，我们不再提供一个统一的工厂类来创建所有的对象，而是针对不同的对象提供不同的工厂。也就是说 每个对象都有一个与之对应的工厂 。工厂方法模式应该是在工厂模式家族中是用的最多模式，一般项目中存在最多的就是这个模式。
创建工厂接口

public interface Factory {
    Shape getShape();
}

圆形工厂

public class CircleFactory implements Factory {
    @Override
    public Shape getShape() {
        return new Circle();
    }
}

测试类

public class Test {
    public static void main(String[] args) {
        CircleFactory factory = new CircleFactory();
        Shape circle = factory.getShape();
        circle.draw();
    }
}

抽象工厂(Abstract Factory)

在工厂方法模式中，其实我们有一个潜在意识的意识。那就是我们生产的都是同一类产品。抽象工厂模式是工厂方法的仅一步深化，在这个模式中的工厂类不单单可以创建一种产品，而是可以创建一组产品。

创建抽象类

public interface Animal {
    public void catching();
}

public interface Food {
    public void cook();
}

创建实体类

public class Cattle implements Animal {
    @Override
    public void catching() {
        System.out.println("catching cattle...");
    }
}

public class Beef implements Food {
    @Override
    public void cook() {
        System.out.println("cooking beef...");
    }
}

创建工厂接口

public interface Factory {
    Food getFood();
    Animal catchingAnimal();
}

创建牛肉工厂

public class BeefFactroy implements Factory {
    @Override
    public Food getFood() {
        return new Beef();
    }
    @Override
    public Animal catchingAnimal() {
        return new Cattle();
    }
}

测试类

public class Test {
    public static void main(String[] args) {
        Factory AKFactory = new BeefFactroy();
        Animal bullet = AKFactory.catchingAnimal();
        Food food = AKFactory.getFood();
        bullet.catching();
        food.cook();
    }
}

输出

catching cattle...
cooking beef...