java 工厂模式简单介绍及例子

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

 

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

 

Animal类：

 

package com.bean;

/**
 * 动物类
 * @author Lyon Yao
 *
 */
public abstract class Animal {
	
	private String name;
	
	public Animal() {
		super();
		// TODO Auto-generated constructor stub
	}
	public Animal(String name) {
		super();
		this.name = name;
	}
	public abstract void eat();
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	
}

 猫类：

 

package com.bean;

/**
 * 猫类
 * @author Lyon Yao
 *
 */
public class Cat extends Animal {

	public Cat() {
		// TODO Auto-generated constructor stub
	}

	public Cat(String name) {
		super(name);
		// TODO Auto-generated constructor stub
	}

	@Override
	public void eat() {
		// TODO Auto-generated method stub
		System.out.println("I like to eat fish!");
	}

}

 

 

狗类：package com.bean;

/**
 * 狗类
 * @author Lyon Yao
 *
 */
public class Dog extends Animal {

	public Dog() {
		// TODO Auto-generated constructor stub
	}

	public Dog(String name) {
		super(name);
		// TODO Auto-generated constructor stub
	}

	@Override
	public void eat() {
		// TODO Auto-generated method stub
		System.out.println("I like to eat bone！");
	}

}

 

 

静态工厂类：

 

package com.factory.sta;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

/**
 * 静态工厂创建一个对象  静态工厂类产生的对象一般都有共同的特性，继承某一类，或者引用接口之类，在此
 * 没有看似没有，但不可否认他们都是Object或者Object的一个子类
 * @author Lyon Yao
 *
 */
