Java设计模式-----工厂方法模式（Factory Pattern）

       工厂模式：主要关注的是结果，不关注过程。相比，代理模式关注的是过程，不关注结果。

       工厂方法模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。在工厂方法模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

       所谓工厂方法模式，其实也像我们现实生活中的工厂，现实生活中是用来生产东西的，只不过我们代码中的工厂是用来生产新的对象的。

      现在我们就拿一个具体的实例，来解析一下：

 需求：

        目前，有Cat，Dog，Monkey三个动物类，它们每个动物都有一种行为，那就是eat()。接下来，我们就一步一步来解析工厂方法模式的由来：

①如果我们现在，要让Cat，Dog，Monkey分别执行eat()方法，在我们平常的代码编写中，是这样子的：

   我们会分别写三个实体类：Cat.java，Dog.java，Monkey.java；然后分别定义它们里面的eat()方法

//1.Cat.java
public class Cat {
    public void eat(){
        System.out.println("I am Cat's eat method");
    }
}
//2.Dog.java
public class Dog {
    public void eat(){
        System.out.println("I am Dog's eat method");
    }
}
//3.Monkey.java
public class Monkey {
    public void eat(){
        System.out.println("I am Monkey's eat method");
    }
}

 然后，我们在写个测试类，通过new方法创建一个Cat对象，然后执行它的eat()方法。

public class Test {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.eat();  //打印结果：I am Cat's eat method
    }
}

 事实证明，这样写是完全没问题的。这样写的不合理之处在于：

     1.现实生活中，有多到数不清种动物，所以这样写太多遍明显是不合理的；

     2.如果某一天，我们不要这些动物的eat()方法了，我们要换成sleep()方法。那我就得有多少个改多少遍，那不得累死啊！！！

②于是我们发现，它们都有eat()方法，所以我们可以将eat()方法抽取出来，封装成一个接口IAnimal

public interface IAnimal {
    public void eat();
}

 ③让这些Cat.java，Dog.java等类去实现该接口，各自实现各自的功能

//1.Cat.java实现IAnimal接口
public class Cat implements IAnimal {
    @Override
    public void eat(){
        System.out.println("I am Cat's eat method");
    }
}
//2.Dog .java实现IAnimal接口
public class Dog implements IAnimal {
    @Override
    public void eat(){
        System.out.println("I am Dog's eat method");
    }
}
//3.Monkey .java实现IAnimal接口
public class Monkey implements IAnimal {
    @Override
    public void eat(){
        System.out.println("I am Monkey's eat method");
    }
}

④根据目前这种情况，所以可以创建一个工厂类AnimalsFactory，相当于工厂一样来批量生产，所以它会有一个product()方法

public class AnimalsFactory {
    public IAnimal product(String type){
        if(type.equalsIgnoreCase("Dog")){
            return new Dog();
        }else if(type.equalsIgnoreCase("Cat")){
            return new Cat();
        }else if(type.equalsIgnoreCase("Monkey")){
            return new Monkey();
        }else{
            return null;
        }
    }
}

⑤接下来我们就可以用④中创建的AnimalsFactory工厂来生产动物了。如下：用factory来生产了一只Dog和一只Cat

public class Test {
    public static void main(String[] args) {
        //1.利用AnimalsFactory来生成Dog对象
        AnimalsFactory factory = new AnimalsFactory();
        IAnimal dog = factory.product("dog");
        dog.eat(); //打印结果：I am Dog's eat method
        IAnimal cat = factory.product("cat");
        cat.eat(); //打印结果：I am Cat's eat method
    }
}

⑥如果我现在突然想生产一条鱼，它也要来eat()吃东西咋办？明显这个工厂没有生产鱼的这个本事，所以我们需要加一条生产鱼的生产线。需要满足如下两个步骤：

         1：在步骤③新建一个Fish类

         2：重新编写④中的AnimalsFactory工厂类，让它有生产鱼的本事

看得出来，我要新加一条生产线来生产鱼，还是比较麻烦的。上面所说的就是简单工厂模式

