package dao;

/**
 * 定义一个人类的统称
 * @author Mr.Zhang
 *
 */
public interface Human {

	/**
	 * 首先定义什么事人类
	 */
	
	//会笑的
	public void laugh();
	
	//会哭的
	public void cry();
	
	//会说话的
	public void talk();
}

package daoimpl;

import dao.Human;

/**
 * 黑人
 * @author Mr.Zhang
 *
 */
public class BlackHuman implements Human {

	@Override
	public void laugh() {
		System.out.println("黑人会笑");

	}

	@Override
	public void cry() {
		System.out.println("黑人会哭");
	}

	@Override
	public void talk() {
		System.out.println("黑人会说话");

	}

}

package daoimpl;

import dao.Human;

/**
 * 白人
 * @author Mr.Zhang
 *
 */
public class WhiteHuman implements Human {

	@Override
	public void laugh() {
		System.out.println("白人会笑");

	}

	@Override
	public void cry() {
		System.out.println("白人会哭");
	}

	@Override
	public void talk() {
		System.out.println("白人会说话");

	}
}

package daoimpl;
import dao.Human;

/**
 * 黄种人
 * @author Mr.Zhang
 *
 */
public class YellowHuman implements Human {

	@Override
	public void laugh() {
		System.out.println("黄种人会笑");

	}

	@Override
	public void cry() {
		System.out.println("黄种人会哭");
	}

	@Override
	public void talk() {
		System.out.println("黄种人会说话");
	}

}

package Factory;

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

import dao.Human;

/**
 * 工厂类
 * 
 * @author Mr.Zhang 八卦炉
 */
@SuppressWarnings("all")
public class HumanFactory {

	/**
	 * 定一个烤箱，泥巴塞进去，人就出来，这个太先进了
	 * 
	 * @return （基本的工厂类用法）
	 */
	public static Human createHuman(Class man) {
		// 定义一个类型的人类
		Human human = null;
		try {
			human = (Human) Class.forName(man.getName()).newInstance();
		} catch (Exception e) {
			e.printStackTrace();
		}
		return human;
	}

	/**
	 * 女娲生气了，把一团泥巴塞到八卦炉，哎产生啥人类就啥人类 （比较高级的工厂类用法）
	 */
	public static Human createHuman() {
		// 定义一个类型的人类
		Human human = null;
		// 首先是获得有多少个实现类(多少个人类)？？？为什么此处获取不到实现类
		List<Class> concreteHumanList = ClassUtils.getAllClassByInterface(Human.class);
		Random ran = new Random();
		int rand = ran.nextInt(concreteHumanList.size());
		human = createHuman(concreteHumanList.get(rand));
		return human;
	}

	/**
	 * 工厂方法模式还有一个非常重要的应用，就是延迟始化(Lazy initialization)，什么是延迟始化呢？
	 * 一个对象初始化完毕后就不释放，等到再次用到得就不用再次初始化了，直接从内存过中拿到就可以了， 怎么实现呢，很简单，看例子：
	 */

	// 定义一个 MAP, 初始化过的 Human 对象都放在这里
	private static HashMap<String, Human> humans = new HashMap<String, Human>();

	/**
	 * 定一个烤箱，泥巴塞进去，人就出来，这个太先进了
	 * @param c
	 * @return
	 */
	public static Human createHuman2(Class man) {
		Human human = null; // 定义一个类型的人类
		try {
			// 如果 MAP 中有，则直接从取出，不用初始化了
			if (humans.containsKey(man.getSimpleName())) {
				human = humans.get(man.getSimpleName());
			} else {
				human = (Human) Class.forName(man.getName()).newInstance();
				// 放到 MAP 中
				humans.put(man.getSimpleName(), human);
			}
		} catch (Exception e) {
			e.printStackTrace();
		} 
		return human;
	}
}

package Factory;

import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.List;

import dao.Human;

/**
 * 可以由一个接口查找到所有的实现类，也可以由父类查找到所有的子类
 * 
 * @author Mr.Zhang
 * 
 */
@SuppressWarnings("all")
public class ClassUtils {
	List<Class> returnClassList = new ArrayList<Class>(); // 返回结果
	

