设计模式 -- 工厂模式

发布时间:2022-03-01 12:01:30 作者:yexindonglai@163.com 阅读(65)

工厂的指责就是制作产品,那么产品就可以理解为是我们的对象,而工厂就是为了实例化对象而对象的,根据工厂的抽象程度可分为工厂方法模式和抽象工厂模式。该模式用于封装和管理对象的创建,是一种创建型模式。

 

1、简单工厂模式

简单工厂模式:也叫静态工厂模式,简单工厂模式相当于试试一个工厂中有各种产品,创建在一个类中,客户无需知道具体产品的名称,只需要知道产品的参数即可,相当于所有的汽车都是由一个厂里面生产出来的的,这个厂既能生产宝马,又能生产奔驰,还能生产其他的品牌的汽车,但是工厂的职责过重,而且当类型过多时不利于系统的扩展维护;简单工厂模式是不属于23种设计模式里面的;

简单工厂模式示例代码

  1. package com.designPatterm.factory.one;
  2. /**
  3. * 设计模式-工厂模式: 普通工厂模式
  4. */
  5. public class OrdinaryFactory {
  6. public static void main(String[] args) {
  7. CarFactory.getInstance("bc").showCar();
  8. CarFactory.getInstance("bmw").showCar();
  9. }
  10. }
  11. // 造车的工厂
  12. class CarFactory {
  13. public static Car getInstance(String car){
  14. if(car.equals("bmw")){
  15. return new BmwCar();
  16. }
  17. if(car.equals("bc")){
  18. return new BcCar();
  19. }
  20. return null;
  21. }
  22. }
  23. // 车的接口类
  24. interface Car {
  25. public void showCar();
  26. }
  27. // 宝马车
  28. class BmwCar implements Car{
  29. public void showCar(){
  30. System.out.println("我是宝马车");
  31. }
  32. }
  33. //奔驰车
  34. class BcCar implements Car{
  35. public void showCar(){
  36. System.out.println("我是奔驰车");
  37. }
  38. }

 

2、工厂方法模式

工厂方法模式Factory Method,又称多态性工厂模式。在工厂方法模式中,核心的工厂类不再负责所有的产品的创建,而是将具体创建的工作交给子类去做。该核心类成为一个抽象工厂角色,仅负责给出具体工厂子类必须实现的接口,而不接触哪一个产品类应当被实例化这种细节。而且每个工厂都只创建一种产品;

工厂方法模式示例代码

  1. package com.designPatterm.factory.two;
  2. /**
  3. * 设计模式-工厂模式: 工厂方法模式
  4. */
  5. public class FactoryMethod {
  6. public static void main(String[] args) {
  7. Factory bmwFa = new BmwCarFactory();
  8. Factory bcFa = new BcCarFactory();
  9. Car bmw = bmwFa.createCar();
  10. Car bc = bcFa.createCar();
  11. bmw.showCar();
  12. bc.showCar();
  13. }
  14. }
  15. // 工厂接口,所有造车的工厂都实现 Factory 接口
  16. interface Factory{
  17. Car createCar();
  18. }
  19. // 造宝马车的工厂
  20. class BmwCarFactory implements Factory{
  21. @Override
  22. public Car createCar() {
  23. return new BmwCar();
  24. }
  25. }
  26. // 造奔驰车的工厂
  27. class BcCarFactory implements Factory{
  28. @Override
  29. public Car createCar() {
  30. return new BcCar();
  31. }
  32. }
  33. // 车的接口,所有车都实现 Car 接口
  34. interface Car {
  35. public void showCar();
  36. }
  37. // 宝马车
  38. class BmwCar implements Car{
  39. public void showCar(){
  40. System.out.println("我是宝马车");
  41. }
  42. }
  43. //奔驰车
  44. class BcCar implements Car{
  45. public void showCar(){
  46. System.out.println("我是奔驰车");
  47. }
  48. }

 

3、抽象工厂模式

上面说到的工厂方法模式里面,每个工厂都只创建一种产品;那么抽象工厂模式就可以理解为每个工厂都可以创建多个产品;

例如: 小米工厂可以生产小米手机和笔记本电脑,而苹果工厂可以生产iphone 和 mac,具体流程图如下:

抽象工厂模式示例代码

  1. package com.designPatterm.factory.three;
  2. /**
  3. * 设计模式-工厂模式: 抽象工厂模式
  4. */
  5. public class AbstractFactory {
  6. public static void main(String[] args) {
  7. // 实例化工厂类
  8. Factory bmwFa = new BmwFactory();
  9. Factory bcFa = new BcFactory();
  10. // 生产宝马车的轮子和座椅
  11. Car bmwWheel = bmwFa.createWheel();
  12. Car bmwChair = bmwFa.createChair();
  13. // 生产奔驰车的轮子和座椅
  14. Car bcWheel = bcFa.createWheel();
  15. Car bcChair = bcFa.createChair();
  16. // 展示生产完成的宝马车轮子和座椅
  17. bmwWheel.showCar();
  18. bmwChair.showCar();
  19. // 展示生产完成的宝马车轮子和座椅
  20. bcWheel.showCar();
  21. bcChair.showCar();
  22. }
  23. }
  24. // 工厂接口,所有造车的工厂都实现 Factory 接口
  25. interface Factory{
  26. // 生产轮子
  27. Car createWheel();
  28. // 生产座椅
  29. Car createChair();
  30. }
  31. // 造宝马车零件的工厂
  32. class BmwFactory implements Factory {
  33. @Override
  34. public Car createWheel() {
  35. return new Wheel("宝马");
  36. }
  37. @Override
  38. public Car createChair() {
  39. return new Chair("宝马");
  40. }
  41. }
  42. // 造奔驰车零件的工厂
  43. class BcFactory implements Factory {
  44. @Override
  45. public Car createWheel() {
  46. return new Wheel("奔驰");
  47. }
  48. @Override
  49. public Car createChair() {
  50. return new Chair("奔驰");
  51. }
  52. }
  53. // 车的接口,所有车都实现 Car 接口
  54. interface Car {
  55. public void showCar();
  56. }
  57. // 轮子
  58. class Wheel implements Car {
  59. String carName;
  60. public Wheel(String carName){
  61. this.carName = carName;
  62. }
  63. public void showCar(){
  64. System.out.println("生产了 "+carName+"车轮子");
  65. }
  66. }
  67. // 座椅
  68. class Chair implements Car {
  69. String carName;
  70. public Chair(String carName){
  71. this.carName = carName;
  72. }
  73. public void showCar(){
  74. System.out.println("生产了 "+carName+"车座椅");
  75. }
  76. }

 

关键字设计模式