工厂模式

参考文章

1、工厂模式介绍

1.1 工厂模式的定义

在基类中定义创建对象的一个接口，让子类决定实例化哪个类。工厂方法让一个类的实例化延迟到子类中进行。

1.2 工厂模式的分类

1. 简单工厂：静态工厂模式
2. 工厂方法：多态性工厂
3. 抽象工厂：工具箱模式

1.3 优点

1. 解耦：把对象的创建和使用分开
2. 降低代码重复
3. 降低维护成本：创建过程由工厂统一管理，如果业务逻辑变化，只需要修改工厂。

2、简单工厂

2.1 简单工厂实现

2.1.1 创建 Shape 接口

public interface Shape {
    void draw();
}

2.1.2 创建实现该接口的具体图形类

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

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

2.1.3 创建工厂类

public class ShapeFactory {

    // 使用 getShape 方法获取形状类型的对象
    public static Shape getShape(String shapeType) {
        if (shapeType == null) {
            return null;
        }
        if (shapeType.equalsIgnoreCase("CIRCLE")) {
            return new Circle();
        } else if (shapeType.equalsIgnoreCase("RECTANGLE")) {
            return new Rectangle();
        } else if (shapeType.equalsIgnoreCase("SQUARE")) {
            return new Square();
        }
        return null;
    }
}

2.1.4 测试方法

public class Test {

    public static void main(String[] args) {

        // 获取 Circle 的对象，并调用它的 draw 方法
        Shape circle = ShapeFactory.getShape("CIRCLE");
        circle.draw();

        // 获取 Rectangle 的对象，并调用它的 draw 方法
        Shape rectangle = ShapeFactory.getShape("RECTANGLE");
        rectangle.draw();

        // 获取 Square 的对象，并调用它的 draw 方法
        Shape square = ShapeFactory.getShape("SQUARE");
        square.draw();
    }
}

缺点：不符合 开放-封闭 原则。

2.2 使用反射机制改善

public class ShapFactory{
	public static Object getClass(Class < ? extends Shape>  clazz){
		Object obj = null;
		try{
			obj = Class.forName(clazz.getName()).newInstance();
		} catch(ClassNotFoundException e){
			e.printStackTrace();
		} catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        return obj;
	}
}

3、工厂方法模式

每个对象都有一个与之对应的工厂 。

3.1 适用场景

• 一个类不知道它所需要的对象的类：客户端只需要知道创建具体产品的工厂类。
• 一个类通过其子类来指定创建哪个对象：对于抽象工厂类只需要提供一个创建产品的接口，而由其子类来确定具体要创建的对象。
• 将创建对象的任务委托给多个工厂子类中的某一个，客户端在使用时可以无需关心是哪一个工厂子类创建产品子类，需要时再动态指定，可将具体工厂类的类名存储在配置文件或数据库中。

3.2 工厂模式实例

3.2.1 增加工厂接口

public interface Factory{
	public Shape getShape();
}

3.2.2 增加相关工厂类

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

public class RectangleFactory implements Factory{

    @Override
    public Shape getShape() {
        // TODO Auto-generated method stub
        return new Rectangle();
    }

}

3.2.3 测试

public class Test {

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

}

4、抽象工厂模式

一个抽象工厂可以创建多个不同的对象。

4.1 抽象工厂的工厂和工厂方法中的工厂有什么区别呢？

抽象工厂是生产一整套有产品的（至少要生产两个产品)，这些产品必须相互是有关系或有依赖的，而工厂方法中的工厂是生产单一产品的工厂。

4.1.1 创建接口

public interface Gun {
    public void shooting();
}

public interface Bullet {
    public void load();
}

4.1.2 创建接口对应实现类

public class AK implements Gun{

    @Override
    public void shooting() {
        System.out.println("shooting with AK");

    }

}

public class M4A1 implements Gun {

    @Override
    public void shooting() {
        System.out.println("shooting with M4A1");

    }

}

public class AK_Bullet implements Bullet {

    @Override
    public void load() {
        System.out.println("Load bullets with AK");
    }

}

public class M4A1_Bullet implements Bullet {

    @Override
    public void load() {
        System.out.println("Load bullets with M4A1");
    }

}

4.1.3 创建具体工厂

public class AK_Factory implements Factory{

    @Override
    public Gun produceGun() {
        return new AK();
    }

    @Override
    public Bullet produceBullet() {
        return new AK_Bullet();
    }

}

public class M4A1_Factory implements Factory{

    @Override
    public Gun produceGun() {
        return new M4A1();
    }

    @Override
    public Bullet produceBullet() {
        return new M4A1_Bullet();
    }

}

4.1.4 测试

public class Test {

    public static void main(String[] args) {  

     Factory factory;
     Gun gun;
     Bullet bullet;

     factory =new AK_Factory();
     bullet=factory.produceBullet();
     bullet.load();
     gun=factory.produceGun();
     gun.shooting(); 

    }

}