简单工厂模式、工厂方法模式及抽象工厂模式

简单工厂模式：
描述：简单工厂模式属于类的创建型模式,又叫做静态工厂方法模式。通过专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。
角色职责：
1.工厂（Creator）角色简单工厂模式的核心，它负责实现创建所有实例的内部逻辑。工厂类可以被外界直接调用，创建所需的产品对象。
2.抽象（Product）角色简单工厂模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。
3.具体产品（Concrete Product）角色简单工厂模式所创建的具体实例对象
优缺点：在这个模式中，工厂类是整个模式的关键所在。它包含必要的判断
逻辑，能够根据外界给定的信息，决定究竟应该创建哪个具体类的对象。用户在使用时可以直接根据工厂类去创建所需的实例，而无需了解这些对象是如何创建以及如何组织的。有利于整个软件体系结构的优化。不难发现，简单工厂模式的缺点也正体现在其工厂类上，由于工厂类集中了所有实例的创建逻辑，所以“高内聚”方面做的并不好。另外，当系统中的具体产品类不断增多时，可能会出现要求工厂类也要做相应的修改，扩展性并不很好。

package simpleFactory;

public class SimpleFactoryTest {

    /**
     * @param args
     */
    public static void main(String[] args) throws Exception{
        Animal dog = AnimalFactory.getAnimal("Dog");
        Animal cat = AnimalFactory.getAnimal("Cat");
        dog.eat("dog food");
        cat.eat("cat food");
    }

}
//抽象角色
interface Animal{
    public void eat(String food);
    public void walk(String street);
}
//具体角色
class Dog implements Animal{

    @Override
    public void eat(String food) {
        System.out.println("Dog is eating "+food);
        
    }

    @Override
    public void walk(String street) {
        System.out.println("Dog is walking in "+ street);
        
    }
}
//具体角色
class Cat implements Animal{

    @Override
    public void eat(String food) {
        System.out.println("Cat is eating "+ food);
    }

    @Override
    public void walk(String street) {
        System.out.println(" Cat is waling in "+ street);
    }
}
//简单工厂
class AnimalFactory {
    public static Animal getAnimal(String name) throws Exception{
        //运用反射的方式获取，影响速度，而且不能放到一个文件中
        //return (Animal)Class.forName(name).newInstance();
        if("Dog".equalsIgnoreCase(name)){
            return new Dog();
        }else if("Cat".equalsIgnoreCase(name)){
            return new Cat();
        }else{
            System.out.println("There is no this animal");
            return null;
        }
    }
}

工厂方法模式：
描述：工厂方法模式同样属于类的创建型模式又被称为多态工厂模式 。工厂方法模式的意义是定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类当中。核心工厂类不再负责产品的创建，这样核心类成为一个抽象工厂角色，仅负责具体工厂子类必须实现的接口，这样进一步抽象化的好处是使得工厂方法模式可以使系统在不修改具体工厂角色的情况下引进新的产品。
角色职责：
1.抽象工厂（Creator）角色工厂方法模式的核心，任何工厂类都必须实现这个接口。
2.具体工厂（ Concrete Creator）角色具体工厂类是抽象工厂的一个实现，负责实例化产品对象。
3.抽象（Product）角色工厂方法模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。
4.具体产品（Concrete Product）角色工厂方法模式所创建的具体实例对象
工厂方法模式和简单工厂模式比较
工厂方法模式与简单工厂模式在结构上的不同不是很明显。工厂方法类的核心是一个抽象工厂类，而简单工厂模式把核心放在一个具体类上。 
工厂方法模式之所以有一个别名叫多态性工厂模式是因为具体工厂类都有共同的接口，或者有共同的抽象父类。当系统扩展需要添加新的产品对象时，仅仅需要添加一个具体对象以及一个具体工厂对象，原有工厂对象不需要进行任何修改，也不需要修改客户端，很好的符合了“开放－封闭”原则。而简单工厂模式在添加新产品对象后不得不修改工厂方法，扩展性不好。工厂方法模式退化后可以演变成简单工厂模式。

package factoryMethod;



public class FactoryMethodTest {

    /**
     * @param args
     */
    public static void main(String[] args) {
        AnimalFacotry ff = new CatFacotry();
        Animal cat = ff.getAnimal();
        
        AnimalFacotry ff2 = new DogFacotry();
        Animal dog = ff2.getAnimal();
        
        cat.eat("catFood");
        dog.eat("DogFood");
    }

}
//抽象角色
interface Animal{
    public void eat(String food);
    public void walk(String street);
}

class Dog implements Animal{

    @Override
    public void eat(String food) {
        System.out.println("Dog is eating "+food);
        
    }

