工厂模式是java中常用的设计模式之一。它属于创建型设计模式;
创建型设计模式主要关注的是对象的创建过程,将对象的创建进行封装、抽象,客户端不需关心对象如何创建即可使用,有效的进行了业务解耦以及隔离。它主要分为:
1:单例模式;
2:简单工厂模式;
3:工厂方法模式;
4:抽象工厂模式;
5:建造者模式;
6:原型模式;
本文介绍2,3,4三个设计模式;
简单工厂设计模式
概念:简单工厂设计模式就相当于定义一个创建对象的统一入口,这样以来客户端只需要告诉工厂要创建什么类型的实例即可;
案例介绍:在很久以前人们生活中还没有汽车工厂时,若想得到一个汽车,那么每家每户都会去造车。如果有一天车子中某个零件的使用方式变化了,那么这时候每家每户都要去按照原先造车时放的零件给替换,由于每家车子按照方法也不同,导致维修也十分的困难。这样的持续发展,社会中就衍生出汽车工厂这一概念,统一了标准。
角色组成:抽象产品;具体产品;具体工厂;
代码演示:
案例介绍:沿用上一个案例,由于汽车品牌越来越多,同时也伴随着统一品牌下的车系种类越来越多,这个时候一个工厂中需要干的事情非常的多,越来越不专业;
角色组成:抽象产品;具体产品;抽象工厂;具体工厂;
代码演示:
概念:抽象工厂设计模式类似工厂方法,当抽象工厂产品族只有一个产品时就成为了工厂方法,也可以理解为工厂方法的升级版。抽象工厂主要是用于创建一个产品族。
案例介绍:现在有BWM工厂,但是现在BWM中各个系列中比如:引擎,轮毂等;那么BWM工厂需要生产出各个系列车子的不同产品。
角色组成:多个抽象产品、多个具体产品、抽象工厂、具体工厂。
代码演示:
创建型设计模式主要关注的是对象的创建过程,将对象的创建进行封装、抽象,客户端不需关心对象如何创建即可使用,有效的进行了业务解耦以及隔离。它主要分为:
1:单例模式;
2:简单工厂模式;
3:工厂方法模式;
4:抽象工厂模式;
5:建造者模式;
6:原型模式;
本文介绍2,3,4三个设计模式;
简单工厂设计模式
概念:简单工厂设计模式就相当于定义一个创建对象的统一入口,这样以来客户端只需要告诉工厂要创建什么类型的实例即可;
案例介绍:在很久以前人们生活中还没有汽车工厂时,若想得到一个汽车,那么每家每户都会去造车。如果有一天车子中某个零件的使用方式变化了,那么这时候每家每户都要去按照原先造车时放的零件给替换,由于每家车子按照方法也不同,导致维修也十分的困难。这样的持续发展,社会中就衍生出汽车工厂这一概念,统一了标准。
角色组成:抽象产品;具体产品;具体工厂;
代码演示:
抽象产品:
/**
* 抽象产品角色-汽车
*
* @author zx
**/
public abstract class Car {
private String name;
//....等等属性
public abstract void drive();
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
具体产品:
/**
* 具体产品角色-宝马车
*
* @author zx
**/
public class Bwm extends Car {
@Override
public void drive() {
System.out.println("bwm car driving");
}
}
/**
* 具体产品角色-奔驰车
*
* @author zx
**/
public class BanZ extends Car {
@Override
public void drive() {
System.out.println("BanZ car driving");
}
}
工厂:
/**
* 汽车简单工厂
*
* @author zx
**/
public class CarFactory {
public static Car createCar(String type) {
if (type == null || "".equals(type)) {
return null;
}
Car car = null;
switch (type) {
case "BWM":
car = new Bwm();
car.setName("BWM");
break;
case "BenZ":
car = new BanZ();
car.setName("BeanZ");
break;
default:
break;
}
return car;
}
}
工厂客户端:
/**
* 工厂客户端
*
* @author zx
**/
public class Client {
class Client1 {
public void doSomething() {
// 没有工厂时
Car bwm1 = new Bwm();
bwm1.setName("BWM"); // 如果这个时候由于业务需要把BWM改成宝马,把BanZ改成奔驰。自行对比对于系统的影响面
bwm1.drive();
// 有工厂
Car bwm = CarFactory.createCar("BWM");
bwm.drive();
}
}
class Client2 {
public void doSomething() {
// 没有工厂时
Car banZ1 = new BanZ();
banZ1.setName("BanZ"); // 如果这个时候由于业务需要把BWM改成宝马,把BanZ改成奔驰。自行对比对于系统的影响面
banZ1.drive();
// 有工厂
Car banZ = CarFactory.createCar("BanZ");
banZ.drive();
}
}
}
工厂方法设计模式
概念:工厂方法设计模式是对简单工厂设计模式的一种升华。原先是大工厂,现在可以根据面向对象抽象出某一类具有相同特性的工厂;由于简单工厂设计模式其实是违背了设计模式原则中的开闭原则。案例介绍:沿用上一个案例,由于汽车品牌越来越多,同时也伴随着统一品牌下的车系种类越来越多,这个时候一个工厂中需要干的事情非常的多,越来越不专业;
角色组成:抽象产品;具体产品;抽象工厂;具体工厂;
代码演示:
抽象产品:
/**
* 抽象产品-汽车
*
* @author zx
**/
public abstract class Car {
private String name;
// ...
public abstract void drive();
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
具体产品:
/**
* 具体产品-宝马车
*
* @author zx
**/
public class Bwm extends Car {
@Override
public void drive() {
System.out.println("bwm car driving");
}
}
/**
* 具体产品-奔驰车
*
* @author zx
**/
public class BanZ extends Car {
@Override
public void drive() {
System.out.println("banz car driving");
}
}
抽象工厂:
/**
* 工厂抽象角色
*
* @author zx
**/
public interface CarFactory {
public Car createCar();
}
具体工厂:
/**
* 具体抽象工厂角色-宝马工厂
*
* @author zx
**/
public class BwmFactory implements CarFactory {
@Override
public Car createCar() {
Bwm bwm = new Bwm();
bwm.setName("BWM");
return bwm;
}
}
/**
* 具体抽象工厂角色-奔驰工厂
*
* @author zx
**/
public class BanZFactory implements CarFactory {
@Override
public Car createCar() {
BanZ banZ = new BanZ();
banZ.setName("BanZ");
return banZ;
}
}
工厂客户端:
/**
* 客户端
*
* @author zx
**/
public class Client {
class Client1 {
public void doSomething() {
CarFactory factory = new BwmFactory();
factory.createCar().drive();
}
}
class Client2 {
public void doSomething() {
CarFactory factory = new BanZFactory();
factory.createCar().drive();
}
}
}
抽象工厂设计模式
概念:抽象工厂设计模式类似工厂方法,当抽象工厂产品族只有一个产品时就成为了工厂方法,也可以理解为工厂方法的升级版。抽象工厂主要是用于创建一个产品族。
案例介绍:现在有BWM工厂,但是现在BWM中各个系列中比如:引擎,轮毂等;那么BWM工厂需要生产出各个系列车子的不同产品。
角色组成:多个抽象产品、多个具体产品、抽象工厂、具体工厂。
代码演示:
抽象产品:
/**
* 抽象产品--轮毂
*
* @author zx
**/
public abstract class BwmWheel {
private String name;
public abstract void useWheel();
}
/**
* 抽象产品--引擎
*
* @author zx
**/
public abstract class BwmEngine {
private String name;
public abstract void use();
}
具体产品:
/**
* 具体产品--宝马320轮毂
*
* @author zx
**/
public class Bwm320Wheel extends BwmWheel {
@Override
public void useWheel() {
System.out.println("i am using bwm320 wheel");
}
}
/**
* 具体产品--宝马520轮毂
*
* @author zx
**/
public class Bwm520Wheel extends BwmWheel {
@Override
public void useWheel() {
System.out.println("i am using bwm520 wheel");
}
}
/**
* 具体产品--宝马320引擎
*
* @author zx
**/
public class Bwm320Engine extends BwmEngine {
@Override
public void use() {
System.out.println("i am using bwm320 engine");
}
}
/**
* 具体产品--宝马520
*
* @author zx
**/
public class Bwm520Engine extends BwmEngine {
@Override
public void use() {
System.out.println("i am using bwm520 engine");
}
}
抽象工厂:
/**
* 抽象工厂--宝马工厂
*
* @author zx
**/
public interface BwmFactory {
public BwmEngine createEngine();
public BwmWheel createWheel();
}
具体工厂:
/**
* 具体工厂--宝马320工厂
*
* @author zx
**/
public class Bwm320Factory implements BwmFactory {
@Override
public BwmEngine createEngine() {
return new Bwm320Engine();
}
@Override
public BwmWheel createWheel() {
return new Bwm320Wheel();
}
}
/**
* 具体工厂--520
*
* @author zx
**/
public class Bwm520Factory implements BwmFactory {
@Override
public BwmEngine createEngine() {
return new Bwm520Engine();
}
@Override
public BwmWheel createWheel() {
return new Bwm520Wheel();
}
}
工厂客户端:
/**
* 客户端
*
* @author zx
**/
public class Client {
class Client1 {
public void doSomething() {
BwmFactory factory = new Bwm320Factory();
factory.createEngine().use();
factory.createWheel().useWheel();
}
}
class Client2 {
public void doSomething() {
Bwm520Factory factory = new Bwm520Factory();
factory.createEngine().use();
factory.createWheel().useWheel();
}
}
}
总结:抽象工厂和工厂方法最主要的区别就是产品。工厂方法只有一个产品,而抽象工厂是一个产品族;自然而然对应的工厂也就不同,工厂方法只能创建一个产品,抽象工厂需要创建的是一个产品族。在设计程序时,不要过多在意与是抽象工厂还是工厂方法,在程序使用工厂时,注重的是为了程序能够更好的解耦,往往也不会单独的工厂模式出现,会存在多种设计模式组合而成。