设计模式学习笔记---工厂模式（Java版）

详细分类

一、简单工厂模式

二、工厂方法模式

三、抽象工厂模式

一、简单工厂模式



简单工厂模式的工厂类一般是使用静态方法，通过接收的参数的不同来返回不同的对象实例。不修改代码的话，是无法扩展的。



无工厂模式

package com.lgd.simplefactory;

public interface Car {
	void run();
}

package com.lgd.simplefactory;

public class Byd implements Car {

	@Override
	public void run() {
		// TODO Auto-generated method stub
		System.out.println("byd is runing");
	}

}

package com.lgd.simplefactory;

public class Audi implements Car {

	@Override
	public void run() {
		// TODO Auto-generated method stub
		System.out.println("audi is runing");
	}

}

client

package com.lgd.simplefactory;
/**
 * 测试没有工厂模式的情况下
 * @author Administrator
 *
 */
public class Client01 {

	public static void main(String[] args) {
		Car c1 = new Audi();
		Car c2 = new Byd();
		c1.run();
		c2.run();
	}
}

简单工厂模式

package com.lgd.simplefactory;

public class CarFactory {
	//方式1
	public static Car createCar(String type)
	{
		if("audi".equals(type))
		{
			return new Audi();
		}
		else if("byd".equals(type)){
			return new Byd();
		}
		else {
			return null;
		}
	}
	//方式2
	/*public static Car createAudi()
	{
		return new Audi();
	}
	public static Car createByd()
	{
		return new Byd();
	}*/
	
}

package com.lgd.simplefactory;
/**
 * 测试简单工厂模式的情况下
 * @author Administrator
 *
 */
public class Client02 {

	public static void main(String[] args) {
		Car c1 = CarFactory.createCar("audi");
		Car c2 = CarFactory.createCar("byd");
		c1.run();
		c2.run();
	}
}

二、工厂方法模式

工厂方法是针对每一种产品提供一个工厂类。通过不同的工厂实例来创建不同的产品实例。在同一等级结构中，支持增加任意产品。



interface Car

class Audi implements Car

class Byd implements Car

package com.lgd.factorymethod;

public interface CarFactory {
	Car createCar();
}

package com.lgd.factorymethod;

public class AudiFactory implements CarFactory {

	@Override
	public Car createCar() {
		// TODO Auto-generated method stub
		return new Audi();
	}

}

package com.lgd.factorymethod;

public class BydFactory implements CarFactory {

	@Override
	public Car createCar() {
		// TODO Auto-generated method stub
		return new Benz();
	}

}

client

package com.lgd.factorymethod;
/**
 * 工厂方法模式
 * @author Administrator
 *
 */
public class Client {
	public static void main(String[] args) {
		Car c1 = new AudiFactory().createCar();
		Car c2 = new BydFactory().createCar();
		c1.run();
		c2.run();
		//新增  不用改变原有类
		Car c3 = new BenzFactory().createCar();
		c3.run();
	}
	
}

新增

package com.lgd.factorymethod;

public class Benz implements Car {

	@Override
	public void run() {
		// TODO Auto-generated method stub
		System.out.println("benz is runing");
	}

}

package com.lgd.factorymethod;

public class BenzFactory implements CarFactory {

	@Override
	public Car createCar() {
		// TODO Auto-generated method stub
		return new Byd();
	}

}

三、抽象工厂模式



抽象工厂是应对产品族概念的。比如说，每个汽车公司可能要同时生产轿车，货车，客车，那么每一个工厂都要有创建轿车，货车和客车的方法。

应对产品族概念而生，增加新的产品线很容易，但是无法增加新的产品。

1、

interface Tyre

class LuxuryTyre implements Tyre

class LowTyre implements Tyre

interface Seat

class LuxurySeat implements Seat

class LowSeat implements Seat

interface Engine

class LuxuryEngine implements Engine

class LowEngine implements Engine

package com.lgd.abstractfactory;

public interface Tyre {
	void revolve();
}

class LuxuryTyre implements Tyre
{

	@Override
	public void revolve() {
		// TODO Auto-generated method stub
		System.out.println("高：轮胎好");
	}
}

class LowTyre implements Tyre{

	@Override
	public void revolve() {
		// TODO Auto-generated method stub
		System.out.println("低：轮胎差");
	}
	
}

package com.lgd.abstractfactory;

public interface Seat {
	void massage();
}

class LuxurySeat implements Seat
{

	@Override
	public void massage() {
		// TODO Auto-generated method stub
		System.out.println("高，软");
	}
	
}

class LowSeat implements Seat{

	@Override
	public void massage() {
		// TODO Auto-generated method stub
		System.out.println("低，硬");
	}
	
}

package com.lgd.abstractfactory;

public interface Engine {
	void run();
	void start();
}

class LuxuryEngine implements Engine{

	@Override
	public void run() {
		// TODO Auto-generated method stub
		System.out.println("快");
	}

	@Override
	public void start() {
		// TODO Auto-generated method stub
		System.out.println("启动快");
	}
	
}

class LowEngine implements Engine
{

	@Override
	public void run() {
		// TODO Auto-generated method stub
		System.out.println("慢");
	}

	@Override
	public void start() {
		// TODO Auto-generated method stub
		System.out.println("启动慢");
	}
}

2、

package com.lgd.abstractfactory;

public interface CarFactory {
	Engine createEngine();
	Seat createSeat();
	Tyre createTyre();
	
}

package com.lgd.abstractfactory;

public class LowCarFactory implements CarFactory {

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

	@Override
	public Seat createSeat() {
		// TODO Auto-generated method stub
		return new LowSeat();
	}

	@Override
	public Tyre createTyre() {
		// TODO Auto-generated method stub
		return new LowTyre();
	}

}

package com.lgd.abstractfactory;

public class LuxuryCarFactory implements CarFactory {

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

	@Override
	public Seat createSeat() {
		// TODO Auto-generated method stub
		return new LuxurySeat();
	}

	@Override
	public Tyre createTyre() {
		// TODO Auto-generated method stub
		return new LuxuryTyre();
	}

}

3、Client

package com.lgd.abstractfactory;

public class Client {
	public static void main(String[] args) {
		CarFactory factory = new LuxuryCarFactory();
		Engine e = factory.createEngine();
		e.run();
		e.start();
	}
}

小结

★工厂模式中，重要的是工厂类，而不是产品类。产品类可以是多种形式，多层继承或者是单个类都是可以的。但要明确的，工厂模式的接口只会返回一种类型的实例，这是在设计产品类的时候需要注意的，最好是有父类或者共同实现的接口。

★使用工厂模式，返回的实例一定是工厂创建的，而不是从其他对象中获取的。

★工厂模式返回的实例可以不是新创建的，返回由工厂创建好的实例也是可以的。



区别

简单工厂 ： 用来生产同一等级结构中的任意产品。（对于增加新的产品，无能为力）

工厂方法 ：用来生产同一等级结构中的固定产品。（支持增加任意产品）

抽象工厂 ：用来生产不同产品族的全部产品。（对于增加新的产品，无能为力；支持增加产品族）



以上三种工厂 方法在等级结构和产品族这两个方向上的支持程度不同。所以要根据情况考虑应该使用哪种方法。