今天回看之前总结的抽象工厂模式的实现《 Java常用设计模式————抽象工厂模式 》，聚焦于抽象工厂模式的缺点，试着改进了一下。

回顾一下抽象工厂模式的缺点：

在添加新的产品类型时，难以扩展抽象工厂来生产新种类的产品。

这是怎么回事呢？原来，老套的实现方式是为每种类型的产品都创建一个具体的工厂类，这个类只生产一种特定类型的产品。因此，当有新的类型的产品加入系统时，就必须添加一个对应的工厂类来支持这类产品，不仅不利于扩展，而且会增加大量的工厂类。

例如之前会有如下两个具体产品的工厂类来生产对应类型的产品：

今天试着使用泛型的方式，得出了一种更加通用的抽象工厂实现方式。可以避免大量工厂的再造。

为了本篇文章的完整性，依然将全部实现过程贴出，各位同学可以与《 Java常用设计模式————抽象工厂模式 》进行比较阅读。

一、抽象化产品族

产品族的概念其实很好理解，每种类型的产品就是一个产品族，它包含多种不同的表现形式，例如汽车就是一个产品族，它包含卡车、轿车等，这些具体的产品隶属于汽车这个产品族。

如图所示，创建了电视产品族和汽车产品族。 电视产品族 包括 索尼电视 和 夏普电视：

public interface Television {
    void play();
public class SonyTV implements Television{
    @Override
    public void play() {
        System.out.println("SonyTV playing...");
public class SharpTV implements Television{
    @Override
    public void play() {
        System.out.println("SharpTV playing...");
汽车产品族包括奥迪汽车和奔驰汽车：
 
public interface Car {
    void run();
public class Audi implements Car{
    @Override
    public void run() {
        System.out.println("Audi running...");
public class Benz implements Car{
    @Override
    public void run() {
        System.out.println("Benz running...");
二、创建抽象工厂及泛型工厂
 
抽象工厂是具体工厂的进一步抽象化，在原版的抽象工厂模式实现中，会存在多个具体的产品工厂，而在本例中，将会以泛型化的实现类来代替它们，而且即便再增加新的产品族也不需要修改泛型工厂：
 
public interface Factory<T> {
    T getProduct(Class<? extends T> clazz);
public class GenericFactory<T> implements Factory<T> {
    @Override
    public T getProduct(Class<? extends T> clazz) {
        if (clazz == null)
            return null;
        try {
            T obj = (T) clazz.newInstance();
            return obj;
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        return null;
三、测试产品的生产
 
public class MyProgram {
    public static void main(String[] args) {
        Factory<Car> carFactory = new GenericFactory<>();
        Factory<Television> tvFactory = new GenericFactory<>();
        Car benz = carFactory.getProduct(Benz.class);
        Car audi = carFactory.getProduct(Audi.class);
        benz.run();
        audi.run();
        Television sonyTV = tvFactory.getProduct(SonyTV.class);
        Television sharpTV = tvFactory.getProduct(SharpTV.class);
        sonyTV.play();
        sharpTV.play();
执行结果：
 
抽象工厂是一种非常有趣的设计模式，它隔离了对象创建的过程，并且可以应用反射机制来完成这一经典的设计模式。但传统的实现需要具体每一个产品族的工厂，这样就依然没有提高通用性。本例中使用泛型的工厂方式，不需要为具体工厂的创建而增加新的编码。这种方式需要注意泛型的实现，使用<? extends T>可以完美的应对具体产品生产的需要。是一个非常不错的实现手段。
 
《Java常用设计模式————抽象工厂模式》
 
《Java泛型初探————泛型通配》
                                    工厂设计模式中的超类可以是接口抽象类或普通 Java 类。对于我们的工厂设计模式示例，我们有一个抽象超类，其中重写了 toString()方法以用于测试目的。@Override假设我们的计算机Computer有两个子类PC和Server。PC类的实现@Override@Override@OverrideServer类的实现@Override@Override@Override关于工厂设计模式方法的一些要点是；我们可以保留工厂类。
                                    我们都知道在web开发时经常使用三层架构(web、service、dao)，每一层有着自己的实现类，而通过对实现类进行抽取方法形成接口，每一层通过接口进行上下层之间的耦合。例如在业务service层和数据访问dao层之间，当dao层写好了对数据库的增删改查方法时，抽取成dao接口，而在service如果要调用dao层的方法就只要使用dao接口即可，但是关键是在service层使用dao接口的时候，...
     抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。 
      在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。
二、应用抽象工厂模式来解决问题的思路
     创建一系列的产品对象，而且这一系列对象是构成新的对...
                                    抽象工厂模式是对工厂模式在产品扩展上的抽象化。抽象化的目的是为了对产品特性进行扩展。
比如，先前，我们的产品接口是这样：
public interface Product {
	public void doSomething();
现在要扩展产品新特性：
public interface Product {
	public void doSomething();
	public
设计模式之简单工厂模式到泛型工厂
         简单工厂模式（Simple Factory Pattern）又称为虽然23种设计模式中并不包含简单工厂模式，但是它是一种创建性模式应用的也相对比较广泛。在简单工厂模式中，可以根据参数的不同返回不同类的实例，被创建的实例通常都有相同的父类。
        以下是该模式的模式结构图：
        首先我们称创建的实例为产品
                                    1.反射的工厂模式
工厂模式的最大弊端是在工厂类中使用了new关键字，如果子类有n多个子类，则在工厂中需要写n个判断语句，这是很不理想的。因此我们可以用反射来优化工厂，利用newInstance()方法实例化对象，同时利用Class.forName()方法来接受String类的名称。 
interface Fruit{
    void eat();
class Apple...