1.简单工厂模式的话不能算是设计模式，它只能算是工厂方法模式的入门模式。

2.如果学过简单工厂模式，就应该知道，工厂的目的是为了帮我们解决创建对象实例的问题，并且工厂能够隐藏类名及对象创建的细节，让我们无需关心对象的创建。

⑦现实生活中，没有这么厉害的工厂，啥都能干。哈哈。如下讲的模块就是工厂方法模式了。 现在我们就来创建一个工厂，因为工厂就是用来生产Cat，Dog等，所以他们都有一个product()方法，于是乎你可以将product()方法抽取出来成为单独一个接口IFactory，然后就分别让CatFactory，DogFactory，MonkeyFactory，FishFactory等等工厂来实现IFactory接口，让他们各司其职，而不是囫囵吞枣的由一个工厂来干。

//IFactory接口
public interface IFactory {
    public IAnimal product();
}

//1.猫厂
public class CatFactory implements IFactory {
    public IAnimal product(){
        return new Cat();
    }
}
//2.狗厂
public class DogFactory implements IFactory {
    public static IAnimal product(){
        return new Dog();
    }
}
//3.猴厂
public class MonkeyFactory implements IFactory {
    public IAnimal product(){
        return new Monkey();
    }
}
//4.鱼厂
public class FishFactory implements IFactory {
    public IAnimal product(){
        return new Fish();
    }
}

⑧接下来对各个猫厂，狗厂啥的进行测试

//对其进行测试，因为CatFactory和DogFactory都实现了IFactory接口
public class Test01 {
    public static void main(String[] args) {
        IFactory factory = new CatFactory();//所以此处返回的是IFactory类
        IAnimal animal= factory.product();
        animal.eat();// 打印结果：I am Cat's eat method   
}

⑨如果在这种情形下，我们现在要来个鸡厂生产鸡，而不要猫了，咋整？需要以下两个步骤：

         1：在步骤③新建一个Chicken类

         2：在步骤⑦中，新建一个ChickenFactory鸡厂类

         3：只需要以上1,2两步，然后在⑧中，将new CatFactory()换成new ChickenFactory()就可以了，此时由于多态的特性，使得 IAnimals接口的对象 animal根本不知道是在访问哪个厂，却可以在运行时很好的完成工作，这就是所谓的业务逻辑与数据访问的解耦。

        看到这里：你可能发现它和简单工厂模式没啥两样子，一样是麻烦的。对，它相对简单工厂模式来说，一样也不简单。但是用在大型项目中，你就会发现它存在的意义了。

⑩现在遇到一个问题，就是我每次要生产一只猫，就要用CatFactory来生产，要狗就用DogFactory来生产，好麻烦啊。。。怎么办？有没有解决办法？？？我们可以通过反射机制，来给它来一个上帝，毕竟上帝创造众生吗，哈哈

//来个GodFactory上帝工厂吧
public class GodFactory {
    public static IAnimal product(Class clazz){
        IAnimal animal = null;
        try {
            animal = (IAnimal) Class.forName(clazz.getName()).newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return animal;
    }
}

⑪来个上帝创造众生的Demo吧

public class Test02 {
    public static void main(String[] args) {
        IAnimal cat = GodFactory.product(Cat.class);
        cat.eat(); //I am Cat's eat method
        IAnimal dog = GodFactory.product(Dog.class);
        dog.eat(); //I am Dog's eat method
    }
}

⑫至此，工厂方法模式就到此结束了

总结：工厂方法模式看起来要比起简单工厂要麻烦不少，一个产品类就要对应一个工厂类，要增加产品类时也要相应地增加工厂类，客户端的代码也增加了不少。的确，简单工厂是要简便些，所以它不适合应用在比较大的项目里，而且大部分情况下也是简单工厂要常用些。但是，你得先事先考虑好简单工厂是否无法承受你的项目，如果不能承受，就应该考虑使用工厂方法模式。所以，有些设计模式只有在接触到大型项目时才能体会到它们好在哪里。

---->如有疑问，请发表评论，或者联系博主：[email protected]，欢迎哦^_^