版权声明： https://blog.csdn.net/if_i_were_a/article/details/83017190
在有道云笔记上写的，抽象工厂模式
抽象工厂模式：提供一个创建一系列相关或相互依赖的对象的接口，而无需指定他们具体的类
抽象工厂模式的优点：易于交换产品系列，在一个应用中只需要在初始化的时候出现一次。它让具体的创建实例与客户端相分离，不会出现在客户端的代码中
缺点：如果要增加一个产品的话，需要改动的类很多
这是我写的三个例子：每个part下面一个例子
part01:抽象工厂模式
抽象工厂模式的类图如下：（选自大话设计模式，ps我的所有的设计模式的图片都来自这里）
以下是代码
public abstract class AbstractProductA {
public AbstractProductA() {
}
}
public abstract class AbstractProductB {
public AbstractProductB() {
}
}
public class ProductA1 extends AbstractProductA {
public ProductA1() {
}
}
public class ProductA2 extends AbstractProductA {
public ProductA2() {
}
}
public class ProductB1 extends AbstractProductB {
public ProductB1() {
}
}
public class ProductB2 extends AbstractProductB {
public ProductB2() {
}
}
public abstract class AbstractFactory {
public abstract AbstractProductA createProductA();
public abstract AbstractProductB createProductB();
}
public class ConcreteFactory1 extends AbstractFactory {
@Override
public AbstractProductA createProductA() {
System.out.println("工厂一生产产品A1");
return new ProductA1();
}
@Override
public AbstractProductB createProductB() {
System.out.println("工厂一生产产品B1");
return new ProductB1();
}
}
public class ConcreteFactory2 extends AbstractFactory {
@Override
public AbstractProductA createProductA() {
System.out.println("工厂二生产产品A2");
return new ProductA2();
}
@Override
public AbstractProductB createProductB() {
System.out.println("工厂二生产产品B2");
return new ProductB2();
}
}
public class Client {
public static void main(String[] args) {
AbstractFactory af=new ConcreteFactory2();
af.createProductA();
af.createProductB();
}
}加入我现在要加一个产品C，需要改变的类由AbstractProduct,ConctreteFactory1,,ConctreteFactory2,这是很麻烦的，所以不如简单工厂模式来的痛快
part01:针对以上问题写的简单工厂模式
public abstract class AbstractProductA {
public AbstractProductA() {
}
}
public abstract class AbstractProductB {
public AbstractProductB() {
}
}
public class ProductA1 extends AbstractProductA {
public ProductA1() {
}
}
public class ProductA2 extends AbstractProductA {
public ProductA2() {
}
}
public class ProductB1 extends AbstractProductB {
public ProductB1() {
}
}
public class ProductB2 extends AbstractProductB {
public ProductB2() {
}
}
public class SimpleFactory {
public SimpleFactory() {
}
public AbstractProductA createProductA(String h){
AbstractProductA a;
switch (h)
{
case "A1":
a=new ProductA1();
System.out.println("生产A1");
break;
case "A2":
a=new ProductA2();
System.out.println("生产A2");
break;
default:
a=null;
break;
}
return a;
}
public AbstractProductB createProdutB(String h){
AbstractProductB b;
switch (h)
{
case "B1":
b=new ProductB1();
System.out.println("生产B1");
break;
case "B2":
b=new ProductB2();
System.out.println("生产B2");
break;
default:
b=null;
break;
}
return b;
}
}
public class Client {
public static void main(String[] args) {
SimpleFactory simpleFactory=new SimpleFactory();
simpleFactory.createProductA("A1");
simpleFactory.createProdutB("B2");
}
}但是正如你知道的，简单工厂模式违背了开放-封闭原则，所以part03是用反射解决这个问题的
public abstract class AbstractProductA {
public AbstractProductA() {
}
}
public abstract class AbstractProductB {
public AbstractProductB() {
}
}
public class ProductA1 extends AbstractProductA {
public ProductA1() {
}
}
public class ProductA2 extends AbstractProductA {
public ProductA2() {
}
}
public class ProductB1 extends AbstractProductB {
public ProductB1() {
}
}
public class ProductB2 extends AbstractProductB {
public ProductB2() {
}
}
public class Factory {
public Class createProductA(String h) throws ClassNotFoundException {
if(h=="A1"||h=="A2") {
Class a = Class.forName("AbstractFactory.part03.Product"+h);
System.out.println("生产产品"+h);
return a;
}
else
{
return null;
}
}
public Class createProductB(String h) throws ClassNotFoundException {
if(h=="B1"||h=="B2") {
Class b = Class.forName( "AbstractFactory.part03.Product"+h);
System.out.println("生产产品"+h);
return b;
}else
{
return null;
}
}
}
public class Client {
public static void main(String[] args) throws ClassNotFoundException {
Factory f=new Factory();
f.createProductA("A1");
f.createProductA("A2");
f.createProductB("B1");
f.createProductB("B2");
}
}这个是最有效的方法啦