Java工厂设计模式主要分为三种:
简单工厂模式(Simple Factory Pattern):使用一个工厂类来封装对象创建的过程,客户端只需要通过传递不同的参数来获取不同的产品对象,从而避免了客户端直接创建产品对象的操作
工厂方法模式(Factory Method Pattern):将工厂类抽象出来,每个具体产品类对应一个具体工厂类,工厂类通过多态性来创建对应的产品对象,客户端只需要知道工厂接口及其实现类即可,可以根据需求动态切换工厂实现,扩展性更好.
抽象工厂模式(Abstract Factory Pattern):在工厂方法模式的基础上,将工厂类再进行一次抽象,将多个工厂接口放到一个工厂接口中,每个具体产品对应一个具体工厂类,通过多态性来创建对应的产品对象,具有更好的扩展性和更高的抽象程度,但是也增加了系统复杂度
首先先定义一个抽象产品类:
package com.fanqiechaodan.factory.simple.product;
/**
* @Classname Product
* @Description 抽象产品类
*/
public abstract class Product {
public abstract void use();
}然后定义具体产品类
public class ProductA extends Product{
@Override
public void use() {
System.out.println("使用具体产品类A...");
}
}
public class ProductB extends Product{
@Override
public void use() {
System.out.println("使用具体产品类B...");
}
}
public class ProductC extends Product{
@Override
public void use() {
System.out.println("使用具体产品类C...");
}
}接下来定义工厂类,用于创建不同的产品
package com.fanqiechaodan.factory.simple.factory;
import com.fanqiechaodan.factory.simple.product.Product;
import com.fanqiechaodan.factory.simple.product.ProductA;
import com.fanqiechaodan.factory.simple.product.ProductB;
import com.fanqiechaodan.factory.simple.product.ProductC;
/**
* @Classname SimpleFactory
* @Description 工厂类
*/
public class SimpleFactory {
public static Product createProduct(String type) {
switch (type) {
case "A":
return new ProductA();
case "B":
return new ProductB();
case "C":
return new ProductC();
default:
throw new RuntimeException("不支持的产品类型:" + type);
}
}
}测试:
package com.fanqiechaodan.factory.simple;
import com.fanqiechaodan.factory.simple.factory.SimpleFactory;
import com.fanqiechaodan.factory.simple.product.Product;
/**
* @Classname Demo
* @Description 简单工厂模式
*/
public class Demo {
public static void main(String[] args) {
Product productA = SimpleFactory.createProduct("A");
productA.use();
Product productB = SimpleFactory.createProduct("B");
productB.use();
Product productC = SimpleFactory.createProduct("C");
productC.use();
Product productD = SimpleFactory.createProduct("D");
productD.use();
}
}
首先定义一个接口表示产品
package com.fanqiechaodan.factory.method.product;
/**
* @Classname Product
* @Description 产品接口
*/
public interface Product {
void use();
}其次定义两个具体的产品实现类
public class ProductA implements Product{
@Override
public void use() {
System.out.println("使用具体产品A...");
}
}
public class ProductB implements Product{
@Override
public void use() {
System.out.println("使用具体产品B...");
}
}然后定义一个工厂接口用于创建产品
package com.fanqiechaodan.factory.method.factory;
import com.fanqiechaodan.factory.method.product.Product;
/**
* @Classname Factory
* @Description 工厂接口
*/
public interface Factory {
Product createProduct();
}接下来,定义两个具体的工厂实现类,分别用于创建不同的产品
public class FactoryA implements Factory{
@Override
public Product createProduct() {
return new ProductA();
}
}
public class FactoryB implements Factory{
@Override
public Product createProduct() {
return new ProductB();
}
}测试
package com.fanqiechaodan.factory.method.factory;
import com.fanqiechaodan.factory.method.product.Product;
import com.fanqiechaodan.factory.method.product.ProductB;
/**
* @Classname FactoryB
* @Description 工厂实现类B
*/
public class FactoryB implements Factory{
@Override
public Product createProduct() {
return new ProductB();
}
}
首先定义抽象产品
public interface ProductA {
void doSomething();
}
public interface ProductB {
void doSomething();
}其次定义具体产品
public class ProductA1 implements ProductA{
@Override
public void doSomething() {
System.out.println("ProductA1 doSomething ...");
}
}
public class ProductA2 implements ProductA{
@Override
public void doSomething() {
System.out.println("ProductA2 doSomething ...");
}
}
public class ProductB1 implements ProductB{
@Override
public void doSomething() {
System.out.println("ProductB1 doSomething ...");
}
}
public class ProductB2 implements ProductB{
@Override
public void doSomething() {
System.out.println("ProductB2 doSomething ...");
}
}然后定义抽象工厂
package com.fanqiechaodan.factory.abstractfactory.factory;
import com.fanqiechaodan.factory.abstractfactory.product.ProductA;
import com.fanqiechaodan.factory.abstractfactory.product.ProductB;
/**
* @Classname AbstractFactory
* @Description 抽象工厂
*/
public interface AbstractFactory {
ProductA createProductA();
ProductB createProductB();
}接下来定义具体工厂
public class Factory1 implements AbstractFactory{
@Override
public ProductA createProductA() {
return new ProductA1();
}
@Override
public ProductB createProductB() {
return new ProductB1();
}
}
public class Factory2 implements AbstractFactory{
@Override
public ProductA createProductA() {
return new ProductA2();
}
@Override
public ProductB createProductB() {
return new ProductB2();
}
}测试
package com.fanqiechaodan.factory.abstractfactory;
import com.fanqiechaodan.factory.abstractfactory.factory.AbstractFactory;
import com.fanqiechaodan.factory.abstractfactory.factory.Factory1;
import com.fanqiechaodan.factory.abstractfactory.factory.Factory2;
import com.fanqiechaodan.factory.abstractfactory.product.ProductA;
import com.fanqiechaodan.factory.abstractfactory.product.ProductB;
/**
* @Classname Demo
* @Description 抽象工厂模式
*/
public class Demo {
public static void main(String[] args) {
// 使用具体工厂1创建产品A和产品B
AbstractFactory factory1 = new Factory1();
ProductA productA1 = factory1.createProductA();
ProductB productB1 = factory1.createProductB();
productA1.doSomething();
productB1.doSomething();
// 使用具体工厂2创建产品A和产品B
AbstractFactory factory2 = new Factory2();
ProductA productA2 = factory2.createProductA();
ProductB productB2 = factory2.createProductB();
productA2.doSomething();
productB2.doSomething();
}
}
