工厂设计模式

工厂设计模式

简单工厂模式

/**
 * 简单工厂模式
 */
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;
    }
}

工厂方法模式

模式定义

定义一个用于创建对象的接口，让子类决定实例化哪一个类，FactoryMethod使得一个类的实例化延迟到子类

应用场景

1.当你不知道该使用对象的确切类型的时候

2.当你希望为库或框架提供拓展其内部组件的方法时

优点

将具体产品和创建者解耦

符合单一指责原则

符合开闭原则

/**
 * 工厂方法模式
 */
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();
}

实现这几个类就可以实现对应的功能

优点

可以确信你从工厂得到的产品是相互兼容的

可以避免具体产品和客户端代码之间的耦合

符合单一指责原则