1. 设计模式 工厂模式

1.工厂方法模式
工厂方法（FactoryMethod）模式的定义：定义一个创建产品对象的工厂接口，将产品对象的实际创建工作推迟到具体子工厂类当中。这满足创建型模式中所要求的“创建与使用相分离”的特点。
 

我们把被创建的对象称为“产品”，把创建产品的对象称为“工厂”。如果要创建的产品不多，只要一个工厂类就可以完成，这种模式叫“简单工厂模式”，它不属于 GoF 的 23 种经典设计模式，它的缺点是增加新产品时会违背“开闭原则”。

本节介绍的“工厂方法模式”是对简单工厂模式的进一步抽象化，其好处是可以使系统在不修改原来代码的情况下引进新的产品，即满足开闭原则。
 

 

原文链接 

http://www.javaxmw.com/info?intId=15

config1.xml ：

<?xml version="1.0" encoding="UTF-8"?>
<config>
   <className>ConcreteFactory1className>
config>

ReadXML1.java

public class ReadXML1 {
   static String path = "config1.xml";
   public static Object getObject() {
      try {
         DocumentBuilderFactory  dFactory =  DocumentBuilderFactory.newInstance();
            DocumentBuilder builder= dFactory.newDocumentBuilder();
            Document doc;
            doc = builder.parse(new File(path));
            //获取包含类名的文本节点
            NodeList nl=doc.getElementsByTagName("className");
            Node classNode=nl.item(0).getFirstChild();
            String cName="com.springboot.springBootDemo.designpatterns.factory."+classNode.getNodeValue();
            //System.out.println("新类名："+cName);
            //通过类名生成实例对象并将其返回
            Class<?> c=Class.forName(cName);
              Object obj=c.newInstance();
            return obj;
      } catch (Exception e) 
      {
            e.printStackTrace();
            return null;
      }
   }
}

 

Factory.java ：

public class Factory {

   public static void main(String[] args) {
      try {
         Product a;
         AbstractFactory af;
         af = (AbstractFactory)ReadXML1.getObject();
         a = af.newProduct();
         a.show();
         
      } catch (Exception e)
      {
            System.out.println(e.getMessage());
      }

   }

   
}

interface Product
{
   void show();
}


class ConcreteProduct1 implements Product
{

   @Override
   public void show() {
        System.out.println("具体产品1显示...");
   }
   
}

class ConcreteProduct2 implements Product
{

   @Override
   public void show() {
        System.out.println("具体产品2显示...");
   }
}

//抽象工厂：提供了厂品的生成方法
interface AbstractFactory
{
   Product newProduct();

}

//具体工厂1：实现了厂品的生成方法
class ConcreteFactory1 implements AbstractFactory
{
    public Product newProduct()
    {
        System.out.println("具体工厂1生成-->具体产品1...");
        return new ConcreteProduct1();
    }
}

//具体工厂1：实现了厂品的生成方法
class ConcreteFactory2 implements AbstractFactory
{
   public Product newProduct()
   {
      System.out.println("具体工厂1生成-->具体产品1...");
      return new ConcreteProduct2();
   }
}

2.抽象工厂模式

模式的定义与特点

抽象工厂（AbstractFactory）模式的定义：是一种为访问类提供一个创建一组相关或相互依赖对象的接口，且访问类无须指定所要产品的具体类就能得到同族的不同等级的产品的模式结构。

抽象工厂模式是工厂方法模式的升级版本，工厂方法模式只生产一个等级的产品，而抽象工厂模式可生产多个等级的产品。

使用抽象工厂模式一般要满足以下条件。

• 系统中有多个产品族，每个具体工厂创建同一族但属于不同等级结构的产品。
• 系统一次只可能消费其中某一族产品，即同族的产品一起使用。

抽象工厂模式除了具有工厂方法模式的优点外，其他主要优点如下。

• 可以在类的内部对产品族中相关联的多等级产品共同管理，而不必专门引入多个新的类来进行管理。
• 当增加一个新的产品族时不需要修改原代码，满足开闭原则。

其缺点是：当产品族中需要增加一个新的产品时，所有的工厂类都需要进行修改

public class AbstractFactoryJ {
   public static void main(String[] args) {
   }
}

interface AbstractFactoryM
{
     Product1 newProduct1();
     Product2 newProduct2();
}


class ConcreateFactory1 implements AbstractFactoryM {

   @Override
   public Product1 newProduct1() {
      return new ConcreteProductM1();
   }

   @Override
   public Product2 newProduct2() {
      return new ConcreteProductM2();
   }
   
}


//具体工厂1：实现了厂品的生成方法
class ConcreteProductM1 implements Product1
{

   @Override
   public void show() {

   }
}
//具体工厂2：实现了厂品的生成方法
class ConcreteProductM2 implements Product2
{
   @Override
   public void show() {

   }
}