转载请标明出处:
http://blog.csdn.net/qq_34707744/article/details/79206653
本文出自:【生平少年】
定义
在工厂模式中,我们在创建对象时不会对客户端暴露创建逻辑,并且是通过使用一个共同的接口来指向新创建的对象。
UML图
个人理解:比如一个A类中定义了若干方法,而在另一个B类中需要调用A类其中的一个方法,当然,我们可以直接 new,但是,这样做的结果就是将A类的所有方法都引用了进来,此时,不仅违背了java面对对象的编程思想,还与A类的复杂构造逻辑耦合。但是如果我们此时向A类中传递一个参数或多个参数,只引用我们所需要的的方法,此时需要创建一个接口。这种模式便称之为工厂模式。它能够有效的避免方法的暴露。当然,根据业务逻辑而定。
分类
代码以生产手机和 PAD 为例:
手机车间
//定义一个手机抽象类
abstract class phone {
// 手机品牌
public abstract void phoneModel();
}
生产手机的机器
//三星手机(继承phone抽象类)放在生产手机的车间
class samsungPhone extends phone {
@Override
public void phoneModel() {System.out.println("三星手机开始生产...");}
}
//华为手机
class huaweiPhone extends phone {
@Override
public void phoneModel() {System.out.println("华为手机开始生产...");}
}
//苹果手机
class iphone extends phone {
@Override
public void phoneModel() {System.out.println("苹果手机开始生产...");}
}
1、简单工厂:
简单工厂模式其实不是一个设计模式,反而比较像一种编程习惯。主要我们定义一个非常简单的类主要负责帮我们生产不同的产品
class SimpelPhoneFactory {
//三星手机
public static final int TYPE_SUM = 1;
//华为手机
public static final int TYPE_HUAWEI = 2;
//苹果手机
public static final int TYPE_APPLE = 3;
public static phone createPhones(int type) {
switch (type) {
case TYPE_SUM:return new samsungPhone();
case TYPE_HUAWEI:return new huaweiPhone();
case TYPE_APPLE:
default: return new iphone();
}
}
}
测试
public static void main(String[] args) {
//简单工厂
phone iphone = SimpelPhoneFactory.createPhones(SimpelPhoneFactory.TYPE_APPLE);
iphone.phoneModel();
}
结果
苹果手机开始生产...
2、简单工厂(反射实现):
利用反射Class.forName(clz.getName()).newInstance()实现的简单工厂
class StaticPhoneFactory {
public static <T extends phone> T createPhoen(Class<T> tClass) {
T t = null;
try { t = (T) Class.forName(tClass.getName()).newInstance();
} catch (Exception e) { e.printStackTrace();}
return t;
}
}
测试
public static void main(String[] args) {
//简单工厂
phone sumsangPhone = phoneFactory.createSamsang();
sumsangPhone.phoneModel();
}
结果
华为手机开始生产...
3、方法工厂
通过定义不同的方法,然后随机调用实现,例如 Controller 层调用 Servers 层中的方法。
class phoneFactory {
/**
* 生产samsang手机
*/
public static phone createSamsang() {return new samsungPhone();}
/**
* 生产huawei手机
*/
public static phone createHuawei() {return new huaweiPhone();}
/**
* 生产ipone手机
*/
public static phone createIpone() {return new iphone();}
}
测试
public static void main(String[] args) {
//简单工厂
phone sumsangPhone = phoneFactory.createSamsang();
sumsangPhone.phoneModel();
}
结果
三星手机开始生产...
4、普通工厂
把简单工厂中具体的工厂类,划分成两层:抽象工厂层+具体的工厂子类层
//手机工厂(抽象工厂)
abstract class PhoneFactory {public abstract phone create();}
//Samsang手机工厂
class SamsangFactory extends PhoneFactory {
@Override
public phone create() {return new samsungPhone();}
}
//Huawei手机工厂
class HuaiweiFactory extends PhoneFactory {
@Override
public phone create() { return new huaweiPhone();}
}
//ipone工厂
class Ipone extends PhoneFactory {
@Override
public phone create() { return new iphone();}
}
测试
public static void main(String[] args) {
//普通工厂
PhoneFactory phoneFactory = new SamsangFactory();
phone phone = phoneFactory.create();
phone.phoneModel();
}
结果
三星手机开始生产...
5、抽象工厂
用于多个产品一起生产。为创建一组相关或相互依赖的对象提供一个接口,而且无需指定他们的具体类
//除手机外,还卖电脑
abstract class Pad {
/**
* 平板品牌
*/
public abstract void Modle();
}
//三星平板
class SamsangPad extends Pad {
@Override
public void Modle() {System.out.println("开始生产三星平板电脑...");}
}
//ipad
class IPad extends Pad {
@Override
public void Modle() { System.out.println("开始生产apple平板电脑...");}
}
//抽象工厂
abstract class AbstractPadFactory {
/**
* 生产手机
*/
public abstract phone createPhone();
/**
* 生产Pad
*/
public abstract Pad createPad();
}
//AppleStore
class AppleStore extends AbstractPadFactory{
//卖ipone
@Override
public phone createPhone() {return new iphone();}
//卖ipad
@Override
public Pad createPad() { return new IPad();}
}
//SamsangStore
class SamsangStore extends AbstractPadFactory{
//卖三星手机
@Override
public phone createPhone(){ return new samsungPhone();}
//卖三星平板
@Override
public Pad createPad() {return new SamsangPad();}
}
测试
public static void main(String[] args) {
//抽象工厂
AbstractPadFactory abstractPadFactory = new AppleStore();
abstractPadFactory.createPhone().phoneModel();
abstractPadFactory.createPad().Modle();
abstractPadFactory= new SamsangStore();
abstractPadFactory.createPhone().phoneModel();
abstractPadFactory.createPad().Modle();
结果
苹果手机开始生产...
开始生产apple平板电脑...
三星手机开始生产...
开始生产三星平板电脑...
比较
内容 | 简单工厂 | 简单工厂(反射) | 方法工厂 | 普通工厂 | 抽象工厂 |
---|---|---|---|---|---|
特点 | 一个具体的类,通过createPhones方法利用if或者 switch创建产品并返回,静态 | 一个具体的类,通过createPhones方法利用反射机制生成对象返回 | 不同产品,提供不同的生产方法 | 把简单工厂中具体的工厂类,划分成抽象工厂层和具体的工厂子类层 | 多产品系 |
优点 | 简单,易理解 | 较简单工厂,代码简单 | 容错率高,方便 | 松耦合,面向对象(具体方法) | 面向对象,多产品实现共同生产 |
缺点 | 扩展性差,紧耦合 | 使用发射,效率低下 | 代码较复杂 | 每次新增一个具体产品类,也要同时新增一个具体工厂类 | 容易造成紧耦合 |
THE END