工厂设计模式

/**
 * 简单工厂模式
 */
public class FactoryPattern {
    public static void main(String[] args) {
        //产品使用
        Application application = new Application();
        Product object = application.getObject("0");
        object.method();
    }
}
//抽象产品
interface Product{
    public void method();
}
//具体产品1
class ProductA implements Product{
    @Override
    public void method() {
        System.out.println("ProductA");
    }
}
//具体产品2
class ProductA1 implements  Product{
    @Override
    public void method() {
        System.out.println("ProductA1");
    }
}
//工厂类
class SimpleFactory{
    public static Product createProduct(String type){
        if (type.equals("0")){
            return new ProductA();
        }else if (type.equals("1")){
            return new ProductA1();
        }else {
            return null;
        }
    }
}
//调用具体工厂生产对应产品
class Application{
    private Product createProduct(String type){
        return SimpleFactory.createProduct(type);
    }
    Product getObject(String type){
        Product product = createProduct(type);
        return product;
    }
}

/**
 * 工厂方法模式
 */
public class FactoryMethod {
    public static void main(String[] args) {
        //产品使用
        Application1 concreteProductB = new ConcreteProductB1();
        Product1 object = concreteProductB.getObject();
        object.method();
    }
}
//抽象接口
interface Product1{
    public void method();
}
//产品b
class ProductB implements Product1 {
    @Override
    public void method() {
        System.out.println("ProductB");
    }
}
//产品B1
class ProductB1 implements Product1{
    @Override
    public void method() {
        System.out.println("ProductB1");
    }
}
//抽象方法
abstract class Application1{
    //工厂方法
    abstract Product1 createProduct();
    Product1 getObject(){
        Product1 product1 = createProduct();
        return product1;
    }
}
//把具体的实现交给子类
class ConcreteProductB extends Application1{
    @Override
    Product1 createProduct() {
        return new ProductB();
    }
}
class ConcreteProductB1 extends Application1{
    @Override
    Product1 createProduct() {
        return new ProductB1();
    }
}

/**
 * 抽象设计模式
 */
public class AbstractFactoryTest {
    public static void main(String[] args){
        IDatabaseUtils IDatabaseUtils = new OracleDatabaseUtils();
        IConnection connection = IDatabaseUtils.getConnection();
        connection.connect();
        ICommand command = IDatabaseUtils.getCommand();
        command.command();
    }
}
//抽象连接方法
interface IConnection{
    void connect();
}
//抽象命令方法
interface ICommand{
    void command();
}
//抽象数据库工具接口
interface IDatabaseUtils{
    IConnection getConnection();
    ICommand getCommand();
}
//mysql连接对象
class MysqlConnection implements IConnection{

    @Override
    public void connect() {
        System.out.println("mysql连接");
    }
}
//Oracle连接对象
class OracleConnection implements IConnection{
    @Override
    public void connect() {
        System.out.println("Oracle连接");
    }
}
//mysql发生命令对象
class MysqlCommand implements ICommand{
    @Override
    public void command() {
        System.out.println("mysql发送命令");
    }
}
//oracle发生命令对象
class OracleCommand implements ICommand{
    @Override
    public void command() {
        System.out.println("Oracle发送命令");
    }
}
//mysql工具类
class MysqlDatabaseUtils implements IDatabaseUtils{
    @Override
    public IConnection getConnection() {
        return new MysqlConnection();
    }

    @Override
    public ICommand getCommand() {
        return new MysqlCommand();
    }
}
//oracle工具类
class OracleDatabaseUtils implements IDatabaseUtils{
    @Override
    public IConnection getConnection() {
        return new OracleConnection();
    }

    @Override
    public ICommand getCommand() {
        return new OracleCommand();
    }
}

//抽象连接方法
interface IConnection{
    void connect();
}
//抽象命令方法
interface ICommand{
    void command();
}
//抽象数据库工具接口
interface IDatabaseUtils{
    IConnection getConnection();
    ICommand getCommand();
}