java工厂模式简单实例

java中工厂模式在java ee中经常碰见，是一种常见的模式，其可分为三种：静态工厂模式、工厂方法模式、抽象工厂模式。一下做一简单讲述和例子。

静态工厂模式：顾名思义就知道他是用静态方法实现的，其创建的对象具有一定的特性，譬如说是某类的派生或者某接口的实现。其比较简单。例子如下

Animal类：

Java代码

1. package com.bean;
3. /**
4. * 动物类
5. * @author Lyon Yao
6. *
7. */
8. public abstract class Animal {
10. private String name;
12. public Animal() {
13. super();
14. // TODO Auto-generated constructor stub
15. }
16. public Animal(String name) {
17. super();
18. this.name = name;
19. }
20. public abstract void eat();
21. public String getName() {
22. return name;
23. }
24. public void setName(String name) {
25. this.name = name;
26. }
28. }

猫类：

Java代码

1. package com.bean;
3. /**
4. * 猫类
5. * @author Lyon Yao
6. *
7. */
8. public class Cat extends Animal {
10. public Cat() {
11. // TODO Auto-generated constructor stub
12. }
14. public Cat(String name) {
15. super(name);
16. // TODO Auto-generated constructor stub
17. }
19. @Override
20. public void eat() {
21. // TODO Auto-generated method stub
22. System.out.println("I like to eat fish!");
23. }
25. }

狗类：package com.bean;

Java代码

1. /**
2. * 狗类
3. * @author Lyon Yao
4. *
5. */
6. public class Dog extends Animal {
8. public Dog() {
9. // TODO Auto-generated constructor stub
10. }
12. public Dog(String name) {
13. super(name);
14. // TODO Auto-generated constructor stub
15. }
17. @Override
18. public void eat() {
19. // TODO Auto-generated method stub
20. System.out.println("I like to eat bone！");
21. }
23. }

静态工厂类：

Java代码

1. package com.factory.sta;
3. import java.lang.reflect.Constructor;
4. import java.lang.reflect.InvocationTargetException;
6. /**
7. * 静态工厂创建一个对象 静态工厂类产生的对象一般都有共同的特性，继承某一类，或者引用接口之类，在此
8. * 没有看似没有，但不可否认他们都是Object或者Object的一个子类
9. * @author Lyon Yao
10. *
11. */
12. public class StaticFatory {
13. public static Object getInstance(String className){
14. Object instance=null;
15. try {
16. Class cls=Class.forName(className);
17. instance= cls.newInstance();
18. } catch (ClassNotFoundException e) {
19. // TODO Auto-generated catch block
20. e.printStackTrace();
21. } catch (InstantiationException e) {
22. // TODO Auto-generated catch block
23. e.printStackTrace();
24. } catch (IllegalAccessException e) {
25. // TODO Auto-generated catch block
26. e.printStackTrace();
27. }
28. return instance;
30. }
31. public static Object getInstance(String className,Object ...agrs) {
32. Class cls=null;
33. try {
34. cls = Class.forName(className);
35. } catch (ClassNotFoundException e1) {
36. // TODO Auto-generated catch block
37. return null;
38. }
39. Constructor[] constructors = cls.getConstructors();
40. Object instance=null;
41. for(Constructor cons:constructors){
42. Class <?>[] clses=cons.getParameterTypes();
43. if(clses.length>0){
44. boolean isThisConstructor=true;
45. for(int i=0;i<clses.length;i++){
46. Class c=clses[i];
47. if(! c.isInstance(agrs[i]) ){
48. isThisConstructor=false;
49. }
50. }
51. if(isThisConstructor){
52. try {
53. instance=cons.newInstance(agrs);
54. break;
55. } catch (IllegalArgumentException e) {
56. // TODO Auto-generated catch block
57. e.printStackTrace();
58. } catch (InvocationTargetException e) {
59. // TODO Auto-generated catch block
60. e.printStackTrace();
61. } catch (InstantiationException e) {
62. // TODO Auto-generated catch block
63. e.printStackTrace();
64. } catch (IllegalAccessException e) {
65. // TODO Auto-generated catch block
66. e.printStackTrace();
67. }
68. }else{
69. continue;
70. }
72. }
73. }
74. return instance;
75. }
76. }

工厂方法模式：其主要是对各个类型的东西分类生产，但分类生产的对象仍然是具有某一特性的。譬如说：前面的静态工厂类是一个综合造车工厂，不管是汽车还是火车都能生产，而工厂方法模式就是工厂具体分工，造汽车的工厂只造汽车，造火车的只造火车，不管造汽车还是火车但造出来的还是车。

具体代码例子如下：（这里的例子和上面的例子是一起的，具狗生好多小狗，猫生好多小猫的例子，如果不具体那么是母动物都能生的）

母动物接口：

Java代码

1. package com.factory;
3. import com.bean.Animal;
5. /**
6. * 母亲接口
7. * @author Lyon
8. *
9. */
10. public interface AnimalMother {
11. /**
12. * 生育动物
13. * @return
14. */
15. public Animal giveBirth();
16. }

母狗类：

Java代码

