add AbstractFactory

Author: jarry

.gitignore

@@ -1,6 +1,7 @@
 # Compiled class file
 *.class
 *.pyc
+.idea
 
 # Log file
 *.log

abstract-factory/README.md

@@ -0,0 +1,16 @@
+# 简介
+抽象工厂模式（Abstract Factory Pattern）是一个超级工厂，用来创建其他的工厂。
+工厂方法是一个具体工厂，用来创建对象，而抽象工厂则是用来创建工厂的类。
+
+抽象工厂属于创建型模式，它为访问类提供一个创建一组相互依赖对象的接口，且访问类无须指定具体类就能得到同类下不同等级的对象的模式。在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。
+
+# 实现步骤
+1. 建立抽象工厂类，用于创建产品工厂类。
+2. 新建多个同步系列的具体产品类，均实现该产品接口类。
+3. 建立产品工厂类，继承该抽象工厂类，由产品工厂类创建产品对象。
+4. 想要获取具体产品对象时，先生成工厂，再实例化对象。
+
+# 作用
+- 工厂的创建和调用解耦，便于不同系列产品之间的关联调用。
+- 屏蔽复杂的对象创建逻辑，交由统一的工厂方法，工厂本身也由工厂创建。
+- 采用统一的方式来实例化，还可以防止内存中实例对象不断增多。

abstract-factory/java/src/AbstractFactory.java

@@ -0,0 +1,15 @@
+package src;
+
+import src.vehicle.*;
+import src.shop.*;
+
+/*
+  意图：提供一个创建一系列相互依赖的接口，而无需指定它们具体的类。
+  主要作用：主要解决接口选择的问题。在一个对象家族系统里面里面，抽象定义多个产品对象。
+  何时使用：产品很多，形成产品系列，而系统只需要处理其中某一类的产品。
+  如何解决：在一个产品系列里面，定义多个产品对象。由抽象类来负责创建产品工厂。
+ */
+public abstract class AbstractFactory {
+  public abstract Vehicle getVehicle(VehicleType type);
+  public abstract Shop getShop(String name);
+}

abstract-factory/java/src/FactoryCreator.java

@@ -0,0 +1,19 @@
+package src;
+
+/*
+  工厂创建者，用来创建不同的工厂
+*/
+public class FactoryCreator {
+  public static AbstractFactory getFactory(String name) {
+    switch (name) {
+      // 汽车工厂
+      case "vehicle":
+        return new VehicleFactory();
+      // 商店工厂
+      case "shop":
+        return new ShopFactory();
+      default:
+        return null;
+    }
+  }
+}

abstract-factory/java/src/ShopFactory.java

@@ -0,0 +1,25 @@
+package src;
+import src.vehicle.*;
+import src.shop.*;
+/*
+ 商店创建类，继承自抽象工厂
+*/
+public class ShopFactory extends AbstractFactory {
+  @Override
+  public Shop getShop(String name) {
+    if (name.equals("AgencyShop")) {
+      return new AgencyShop();
+    } else if (name.equals("DirectSaleShop")) {
+      return new DirectSaleShop();
+    } else if (name.equals("SupermarketShop")) {
+      return new SupermarketShop();
+    } else {
+      return null;
+    }
+  }
+
+  @Override
+  public Vehicle getVehicle(VehicleType type) {
+    return null;
+  }
+}

abstract-factory/java/src/VehicleFactory.java

@@ -0,0 +1,32 @@
+package src;
+import src.vehicle.*;
+import src.shop.*;
+/*
+  意图：定义基础接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。
+  主要作用：解决接口选择的问题。统一实例化，用接口来实例化类更加抽象。
+  何时使用：大量构造函数的地方，调用了大量的new来实例化类。
+  如何解决：让其子类实现工厂接口，返回的也是一个抽象的产品。
+ */
+public class VehicleFactory extends AbstractFactory {
+  @Override
+  public Vehicle getVehicle(VehicleType type) {
+    switch (type) {
+      case BUS:
+        return new Bus();
+      case CAR:
+        return new Car();
+      case MOTORCYCLE:
+        return new Motorcycle();
+      case VAN:
+        return new Van();
+      default:
+        return null;
+    }
+
+  }
+
+  @Override
+  public Shop getShop(String name) {
+    return null;
+  }
+}

abstract-factory/java/src/shop/AgencyShop.java

@@ -0,0 +1,8 @@
+package src.shop;
+
+public class AgencyShop implements Shop {
+  @Override
+  public void greetings() {
+    System.out.println("AgencyShop::greetings().");
+  }
+}

abstract-factory/java/src/shop/DirectSaleShop.java

@@ -0,0 +1,7 @@
+package src.shop;
+public class DirectSaleShop implements Shop {
+  @Override
+  public void greetings() {
+     System.out.println("DirectSaleShop::greetings().");
+  }
+}

abstract-factory/java/src/shop/Shop.java

@@ -0,0 +1,4 @@
+package src.shop;
+public interface Shop {
+  void greetings();
+}

abstract-factory/java/src/shop/SupermarketShop.java

@@ -0,0 +1,7 @@
+package src.shop;
+public class SupermarketShop implements Shop {
+  @Override
+  public void greetings() {
+     System.out.println("SupermarketShop::greetings().");
+  }
+}