设计模式之工厂
本文引用了网上一些资料，感谢这些资料的提供者
?
能对对象的生成进行控制的一种模式
1. 单例
第一种实现方式（最优）：
// 既实现了延迟实例化,又不需要线程同步
class Singleton {
private Singleton(){}
public static Singleton getInstance() {
return SingletonHolder.instance;
}
private static class SingletonHolder { // 内部类持有单例的唯一实例
private static final Singleton instance = new Singleton();
}
}
第二种实现方式（实现了延迟实例化，但是需要同步）
class Singleton {
private static Singleton instance;
private Singleton(){}
public synchronized static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
第三种实现方式（不需要同步，但不能延迟实例化）
class Singleton {
private static final Singleton instance = new Singleton();
private Singleton(){}
public static Singleton getInstance() {
return instance;
}
}
2. 多例
class MultiInstance { // 实现一
// 多例
private static final List<MultiInstance> instances = new ArrayList<MultiInstance>();
private MultiInstance(){}
public static MultiInstance getInstance() {
int index = new Random().nextInt(instances.size());
return instances.get(index);
}
}
class MultiInstance { // 实现二
private static final MultiInstance instance1 = new MultiInstance();
private static final MultiInstance instance2 = new MultiInstance();
private static final MultiInstance instance3 = new MultiInstance();
private static final MultiInstance instance4 = new MultiInstance();
private MultiInstance(){}
public static MultiInstance getInstance() {
// 返回某个实例...
return null;
}
}
class MultiInstance { // 实现三
public static final MultiInstance instance1 = new MultiInstance();
public static final MultiInstance instance2 = new MultiInstance();
public static final MultiInstance instance3 = new MultiInstance();
public static final MultiInstance instance4 = new MultiInstance();
private MultiInstance(){}
}
其它应用如线程池等。
3. 静态工厂方法
静态工厂方法一般要求构造函数私有。通过类名.静态工厂方法()的方式去得到对象。
public class Car implements Moveable {
private static Car car = new Car();// 单例
//private static List<Car> cars = new ArrayList<Car>(); // 多例
private Car(){ }
public void run () {
System.out.println("冒着烟奔跑中......");
}
public static Car getInstance() { // 静态工厂方法
return car;
}
}
Effective JAVA中有关于静态工厂方法的阐述：
类可以提供一个公有的静态工厂方法（static factory method），所谓静态工厂方法，实际上只是一个简单的静态方法，它返回类的一个实例。类可以为它的客户 提供一些静态工厂方法，来替代构造方法，或者同时也提供一些构造方法。
例如：
把一个boolean原语值（原语类型为值不是对象）转化为一个Boolean对象引用：
java 代码
public static Boolean valueOf(boolean b) {
return (b ? Boolean.TRUE : Boolean.FALSE);
}
String.valueOf()，getInstance()等
静态工厂方法的优点：
1、静态工厂方法具有名字，可以更好的描述被返回的对象。
如果一个构造方法的参数没有确切的描述被返回的对象，那么选用适当名字的静态工厂方法可以使一个类更易于使用，并且相应的客户代码更易于阅读。
2、静态工厂方法在每次被调用的时候，不要求必须创建一个新的对象。
这使得一些非可变类可以使用一个预先构造好的实例，或者把已经构造好的实例缓存起来，以后再把这些实例分发给客户。
静态工厂方法可以为重复的调用返回同一个对象，这也可以被用来控制“在某一时刻哪些实例应该存在”。这样做有两个理由。第一，它使得一个类可以保证是一个singleton。第二，它使非可变类可以保证“不会有两个相等的实例存在”，即当且仅当a == b的时候才有a.equals(b)为true。
3、静态工厂方法可以返回一个原返回类型的子类对象。
使用这样的静态工厂方法，可以强迫客户通过接口来引用被返回的对象，而不是通过实现类来引用被返回的对象，这是一个良好的习惯。
静态工厂方法的缺点：
1、类如果不含公有的或者受保护的构造方法，就不能被子类实例化。
2、静态工厂方法与其他的静态方法没有任何区别。在API文档中不能像构造方法那样被明确标示出来，背离规范。
?
4. 简单工厂
即静态工厂方法，精髓在于：使用一个工厂去创建一个产品系列。
代码：
interface Fruit {
void grow();
}
class Apple implements Fruit {
public void grow() {
System.out.println("Apple is growing...");
}
}
class Grape implements Fruit {
public void grow () {
System.out.println("Grape is growing...");
}
}
class Strawberry implements Fruit {
public void grow () {
System.out.println("Strawberry is growing...");
}
}
class SimpleFactory { // 简单工厂一定使用静态方法。生成的对象不一定是单例或多例。
public static Fruit createFruit(String which) { // 可以有多个工厂方法，每个工厂方法负责创建不同系列的产品
if (which.equalsIgnoreCase("apple")) {
return new Apple();
} else if (which.equalsIgnoreCase("grape")){
return new Grape();
} else if (which.equalsIgnoreCase("strawberry")) {
return new Strawberry();
} else {
throw new RuntimeException("Bad fruit request.");
}
}
}
public class Test {
public static void main(String[] args) {
Fruit f = SimpleFactory.createFruit("apple");
f.grow();
f = SimpleFactory.createFruit("grape");
f.grow();
f = SimpleFactory.createFruit("strawberry");
f.grow();
}
}
缺点是当增加一个新的产品类时，要修改工厂方法的代码。
5. 工厂方法
代码：
interface Fruit {
void grow();
}
class Apple implements Fruit {
public void grow() {
System.out.println("Apple is growing...");
}
}
class Grape implements Fruit {
public void grow () {
System.out.println("Grape is growing...");
}
}
class Strawberry implements Fruit {
public void grow () {
System.out.println("Strawberry is growing...");
}
}
interface FruitFactory {
Fruit createFruit();
}
class AppleFactory implements FruitFactory{
public Fruit createFruit() {
return new Apple();
}
}
class GrapeFactory implements FruitFactory {
public Fruit createFruit() {
return new Grape();
}
}
class StrawberryFactory implements FruitFactory {
public Fruit createFruit() {
return new Strawberry();
}
}
public class Test {
public static void main(String[] args) {
FruitFactory factory = new AppleFactory();
factory.createFruit().grow();
factory = new GrapeFactory();
factory.createFruit().grow();
factory = new StrawberryFactory();
factory.createFruit().grow();
}
}
?
6. 抽象工厂
代码：
interface Button { // 抽象产品1
void click();
}
class WinButton implements Button {
public void click () {
System.out.println("click windows button...");
}
}
class UnixButton implements Button {
public void click(){
System.out.println("click unix button...");
}
}
interface Icon { // 抽象产品2
void paint();
}
class WinIcon implements Icon {
public void paint () {
System.out.println("paint windows icon");
}
}
class UnixIcon implements Icon {
public void paint() {
System.out.println("paint unix icon");
}
}
interface AbstractFactory { // 抽象工厂
Button createButton();
Icon createIcon();
}
class WinFactory implements AbstractFactory {
public Button createButton () {
return new WinButton();
}
public Icon createIcon () {
return new WinIcon();
}
}
class UnixFactory implements AbstractFactory {
public Button createButton () {
return new UnixButton();
}
public Icon createIcon () {
return new UnixIcon();
}
}
public class Test { // 测试
public static void main(String[] args) throws IOException {
Button btn = new WinFactory().createButton();
Icon icon = new WinFactory().createIcon();
btn.click();
icon.paint();
btn = new UnixFactory().createButton();
icon = new UnixFactory().createIcon();
btn.click();
icon.paint();
}
}
总结：用最简单的话来概括就是，简单工厂只有一个具体工厂类来创建一种基类的多个不同派生类，工厂方法就是有多个派生于一个基类的具体工厂类，每个具体工厂只生产一种基类的一个派生类，抽象工厂也是只有一个工厂基类，但是每个具体工厂生产多个相关基类的各一个派生类。
?
owl简介：
??? http://wenku.baidu.com/view/627575d63186bceb19e8bbb4.html?from=related&hasrec=1
?? owl参考：
??? http://www.w3.org/TR/2004/REC-owl-ref-20040210/#EnumeratedDatatype
?? OWL本体语言指南：
??? http://wenku.baidu.com/view/8f2e4322aaea998fcc220ef7.html?from=rec&pos=2&weight=8&lastweight=6&count=5
知识库基础：
http://wenku.baidu.com/view/5f28917a5acfa1c7aa00cc69.html?from=related&hasrec=1
?
