Java工厂设计模式

    在Java中，接口是实现多重继承的途径，而生成遵循某个接口的对象的典型方式就是工厂设计模式，我们在工厂对象上调用其定义的静态方法，工厂将生成接口的某个实现的对象。通过这种方式，我们可以实现把代码和接口的实现分离。并且，如果把主方法看作客户端，那么，对于程序的修改就不应该影响或改动客户端。

    使用工厂设计模式就可以很好的解决这个问题，就可以让我们根据需求将一个实现替换为另一个实现，我将介绍两种工厂设计模式。现在我先介绍简单工厂设计模式（Simple Factory）

interface Eating{//首先定义一个接口
    void Eat();
}
//-----------------------------------------------------
class Factory{//工厂根据主函数的需求提供不同的接口实现对象
    public static Eating GetInstance(String food){
        if("meat".equals(food)){
            return new meat();
        }
        if("rice".equals(food)){
            return new rice();
        }
        if("noodles".equals(food)){
            return new noodles();
        }
        return null;
    }
}
//------------------------------------------------------
class rice implements Eating{//接口的实现1
    public void Eat(){
        System.out.println("eat rice");
    }
}

class meat implements Eating{//接口的实现2
    public void Eat(){
        System.out.println("eat meat");
    }
}

class noodles implements Eating{//接口的实现3
    public void Eat(){
        System.out.println("eat noodles");
    }
}

public class Main {//主函数（客户端）
    public static void main(String[] args) {
        Eating New_Eating = Factory.GetInstance(args[0]);//客户端输入需求
        New_Eating.Eat();
    }
}

    我们可以发现在更改调用的Eating子类的时候，主函数不用发生任何变化。这种设计模式就称为工厂设计模式。

    但是，我们发现，每当客户端再增加了一个需求的时候，在工厂里都会被动的增加一段代码来与新增加的需求所对应，这样显得工厂处于一种被动的地位，并且违反了开放—关闭的原则，所以，在这里介绍一种新的工厂设计模式，就是工厂方法模式。

    对于工厂方法模式(Factory Method),我先上代码

abstract class Factory{//创建工厂的接口
    public abstract Product Get_Product();
}

abstract class Product{//创建产品的接口
    public abstract void Show_Product();
}

class Product_one extends Product{//产品1
    @Override
    public void Show_Product() {
        System.out.println("Get Product_one");
    }
}

class Product_two extends Product{//产品2
    @Override
    public void Show_Product() {
        System.out.println("Get Product_two");
    }
}

class Factory_one extends Factory{//生产产品1的工厂子类
    @Override
    public Product Get_Product() {
        return new Product_one();
    }
}

class Factory_two extends Factory{//生产产品2的工厂子类
    @Override
    public Product Get_Product() {
        return new Product_two();
    }
}

public class Main {//主函数（客户端）
    public static void main(String[] args) {
        Factory New_Factory_one = new Factory_one();//创建一个工厂对象，用生产产品1的子类实例化
        New_Factory_one.Get_Product().Show_Product();//生产一个产品1
        Factory New_Factory_Two = new Factory_two();//创建一个工厂对象，用生产产品2的子类实例化
        New_Factory_Two.Get_Product().Show_Product();//生产一个产品2
    }
}

    这就是工厂方法模式，这种设计方式可以保证了工厂方法内的对修改关闭，解决了简单工厂模式的问题。但是再增加新的产品（需求）的时候，我们也要增加对应的工厂子类和产品子类，这样做在一定程度上增加了程序的复杂性，同时，有太多的类需要编译，也增加了系统的开销。

    所以，我们在更多的情况下是把这两种模式结合起来使用，可以更好的实现需求。

    综上所述，关于两种设计模式的利弊，我总结了其使用的场景

    1：当一个类不知道它所需要的对象的类时，在工厂方法模式中，客户端不需要知道具体产品类的类名，只需要调用对应的工厂类或者工厂方法即可；

    2：当一个类希望通过其子类来指定创建对象时，在工厂方法模式中，抽象工厂类只被指定提供一个产品；

最后，在JDK中，有两处用到工厂模式的典型操作

    1：Collection中的iterator方法（集合类中的迭代器）；

    2：java.util包中的sql相关操作；

   我的总结暂时先到这里，后续会有补充。