• 基本概念
  工厂模式是一种创建型模式，它提供了一个创建对象的工厂，当开发者需要相关的对象实例时，由工厂来创建提供。简单来说，工厂模式可以根据不同的条件生产不同的实例，通常这些实例继承于同一个父类，工厂模式把创建这些实例的具体过程封装起来，简化了客户端的操作，也改善了应用的扩展性。

• 普通工厂模式
  举一个使用工厂模式获取汪星人和喵星人的例子：

//创建二者共同的接口
public interface Animal {
    public void eat();
}

//创建汪星人实现类
public class Dog implements Animal {
    @Override
    public void eat() {
        System.out.println("吃骨头");
    }
}

//创建喵星人实现类
public class Cat implements Animal {
    @Override
    public void eat() {
        System.out.println("吃小鱼");
    }
}

//创建工厂类
public class AnimalFactory {
    public Animal getAnimal(String type){
        if("dog".equals(type)){
            return new Dog();
        }else if("cat".equals(type)){
            return new Cat();
        }else{
            return null;
        }
    }
}
//测试
Animal dog = new AnimalFactory().getAnimal("dog");

• 直接获取模式
  由于普通工厂模式会因为传错字符串导致无法获得实例，故使用直接获取模式

//将创建工厂类修改
public class AnimalFactory {
    public Animal getDog(){
        return new Dog();
    }
    public Animal getCat(){
        return Cat();
    }
}
//测试 不用传入字符串，可直接获取
Animal dog = new AnimalFactory.getDog();

• 静态工厂方法
  将多个工厂方法设置为静态的，不用创建工厂实例，直接获取

public class AnimalFactory {
    public static Animal getDog(){
        return new Dog();
    }
    public static Animal getCat(){
        return new Cat();
    }
}
//测试 不用 new AnimalFatory() 直接获取
Animal dog = AnimalFactory.getDog();

总体来说，工厂模式适合：出现了大量的实例需要创建，并且具有共同的接口时，可以通过工厂方法模式进行创建。在以上的三种模式中，第一种如果传入的字符串有误，不能正确创建对象，第三种相对于第二种，不需要实例化工厂类，所以，大多数情况下，我们会选用第三种——静态工厂方法模式。

当然对于上述几种工厂模式，有一个不好的地方就是，新增一个类，需要对生产工厂(AnimalFactory)进行修改，极大的限制了程序的可扩展性。
为了解决这一问题，引入了抽象工厂模式：所谓抽象工厂模式，就是为每一个实例提供一个工厂方法，当需要新增一个类时，不需要修改原来的工厂方法，只需要新建一个对应的工厂即可。上代码：

//定义接口
public interface Animal {
    public void eat();
}

//实现接口
public class Cat implements Animal {
    @Override
    public void eat(){
        System.out.println("吃小鱼");
    }
}

//实现工厂类
public class CatFactory implements Provider {
    @Override
    public Animal produce(){
        return new Cat();
    }
}

public interface Provider {
    public void produce();
}

//测试
Provider provider = new CatFactory();
Cat cat = provider.produce();

这样以后想新增Dog类 只需要让Dog实现Animal接口，并提供DogFactory实现Provider即可，不需要修改之前的代码。

之前一直有个疑问，为什么在定义dog的时候用

Animal dog = new AnimalFactory().getAnimal("dog");

而不用

Dog dog = new AnimalFactory().getAnimal("dog");

其实这就是为什么使用接口或者抽象类的问题了。由于JAVA具有继承与多态的特点，当一个类继承抽象类或实现接口，其父类或者接口能够接受子类或者实现接口者的实例。这样能够提高代码的扩展性。
比如：

ErHaDog dog = new AnimalFactory().getAnimal("dog");

当主人不想养二哈，而想养一只金毛，那么只需要创建一只JinMaoDog并实现Ainmal接口，这样只需要将工厂中创建二哈的代码替换成金毛即可，其他都不用修改，大大提高了程序的扩展性。反之，需要修改：

JinMaoDog dog = new AnimalFactory().getAnimal("dog");

使程序的耦合度太高