public class StaticFatory {
	public static Object getInstance(String className){
		Object instance=null;
		try {
			Class cls=Class.forName(className);
			instance= cls.newInstance();
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (InstantiationException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return instance;
		
	}
	public static Object getInstance(String className,Object ...agrs) {
		Class cls=null;
		try {
			cls = Class.forName(className);
		} catch (ClassNotFoundException e1) {
			// TODO Auto-generated catch block
			return null;
		}
		Constructor[] constructors = cls.getConstructors();
		Object instance=null;
		for(Constructor cons:constructors){
			Class <?>[] clses=cons.getParameterTypes();
			if(clses.length>0){
				boolean isThisConstructor=true;
				for(int i=0;i<clses.length;i++){
					Class c=clses[i]; 
					if(! c.isInstance(agrs[i]) ){
						isThisConstructor=false;
					}
				}
				if(isThisConstructor){
					try {
						instance=cons.newInstance(agrs);
						break;
					} catch (IllegalArgumentException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					} catch (InvocationTargetException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					} catch (InstantiationException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					} catch (IllegalAccessException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}else{
					continue;
				}
				
			}
		}
		return instance;
	}
}

 

 

 

 

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

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

 

母动物接口：

 

package com.factory;

import com.bean.Animal;

/**
 * 母亲接口
 * @author Lyon
 *
 */
public interface AnimalMother {
	/**
	 * 生育动物
	 * @return
	 */
	public  Animal giveBirth();
}

 

 母狗类：

 

package com.factory.impl;

import com.bean.Animal;
import com.bean.Dog;
import com.factory.AnimalMother;

/**
 * 狗母亲  生狗
 * @author Lyon Yao
 *
 */
public class DogMother implements AnimalMother {

	@Override
	public Animal giveBirth() {
		// TODO Auto-generated method stub
		Animal dog=new Dog();
		System.out.println("狗母亲生了一只小狗");
		return dog;
	}

}

 

 

母猫类：

 

package com.factory.impl;

import com.bean.Animal;
import com.bean.Cat;
import com.factory.AnimalMother;

/**
 * 猫母亲 生猫咪
 * @author Lyon Yao
 *
 */
public class CatMother implements AnimalMother {

	@Override
	public Animal giveBirth() {
		// TODO Auto-generated method stub
		Animal cat=new Cat();
		System.out.println("猫母亲生了一只小猫眯");
		return cat;
	}

}

 

 

 

 

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

例子如下：

 

总工厂：

 

package com.factory;

import com.bean.Milk;

/**
 * 能产奶的 动物母亲
 * 这里继承 AnimalMother 实现 生育小动物  产奶在此接口声明 构成抽象工厂总接口
 * @author Lyon Yao
 *
 */
public interface MilkAnimalMother extends AnimalMother {
	/**
	 * 产奶
	 * @return
	 */
	public Milk produceMilk();
}

 

奶羊：

 

package com.factory.impl;

import com.bean.Animal;
import com.bean.Milk;
import com.bean.Sheep;
import com.bean.SheepMilk;
import com.factory.MilkAnimalMother;

/**
 * 奶羊
 * @author Lyon Yao
 *
 */
public class SheepMilkMother implements MilkAnimalMother{

	@Override
	public Animal giveBirth() {
		// TODO Auto-generated method stub
		Animal sheep=new Sheep();
		System.out.println("奶羊生了一只小羊");
		return sheep;
	}

	@Override
	public Milk produceMilk() {
		// TODO Auto-generated method stub
		Milk milk=new SheepMilk();
		System.out.println("奶羊生产了羊奶");
		return milk;
	}

}

 奶牛：

 

package com.factory.impl;

import com.bean.Animal;
import com.bean.Cattle;
import com.bean.CattleMile;
import com.bean.Milk;
import com.factory.MilkAnimalMother;

/**
 * 奶牛()
 * @author Lyon Yao
 *
 */
public class CattleMilkMother implements MilkAnimalMother {

	@Override
	public Animal giveBirth() {
		// TODO Auto-generated method stub
		Cattle cattle=new Cattle();
		System.out.println("奶牛生了一只小牛");
		return cattle;
	}

	@Override
	public Milk produceMilk() {
		// TODO Auto-generated method stub
		Milk milk=new CattleMile();
		System.out.println("奶牛生产了牛奶");
		return milk;
	}

}

 

 

下面是测试例子：

 

package com.test;

import org.junit.Test;

import com.bean.Animal;
import com.bean.Cat;
import com.bean.Dog;
import com.factory.AnimalMother;
import com.factory.MilkAnimalMother;
import com.factory.impl.CatMother;
import com.factory.impl.CattleMilkMother;
import com.factory.impl.DogMother;
import com.factory.impl.SheepMilkMother;
import com.factory.sta.StaticFatory;

/**
 * 测试类
 * 
 * @author Lyon Yao
 * 
 */
public class TestCase {
	/**
	 * 静态工厂类 测试
	 */
	@Test
	public void staticFactoryTest() {
		Animal ani1=(Animal) StaticFatory.getInstance(Cat.class.getName());
		System.out.println(ani1.getName());
		ani1.eat();
		ani1=(Animal) StaticFatory.getInstance(Dog.class.getName(),"dog");
		System.out.println(ani1.getName());
		ani1.eat();
	}
	/**
	 * 工厂方法模式测试
	 */
	@Test
	public void methodFactoryTest(){
		AnimalMother mother=new CatMother();
		mother.giveBirth();
		mother=new DogMother();
		mother.giveBirth();
	}
	/**
	 * 抽象工厂模式测试
	 */
	@Test
	public void abstrFactoryTest(){
		MilkAnimalMother mother=new SheepMilkMother();
		mother.giveBirth();
		mother.produceMilk();
		mother=new CattleMilkMother();
		mother.giveBirth();
		mother.produceMilk();
	}
}

 控制台输出：

 

 

null

I like to eat fish!

dog

I like to eat bone！

猫母亲生了一只小猫眯

狗母亲生了一只小狗

奶羊生了一只小羊

奶羊生产了羊奶

奶牛生了一只小牛

奶牛生产了牛奶

 

 

例子可能比较牵强，各位见笑了。