Java设计模式-工厂模式

这篇文章介绍Java设计模式中的工厂模式，工厂模式抽象了对象创建的具体细节，创建的时候只需要用特定函数封装特定接口的创建细节。

主要举几个例子来说明：

一、简单工厂模式

　　有一个Cat 和 Dog类，都实现了Animals接口，重写了 eat方法

public class Cat implements Animals {
    public void eat() {
        System.out.println("cat food");
    }    
}

public class Dog implements Animals {
    public void eat() {
        System.out.println("dog food");
    }
}

public interface Animals {
    void eat();
}

　　

　　同时也有CatFactory 和 DogFactory 用于创建 Cat 和 Dog实例

public class CatFactory extends AnimalsFactory{
    @Override
    public Animals create() {
        Cat cat = new Cat();
        return cat;
    }
}

public class DogFactory extends AnimalsFactory {
    @Override
    public Animals create() {
        Dog dog = new Dog();
        return dog;
    }
}

　　抽象出来一个AnimalsFactory，用于 动态绑定 到具体的Factory

public abstract class AnimalsFactory {
    public abstract Animals create();
}

　　分析使用这个简单工厂后对象的创建过程：

　　1.先得到对应的工厂，猫有猫的工厂，狗有狗的工厂

　　2.调用这个工厂的create方法，这里体现了多态，create调用的是 具体的工厂的create方法，返回的其实是具体的实例（Dog），但是我们这里用一个Animals去接收

　　3.调用Animals的eat方法，这里同样体现多态，eat调用的 具体的实例的 eat方法（Dog.eat()）

　　

　　工厂用于控制这个类的对象的创建过程（DogFactory用于控制创建 Dog 的过程）

/*简单工厂模式的核心思想就是：有一个专门的类来负责创建实例的过程。
 * 该工厂只用于控制 这个类的对象的创建过程
 * 
 * */
public class TestAnimals {
    public static void main(String[] args) {     
        AnimalsFactory factory = new DogFactory();
        //工厂在这里面起的作用，就是隐藏了创建过程的复杂度,我只要调用 工厂的create方法，就可以得到
        //把new对象时的构造函数和参数屏蔽了
        //使用者再也不担心，对象是怎么创建的
        Animals animals = factory.create();
        animals.eat();
    }
}

这样写的好处，

　　　　1.工厂在这里面起的作用，就是隐藏了创建过程的复杂度,我只要调用 工厂的create方法，就可以得到，把new对象时的构造函数和参数屏蔽了，使用者再也不担心，对象是怎么创建的

　　　　2.想要得到不同的对象，只要 将这个  ‘new  DogFactory（）’替换，甚至在使用XML文件后，这里也不需要改

 

二、抽象工厂模式

抽象工厂用于控制多个类的一系列创建，是针对一系列产品，对这一系列产品的扩展和维护

但是无法针对 这一系列产品中的某产品进行控制（简单工厂做这个）

　　Apple->Food

　　Cat->Anilmals　　　　->defaultFactory->AbstractFactory

　　AK47->Gun

在defaultFactory中完成了一系列对象的创建

public class DefaultFactory implements AbstractFactory {

    public Animals createAnimals() {
        return new Cat();
    }

    public Food createFood() {
        return new Apple();
    }

    public Gun createGun() {
        return new AK47();
    }
}
    

　　可以创建另外一个如MyFactory，这个Factory用于创建另外的一系列的对象，如：Dog，Orange，AK74，

　　后面要替换的话，也可以对这一系列产品一起替换，只需要将DefaultFactory 换成 MyFactory，

之后返回的对象都是 MyFactory 里创建的

/*
 * 抽象工厂用于 用于控制多个类的 一系列创建
 * 
 * 抽象工厂是针对  一系列产品，对这一系列产品的扩展和维护
 * 
 * 但是无法针对 这 一 系列产品中的某个产品进行控制，（简单工厂做这个）
 * */
public class Test {
    
    public static void main(String[] args) {
        AbstractFactory abstractFactort = new DefaultFactory();
        abstractFactort.createAnimals().eat();
        abstractFactort.createFood().printName();
        abstractFactort.createGun().shoot();
    }
    
}