工厂设计模式和抽象工厂设计模式

工厂设计模式，相信大家都不陌生，省去了new的过程，方便了程序的书写，接下来让我们看看抽象工厂设计模式把。

首先我们定义一个动物类接口，所有的动物都是它的子类，代码如下

package com.zzq.factorypattern.po;

/**
 * 定义动物接口
 * @author Administrator
 *
 */
public interface Animal {
	
	/**
	 * 动物会跑
	 */
	public void run();
	
	/**
	 * 动物会吃
	 */
	public void eat();
	
	/**
	 * 动物会笑
	 */
	public void laugh();
}

然后我们定义几个具体的动物实现类

package com.zzq.factorypattern.po.impl;

import com.zzq.factorypattern.po.Animal;

/**
 * 定义一个鸟
 * @author Administrator
 *
 */
public class Bird implements Animal {

	@Override
	public void run() {
		System.out.println("鸟也会跑，用翅膀跑的");
	}

	@Override
	public void eat() {
		System.out.println("鸟也会吃，啄啄啄吃的");
	}

	@Override
	public void laugh() {
		System.out.println("鸟也叫，叽叽叽");
	}

}

以及狗，habadog

然后定义工厂

package com.zzq.factorypattern.po;

import java.util.HashMap;
import java.util.List;
import java.util.Random;

/**
 * 工厂
 * @author Administrator
 *
 */
public class AnimalFactory {
	
	// 定义一个map，用来存Animal，实现延迟加载
	private static HashMap<String, Animal> map = new HashMap<String,Animal>();
	
	/**
	 * 定义一个动物工厂，输入要什么动物，他就给你什么动物
	 * @param cls
	 * @return Animal
	 */
	public Animal createAnimal(Class cls) {
		// 定义一个动物
		Animal animal = null;
		
		try {
			// 如果map里面有该animal 就返回该animal
			if(map.containsKey(cls.getSimpleName())){
				return map.get(cls.getSimpleName());
			}else {
				animal = (Animal)Class.forName(cls.getName()).newInstance();
				map.put(cls.getSimpleName(), animal);
			}
		} catch (InstantiationException e) {
			System.out.println("请输入动物物种");
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			System.out.println("输入动物物种错误！");
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			System.out.println("没有这个物种");
			e.printStackTrace();
		}
		
		return animal;
	}
	
	/**
	 * 生产动物，随机生产
	 * @return 返回动物
	 */
	public Animal createAnimal() {
		List<Class> allClassByInterface = ClassUtil.getAllClassByInterface(Animal.class);
		int index = new Random().nextInt(allClassByInterface.size());
		return createAnimal(allClassByInterface.get(index));
	}
	
}

这个工厂所产生的对象如果使用map存入之后则可以做到延迟加载，不必一直new对象，节约资源，当然有时候需要一个全新的对象的时候还是不能走缓存。

再来看我们的客户端：

package com.zzq.factorypattern.po;

import com.zzq.factorypattern.po.impl.Bird;
import com.zzq.factorypattern.po.impl.Dog;
import com.zzq.factorypattern.po.impl.HabaDog;

/**
 * 生产动物
 * @author Administrator
 *
 */
public class CreateAnimal {
	
	public static void main(String[] args) {
		AnimalFactory animalFactory = new AnimalFactory();
		Animal animal1 = animalFactory.createAnimal(Bird.class);
		Animal animal2 = animalFactory.createAnimal(Dog.class);
		Animal animal3 = animalFactory.createAnimal(HabaDog.class);
		
		animal1.laugh();
		animal2.laugh();
		animal3.laugh();
		
	}
	
}

运行截图：

好像很好用，但是我们有没有发现一个问题，如果我们生产出来的狗要分品种呢，要分雌雄呢，怎么办，都去直接实现 animal接口也不好管理，怎么办呢，于是就有抽象工厂设计模式诞生了

其实也没做多大的改动，就是在狗那里定义了一个抽象类，然后让具体狗去继承那个抽象类，然后再生成，代码结构图如下

客户端调用如下

package com.zzq.abstractfactorypattern.po;

import java.util.List;

import com.zzq.abstractfactorypattern.po.abs.ext.FemaleDaBird;
import com.zzq.abstractfactorypattern.po.abs.ext.MaleHabaDog;
import com.zzq.factorypattern.po.ClassUtil;

public class CreateAnimal {
	
	public static void main(String[] args) {
		AnimalFactory factory = new AnimalFactory();
		Animal habadog = factory.createAnimal(MaleHabaDog.class);
		habadog.eat();
		habadog.laugh();
		habadog.run();
		habadog.sex();
		System.out.println("------------------------");
		Animal femaleDaBird = factory.createAnimal(FemaleDaBird.class);
		femaleDaBird.eat();
		femaleDaBird.laugh();
		femaleDaBird.run();
		femaleDaBird.sex();
		
	}
	
}

运行结果如下