[设计模式] 简单工厂/工厂方法/抽象工厂

问题

典型的接口和实现类如下，我们要根据相应的需求创建出不同的对象。

public interface Animal {
void say();
}

public class Cat implements Animal {
public void say() {
        System.out.println("I am a cat");
    }
}

public class Dog implements Animal {
public void say() {
        System.out.println("I am a dog");
    }
}

简单工厂

public class AnimalFactory {
public static Animal createAnimal(String animal) {
if (animal.equals("Dog")) {
return new Dog();
        }else if (animal.equals("Cat")) {
return new Cat();
        }
return null;
    }
}

public class Client {
public static void main(String[] args) {
        Animal cat = AnimalFactory.createAnimal("Cat");
        Animal dog = AnimalFactory.createAnimal("Dog");
    }
}

简单工厂其实就是：传入一个对象的标识，然后根据标识创建对象。这个方法实现简单，但是如果再添加一个Bird类，需要创建Bird对象的话则需改动AnimalFactory方法。

工厂方法

public interface Factory {
    Animal createAnimal();
}
public class CatFactory implements Factory{
public Animal createAnimal() {
return new Cat();
    }
}
public class DogFactory implements Factory {
public Animal createAnimal() {
return new Dog();
    }
}

public class Client {
public static void main(String[] args) {
        Animal cat = new CatFactory().createAnimal();
        Animal dog = new DogFactory().createAnimal();
    }
}

工厂方法如上，即使当需要添加一个Bird时，同时创建BirdFactory即可在客户端中使用，而不用改动到其它代码。

抽象工厂

这个设计到一个产品族的概念，Cat，Dog是分为不同家的。我要么统一买A家的Cat，Dog，要么统一买B家的。

public interface Animal {
void say();
}
//A家产品
public class CatA implements Animal {
public void say() {
        System.out.println("I am a cat from A");
    }
}
public class DogA implements Animal {
public void say() {
        System.out.println("I am a dog from A");
    }
}
//B家产品
public class CatB implements Animal {
public void say() {
        System.out.println("I am a cat from B");
    }
}
public class DogB implements Animal {
public void say() {
        System.out.println("I am a dog from B");
    }
}

public interface Factory {
     Animal createCat();
     Animal createDog();
}

public class FactoryA implements Factory {//A家工厂
public Animal createCat() {
return new CatA();
    }
public Animal createDog() {
return new DogA();
    }
}
public class FactoryB implements Factory {//B家工厂
public Animal createCat() {
return new CatB();
    }
public Animal createDog() {
return new DogB();
    }
}

public class Client {
public static void main(String[] args) {
        Factory factoryA = new FactoryA();
        Animal catA = factoryA.createCat();
        Animal dogA = factoryA.createDog();
    }
}

抽象工厂如上，创建一个A工厂，从A工厂生产出来的都是A家的产品，避免了产品创建之间的混乱。