本文目录一览：
做java项目时，要求程序支持功能扩展。这就需要用到接口和工厂模式。有必要给每一个类都增加接口和工厂吗?
这个是设计模式，设计模式不是框架，没有特定的场景，不过你多做项目，然后经验多了会不经意的去寻找开发项目的快捷性，当你实现了你的这种思路之后，他就是设计模式，不要刻意去使用设计模式，只有当你需要或者解决某中需求的时候，发现java里的一些设计模式适合你的需求，你就可以用他，对于程序的拓展性，java中你必须明白
- 一个类有且仅有一个引起他变化的因素
- 对于程序，应该对修改关闭，对新增开放，就是说你设计一个模块的时候尽量让它做到不要去修改，但是新增模块可以， 总之设计模式很重要，如果你领会了，会对你以后的编程带来层次上的提高，它是编程思想上的提升
java中 什么是工厂
工厂是一种设计模式！ 为何使用? 工厂模式是我们最常用的模式了,著名的Jive论坛 ,就大量使用了工厂模式，工厂模式在Java程序系统可以说是随处可见。 为什么工厂模式是如此常用？因为工厂模式就相当于创建实例对象的new，我们经常要根据类Class生成实例对象，如A a=new A() 工厂模式也是用来创建实例对象的，所以以后new时就要多个心眼，是否可以考虑实用工厂模式，虽然这样做，可能多做一些工作，但会给你系统带来更大的可扩展性和尽量少的修改量。 我们以类Sample为例， 如果我们要创建Sample的实例对象:
Sample sample = new Sample();
可是，实际情况是，通常我们都要在创建sample实例时做点初始化的工作,比如赋值 查询数据库等。 首先，我们想到的是，可以使用Sample的构造函数，这样生成实例就写成:
Sample sample = new Sample(参数);
但是，如果创建sample实例时所做的初始化工作不是象赋值这样简单的事，可能是很长一段代码，如果也写入构造函数中，那你的代码很难看了（就需要Refactor重整）。 为什么说代码很难看，初学者可能没有这种感觉，我们分析如下，初始化工作如果是很长一段代码，说明要做的工作很多，将很多工作装入一个方法中，相当于将很多鸡蛋放在一个篮子里，是很危险的，这也是有背于Java 面向对象的原则，面向对象的封装(Encapsulation)和分派(Delegation)告诉我们，尽量将长的代码分派“切割”成每段，将每段再 “封装”起来(减少段和段之间偶合联系性)，这样，就会将风险分散，以后如果需要修改，只要更改每段，不会再发生牵一动百的事情。 在本例中，首先，我们需要将创建实例的工作与使用实例的工作分开, 也就是说，让创建实例所需要的大量初始化工作从Sample的构造函数中分离出去。 这时我们就需要Factory工厂模式来生成对象了，不能再用上面简单new Sample(参数)。还有,如果Sample有个继承如MySample, 按照面向接口编程,我们需要将Sample抽象成一个接口.现在Sample是接口,有两个子类MySample 和HisSample .我们要实例化他们时,如下:
Sample mysample = new MySample();
Sample hissample = new HisSample();
随着项目的深入,Sample可能还会"生出很多儿子出来", 那么我们要对这些儿子一个个实例化,更糟糕的是,可能还要对以前的代码进行修改:加入后来生出儿子的实例.这在传统程序中是无法避免的. 但如果你一开始就有意识使用了工厂模式,这些麻烦就没有了.
工厂方法
你会建立一个专门生产Sample实例的工厂:
public class Factory{
public static Sample creator(int which){
//getClass 产生Sample 一般可使用动态类装载装入类。
if (which == 1)
return new SampleA();
else if (which == 2)
return new SampleB();
}
}
那么在你的程序中,如果要实例化Sample时.就使用
Sample sampleA = Factory.creator(1);
这样,在整个就不涉及到 Sample的具体子类,达到封装效果,也就减少错误修改的机会,这个原理可以用很通俗的话来比喻:就是具体事情做得越多,越容易范错误.这每个做过具体工作的人都深有体会,相反,官做得越高,说出的话越抽象越笼统,范错误可能性就越少.好象我们从编程序中也能悟出人生道理?呵呵. 使用工厂方法 要注意几个角色，首先你要定义产品接口，如上面的Sample,产品接口下有Sample接口的实现类,如SampleA,其次要有一个factory类，用来生成产品Sample，如下图，最右边是生产的对象Sample： 进一步稍微复杂一点，就是在工厂类上进行拓展，工厂类也有继承它的实现类concreteFactory了。
抽象工厂
工厂模式中有: 工厂方法(Factory Method) 抽象工厂(Abstract Factory). 这两个模式区别在于需要创建对象的复杂程度上。如果我们创建对象的方法变得复杂了,如上面工厂方法中是创建一个对象Sample,如果我们还有新的产品接口Sample2. 这里假设：Sample有两个concrete类SampleA和SamleB，而Sample2也有两个concrete类Sample2A和SampleB2 那么，我们就将上例中Factory变成抽象类,将共同部分封装在抽象类中,不同部分使用子类实现，下面就是将上例中的Factory拓展成抽象工厂:
public abstract class Factory{
public abstract Sample creator();
public abstract Sample2 creator(String name);
}
public class SimpleFactory extends Factory{
public Sample creator(){
.....
return new SampleA;
}
public Sample2 creator(String name){
.....
return new Sample2A;
}
}
public class BombFactory extends Factory{
public Sample creator(){
.....
return new SampleB;
}
public Sample2 creator(String name){
.....
return new Sample2B;
}
}
从上面看到两个工厂各自生产出一套Sample和Sample2,也许你会疑问，为什么我不可以使用两个工厂方法来分别生产Sample和Sample2? 抽象工厂还有另外一个关键要点，是因为 SimpleFactory内，生产Sample和生产Sample2的方法之间有一定联系，所以才要将这两个方法捆绑在一个类中，这个工厂类有其本身特征，也许制造过程是统一的，比如：制造工艺比较简单，所以名称叫SimpleFactory。 在实际应用中，工厂方法用得比较多一些，而且是和动态类装入器组合在一起应用。
java中的工厂模式是什么意思？
工厂模式简单的讲就是用工厂方法代替了new的操作， 在通俗点就是说，你new一个对象的时候直接调用工厂方法就行了， 在编程时，需要定义一个工厂接口，由不同的的子类去实现，再定一个具体工厂类，定义一个产生实例的方法，我们通过这个方法来获得实例就行了，
Java的几个工厂方法解析
Java工厂模式可分为三种：
- 静态工厂模式
- 工厂方法模式
- 抽象工厂模式
一、静态工厂模式：用静态的方法实现，其创建的对象具有一定的特性
举例如下： Vehicle类：
public abstract class Vehicle {
private String name;
public Vehicle() {
super();
}
public Vehicle(String name) {
super();
this.name = name;
}
public abstract void run();
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
Bus类：
public class Bus extends Vehicle {
private String name;
public Bus() {}
public Bus(String name) {
super(name);
}
@Override
public void run() {
System.out.println("Bus is running");
}
}
Car类：
public class Car extends Vehicle {
private String name;
public Car() {}
public Car(String name) {
super(name);
}
@Override
public void run() {
System.out.println("Car is running");
}
}
静态工厂类： （静态工厂创建一个对象，静态工厂创建的对象一般都有一个共同的特性，继承自某一个类，或者引用一个接口）
public class StaticFactory {
public static Object getInstance(String className) {
Object instance = null;
try {
Class c = Class.forName(className);
instance = c.newInstance();
} catch (Exception e) {}
return instance;
}
public static Object getInstance(String className, Object... args) {
Class c = null;
try {
c = Class.forName(className);
} catch (Exception e) {}
Constructor[] cons = c.getConstructors();
Object instance = null;
for (Constructor con : cons) {
Class<?>[] cs = con.getParameterTypes();
if (cs.length == args.length) {
boolean isConstructor = true;
for (int i = 0; i < cs.length; i++) {
Class t = cs[i];
if (!t.isInstance(args[i])) {
isConstructor = false;
}
}
if (isConstructor) {
try {
instance = con.newInstance(args);
break;
} catch (Exception e) {}
} else {
continue;
}
}
}
return instance;
}
}
二、工厂方法模式：主要是对各类东西分类生产，但分类生产的对象仍然具有某一特性。
如果说静态工厂是一个综合的交通工具建造工厂，那么工厂方法模式就是具体分工，分成Bus与Car的工厂，各自生产各自的产品，但是造出来的还是交通工具。 交通工具制造接口：
public interface VehicleMake {
/**制造交通工具**/
public Vehicle make();
}
Bus制造类：
public class BusMake implements VehicleMake {
@Override
public Vehicle make() {
Vehicle bus = new Bus();
System.out.println("Bus工厂制造了一辆Bus");
return bus;
}
}
Car制造类：
public class CarMake implements VehicleMake {
@Override
public Vehicle make() {
Vehicle car = new Car();
System.out.println("Car工厂制造了一辆Car");
return car;
}
}
三、抽象工厂模式：抽象工厂生产的对象可能是没有共同特性的。比如，一个制造工厂BusMake不仅能制造Bus还能生产轮胎wheel等配件，Bus是交通工具，wheel是配件（代码中有部分类没具体写出来只给了类名）
总工厂（抽象工厂总接口）：
public interface WheelVehicleMake extends VehicleMake {
/**制造轮胎**/
public Wheel makeWheel();
}
轮子BusMake：
public class WheelBusMake implements WheelVehicleMake {
@Override
public Vehicle make() {
Vehicle bus = new Bus();
System.out.println("WheelBusMake生产了一辆Bus");
return bus;
}
@Override
public Wheel makeWheel() {
Wheel busWheel = new BusWheel();
System.out.println("WheelBusMake生产了一个Bus轮子");
return busWheel;
}
}
轮子CarMake：
public class WheelCarMake implements WheelVehicleMake {
@Override
public Vehicle make() {
Vehicle car = new Car();
System.out.println("WheelCarMake生产了一辆Car");
return car;
}
@Override
public Wheel makeWheel() {
Wheel carWheel = new CarWheel();
System.out.println("WheelCarMake生产了一个Car轮子");
return carWheel;
}
}
