一、 工厂设计模式

1.定义

一个用于创建对象的接口，让子类决定实例化哪个类

2.使用场景

在任何需要生成复杂对象的地方，都可以使用工厂方法模式，复杂对象适合使用工厂模式，直接用new出来的对象无需使用工厂模式。

3.核心类以及UML建模图

抽象工厂类，具体工厂类，抽象产品类，具体产品类，客户端使用

简单工厂设计模式.jpg

3.1 抽象工厂类

public abstract class AbastractIoFactory {

    public abstract  <T extends IoHandler> T getIoHandler(Class<T> clazz);
}

3.2 具体工厂

public class IoFactory extends AbastractIoFactory {

    @Override
    public  <T extends IoHandler> T getIoHandler(Class<T> clazz) {
        IoHandler handler = null;

        try {
            handler = (IoHandler) Class.forName(clazz.getName()).newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return (T) handler;

    }
}

3.3 抽象产品

public abstract class IoHandler {

    /**
     * 添加数据方法
     * @param message
     */
    abstract void add(String message);

    /**
     * 删除方法
     * @param message
     */
    abstract void delete(String message);

    /**
     * 更新
     * @param message
     */
    abstract void update(String message);

    /**
     * 查找
     * @param message
     */
    abstract void query(String message);

}

3.4具体产品A

public class GreenDaoHandler extends IoHandler {
    @Override
    void add(String message) {
        System.out.println("GreenDaoHandler handle add()" + message);
    }

    @Override
    void delete(String message) {
        System.out.println("GreenDaoHandler handle delete()" + message);
    }

    @Override
    void update(String message) {
        System.out.println("GreenDaoHandler handle update()" + message);
    }

    @Override
    void query(String message) {
        System.out.println("GreenDaoHandler handle query()" + message);
    }
}

3.5 具体产品B

public class RealRoomHandler extends IoHandler {
    @Override
    void add(String message) {
        System.out.println("RealRoomHandler handle add()" + message);
    }

    @Override
    void delete(String message) {
        System.out.println("RealRoomHandler handle delete()" + message);
    }

    @Override
    void update(String message) {
        System.out.println("RealRoomHandler handle update()" + message);
    }

    @Override
    void query(String message) {
        System.out.println("RealRoomHandler handle query()" + message);
    }
}

3.6 client

   
public class Client {

    public static void main(String[] args){
        
        AbastractIoFactory ioFactory=new IoFactory();
        
        IoHandler greenDaoHandler = ioFactory.getIoHandler(GreenDaoHandler.class);
        greenDaoHandler.add("One X");
        greenDaoHandler.delete("One X");
        greenDaoHandler.update("One X");
        greenDaoHandler.query("One X");


        IoHandler realRoomHandler = ioFactory.getIoHandler(RealRoomHandler.class);
        realRoomHandler.add("One X");
        realRoomHandler.delete("One X");
        realRoomHandler.update("One X");
        realRoomHandler.query("One X");

    }
}

二、 抽象工厂设计模式

1、核心实现类

• 抽象工厂类 ：抽象工厂角色，声明一组创建产品的方法，每一个方法对应生成一种产品

• 具体工厂角色： 实现抽象工厂中定义的创建产品的方法，生成一组具体的产品，这些产品构成一个产品品种，每一个产品都位于每个产品的等级结构中

• 抽象产品角色，为每一种产品申明接口，即该类产品必须所应有的属性或者方法

• 具体产品角色，定义具体工厂生产的具体产品对象，实现抽象产品接口中申明的业务方法。

2、具体使用

2.1抽象工厂角色

public abstract class AbstractFactory {
    public abstract AbastractProductA createProductA();
    public abstract AbastractProductB createProductB();

}

2.2具体工厂角色A

public class RealFactory1 extends AbstractFactory {
    @Override
    public AbastractProductA createProductA() {
        return new RealProductA1();
    }

    @Override
    public AbastractProductB createProductB() {
        return new RealProductB1();
    }
}

2.3抽象产品

public interface AbastractProductA {
     void method();
}

2.4具体产品

public class RealProductA1 implements AbastractProductA{
    @Override
    public void method() {
        System.out.println("我是A1产品");
    }
}

2.5具体使用

public class Client {

    public static void main(String[] args){

        AbstractFactory factory=new RealFactory1();
        AbastractProductA productA = factory.createProductA();

        productA.method();

        AbastractProductB productB = factory.createProductB();
        productB.method();

        AbstractFactory factoryB=new RealFactory2();
        AbastractProductA productA1 = factoryB.createProductA();
        productA1.method();

        AbastractProductB productB1 = factoryB.createProductB();
        productB1.method();
    }
}