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

工厂设计模式，相信大家都不陌生，省去了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();

}

}运行结果如下