工厂模式

最新推荐文章于 2026-01-01 15:45:23 发布

转载最新推荐文章于 2026-01-01 15:45:23 发布 · 75 阅读

0 ·

CC 4.0 BY-SA版权

原文链接：https://my.oschina.net/kimspan/blog/552581

文章标签：

#python

本文详细介绍了四种工厂模式：普通工厂模式、多个工厂方法模式、静态工厂模式及抽象工厂模式，并通过宝马和奔驰汽车的例子展示了每种模式的具体实现过程。

2019独角兽企业重金招聘Python工程师标准>>>

1、普通工厂模式

以宝马和奔驰车为例
//创建二者接口
public interface Car{
    public void display();
}
//创建实现类
public class BwmCar implements Car{
    @Override
    public void display() {
	System.out.println("I am 宝马!");
    }
}

public class BenChiCar implements Car{
    @Override
    public void display() {
	System.out.println("I am 奔驰!");
    }
}
//创建工厂类
public class CarFactory {
    public Car produce(String type) {
	if ("bwm".equals(type)) {
		return new BwmCar();
	} else if ("benchi".equals(type)) {
		return new BenChiCar();
	} else {
		System.out.println("请输入正确的类型!");
		return null;
	}
    }
}

//测试一下
public class FactoryTest {
    public static void main(String[] args) {
	CarFactory  factory = new CarFactory ();
	Car car = factory.produce("bwm");
	car.display();
    }
}

2、多个工厂方法模式

//修改一下上面的工厂类
public class CarFactory {
    public Car produceBwmCar(){
	return new BwmCar();
    }
	
    public Car produceBenChiCar(){
	return new BenChiCar();
    }
}

//测试如下
public class FactoryTest {
    public static void main(String[] args) {
	CarFactory factory = new CarFactory();
	Car car = factory.produceBwmCar();
	car.display();
    }
}

3、静态工厂模式

public class CarFactory {
    public static Car produceBwmCar(){
	return new BwmCar();
    }
	
    public static Car produceBenChiCar(){
        return new BenChiCar();
    }
}

4、抽象工厂模式

工厂方法模式有一个问题就是，类的创建依赖工厂类，也就是说，如果想要拓展程序，必须对工厂类进行修改，这违背了闭包原则，所以，从设计角度看，有一定的问题，如何解决？
就用到抽象工厂模式，创建多个工厂类，这样一旦需要增加新的功能，直接增加新的工厂类就可以了，不需要修改之前的代码。
public interface Car{
	public void display();
}
两个实现类：
public class BwmCar implements Car{
	@Override
	public void display() {
		System.out.println("I am 宝马!");
	}
}
public class BenChiCar implements Car{

	@Override
	public void display() {
		System.out.println("I am 奔驰!");
	}
}
两个工厂类：
public class BwmCarFactory implements Provider {
	
	@Override
	public Car produce(){
		return new BwmCar();
	}
}
public class BenChiCarFactory implements Provider{

	@Override
	public Car produce() {
		return new BenChiCar();
	}
}
在提供一个接口：
public interface Provider {
	public Car produce();
}
测试类：
public class Test {

	public static void main(String[] args) {
		Provider provider = new SendMailFactory();
		Sender sender = provider.produce();
		sender.Send();
	}
}
其实这个模式的好处就是，如果你现在想增加一个品牌的车时，则只需做一个实现类，实现Car接口，同时做一个工厂类，实现Provider接口，就OK了，无需去改动现成的代码。

转载于:https://my.oschina.net/kimspan/blog/552581