跟着实例学习设计模式(4)-抽象工厂(创建型)

前端之家收集整理的这篇文章主要介绍了跟着实例学习设计模式(4)-抽象工厂(创建型)前端之家小编觉得挺不错的,现在分享给大家,也给大家做个参考。

抽象工厂属于创建型设计模式

设计意图:提供一个接口,可以创建一系列相关或相互依赖的对象,而无须指定它们具体的类。

光看设计意图有些抽象,不好理解,让我们来看一下实例类图,结合类图我们再做具体的解释,相信会让大家豁然开朗的。我们以生产汽车为例,我们生产的汽车分两个系列,小车、卡车,每个系列汽车都有发动机和油箱。

上图:

IAbstrcatFactory:抽象工厂接口,声明创建抽象产品的方法

CarFactory:小车工厂实现类。

TrunkFactory:卡车工厂实现类。

这里我们为每个系列提供一个工厂实现类,记住这就是抽象工厂的核心,就是有几个系列就有几个创建工厂实现类,如果我们的系列又增加一个跑车,那我们就需要增加一个跑车工厂实现类。

IVehicle:汽车产品接口,声明生产汽车的方法

Car:小车实现类。

Trunk:卡车实现类。

IEngine:发动机产品接口,声明生产发动机的方法

CarEngine:小车发动机实现类。

TrunkEngine:卡车发动机实现类。

ITank:油箱产品接口,声明生产油箱的方法

CarTank:小车油箱产品。

TrunkTank:卡车油箱产品。

每个产品都有一个抽象接口,我们的创建也是针对这些抽象接口,在client中,我们的创建过程都是封闭的,你只到这个接口创建的谁,但是你不知道它是怎么被创建出来的。让我们来先看client的代码

package com.factory.abstrcatfactory;

import com.factory.abstrcatfactory.factory.CarFactory;
import com.factory.abstrcatfactory.factory.IAbstrcatFactory;
import com.factory.abstrcatfactory.factory.TrunkFactory;
import com.factory.abstrcatfactory.model.Engine;
import com.factory.abstrcatfactory.model.Tank;
import com.factory.abstrcatfactory.model.Vehicle;
import com.factory.abstrcatfactory.product.IEngine;
import com.factory.abstrcatfactory.product.ITank;
import com.factory.abstrcatfactory.product.IVehicle;

public class Client {

	/**抽象工厂
	 * 有几个抽象系列产品就有几个工厂,每个工厂负责创见该系列的产品
	 * 每个系统产品都有多个子产品,每个子产品都有一个接口类
	 * @author gaoxu
	 * @param args
	 */
	public static void main(String[] args) {
		
		//小车抽象对象的创建
		IAbstrcatFactory carFactory = new CarFactory();
		//小车发动机
		IEngine engineC = carFactory.createEngineObject();
		Engine carEngine= engineC.createEngine();
		//小车油箱
		ITank tankC = carFactory.createTankObject();
		Tank catTank = tankC.createTank();
		
		IVehicle vehicleC = carFactory.createVehicleObject();
		//创建出来小车
		Vehicle car = vehicleC.createVehicle(carEngine,catTank);
		
		//////////////////////////////////////////////////////////
		
		//卡车抽象对象的创建
		IAbstrcatFactory trunkFactory = new TrunkFactory();
		//卡车发动机
		IEngine engineT = trunkFactory.createEngineObject();
		Engine trunkEngine = engineT.createEngine();
		//卡车油箱
		ITank tankT = trunkFactory.createTankObject();
		Tank trunkTank = tankT.createTank();
		
		IVehicle vehicleT = trunkFactory.createVehicleObject();
		//创建出来卡车
		Vehicle trunk = vehicleT.createVehicle(trunkEngine,trunkTank);
				
		
		
		
	}

}

找找代码中,我们看不到具体的产品生成类,只能看到不同的创建方法,所以抽象工厂面对的是抽象的产品生产,汽车是一个抽象的产品概念,它由小车、卡车抽象而来,而我们现在要实现他们的抽象基础中的各个产品,这样使用抽象工厂那就再合适不过了,我们也可以看到,发动机、油箱都是有两个抽象基础的,小车和卡车。

而且如果抽象产品又增加一个抽象基础,例如:跑车,那么我们只需要在client中增加一段和跑车相关的代码,并且增加一个系统的工厂实现和产品实现类就可以,完全是不会影响到其它系列产品的代码

两个系统,两个工厂实现。

package com.factory.abstrcatfactory.factory;

import com.factory.abstrcatfactory.product.IEngine;
import com.factory.abstrcatfactory.product.ITank;
import com.factory.abstrcatfactory.product.IVehicle;

/**
 * @author gaoxu
 * 实践出真知!
 */
public interface IAbstrcatFactory {
	
	
	/**
	 * @author gaoxu
	 * @return
	 */
	public ITank createTankObject();
	/**
	 * @author gaoxu
	 * @return
	 */
	public IEngine createEngineObject();
	/**
	 * @author gaoxu
	 * @return
	 */
	public IVehicle createVehicleObject();
}

package com.factory.abstrcatfactory.factory;

import com.factory.abstrcatfactory.product.Car;
import com.factory.abstrcatfactory.product.CarEngine;
import com.factory.abstrcatfactory.product.CarTank;
import com.factory.abstrcatfactory.product.IEngine;
import com.factory.abstrcatfactory.product.ITank;
import com.factory.abstrcatfactory.product.IVehicle;

