工厂模式----一个工厂vs多个模型对象

[java]代码库

简单工厂

1.创建一个子弹类Bullet和士兵类Soldier
public class Bullet{}
public class Soldier{}

2.一个生产子弹（bullet）的工厂
public class BulletFactory {
	//单例
	private static BulletFactory factory=new BulletFactory();
	//私有化构造函数
	private BulletFactory(){}
	//定义一个对外开放的方法，以获取该工厂实例
	public static BulletFactory getFactory(){
		return factory;
	}
	//创建子弹对象
	public Bullet newInstance(){
		try {
			//获取bullet类的全名（包含包名model.Bullet）
			String className="factory.Bullet";
			//获取该类的字节码对象
			Class clz=Class.forName(className);
			//创建子弹类的实例并返回
			return (Bullet) clz.newInstance();
		} catch (Exception e) {
			e.printStackTrace();
			throw new RuntimeException(e);
		}
	}
}

3.创建一个生产士兵的工厂
public class SoldierFactory {
	//单例
	private static SoldierFactory factory=new SoldierFactory();
	//私有化构造函数
	private SoldierFactory(){}
	//定义一个对外开放的方法，以获取该工厂实例
	public static SoldierFactory getFactory(){
		return factory;
	}
	//创建子弹对象
	public Soldier newInstance(){
		try {
			//获取bullet类的全名（包含包名factory.Bullet）
			String className="model.Soldier";
			//获取该类的字节码对象
			Class clz=Class.forName(className);
			//创建子弹类的实例并返回
			return (Soldier) clz.newInstance();
		} catch (Exception e) {
			e.printStackTrace();
			throw new RuntimeException(e);
		}
	}
}

4.如果要为每一个类都创建一个工厂，当要创建实例的类很多的时候，要创建的工厂也就多了，这时要想办法使用一个工厂（BasicFactory）就能够创建各种各样的对象（既能创造子弹、士兵、还能创造人民币、美元、汽车等不同的对象）-------使用泛型
    
这时我们把要创建实例的对象都放到一个配置文件中，如果要创建该类的实例，就修改配置文件就可以了
conf.properties信息（properties类来读取）
#className=model.Bullet
className=model.Soldier
 通过读取配置文件，来获取要创建实例的类的名称
=========================================================
5 PropUtils工具类--读取配置文件
package model;
import java.io.File;
import java.io.FileInputStream;
import java.util.Properties;

public class PropUtils {
	private static Properties prop = new Properties();
	static{
		try {
			//通过类加载器读取配置文件的路径
			String path = PropUtils.class.getClassLoader().getResource("conf.properties").getPath();
			prop.load(new FileInputStream(new File(path)));		
		} catch (Exception e) {
			e.printStackTrace();
			throw new RuntimeException(e);
		}
	}	
	/**
	 * 根据key获取配置文件中的value
	 * @param string key
	 * @return string value
	 */
	public static String getProp(String key) {
		return prop.getProperty(key);
	}	
}

6.创建一个工厂（BasicFactory）

public class BasicFactory {
	private static Properties prop = new Properties();
	//单例
	private static BasicFactory factory=new BasicFactory();
	//私有化构造函数
	private BasicFactory(){}
	//定义一个对外开放的方法，以获取该工厂实例
	public static BasicFactory getFactory(){
		return factory;
	}
	//创建子弹对象
	@SuppressWarnings("unchecked")
	public <T>T newInstance(){
		try {
			//获取类的全称(key : className ; value : 类名)
			String className=prop.getProperty("className");
			//获取该类的字节码对象
			Class clz=Class.forName(className);
			//创建实例并返回
			return (T) clz.newInstance();
		} catch (Exception e) {
			e.printStackTrace();
			throw new RuntimeException(e);
		}
	}
}
========================================================================
7.如果  想要调用接口中的方法，那我们首先要创建接口实现类的对象，当需要创建多个实现类的对象时，配置文件conf.properties:
# 例如顶一个三个接口  Person    Car     Money
#  Person有两个实现类 Student 和Teacher
#  Car有1个实现类  CarImpl
#  Money有2个实现类  Rmb   Dollar
#  可以将接口名称作为key键，对应的接口实现类作为value值
  Person=model.person.Student
  #Person=model.person.Teacher
  Car=model.car.CarImpl
  #Money=model.money.Dollar
  Money=model.money.Rmb
==========================================
8.接口和实现类
8-1 Person
package model.person;
public interface Person {
    public void work();
}
public class Student implements Person {
    public void work() {
		System.out.println("学习java");
	}
}
public class Teacher implements Person {
	public void work() {
		System.out.println("教你Java编程思想");
	}
}
8-2 Car
package model.car;
public interface Car {
    public void driver();
}
public class CarImpl implements Car {
	@Override
	public void driver() {
		System.out.println("老司机要上车了，带你们");
	}
}
8-3 Money
package model.money;
public interface Money {
	public void buy();
}
public class Rmb implements Money {
	@Override
	public void buy() {
		System.out.println("买五芳斋粽子");
	}
}
public class Dollar implements Money {
	@Override
	public void buy() {
		System.out.println("只能买汉堡");
	}
}
==================================
9.  BasicFactory的newInstance()方法
	public <T>T newInstance(Class<T> clazz){
		try {
			//获取类的全称(key : 接口名 ; value : 实现类类名)
			String className=prop.getProperty(clazz.getSimpleName());
			//获取该类的字节码对象
			Class clz=Class.forName(className);
			//创建实例并返回
			return (T) clz.newInstance();
		} catch (Exception e) {
			e.printStackTrace();
			throw new RuntimeException(e);
		}
	}
}
==================================
10.测试类 Test.java
package model;
import factory.BasicFactory;
import model.car.Car;
import model.money.Money;
import model.person.Person;
public class Test {
	public static void main(String[] args) {
		Person p=BasicFactory.getFactory().newInstance(Person.class);
		Car car=BasicFactory.getFactory().newInstance(Car.class);
		Money money=BasicFactory.getFactory().newInstance(Money.class);
		p.work();  //    学习java------------------------------输出结果
		car.driver(); //老司机要上车了，带你们--------------输出结果
		money.buy(); //买五芳斋粽子------------------------输出结果
	}
}
   实现了一个工厂可以创建不同对象的功能
======================================================
  如果要为特定的类创建代理对象，这就要用到代理模式。。。好难啊，动态代理？？？？
======================================================