今天学习了一下工厂模式(Factory),平时编程的时候需要对象的时候,会使用到大量的new关键字,现在如果使用工厂方法,我们可以必须公开实例化使用new关键字了;
(一) 工厂模式又分了,简单工厂模式,抽象工厂模式,工厂方法模式,首先看下工厂方法模式的类图:
上面的类图声明了两个抽象类,生成Weapon的抽象工厂类,然后要生产具体的Weapon的之类工厂去实现,还有一个Weapon抽象类,并且定义了一个attack()的抽象方法,子类去继承Weapon类,并且同时实现attack()方法。
在客户端进行使用的时候只要WeaponFactory factory=new XXXFactory() 这里可以new一个具体的实现类即可。。
看下代码实现:
①:Weapon接口类和对应的实现类
package com.jiangqq.dp.simplefactory;
//武器的接口类
public interface Weapon {
//同时里面声明一个需要子类实现的方法
public void attack();
}
package com.jiangqq.dp.simplefactory;
//具体的轰炸机类
public class Bomber implements Weapon {
@Override
public void attack() {
// TODO Auto-generated method stub
System.out.println("轰炸机发射.....");
}
}
package com.jiangqq.dp.simplefactory;
//具体的机枪的类
public class Gun implements Weapon {
@Override
public void attack() {
// TODO Auto-generated method stub
System.out.println("机枪发射子弹....");
}
}
②:WeaponFactory工厂和具体的创建对象工厂实现类:
package com.jiangqq.dp.simplefactory;
//武器的创建接口类
public interface WeaponFactory {
public Weapon create();
}
package com.jiangqq.dp.simplefactory;
//机枪的具体实现类
public class GunFactory implements WeaponFactory {
//创建一个具体的机枪对象
@Override
public Weapon create() {
return new Gun();
}
}
package com.jiangqq.dp.simplefactory;
//轰炸机的具体实现类
public class BomberFactory implements WeaponFactory {
//创建一个具体的轰炸机对象
@Override
public Weapon create() {
return new Bomber();
}
}
③:下面是Client测试方法:
package com.jiangqq.dp.simplefactory;
/**=================================
* 简单工厂模式测试客户端
* @author jiangqq
* @time 2012/3/15 20:57
* ====================================
*/
public class ClientTest {
public static void main(String[] args) {
//声明一个可以生成机枪对象的工厂
WeaponFactory factory1 = new GunFactory();
//创建出对象的Weapon,--->Gun
Weapon weapon1=factory1.create();
//调用具体方法...
weapon1.attack();
WeaponFactory factory2 = new BomberFactory();
Weapon weapon2=factory2.create();
weapon2.attack();
}
}
运行效果如下:
使用接口,工厂方法,我们可以很好的去把类中相同的实现方法抽取能接口,这样我们就可以进行面向接口编程,并且在工厂实现类中进行对象的实例化,有效减了少在Client端调用的时候公开化的new实例化对象........
但是如果我们要一次性的生成一系列的产品的时候,如果还是使用工厂方法模式的话,那就在客户端实例化的对象将会一次性成倍增加,这就需要用到抽象工厂模式了。
(二)接着我们来看看另一种工厂模式---抽象工厂模式,同样先看一下类图:
直接看这张图有点复杂:简单的解释一下:上面有三个抽象类分别是
①:抽象工厂类(AbstractFactory):并且其中声明了两个创建具体对象的方法,让它的实现类继承并且实现,其中实现它的FirstFactory和SecondFactory是具体工厂生成出来的产品,且可以生成出一系列的对象如:Apple,Bomber...
②:下面两个为Fruits,Weapon抽象类,并且具体子类去实现,可以实例化具体的对象,
先看如客户端测试的代码
package com.jiangqq.dp.abstractfactory;
/*
* ==========================================
* 抽象工厂模式测试客户端
* @author jiangqq
* @time 2012/3/15/ 21:28 =============================================
*/
public class ClientTest {
public static void main(String[] args) {
System.out.println("第一个工厂================================");
//生成一个具体的产品
AbstractFactory factory1 = new FirstFactory();
//得到weapon
Weapon weapon1 = factory1.createWeapon();
//得到fruits
Fruits fruits1 = factory1.createFruits();
//根据生成的对象调用具体的方法
weapon1.attack();
fruits1.eat();
System.out.println("第二个工厂================================");
AbstractFactory factory2 = new SecondFactory();
Weapon weapon2 = factory2.createWeapon();
Fruits fruits2 = factory2.createFruits();
weapon2.attack();
fruits2.eat();
}
}
工厂类:
package com.jiangqq.dp.abstractfactory;
//工厂抽象类
public abstract class AbstractFactory {
//定义创建武器类,让继承它的具体工厂类具体去实现
public abstract Weapon createWeapon();
//定义创建水果类,让继承它的具体工厂类具体去实现
public abstract Fruits createFruits();
}
package com.jiangqq.dp.abstractfactory;
//具体生产对象类
public class FirstFactory extends AbstractFactory {
//生产出机枪
@Override
public Weapon createWeapon() {
return new Gun();
}
//生成出香蕉
@Override
public Fruits createFruits() {
return new Banana();
}
}
package com.jiangqq.dp.abstractfactory;
//具体生产对象类
public class SecondFactory extends AbstractFactory {
// 生产出轰炸机
@Override
public Weapon createWeapon() {
return new Bomber();
}
// 生产出苹果
@Override
public Fruits createFruits() {
return new Apple();
}
}
Fruits类:
package com.jiangqq.dp.abstractfactory;
//水果抽象类
public abstract class Fruits {
//声明的水果的方法,具体让子类去实现
public abstract void eat();
}
package com.jiangqq.dp.abstractfactory;
//苹果具体类
public class Apple extends Fruits {
//实现苹果的方法
@Override
public void eat() {
System.out.println("吃这苹果.....");
}
}
package com.jiangqq.dp.abstractfactory;
//香蕉具体类
public class Banana extends Fruits {
//实现香蕉的方法
@Override
public void eat() {
System.out.println("吃着香蕉.....");
}
}
Weapon类:
package com.jiangqq.dp.abstractfactory;
//武器抽象类
public abstract class Weapon {
//声明武器的方法,具体让子类去实现
public abstract void attack();
}
package com.jiangqq.dp.abstractfactory;
//机枪的具体类
public class Gun extends Weapon{
//实现机枪的方法
public void attack() {
// TODO Auto-generated method stub
System.out.println("机枪发射子弹....");
}
}
package com.jiangqq.dp.abstractfactory;
//轰炸机的具体实现类
public class Bomber extends Weapon {
//实现轰炸机的方法
@Override
public void attack() {
// TODO Auto-generated method stub
System.out.println("轰炸机发射.....");
}
}
虽然使用抽象工厂模式,在我们需要一次性实例化一系列的产品的时候,方便很多,但是如果需要增加新的产品的时候,那么类的数量也会成倍的增加,所以说使用工厂方法或者抽象工厂都会有利有弊的,决定于具体场合我们去实现;
最后一个是简单工厂模式,但是简单工厂模式不是严格意义上的设计模式,所以这里也没有具体列出来....
分享到:
相关推荐
设计模式学习笔记,分析了GOF的23种模式和类设计的原则
Java设计模式学习笔记
我收集的设计模式的学习笔记,采用pdf格式,便于收藏和查看
各个模式都有详细的例子C#学习笔记,打开就知道了
设计模式学习笔记(一)--简单工厂模式源码和类图
HeadFirst设计模式学习笔记比较全面详细地讲解了13个设计模式,有利于大家更好的学习HeadFirst设计模式,希望亲们会喜欢~~~
总结了java开发中的21种设计模式,详解和例子,带书签的pdf格式,方便阅读!
设计模式学习笔记.ppt 自己写的一点学习笔记。
设计模式学习笔记,总共23个设计模式,还有几个设计原则
Head First 设计模式学习笔记。更多内容请参见文章内容。
23种设计模式学习笔记及源码,全部原创 欢迎提出意见和建议
学习Java设计模式的笔记,标注了其中重要的要点,如果有需要的小伙伴,自行下载哦
设计模式学习笔记--Flyweight享元模式.docx设计模式学习笔记--Flyweight享元模式.docx设计模式学习笔记--Flyweight享元模式.docx设计模式学习笔记--Flyweight享元模式.docx设计模式学习笔记--Flyweight享元模式.docx
设计模式之美—学习笔记,纯手打,学习极客时间课程得到。 如有意见或建议,欢迎联系,一起学习讨论。
代理模式学习笔记、单例模式学习笔记、命令模式、原型模式、模式特点总结。 为个人对设计模式的理解,如果有理解不一致的不要砸砖啊
学习设计模式入门的好材料 简单明了,一看就懂 帮助你快速学习或是复习23种设计模式
设计模式学习笔记-命令模式
java设计模式的学习笔记,其中包含各种模式的代码实现
资源名称:设计模式C 学习笔记资源目录:【】设计模式C 学习笔记源代码【】设计模式C 学习笔记目录【】设计模式C 学习笔记(1)【】设计模式C 学习笔记(2)【】设计模式C 学习笔记(3)【】设计模式C 学习笔记(4)...
Head.First 设计模式学习笔记.pdf Head.First 设计模式学习笔记.pdf