/**小车工厂实现
 * @author gaoxu
 * 实践出真知!
 */
public class CarFactory implements IAbstrcatFactory{

	@Override
	public ITank createTankObject() {
		
		return new CarTank();
	}

	@Override
	public IEngine createEngineObject() {
		
		return new CarEngine();
	}

	@Override
	public IVehicle createVehicleObject() {
		
		return new Car();
	}

}

package com.factory.abstrcatfactory.factory;

import com.factory.abstrcatfactory.product.IEngine;
import com.factory.abstrcatfactory.product.ITank;
import com.factory.abstrcatfactory.product.IVehicle;
import com.factory.abstrcatfactory.product.Trunk;
import com.factory.abstrcatfactory.product.TrunkEngine;
import com.factory.abstrcatfactory.product.TrunkTank;

/**卡车工厂实现
 * @author gaoxu
 * 实践出真知!
 */
public class TrunkFactory implements IAbstrcatFactory{

	@Override
	public ITank createTankObject() {
		
		return new  TrunkTank();
	}

	@Override
	public IEngine createEngineObject() {
		
		return new TrunkEngine();
	}

	@Override
	public IVehicle createVehicleObject() {
		
		return new Trunk();
	}

}

汽车产品、发动机产品、油箱产品

他们之间的关系是一种聚合关系。


package com.factory.abstrcatfactory.product;

import com.factory.abstrcatfactory.model.Engine;
import com.factory.abstrcatfactory.model.Tank;
import com.factory.abstrcatfactory.model.Vehicle;

/**汽车产品接口
 * @author gaoxu
 * 实践出真知!
 */
public interface IVehicle {
	public Vehicle createVehicle(Engine engine,Tank tank);
}

package com.factory.abstrcatfactory.product;

import com.factory.abstrcatfactory.model.Engine;
import com.factory.abstrcatfactory.model.Tank;
import com.factory.abstrcatfactory.model.Vehicle;

/**小汽车产品实现
 * @author gaoxu
 * 实践出真知!
 */
public class Car implements IVehicle{

	@Override
	public Vehicle createVehicle(Engine engine,Tank tank) {
		Vehicle car = new Vehicle();
		
		car.setEngine(engine);
		car.setTank(tank);
		return car;
	}

}

package com.factory.abstrcatfactory.product;

import com.factory.abstrcatfactory.model.Engine;
import com.factory.abstrcatfactory.model.Tank;
import com.factory.abstrcatfactory.model.Vehicle;

/**卡车产品实现
 * @author gaoxu
 * 实践出真知!
 */
public class Trunk implements IVehicle{

	@Override
	public Vehicle createVehicle(Engine engine,Tank tank) {
		Vehicle trunk = new Vehicle();
		trunk.setEngine(engine);
		trunk.setTank(tank);
		return trunk;
	}

}
package com.factory.abstrcatfactory.product;

import com.factory.abstrcatfactory.model.Engine;

/**发送机产品接口
 * @author gaoxu
 * 实践出真知!
 */
public interface IEngine {
	public Engine createEngine();
}

package com.factory.abstrcatfactory.product;

import com.factory.abstrcatfactory.model.Engine;

/**小车发送机产品实现
 * @author gaoxu
 * 实践出真知!
 */
public class CarEngine implements IEngine{

	@Override
	public Engine createEngine() {
		// TODO Auto-generated method stub
		return null;
	}

}

package com.factory.abstrcatfactory.product;

import com.factory.abstrcatfactory.model.Engine;

/**卡车发动机产品实现
 * @author gaoxu
 * 实践出真知!
 */
public class TrunkEngine implements IEngine{

	@Override
	public Engine createEngine() {
		// TODO Auto-generated method stub
		return null;
	}

}

package com.factory.abstrcatfactory.product;

import com.factory.abstrcatfactory.model.Tank;

/**油箱产品接口
 * @author gaoxu
 * 实践出真知!
 */
public interface ITank {
	public Tank createTank();
}

package com.factory.abstrcatfactory.product;

import com.factory.abstrcatfactory.model.Tank;

/**小车油箱产品实现
 * @author gaoxu
 * 实践出真知!
 */
public class CarTank implements ITank{

	@Override
	public Tank createTank() {
		
		return null;
	}

}

package com.factory.abstrcatfactory.product;

import com.factory.abstrcatfactory.model.Tank;

/**卡车油箱产品实现
 * @author gaoxu
 * 实践出真知!
 */
public class TrunkTank implements ITank{

	@Override
	public Tank createTank() {
		// TODO Auto-generated method stub
		return null;
	}

}

通过一个生产汽车的实例,我们可以很清楚的认识到抽象工厂模式的灵活性、所有的产品在创建的时候基本都是非耦合的,我们只需要根据它们之间的聚合关系来组合它们就行。

总结抽象工厂的优点与缺点:

1:解耦与封装是抽象工厂最大的优点。

2:可以灵活应对产品系列的增加需求。

缺点:

1:每增加一个产品系列,代码工作量太大。

由此我们也可以理解,设计模式的应用并不能完美的解决一切问题,所以还要看我们具体的侧重点是什么。




原文链接:https://www.f2er.com/javaschema/284645.html

猜你在找的设计模式相关文章