    @Override
    public void walk(String street) {
        System.out.println("Dog is walking in "+ street);
        
    }
}

class Cat implements Animal{

    @Override
    public void eat(String food) {
        System.out.println("Cat is eating "+ food);
    }

    @Override
    public void walk(String street) {
        System.out.println(" Cat is waling in "+ street);
    }
}
//抽象工厂角色
interface AnimalFacotry{
    public Animal getAnimal();
}
//具体工厂角色
class DogFacotry implements AnimalFacotry{

    @Override
    public Animal getAnimal() {
        return new Dog();
    }
    
}
//具体工厂角色
class CatFacotry implements AnimalFacotry{

    @Override
    public Animal getAnimal() {
        return new Cat();
    }
    
}

抽象工厂：

它是所有形态工厂模式中最为抽象和最具一般性的一种形态。它的用意是，使得客户端在不必指定产品的具体类型的情况下，创建多个产品簇中的产品对象。

抽象工厂模式与工厂方法模式最大的区别就在于，工厂方法模式针对的是一个产品等级结构，而抽象工厂模式则需要面对多个产品等级结构。

 

抽象工厂模式的角色：

抽象工厂：工厂方法模式的核心，它与应用系统的商业逻辑无关，通常使用Java接口或抽象Java类实现

具体工厂：直接在客户端的调用下创建产品实例

抽象产品：是工厂方法模式所创建的对象的父类

具体产品：抽象工厂模式所创建的任何产品对象都是某一个具体产品类的实例。

 

什么情况下会用抽象工厂模式？

1.一个系统不应当依赖于产品类实例如何被创建，组合和表达的细节，这对于所有形态的工厂模式都是重要的

2.这个系统的产品有多于一个的产品族，而系统只消费其中某一族的产品（抽象工厂的原始用意）

3.同属于同一个产品族的产品是在一起使用的，这一约束必须在系统的设计中体现出来

4.系统提供一个产品类的库，所有产品以同样的接口出现，从而使客户端不依赖于实现。

假如上面的例子中，如果产品，dog和cat又分了两个种类south和north,如果还使用简单工厂模式的化，会使工厂变的混乱，对扩展性不太好，如果使用抽象工厂模式，可以解决这个问题，可以参考代码如下：

public class AbstractFactoryTest {

    /**
     * @param args
     */
    public static void main(String[] args) {
        AnimalFacotry ff = new CatFacotry();
        Animal ncat = ff.getNorthAnimal();
        Animal scat = ff.getSouthAnimal();

        AnimalFacotry ff2 = new DogFacotry();
        Animal ndog = ff2.getNorthAnimal();
        Animal sdog = ff2.getSouthAnimal();

        ncat.eat("catFood");
        ndog.eat("DogFood");
        scat.eat("catFood");
        sdog.eat("DogFood");
    }

}

// 抽象角色
interface Animal {
    public void eat(String food);

    public void walk(String street);
}
//抽象角色类1
interface NorthAnimal extends Animal {

}
//抽象角色类2
interface SouthAnimal extends Animal {

}

class NorthDog implements NorthAnimal {

    @Override
    public void eat(String food) {
        System.out.println("NorthDog is eating " + food);

    }

    @Override
    public void walk(String street) {
        System.out.println("NorthDog is walking in " + street);

    }
}

class SouthDog implements SouthAnimal {

    @Override
    public void eat(String food) {
        System.out.println("SouthDog is eating " + food);

    }

    @Override
    public void walk(String street) {
        System.out.println("SouthDog is walking in " + street);

    }
}

class NorthCat implements NorthAnimal {

    @Override
    public void eat(String food) {
        System.out.println("NorthCat is eating " + food);
    }

    @Override
    public void walk(String street) {
        System.out.println(" NorthCat is waling in " + street);
    }
}

class SouthCat implements SouthAnimal {

    @Override
    public void eat(String food) {
        System.out.println("SouthCat is eating " + food);
    }

    @Override
    public void walk(String street) {
        System.out.println("SouthCat is waling in " + street);
    }
}

// 抽象工厂角色
interface AnimalFacotry {
    public Animal getNorthAnimal();

    public Animal getSouthAnimal();
}

// 具体工厂角色
class DogFacotry implements AnimalFacotry {

    @Override
    public Animal getNorthAnimal() {

        return new NorthDog();
    }

    @Override
    public Animal getSouthAnimal() {
        return new SouthDog();
    }

}

// 具体工厂角色
class CatFacotry implements AnimalFacotry {

    @Override
    public Animal getNorthAnimal() {

        return new NorthCat();
    }

    @Override
    public Animal getSouthAnimal() {
        return new SouthCat();
    }

}