1. package com.factory.impl;
3. import com.bean.Animal;
4. import com.bean.Dog;
5. import com.factory.AnimalMother;
7. /**
8. * 狗母亲 生狗
9. * @author Lyon Yao
10. *
11. */
12. public class DogMother implements AnimalMother {
14. @Override
15. public Animal giveBirth() {
16. // TODO Auto-generated method stub
17. Animal dog=new Dog();
18. System.out.println("狗母亲生了一只小狗");
19. return dog;
20. }
22. }

母猫类：

Java代码

1. package com.factory.impl;
3. import com.bean.Animal;
4. import com.bean.Cat;
5. import com.factory.AnimalMother;
7. /**
8. * 猫母亲 生猫咪
9. * @author Lyon Yao
10. *
11. */
12. public class CatMother implements AnimalMother {
14. @Override
15. public Animal giveBirth() {
16. // TODO Auto-generated method stub
17. Animal cat=new Cat();
18. System.out.println("猫母亲生了一只小猫眯");
19. return cat;
20. }
22. }

抽象工厂模式：前面工厂方法模式是比较具体的，是猫肯定生的是小猫，这是不会有问题的，是具体的，那么抽象工厂它所产生的就不是那么具体，产生的对象可能是没有共同特性的。譬如说 一只奶羊不仅仅能够生小羊，同时也能生产羊奶，但小羊是动物，羊奶是食物。

例子如下：

总工厂：

Java代码

1. package com.factory;
3. import com.bean.Milk;
5. /**
6. * 能产奶的 动物母亲
7. * 这里继承 AnimalMother 实现 生育小动物 产奶在此接口声明 构成抽象工厂总接口
8. * @author Lyon Yao
9. *
10. */
11. public interface MilkAnimalMother extends AnimalMother {
12. /**
13. * 产奶
14. * @return
15. */
16. public Milk produceMilk();
17. }

奶羊：

Java代码

1. package com.factory.impl;
3. import com.bean.Animal;
4. import com.bean.Milk;
5. import com.bean.Sheep;
6. import com.bean.SheepMilk;
7. import com.factory.MilkAnimalMother;
9. /**
10. * 奶羊
11. * @author Lyon Yao
12. *
13. */
14. public class SheepMilkMother implements MilkAnimalMother{
16. @Override
17. public Animal giveBirth() {
18. // TODO Auto-generated method stub
19. Animal sheep=new Sheep();
20. System.out.println("奶羊生了一只小羊");
21. return sheep;
22. }
24. @Override
25. public Milk produceMilk() {
26. // TODO Auto-generated method stub
27. Milk milk=new SheepMilk();
28. System.out.println("奶羊生产了羊奶");
29. return milk;
30. }
32. }

奶牛：

Java代码

1. package com.factory.impl;
3. import com.bean.Animal;
4. import com.bean.Cattle;
5. import com.bean.CattleMile;
6. import com.bean.Milk;
7. import com.factory.MilkAnimalMother;
9. /**
10. * 奶牛()
11. * @author Lyon Yao
12. *
13. */
14. public class CattleMilkMother implements MilkAnimalMother {
16. @Override
17. public Animal giveBirth() {
18. // TODO Auto-generated method stub
19. Cattle cattle=new Cattle();
20. System.out.println("奶牛生了一只小牛");
21. return cattle;
22. }
24. @Override
25. public Milk produceMilk() {
26. // TODO Auto-generated method stub
27. Milk milk=new CattleMile();
28. System.out.println("奶牛生产了牛奶");
29. return milk;
30. }
32. }

下面是测试例子：

Java代码

1. package com.test;
3. import org.junit.Test;
5. import com.bean.Animal;
6. import com.bean.Cat;
7. import com.bean.Dog;
8. import com.factory.AnimalMother;
9. import com.factory.MilkAnimalMother;
10. import com.factory.impl.CatMother;
11. import com.factory.impl.CattleMilkMother;
12. import com.factory.impl.DogMother;
13. import com.factory.impl.SheepMilkMother;
14. import com.factory.sta.StaticFatory;
16. /**
17. * 测试类
18. *
19. * @author Lyon Yao
20. *
21. */
22. public class TestCase {
23. /**
24. * 静态工厂类 测试
25. */
26. @Test
27. public void staticFactoryTest() {
28. Animal ani1=(Animal) StaticFatory.getInstance(Cat.class.getName());
29. System.out.println(ani1.getName());
30. ani1.eat();
31. ani1=(Animal) StaticFatory.getInstance(Dog.class.getName(),"dog");
32. System.out.println(ani1.getName());
33. ani1.eat();
34. }
35. /**
36. * 工厂方法模式测试
37. */
38. @Test
39. public void methodFactoryTest(){
40. AnimalMother mother=new CatMother();
41. mother.giveBirth();
42. mother=new DogMother();
43. mother.giveBirth();
44. }
45. /**
46. * 抽象工厂模式测试
47. */
48. @Test
49. public void abstrFactoryTest(){
50. MilkAnimalMother mother=new SheepMilkMother();
51. mother.giveBirth();
52. mother.produceMilk();
53. mother=new CattleMilkMother();
54. mother.giveBirth();
55. mother.produceMilk();
56. }
57. }

控制台输出：

null

I like to eat fish!

dog

I like to eat bone！

猫母亲生了一只小猫眯

狗母亲生了一只小狗

奶羊生了一只小羊

奶羊生产了羊奶

奶牛生了一只小牛

奶牛生产了牛奶