工厂模式在项目开发中是使用效率非常高的，意思就是说定义一个用于创建对象的接口，让子类去决定实例化哪一个类。这就是一个工厂类的示意图
接着来一个简单的例子：
如上图所示，我们首先定义我们的产品抽象类接口，也可以是抽象类：
package factory;
public abstract class PlatForm {
public void search(){
System.out.println("你搜索的结果是。。。。。。");
}
public abstract void music();
}
下面是一些实现类
package factory;
public class BaiduProduct extends PlatForm{
@Override
public void music() {
System.out.println("baidu music");
}
}
package factory;
public class Qihu360Product extends PlatForm{
@Override
public void music() {
System.out.println("360 music");
}
}
package factory;
public class SogouProduct extends PlatForm{
@Override
public void music() {
System.out.println("sogou music");
}
}
三个实现类已经完成，下面我们要来一个工厂的抽象类
package factory;
public abstract class Creator {
/**
* 创建一个产品对象，其中T 可以为 String Enum Class等 参数可以自己设置
* @param c
* @return
*/
public abstract <T extends PlatForm> T createProduct(Class<T> c);
}
下面是实现类
package factory;
public class ConcrentCreator extends Creator{
@Override
public <T extends PlatForm> T createProduct(Class<T> c) {
PlatForm plat = null;
try {
/**
* 创建一个用于创建对象的接口，让子类去确定实例化哪一个对象。工厂方法，让一个类的实例化延迟到子类
*/
plat = (PlatForm) Class.forName(c.getName()).newInstance();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
return (T) plat;
}
}
package factory;
public class Client {
public static void main(String[] args) {
Creator creator = new ConcrentCreator();
//在这里可以把你要实例化的类给传进去，然后即可调用你想要的方法。
PlatForm plat = creator.createProduct(BaiduProduct.class);
plat.search();
plat.music();
}
}
在这里面模仿了一个客户端，就可以输出你想要的结果。
在工厂模式方法中抽象产品类负责定义产品的共性，实现实物最抽象的定义；creator为产品抽喜创建类，也就是抽象工厂具体如何创建产品类有具体的实现creator的工厂类来完成，工厂类的变种很多，下面，我总结类一个比较通用的源码。
1：抽象产品类
package factory.total;
public abstract class Product {
public void method1(){
//所有产品的共性
}
//抽象方法 具体有继承它的类去实现
public abstract void method2();
}
2：产品实现类
package factory.total;
public class ConcretProduct1 extends Product{
@Override
public void method2() {
//TODO
}
}
package factory.total;
public class ConcretProduct2 extends Product{
@Override
public void method2() {
//TODO
}
}
3：抽象工厂类
package factory.total;
public abstract class Creator {
public abstract <T extends Product> T createMethod(Class<T> c);
}
4：具体工厂类：
package factory.total;
public class ConcreteCreator extends Creator{
@Override
public <T extends Product> T createMethod(Class<T> c) {
Product pro = null;
try {
pro = (Product) Class.forName(c.getName()).newInstance();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
return (T) pro;
}
}
场景模拟类
package factory.total;
public class Client {
public static void main(String[] args) {
Creator creator = new ConcreteCreator();
Product pro = creator.createMethod(ConcretProduct1.class);
pro.method1();
pro.method2();
}
}
其中工厂模式又分为简单工厂模式，和多级工厂模式，不过这两种情况，和上一种都比较类似了，其中简单工厂模式只是简单的把抽象工厂类去掉，然后把工厂实现类的方法改成static方法。多级工厂模式是指：例如当我们见到一个比较复杂的项目时，所有的产品类都放到一个工厂类中去初始化会显得结构不清晰，那么我们现在就为每一种产品都有自己的一个工厂类；下面我会给出实例多级工厂类的应用。
我是有些基础类还是使用以前的，只不过为每个产品增加了一个工厂类
1：抽象工厂类：
package factory.more;
public abstract class AbstractPlatFactory {
public abstract PlatForm createPlat();
}
2:具体工厂类：
package factory.more;
public class BaiduFactory extends AbstractPlatFactory{
@Override
public PlatForm createPlat() {
// TODO Auto-generated method stub
return new BaiduProduct();
}
}
package factory.more;
public class Qihu360Factory extends AbstractPlatFactory{
@Override
public PlatForm createPlat() {
return new Qihu360Product();
}
}
package factory.more;
public class SogouFactory extends AbstractPlatFactory{
@Override
public PlatForm createPlat() {
return new SogouProduct();
}
}
场景类：
package factory.more;
public class Client {
public static void main(String[] args) {
PlatForm plat = new BaiduFactory().createPlat();
plat.search();
plat.music();
}
}
这是多级工厂类的使用，
实际上还有抽象工厂类的应用，它是指为相关对象提供一组接口，无需指定他们的具体类。（今天太晚了，以后有时间会接着说的）