	/**
	 *  给一个接口，返回这个接口的所有实现类
	 * @param c
	 * @return
	 */
	public static List<Class> getAllClassByInterface(Class c) {
		List<Class> returnClassList = new ArrayList<Class>(); // 返回结果
		// 如果不是一个接口，则不做处理
		if (c.isInterface()) {
			String packageName = c.getPackage().getName(); // 获得当前的包名
			try {
				List<Class> allClass = getClasses(packageName); // 获得当前包下以及子包下的所有类
				// 判断是否是同一个接口
				for (int i = 0; i < allClass.size(); i++) {
					if (c.isAssignableFrom(allClass.get(i))) { // 判断是不是一个接口
						if (!c.equals(allClass.get(i))) { // 本身不加进去
							returnClassList.add(allClass.get(i));
						}
					}
				}
			} catch (ClassNotFoundException e) {
				e.printStackTrace();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		return returnClassList;
	}

	/**
	 * 从一个包中查找出所有的类，在jar包中不能查找
	 * @param packageName
	 * @return
	 * @throws ClassNotFoundException
	 * @throws IOException
	 */
	private static List<Class> getClasses(String packageName)throws ClassNotFoundException, IOException {
		  // TODO Auto-generated method stub
		  ClassLoader classLoader = Thread.currentThread()
		    .getContextClassLoader();// 获取当前的线程的类加载器
		  String path = packageName.replace('.', '/');// 将包名替换成相对路经名
		  Enumeration<URL> resources;

		  resources = classLoader.getResources(path);// 查找所有给定名称的资源
		  List<File> dirs = new ArrayList<File>();
		  while (resources.hasMoreElements()) {
		   URL resource = resources.nextElement();
		   dirs.add(new File(resource.getFile()));// 获取此 URL 的文件名 创建文件对象
		   // 添加到List里面
		  }
		  ArrayList<Class> classes = new ArrayList<Class>();
		  for (File directory : dirs) {
		   classes.addAll(findClasses(directory, packageName));
		  }
		  return classes;
	}

	/**
	 * 取得包下的所有类
	 * @param directory
	 * @param packageName
	 * @return
	 * @throws ClassNotFoundException
	 */
	private static List<Class> findClasses(File directory, String packageName)throws ClassNotFoundException {
		List<Class> classes = new ArrayList<Class>();
		if (!directory.exists()) {
			return classes;
		}
		File[] files = directory.listFiles();
		for (File file : files) {
			if (file.isDirectory()) {
				assert !file.getName().contains(".");
				classes.addAll(findClasses(file,packageName + "." + file.getName()));
			} else if (file.getName().endsWith(".class")) {
				classes.add(Class.forName(packageName+ '.'+ file.getName().substring(0,file.getName().length() - 6)));
			}
		}
		return classes;
	}
}

package test;

import Factory.HumanFactory;
import dao.Human;
import daoimpl.BlackHuman;
import daoimpl.WhiteHuman;
import daoimpl.YellowHuman;

public class NvWa {

	/**
	 * 测试类
	 * @param args
	 * 定义一个女娲造人
	 */
	public static void main(String[] args) {
		System.out.println("------------造出的第一批人是这样的：白人-----------------");
				Human whiteHuman = HumanFactory.createHuman(WhiteHuman.class);
				whiteHuman.cry();
				whiteHuman.laugh();
				whiteHuman.talk();
			
		System.out.println("------------造出的第二批人是这样的：黑人-----------------");
				Human blackHuman = HumanFactory.createHuman(BlackHuman.class);
				blackHuman.cry();
				blackHuman.laugh();
				blackHuman.talk();
		System.out.println("------------造出的第三批人是这样的：黄人-----------------");
				Human yellowHuman = HumanFactory.createHuman(YellowHuman.class);
				yellowHuman.cry();
				yellowHuman.laugh();
				yellowHuman.talk();	
				
		System.out.println(">>>>>>>>>>>>>>>>>以下部分属于高级用法，可能存在未知错误>>>>>>>>>>>>>>>>>>>>>>>>>>");
//		/**
//		 * 女娲烦躁了，爱是啥人类就是啥人类，烧吧
//		 */
//		for (int i = 0; i <100; i++) {
//			System.out.println("\n\n------------随机产生人类了-----------------" +i);
//				Human human = HumanFactory.createHuman();
//				human.cry();
//				human.laugh();
//				human.talk();
//		}
		
	}

}