设计模式学习笔记——工厂模式

创新型模式包括：

工厂方法(Factory Method  其中又含简单工厂Simple Factory)

抽象工厂(Abstract Factory)

构造器模式(Builder)

原型模式(Prototype)

单例模式(Singleton)

<!--[endif]-->

 

工厂模式

简单工厂模式:根据所提供的数据返回某个类的一个实例。通常它返回的类都具有共同的父类和共同的方法

 

原理：首先创建一个提取方法，能在多个可能的类中决定返回的是哪一个类的实例，并将其返回。然后就能调用该类实例方法，而不必了解实际使用的哪个子类。从而使得数据依赖性问题和类的可用方法得以分离。

 

 

 
 定义了一个Mobile接口 其中只有一个方法call()

 

public interface Mobile {
	public void call();
}

 

不同的手机品牌分别实现，比如现在有Nokia和Moto2个实例

 

public class Nokia implements Mobile{
	public void call() {
		System.out.println("Nokia produced");
	}
}

public class Moto implements Mobile{
	public void call() {
		System.out.println("Moto produced");
	}
}

 

 而之前所说的提取方法，也就是工厂就是MobileFactory，它根据传入的参数来选择实现不同的实例，有一个produceMobile方法

 

public class MobileFactory {
	public Mobile produceMobile(String s){
		if(s.equals("Nokia")){
			return new Nokia();
		}else{
			return new Moto();
		}
	}
}

 

 

简单工厂把主要的工作都放在了工厂中进行判断，返回哪一个实例完全由工厂确定

 

new MobileFactory().produceMobile("Nokia");

 

 

 

 

工厂方法：

不再由单个工厂类决定到底应该实例化哪个子类，超类将这一决定推迟到每个子类中去完成。

 

 

使用工厂方法的时机：（这个还是不能完全理解，可能需要在实践中慢慢体会）

●类无法预计出必须创建哪个类的对象

●类要使用其子类指定所要创建的对象

●对于将创建哪个类，希望将有关信息局部化

 

工厂模式的几种不同形式：（这个也同样不能完全理解，要一点点找感觉）

●基类是抽象类，并且这种模式必须返回一个完全可工作的类

●基类中包含默认方法，仅当默认方法不够用时，才需要派生子类

●传递给工厂的参数将通知要返回哪些类类型，此时所有类必须有相同的方法名，但实现的操作可不同

 

 

同样还是手机生产的例子

现在将工厂变成一个接口

 

public interface MobileFactory {
	public Mobile produceMobile();
}

 

 而不同的品牌各自有自己的工厂NokiaFactory，MotoFactory，并返回相对应的自己的实例Nokia，Moto

 

public class NokiaFactory implements MobileFactory{
	public Mobile produceMobile(){
		return new Nokia();
	}
}

public class MotoFactory implements MobileFactory{
	public Mobile produceMobile() {
		return new Moto();
	}
}

 

与简单工厂相比，也就是将原本在一个工厂中返回哪一个实例的决定，延迟到了各个品牌各自的工厂类中去实现

而其中NokiaFactory就专门生产Nokia产品，MotoFactory就专门生产Moto产品

 

MobileFactory mf=new NokiaFactory();
Mobile nokia=mf.produceMobile();

 

 

抽象工厂模式：

能返回多个相关对象类中的一个，而每个对象类又能根据要求返回多个不同的对象。即，抽象工厂是一个能从几组类中返回其中某一组的工厂对象。

 

目的：把所生成的具体类相分离，类的实际名称被隐藏在工厂中，客户级不必了解，从而可以自由修改或交换这些产品类系列。

问题：抽象工厂模式生成的所有类具有相同的基类，但不可避免的，某些子类会有与其他类不同的额外方法，你无法确定是否能调用某个类的方法。解决办法： 在积累中定义所有的方法，如果无法修改基类，也可以派生一个新的基类，使之包含全部的方法。

 

 

还是在手机生产的例子上面进行修改，现在不同的手机厂商又有各自品牌下不同的A,B两款手机，这时候就形成了一个组合，也就是Nokia品牌的A型号手机，Nokia品牌的B型号手机，Moto品牌的A型号手机和Moto品牌额B型号手机，这时候就用到了抽象工厂模式

同样定义了一个工厂接口MobileFactory，但是这次不再只声明一个produce方法，因为要返回不同的手机

 

public interface MobileFactory {
	public abstract Nokia produceNokia();
	public abstract Moto produceMoto();
}

 

 FactoryA和FactoryB用来生产A型号手机和B型号手机

 

public class FactoryA implements MobileFactory{
	public Nokia produceNokia() {
		return new NokiaA();
	}
	public Moto produceMoto() {
		return new MotoA();
	}
}

public class FactoryB implements MobileFactory{
	public Nokia produceNokia() {
		return new NokiaB();
	}
	public Moto produceMoto() {
		return new MotoB();
	}
}

 

 而在手机这边，Nokia和Moto由于有不同的品牌，也被声明成了接口

 

public interface Nokia{
	public abstract void call();
}

最后是产品类，也就是NokiaA，NokiaB，MotoA，MotoB

 

public class NokiaA implements Nokia{
	public void call() {
		System.out.println("NokiaA produced");
	}
}

 

 此时，我们要生产一个NokiaA，就可以执行

 

new FactoryA().produceNokia()；

 

 

由于刚看设计模式，参考了很多网上的资料，但是仍然有许多纠结着不明白的地方，比如要是让我说清楚各种工厂方法什么时候该用，就会有些不知道怎么下手，现在只能对着写好的东西去看，去理解

 

3个工厂模式上，个人理解是：

工厂方法是对简单工厂的一种扩展，简单工厂把所有的判断都放在了工厂中，而工厂方法就像是在简单工厂的工厂上又加了一层，从而不再由工厂本身去决定生产那一种实例，而是由实现这个工厂的子类去完成这一工作

抽象工厂和工厂方法上，看了不少网上的资料，有一句话是得到很普遍赞同的

工厂方法是针对一个对象，而抽象工厂模式则是对一个类而言（还是有些一知半解）

我现在可以最方便看出的是，工厂方法上，工厂和生产的实例是一一对应的关系，在创建工厂的同时，产生哪一个实例就已经被确定了，而抽象工厂模式，则是对一个组合的应用，类似于拼装的概念，在A类下有abc产品，B类下也有abc产品，这个时候就用到了抽象工厂，有专门生产a、b、c的工厂，而工厂再返回不同类别的产品，这个过程对客户类是不可见的，他看不到期间生产的实例Aa，Ba等等，而只需要去执行产品的方法就可以了

 

希望大家给予纠正，谢谢

另外，我Google浏览器。为什么在上传rar的时候，会传不上来。。。