关于设计模式:设计模式之工厂模式

7次阅读

共计 4579 个字符，预计需要花费 12 分钟才能阅读完成。

工厂模式能够细分为：简略工厂、工厂办法和形象工厂三种模式

总体而言工厂模式的应用场景分为两种：

单个对象的创立过程比较复杂，如须要做简单初始化操作的对象
须要依据不同的类型创立不同的对象

针对细分的三种模式，应用场景又能够辨别：

当 对象的创立逻辑简略 ，通常只须要 new 一下就能够，此时能够思考 简略工厂模式
当 对象的创立逻辑很简单 ，须要做各种初始化操作，此时能够思考应用 工厂办法模式，将对象创立的简单逻辑拆分到各个工厂类中，让每个工厂类都不至于过于简单
当 零碎中有多于一个产品族 ，而每次只应用其中某一产品族，此时应用 形象工厂模式

ProcuctA 和 ProductB 继承 Product 抽象类，ProductFactory 依据传入的 type 来返回不同的 Product 实例

public abstract class Product {public abstract void use();
}

public class ProductA extends Product {
    @Override
    public void use() {System.out.println("You are using ProductA...");
    }
}

public class ProductB extends Product {
    @Override
    public void use() {System.out.println("You are using ProductB...");
    }
}

public class ProductFactory {public Product createProduct(String type) {
        Product product = null;
        if ("A".equals(type)) {product = new ProductA();
        } else if ("B".equals(type)) {product = new ProductB();
        }
        return product;
    }
}

public class Main {public static void main(String[] args) {ProductFactory factory = new ProductFactory();
        Product product;

        product = factory.createProduct("A");
        product.use();

        product = factory.createProduct("B");
        product.use();}
}

当频繁的新增不同产品时，须要频繁的批改 ProductFactory 中的 if/else 逻辑

JDK

java.text.DateFormat#getDateInstance()
java.text.DateFormat#getDateInstance(int)
java.text.DateFormat#getDateInstance(int, java.util.Locale)

加密类，获取不同加密算法的密钥生成器:

KeyGenerator keyGen=KeyGenerator.getInstance("DESede");

相比简略工厂，这种形式将 ProductFactory 定义为抽象类，而后创立不同的具体的 ProductAFactory 和ProductBFactory，在应用时决定创立那种工厂和对象，防止了 if/else 判断

public abstract class Product {public abstract void use();
}

public class ProductA extends Product {
    @Override
    public void use() {System.out.println("You are using ProductA...");
    }
}

public class ProductB extends Product {
    @Override
    public void use() {System.out.println("You are using ProductB...");
    }
}

public abstract class ProductFactory {public abstract Product createProduct();
}

public class ProductAFactory extends ProductFactory {
    @Override
    public Product createProduct() {return new ProductA();
    }
}

public class ProductBFactory extends ProductFactory {
    @Override
    public Product createProduct() {return new ProductB();
    }
}

public class Main {public static void main(String[] args) {
        ProductFactory factory;
        Product product;

        factory = new ProductAFactory();
        product = factory.createProduct();
        product.use();

        factory = new ProductBFactory();
        product = factory.createProduct();
        product.use();}

}

这种模式更加合乎开闭准则，然而与最原始的 new ProductA() 和new ProductA()相比十分类似，引入工厂模式，反倒让设计变得更加简单了。

JDBC

Connection conn=DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/db1","db_user","123456");
Statement statement=conn.createStatement();
ResultSet rs=statement.executeQuery("select * from user");

为了了解形象工厂模式，咱们要先理解两个概念：

产品等级构造：产品等级构造即产品的继承构造，如一个抽象类是电视机，其子类有海尔电视机、海信电视机、TCL 电视机，则形象电视机与具体品牌的电视机之间形成了一个产品等级构造，形象电视机是父类，而具体品牌的电视机是其子类。
产品族：在形象工厂模式中，产品族是指由同一个工厂生产的，位于不同产品等级构造中的一组产品，如海尔电器工厂生产的海尔电视机、海尔电冰箱，海尔电视机位于电视机产品等级构造中，海尔电冰箱位于电冰箱产品等级构造中。

在工厂办法模式中具体工厂负责生产具体的产品，每一个具体工厂对应一种具体产品。个别状况下，一个具体工厂中只有一个工厂办法或者一组重载的工厂办法。然而有时候咱们须要一个工厂能够提供多个产品对象，而不是繁多的产品对象。

Factory1负责创立 ProductA1 和ProductB1
Factory2负责创立 ProductA2 和ProductB2
客户端不须要晓得具体的产品，只须要晓得创立的工厂即可应用该产品

public abstract class AbstractProductA {public abstract void use();

}

public class ProductA1 extends AbstractProductA {

    @Override
    public void use() {System.out.println("You are using ProductA1...");
    }

}

public class ProductA2 extends AbstractProductA {

    @Override
    public void use() {System.out.println("You are using ProductA2...");
    }

}

public abstract class AbstractProductB {public abstract void eat();

}

public class ProductB1 extends AbstractProductB {

    @Override
    public void eat() {System.out.println("You are eating ProductB1...");
    }

}

public class ProductB2 extends AbstractProductB {

    @Override
    public void eat() {System.out.println("You are eating ProductB2...");
    }

}

public abstract class AbstractFactory {public abstract AbstractProductA createProductA();

    public abstract AbstractProductB createProductB();}

public class Factory1 extends AbstractFactory {

    @Override
    public AbstractProductA createProductA() {return new ProductA1();
    }

    @Override
    public AbstractProductB createProductB() {return new ProductB1();
    }

}

public class Factory2 extends AbstractFactory {

    @Override
    public AbstractProductA createProductA() {return new ProductA2();
    }

    @Override
    public AbstractProductB createProductB() {return new ProductB2();
    }

}

public class Main {public static void main(String[] args) {
        AbstractFactory factory;
        
        factory = new Factory1();
        use(factory);

        factory = new Factory2();
        use(factory);
    }

    public static void use(AbstractFactory factory) {AbstractProductA productA = factory.createProductA();
        productA.use();
        AbstractProductB productB = factory.createProductB();
        productB.eat();}

}

形象工厂模式带来了泛滥类，构造绝对简单，且创立新的产品等级构造麻烦。
形象工厂模式理论工作中利用场景很少，简略关注理解下即可

正文完

设计模式

发表至：设计模式

2022-01-24

0

关于设计模式:策略模式初探

关于设计模式:Head-First-设计模式-13-代理-Proxy-模式

关于设计模式:设计模式建造者模式

关于设计模式:Go应用设计模式之创建型

关于git:如果你觉得学习-Git-很枯燥那是因为你还没玩过这款游戏

关于设计模式:设计模式之工厂模式

应用场景

简略工厂模式

类图

代码实现

Product

ProductA

ProductB

ProductFactory

Main

点评

利用

工厂办法模式

类图

代码实现

Product

ProductA

ProductB

ProductFactory

ProductAFactory

ProductBFactory

Main

点评

利用

形象工厂模式

类图

代码实现

AbstractProductA

ProductA1

ProductA2

AbstractProductB

ProductB1

ProductB2

AbstractFactory

Factory1

Factory2

Main

点评

站内搜索