java va中工厂模式( 静态工厂模式、工厂方法模式、抽象工厂模式）的介绍以及简单例子

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

 

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

 

Animal类：

 

Java代码  

1. package com.bean;  
2.   
3. /** 
4.  * 动物类 
5.  * @author Lyon Yao 
6.  * 
7.  */  
8. public abstract class Animal {  
9.       
10.     private String name;  
11.       
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.     }  
27.       
28. }  

 猫类：

 

Java代码  

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

 

 

狗类：package com.bean;

Java代码  

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

 

 

静态工厂类：

 

Java代码  

1. package com.factory.sta;  
2.   
3. import java.lang.reflect.Constructor;  
4. import java.lang.reflect.InvocationTargetException;  
5.   
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;  
29.           
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.                 }  
71.                   
72.             }  
73.         }  
74.         return instance;  
75.     }  
76. }  

 

 

 

 

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

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

 

母动物接口：

 

Java代码  

1. package com.factory;  
2.   
3. import com.bean.Animal;  
4.   
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;  
2.   
3. import com.bean.Animal;  
4. import com.bean.Dog;  
5. import com.factory.AnimalMother;  
6.   
7. /** 
8.  * 狗母亲  生狗 
9.  * @author Lyon Yao 
10.  * 
11.  */  
12. public class DogMother implements AnimalMother {  
13.   
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.     }  
21.   
22. }  

 

 

母猫类：

 

Java代码  

1. package com.factory.impl;  
2.   
3. import com.bean.Animal;  
4. import com.bean.Cat;  
5. import com.factory.AnimalMother;  
6.   
7. /** 
8.  * 猫母亲 生猫咪 
9.  * @author Lyon Yao 
10.  * 
11.  */  
12. public class CatMother implements AnimalMother {  
13.   
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.     }  
21.   
22. }  

 

 

 

 

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

例子如下：

 

总工厂：

 

Java代码  

1. package com.factory;  
2.   
3. import com.bean.Milk;  
4.   
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;  
2.   
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;  
8.   
9. /** 
10.  * 奶羊 
11.  * @author Lyon Yao 
12.  * 
13.  */  
14. public class SheepMilkMother implements MilkAnimalMother{  
15.   
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.     }  
23.   
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.     }  
31.   
32. }  

 奶牛：

 

Java代码  

1. package com.factory.impl;  
2.   
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;  
8.   
9. /** 
10.  * 奶牛() 
11.  * @author Lyon Yao 
12.  * 
13.  */  
14. public class CattleMilkMother implements MilkAnimalMother {  
15.   
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.     }  
23.   
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.     }  
31.   
32. }  

 

 

下面是测试例子：

 

Java代码  

1. package com.test;  
2.   
3. import org.junit.Test;  
4.   
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;  
15.   
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！

猫母亲生了一只小猫眯

狗母亲生了一只小狗

奶羊生了一只小羊

奶羊生产了羊奶

奶牛生了一只小牛

奶牛生产了牛奶