一、简单工厂模式

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

1 public class Cat implements Animals {2     public void eat() {3         System.out.println("cat food");4     }    5 }

1 public class Dog implements Animals {2     public void eat() {3         System.out.println("dog food");4     }5 }

1 public interface Animals {2     void eat();3 }

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

1 public class CatFactory extends AnimalsFactory{2     @Override3     public Animals create() {4         Cat cat = new Cat();5         return cat;6     }7 }

1 public class DogFactory extends AnimalsFactory {2     @Override3     public Animals create() {4         Dog dog = new Dog();5         return dog;6     }7 }

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

1 public abstract class AnimalsFactory {2     public abstract Animals create();3 }

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

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

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

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

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

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

这样写的好处，

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

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

二、抽象工厂模式

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

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

　　Apple->Food

　　Cat->Anilmals　　　　->defaultFactory->AbstractFactory

　　AK47->Gun

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

1 public class DefaultFactory implements AbstractFactory { 2  3     public Animals createAnimals() { 4         return new Cat(); 5     } 6  7     public Food createFood() { 8         return new Apple(); 9     }10 11     public Gun createGun() {12         return new AK47();13     }14 }15

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

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

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

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

转载于:https://www.cnblogs.com/xuzekun/p/7466927.html

你可能感兴趣的文章