-
简单工厂模式
三个角色： 抽象产品类，具体产品类，简单工厂类
/** 抽象产品类 */
public abstract class AbstractProduct
{
public abstract void func();
}
-------------------------------------------------------------------------------------
/** 具体产品类 */
public class ProductA extends AbstractProduct
{
@Override
public void func()
{
System.out.println("product A");
}
}
/** 具体产品类 */
public class ProductB extends AbstractProduct
{
@Override
public void func()
{
System.out.println("product B");
}
}
/** 具体产品类 */
public class ProductC extends AbstractProduct
{
@Override
public void func()
{
System.out.println("product C");
}
}
-------------------------------------------------------------------------------------
/** 简单工厂类 */
public class SimpleFactory
{
public static AbstractProduct createProduct(String product){
switch (product){
case "A":return new ProductA();
case "B":return new ProductB();
case "C":return new ProductC();
default:return null;
}
}
}
/** 主测试函数 */
public class Main
{
public static void main(String[] args)
{
AbstractProduct product = SimpleFactory.createProduct("A");
product.func();
}
}
Output: "product A"
简单工厂模式写法简单，但是拓展性差，若是想再添加一种产品则需要修改工厂方法内部代码。
-
多方法工厂模式
是简单工厂模式的变种。由于简单工厂模式依据传递的参数判断产品的类型，因此容易造成参数不正确而无法产生合适的产品。这时可以将产品的创建分发到不同的函数中，只要调用合适的方法即可创建合适的产品。
/** 抽象产品类 */
public abstract class AbstractProduct
{
public abstract void func();
}
-------------------------------------------------------------------------------------
/** 具体产品类 */
public class ProductA extends AbstractProduct
{
@Override
public void func()
{
System.out.println("product A");
}
}
/** 具体产品类 */
public class ProductB extends AbstractProduct
{
@Override
public void func()
{
System.out.println("product B");
}
}
/** 具体产品类 */
public class ProductC extends AbstractProduct
{
@Override
public void func()
{
System.out.println("product C");
}
}
-------------------------------------------------------------------------------------
/** 简单工厂类 */
public class SimpleFactory
{
public static AbstractProduct createProductA(){
return new ProductA();
}
public static AbstractProduct createProductB(){
return new ProductB();
}
public static AbstractProduct createProductC(){
return new ProductC();
}
}
/** 主测试函数 */
public class Main
{
public static void main(String[] args)
{
AbstractProduct productA = SimpleFactory.createProductA();
productA.func();
AbstractProduct productB = SimpleFactory.createProductB();
productB.func();
AbstractProduct productC = SimpleFactory.createProductC();
productC.func();
}
}
Output: "porductA \n productB \n productC"
-
工厂方法模式
四个角色：抽象产品，具体产品，抽象工厂，具体工厂。
/** 抽象产品类 */
public abstract class AbstractProduct
{
public abstract void func();
}
-------------------------------------------------------------------------------------
/** 具体产品类 */
public class ProductA extends AbstractProduct
{
@Override
public void func()
{
System.out.println("product A");
}
}
/** 具体产品类 */
public class ProductB extends AbstractProduct
{
@Override
public void func()
{
System.out.println("product B");
}
}
/** 具体产品类 */
public class ProductC extends AbstractProduct
{
@Override
public void func()
{
System.out.println("product C");
}
}
/** 抽象工厂类 */
public abstract class AbstractFactory
{
public abstract AbstractProduct createProduct();
}
-------------------------------------------------------------------------------------
/** 具体工厂类 */
public class FactoryA extends AbstractFactory
{
@Override
public AbstractProduct createProduct()
{
return new ProductA();
}
}
/** 具体工厂类 */
public class FactoryB extends AbstractFactory
{
@Override
public AbstractProduct createProduct()
{
return new ProductB();
}
}
/** 具体工厂类 */
public class FactoryC extends AbstractFactory
{
@Override
public AbstractProduct createProduct()
{
return new ProductC();
}
}
/** 主测试函数 */
public class main
{
public static void main(String[] args)
{
AbstractFactory factoryA = new FactoryA();
AbstractProduct productA = factoryA.createProduct();
productA.func();
AbstractFactory factoryB = new FactoryB();
AbstractProduct productB = factoryB.createProduct();
productB.func();
}
}
Output: "productA \n productB"
工厂方法模式写起来要比简单工厂模式复杂，但是他将简单工厂解耦，产品不需要在一个工厂中被建造，从而在我们增加一项产品时，只需要增加对应的产品工厂和产品即可。
-
抽象工厂模式
四个角色：抽象产品，具体产品，抽象工厂，具体工厂。
与工厂方法模式的区别：
抽象工厂模式的抽象产品可以是多个，而工厂方法模式的抽象产品只能是同一个（只有一个产品簇）。
/** 抽象产品类 */
public abstract class AbstractProductA
{
public abstract void func();
}
/** 具体产品类 */
public class ProductAA extends AbstractProductA
{
@Override
public void func()
{
System.out.println("product AA");
}
}
/** 具体产品类 */
public class ProductAB extends AbstractProductA
{
@Override
public void func()
{
System.out.println("product AB");
}
}
-------------------------------------------------------------------------------------
/** 抽象产品类 */
public abstract class AbstractProductB
{
public abstract void func();
}
/** 具体产品类 */
public class ProductBA extends AbstractProductA
{
@Override
public void func()
{
System.out.println("product BA");
}
}
/** 具体产品类 */
public class ProductBB extends AbstractProductA
{
@Override
public void func()
{
System.out.println("product BB");
}
}
/** 抽象工厂类 */
public abstract class AbstractFactory
{
public abstract AbstractProductA createProductAA();
public abstract AbstractProductA createProductAB();
public abstract AbstractProductB createProductBA();
public abstract AbstractProductB createProductBB();
}
/** 具体工厂类 */
public class Factory extends AbstractFactory
{
@Override
public AbstractProductA createProductAA()
{
return new ProductAA();
}
@Override
public AbstractProductA createProductAB()
{
return new ProductAB();
}
@Override
public AbstractProductB createProductBA()
{
return new ProductBA();
}
@Override
public AbstractProductB createProductBB()
{
return new ProductBB();
}
}
抽象工厂模式主要用于多个产品簇对象的创建过程。
网友评论