1、工厂方式
function Car(){
var ocar = new Object;
ocar.color = "blue";
ocar.doors = 4;
ocar.showColor = function(){
document.write(this.color)
};
return ocar;
}
var car1 = Car();
var car2 = Car();
调用此函数时将创建新对象，并赋予它所有的属性和方法。使用此函数可以创建2个属性完全相同的对象。当然我们可以通过给它传递参数来改版这种方式。
function Car(color,door){
var ocar = new Object;
ocar.color = color;
ocar.doors = door;
ocar.showColor = function(){
document.write(this.color)
};
return ocar;
}
var car1 = Car("red",4);
var car2 = Car("blue",4);
car1.showColor() //output:"red"
car2.showColor() //output:"blue"
现在可以通过给函数传递不同的参数来得到具有不同值的对象。
在前面的例子中，每次调用函数Car(),都要创建showcolor()，意味着每个对象都有一个自己的showcolor()方法。
但是事实上，每个对象都共享了同一个函数。
虽然可以在函数外定义方法，然后通过将函数的属性指向该方法。
function showColor(){
alert(this.color);
}
function Car(){
var ocar = new Object();
ocar.color = color;
ocar.doors = door;
ocar.showColor = showColor;
return ocar;
工厂方法模式，英文Factorymethod pattern，工厂方法模式是简单工厂模式的进化版， 看本文之间最好先看一下简单工厂模式。工厂方法模式是定义一个创建产品对象的工厂接口，工厂接口本身不去创建对象，而是交给其子类或者是其实现类去创建，将实际创建工作推迟到子类中进行，我们先看一下如何实现工厂方法模式，最后再说一下它有什么好处。
实现Operation.java，运算基类，抽象getResult方法。
public abstract class Operation {
protected double numA;
protected double numB;
public double getNumA() {
return numA;
}
public void setNumA(double numA) {
this.numA = numA;
}
public double getNumB() {
return numB;
}
public void setNumB(double numB) {
this.numB = numB;
}
public abstract double getResult();
}
AddOperation.java，加法运算类，继承自Operation，实现getResult方法。
/* 加法 */
public class AddOperation extends Operation {
@Override
public double getResult() {
return numA + numB;
}
}
SubOperation.java，减法运算类，继承自Operation，实现getResult方法。
/* 减法 */
public class SubOperation extends Operation {
@Override
public double getResult() {
return numA - numB;
}
}
乘法、除法运算类略，可以见简单工厂模式第四章第三节。
IFactory.java，创建运算类的工厂接口，包含一个创建运算类的抽象方法。
public interface IFactory {
Operation createOperation();
}
AddFactory.java，加法工厂，实现IFactory，创建加法运算类。
public class AddFactory implements IFactory {
public Operation createOperation() {
return new AddOperation();
}
}
SubFactory.java，减法工厂，实现IFactory，创建减法运算类。
public class SubFactory implements IFactory {
public Operation createOperation() {
return new SubOperation();
}
}
乘法、除法工厂类略。
FactoryMethodTest.java，客户端类。
public class FactoryMethodTest {
public static void main(String[] args) {
IFactory factory = new AddFactory();
Operation operation = factory.createOperation();
operation.setNumA(1);
operation.setNumB(2);
System.out.println(operation.getResult());
}
}
UML
从UML类图中可以看出，工厂方法模式中工厂的个数是和运算类的个数是一样的，也就是说增加一个运算类，就需要增加一个工厂。而简单工厂方法模式中增加一个运算类，需要在静态工厂方法中增加一个判断分支，这样看起来好像工厂方法模式反而麻烦了。现在就得引入软件设计中的一个原则，开放-封闭原则。
原则软件设计中，有很多设计原则，可能我们并非一定要遵守，但我们一定要尽量遵守，因为这始终是利大于弊的。
开放-封闭原则针对扩展是开放的，针对修改是封闭的。详细介绍可以见百度百科，开放-封闭原则是面向对象设计的核心所在，遵循这个原则可以带来巨大好处，可扩展、可维护、可复用。再来说简单工厂方法模式，我需要增加一种运算时，需要增加一个新的运算类，这没有错，但是还需要修改工厂方法，增加分支，这就违背了开放-封闭原则，工厂方法模式就是基于其上的遵循开放-封闭原则的解决方案，针对工厂的变化，抽象出来工厂接口，将静态工厂中的每个分支判断都抽成单独的工厂类，这也是前文提到过的将if…else分支判断转
<s:textfield name="faculty" value="%{#request.updateStudent.classroom.faculty.name}" label="院系" readonly="true"></s:textfield>
说明：request.updateStudent得到的是Student的实例，classroom（Classroom的实例）是Student类的属性，faculty（faculty类的实例）是classroom的属性