===============================================================
简单工厂模式 别名:静态工厂方法模式
该案例有如下几个元素:
产品接口:
具体产品:
静态工厂类:
客户类:
代码如下:
产品接口:
package 创建型模式.简单工厂模式;
/**
* 抽象汽车类
* @author victor
*@time 2013---2013-7-20---上午10:05:30
*@package 创建型模式.简单工厂模式
*/
public abstract class Auto {
//车型名称
private String name;
//抽象的工作方法
abstract public void run();
//获得车型名称的方法
public String getName(){
return name;
}
//设置车型名称方法
public void setName(String name){
this.name=name;
}
}
具体产品类:
package 创建型模式.简单工厂模式;
public class Bus extends Auto {
public Bus(){
this.setName("巴士");
}
@Override
public void run() {
// TODO Auto-generated method stub
System.out.println("启动"+this.getName());
}
}
package 创建型模式.简单工厂模式;
public class Car extends Auto {
//构造方法
public Car(){
this.setName("轿车");
}
@Override
public void run() {
// TODO Auto-generated method stub
System.out.println("启动"+this.getName());
}
}
package 创建型模式.简单工厂模式;
public class Truck extends Auto {
public Truck(){
this.setName("卡车");
}
@Override
public void run() {
// TODO Auto-generated method stub
System.out.println("启动"+this.getName());
}
}
静态工厂类:
package 创建型模式.简单工厂模式;
import javax.management.RuntimeErrorException;
public class StaticFactory {
/**
* 工厂方法
*/
/**
* 工厂方法
* @param 车型编号
* @return 具体车对象
*/
public static Auto createAuto(int autoId){
switch (autoId) {
case 1:
return new Car();
case 2:
return new Truck();
case 3:
return new Bus();
default:
throw new RuntimeException("没有本类型的车");
}
}
}
客户类:
package 创建型模式.简单工厂模式;
public class Client {
/**
* 简单工厂方法的优点:
* 用代码和具体使用的类耦合度降低
* 令 创建和使用的代码向分离,可以独立的变化,易于扩展
*
* 缺点:
* 当产品类曾多时,工厂类只有一个,只能以不变应万变,这就是该模式的缺点
*
*
*
*/
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
//调用静态工厂里的方法创建对象
Auto auto=StaticFactory.createAuto(1);
auto.run();
Auto auto2=StaticFactory.createAuto(2);
auto2.run();
Auto auto3=StaticFactory.createAuto(3);
auto3.run();
}
}
========================================================================================================================================================================================================================================================================
工厂方法模式:
在工厂方法模式的实例中,Auto汽车抽象的代码并没有改变
package 创建型模式.工厂方法模式;
public abstract class Auto {
//车型名称
private String name;
//抽象的工作方法
abstract public void run();
//获得车型名称的方法
public String getName(){
return name;
}
//设置车型名称方法
public void setName(String name){
this.name=name;
}
}
package 创建型模式.工厂方法模式;
public class Truck extends Auto {
public Truck(){
this.setName("卡车");
}
@Override
public void run() {
// TODO Auto-generated method stub
System.out.println("启动"+this.getName());
}
}
package 创建型模式.工厂方法模式;
public class Bus extends Auto {
public Bus(){
this.setName("汽车");
}
@Override
public void run() {
// TODO Auto-generated method stub
System.out.println("启动"+this.getName());
}
}
package 创建型模式.工厂方法模式;
public class Car extends Auto {
public Car(){
this.setName("轿车");
}
@Override
public void run() {
// TODO Auto-generated method stub
System.out.println("启动"+this.getName());
}
}
工厂的抽象层次代码:
package 创建型模式.工厂方法模式;
public abstract class Factory {
/**
* 抽象生产方法,将被子类重写,
* return Auto的子类实例
*/
abstract public Auto createAuto();
}
轿车工厂类:
package 创建型模式.工厂方法模式;
public class CarFactory extends Factory {
/**
* 重写父类生产方法
*/
@Override
public Auto createAuto() {
// TODO Auto-generated method stub
return new Car();
}
}
package 创建型模式.工厂方法模式;
public class BusFactory extends Factory {
@Override
public Auto createAuto() {
// TODO Auto-generated method stub
return new Bus();
}
}
package 创建型模式.工厂方法模式;
public class TruckFactory extends Factory {
@Override
public Auto createAuto() {
// TODO Auto-generated method stub
return new Truck();
}
}
客户端:
package 创建型模式.工厂方法模式;
public class Client2 {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
//调用工厂方法创建不同的对象
//创建变量,(使用抽象类描述,面向接口的编程)
Factory factory;
Auto auto;
//创建Car
factory=new CarFactory();//创
auto=factory.createAuto();//创建
auto.run();
//创建Bus
factory=new BusFactory();
auto=factory.createAuto();
auto.run();
//创建Truck
factory=new TruckFactory();
auto=factory.createAuto();
auto.run();
}
}
oooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo
下面在举个例子讲述工厂方法模式,:货物上架问题:
1。首先是一个货物抽象类:
有货物的名称,货物的宽度
package 创建型模式.工厂方法模式.货架;
public abstract class Goods {
//货物的名称,一厘米做单位
private int width;
private String name;
public int getWidth() {
return width;
}
public void setWidth(int width) {
this.width = width;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
2.然后又三个类,分别是货物类,电视,电话,床
package 创建型模式.工厂方法模式.货架;
public class Phone extends Goods{
public Phone(){
super();
this.setName("电话机");
this.setWidth(20);
}
}
package 创建型模式.工厂方法模式.货架;
public class TV extends Goods {
//构造方法
public TV(){
super();
this.setName("电视机");
this.setWidth(100);
}
}
package 创建型模式.工厂方法模式.货架;
public class Bed extends Goods {
public Bed(){
super();
this.setName("双人床");
this.setWidth(300);
}
}
3.此时是一个货架抽象类:
货架的最大宽度,货架的名称
package 创建型模式.工厂方法模式.货架;
public abstract class Shelf {
private int maxWidth;//货架的宽度
private String shelfname;//货架的名称
public int getMaxWidth() {
return maxWidth;
}
public void setMaxWidth(int maxWidth) {
this.maxWidth = maxWidth;
}
public String getShelfname() {
return shelfname;
}
public void setShelfname(String shelfname) {
this.shelfname = shelfname;
}
public void put(Goods goods){
System.out.println("将"+goods.getName()+"放入"+this.getShelfname());
}
}
此类有两个子类:
大货架,小货架
package 创建型模式.工厂方法模式.货架;
public class BigShelf extends Shelf {
public BigShelf(){
super();
this.setShelfname("大型货架类");
this.setMaxWidth(200);
}
}
package 创建型模式.工厂方法模式.货架;
public class SmallShelf extends Shelf {
public SmallShelf(){
super();
this.setShelfname("小型货架类");
this.setMaxWidth(90);
}
}
4货架抽象工厂类:
package 创建型模式.工厂方法模式.货架;
public abstract class ShelfFactory {
private int maxWidth;
public int getMaxWidth() {
return maxWidth;
}
public void setMaxWidth(int maxWidth) {
this.maxWidth = maxWidth;
}
abstract public Shelf createShelf();
}
下面是两个实现类与生产的两种货架一一对应
小型货架工厂:
package 创建型模式.工厂方法模式.货架;
public class SmallShelfFacroty extends ShelfFactory {
public SmallShelfFacroty(){
super();
this.setMaxWidth(new SmallShelf().getMaxWidth());
}
@Override
public Shelf createShelf() {
// TODO Auto-generated method stub
return new SmallShelf();
}
}
大型货架工厂
package 创建型模式.工厂方法模式.货架;
public class BigShelfFactory extends ShelfFactory {
public BigShelfFactory(){
super();
this.setMaxWidth(new BigShelf().getMaxWidth());
}
@Override
public Shelf createShelf() {
// TODO Auto-generated method stub
return new BigShelf();
}
}
由于客户端使用这三个抽象层次时,会发现很麻烦,所有涉及一个助手类:
package 创建型模式.工厂方法模式.货架;
import java.util.ArrayList;
import java.util.List;
public class PlaceGoodsHelper {
public synchronized static void placegoods(Goods goods){
List<ShelfFactory> shelflist=new ArrayList<ShelfFactory>();
shelflist.add(new SmallShelfFacroty());
shelflist.add(new BigShelfFactory());
//货架的变量
Shelf rightshelf;
for (ShelfFactory sf:shelflist) {
//货架合适
if (sf.getMaxWidth()>=goods.getWidth()) {
//实例化特定的货架,放置货物
try {
rightshelf=sf.createShelf();
rightshelf.put(goods);
return;
} catch (Exception e) {
// TODO: handle exception
}
}
throw new RuntimeException("么有找到合适的框架");
}
}
}
客户端类:
package 创建型模式.工厂方法模式.货架;
import java.util.ArrayList;
import java.util.List;
public class Client3 {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
List<Goods> goodslist=new ArrayList<Goods>();
goodslist.add(new TV());
goodslist.add(new Phone());
goodslist.add(new Bed());
System.out.println("货物初始化完毕");
for (Goods goods:goodslist) {
try {
PlaceGoodsHelper.placegoods(goods);
} catch (Exception e) {
// TODO: handle exception
}
}
System.out.println("货物放置完毕");
}
}
总结:
工厂方法模式是设计模式中应用最为广泛的模式之一。
工厂方法模式要解决的就是对象的创建时机问题,它提供了一种扩展的策略,这很好的符合了开放--封闭的原则。