1、描述
- 工厂模式的本质就是用工厂方法代替new操作创建一种实例化对象的方式。
- 在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。
- 工厂模式可分为简单工厂模式，工厂方法模式和抽象工厂模式三类。
2.1 简单工厂模式
- 简单工厂模式属于类的创建型模式，又叫静态工厂方法模式。通过专门定义一个工厂类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。
2.1.1 简单工厂模式含有3个角色
1）工厂角色（Creator）
这是简单工厂模式的核心，它用来负责实现创建所有实例的内部逻辑。工厂类可以被外界直接调用，创建所需的产品对象。
public class CarFactory {
public static Car creatCar(String type){
Car car= null;
// 这里我们通过switch来判断，具体制作哪一个品牌的车
switch(type){
case "Benz":
car= new Benz();
break;
case "BYD":
car= new BYD();
break;
case "Bentley ":
car= new Bentley();
break;
default:
break;
}
return car;
}
}
2）抽象角色（Product）
这是简单工厂模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。该类可以是接口，也可以是抽象类。
public interface Car{
public void run();
}
3）具体产品角色（Concrete Product）
简单工厂模式所创建的具体的实例对象。
public class Benz implements Car{
public void run(){
System.out.println("这是Benz");
}
}
public class BYD implements Car{
public void run() {
System.out.println("这是BYD");
}
}
public class Bentley implements Car{
public void run(){
System.out.println("这是Bentley");
}
}
4）测试用例
//通过统一的工厂，传入不同参数调用生产汽车的方法去生产不同品牌的车
public class Client {
public static void main(String[] args) {
Car benz= CarFactory.creatCar("Benz");
benz.run();
Car byd= CarFactory.creatCar("BYD");
byd.run();
Car bentley = CarFactory.creatCar("Bentley");
bentley.run();
}
}
2.1.2 结论
简单工厂模式实现了生成产品类的代码跟客户端代码分离，在工厂类中你可以添加所需的生成产品的逻辑代码，但是问题来了，优秀的java代码是符合“开放-封闭”原则的，也就是说对扩展开发，对修改关闭，如果你要加一个产品类C，就要增加if-else判断，修改工厂类里面的生成产品的代码。
2.2 工厂方法模式
- 工厂方法模式是对普通工厂方法模式的改进，在普通工厂方法模式中，如果传递的字符串出错，则不能正确创建对象，而工厂方法模式是提供多个工厂方法，分别创建对象。
- 可以实现“开发-封闭”原则，无论加多少产品类，我们都不用修改原来类中的代码，而是通过增加工厂类来实现。但是这还是有缺点的，如果产品类过多，我们就要生成很多的工厂类。
2.2.1. 和简单工厂模式一样，先定义一个接口。再定义Benz、BYD和Bentley去实现这个接口
public interface Car{
public void run();
}
public class Benz implements Car{
public void run(){
System.out.println("这是Benz");
}
}
public class BYD implements Car{
public void run() {
System.out.println("这是BYD");
}
}
public class Bentley implements Car{
public void run(){
System.out.println("这是Bentley");
}
}
2.2.2. 定义工厂接口
public interface CarFactory {
public Car createCar();
}
2.2.3. 再分别定义BenzFactory、BYDFactory、BentleyFactory，继承刚刚定义的工厂接口
public class BenzFactory implements CarFactory {
public Car createCar(){
return new Benz();
}
}
public class BYDFactory implements CarFactory {
public Car createCar(){
return new BYD();
}
}
public class BentleyFactory implements CarFactory {
public Car createCar() {
return new Bentley();
}
}
2.2.4. 测试用例
// 客户端代码
public class Client {
public static void main(String[] args) {
//生产Benz
CarFactory benzFactory= new BenzFactory();
Car benz= benzFactory.createCar();
benz.run();
//生产BYD
CarFactory bydFactory = new BYDFactory();
Car byd= bydFactory.createCar();
byd.run();
//生产Bently
CarFactory bentleyFactory = new BentleyFactory();
Car bentley= bentleyFactory.createCar();
bentley.run();
}
}
2.3 抽象工厂模式
- 假如我们要实现的产品接口不止一个，也就是有多个产品接口，不同产品接口有对应的产品族。什么是产品族呢？简单的理解就是，不同牌子产的车里面会有跑车类型，家庭类型，商用类型等的车，不同牌子的车的跑车类型的车可以组成一个产品族。对于这种情况我们可以采用抽象工厂模式。
抽象工厂模式中包含的角色及职责：
1.抽象工厂角色（Creator）
这是抽象工厂模式的核心，任何工厂类必须实现这个接口。
1.1 定义工厂接口
public interface CarFactory {
public SUVCar createSUVCar();
public SportsCar createSportsCar();
}
2.具体工厂角色（Concrete Creator）
2.1它是抽象工厂的一个实现，负责实例化产品对象。
定义三个工厂类继承上边的接口并实现其方法
public class BenzFactory implements CarFactory {
public SUVCar createSUVCar(){
return new SUVBenz();
}
public SportsCar createSportsCar(){
return new SportsBenz();
}
}
public class BYDFactory implements CarFactory {
public SUVCar createSUVCar(){
return new SUVBYD();
}
public SportsCar createSportsCar(){
return new SportsBYD();
}
}
public class BentleyFactory implements CarFactory {
public SUVCar createSUVCar(){
return new SUVBentley();
}
public SportsCar createSportsCar(){
return new SportsBentley();
}
}
3.抽象角色（Product）
抽象工厂模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。
3.1 不同型号的汽车
public interface SUVCar {
public void run();
}
public interface SportsCar {
public void run();
}
4.具体产品角色（Concrete Product）
抽象工厂模式所创建的具体的实例对象。
4.1 定义各个型号的汽车，继承刚刚定义的接口，实现其方法
public class SUVBenz implements SUVCar {
public void run() {
System.out.println("这是SUVBenz");
}
}
public class SportsBenz implements SportsCar {
public void run() {
System.out.println("这是SportsBenz");
}
}
public class SUVBYD implements SUVCar {
public void run() {
System.out.println("这是SUVBYD ");
}
}
public class SportsBYD implements SportsCar {
public void run() {
System.out.println("这是SportsBYD ");
}
}
public class SUVBentley implements SUVCar {
public void run() {
System.out.println("这是SUVBentley ");
}
}
public class SportsBentley implements SportsCar {
public void run() {
System.out.println("这是SportsBentley ");
}
}
5. 测试用例
public class Client {
public static void main(String[] args) {
//生产Benz
CarFactory benzFactory = new BenzFactory();
SUVCar suvBenz= benzFactory .createSUVCar();
SportsCar sportsBenz = benzFactory .createSportsCar();
suvBenz.run();
sportsBenz.run();
//生产BYD
CarFactory bydFactory = new BYDFactory();
SUVCar suvBYD = bydFactory.createSUVCar();
SportsCar sportsBYD = bydFactory.createSportsCar();
suvBYD.run();
sportsBYD.run();
//生产Bentley
CarFactory bentleyFactory = new BentleyFactory();
SUVCar suvBentley= bentleyFactory .createSUVCar();
SportsCar sportsBentley = bentleyFactory .createSportsCar();
suvBentley.run();
sportsBentley.run();
}
}
6. 结论
- 简单工厂模式：工厂类是整个模式的关键所在，包含了必要的逻辑判断，能够外界给定的信息， 决定究竟创建哪个具体类的对象。
- 工厂方法模式：是对简单工厂方法模式的一个抽象，抽离出了一个Factory类(或者接口)，这个接口不负责具体产品的生产，而只是指定一些规范，具体的生产工作由其子类去完成。这个模式中，工厂类和产品类往往是一一对应的，完全解决了简单工厂模式中违背“开闭原则”的问题，实现了可扩展；
- 抽象工厂模式 ：存在多个抽象产品类，每个抽象产品类可以派生出多个具体产品类，工厂提供多种方法，去生产“系列”产品。
网友评论