2023-06-15  阅读(62)
原文作者: 求和的小熊猫 原文地址:https://blog.csdn.net/qq_38219153/article/details/110894623

工厂方法模式

工厂模式用于实现逻辑的封装,并通过公共的忌口提供对象的实例化服务,在添加新类时只需要做少量的修改。

1. 静态工厂模式(简单工厂模式)

202306152220031211.png

静态工厂属于创建者模式,静态工厂模式的实现需要三个角色

  • 简单工厂:负责创建具体产品产品,工厂类的方法可以被外界直接调用
  • 抽象产品:在 Java 中,抽象产品是由抽象类或者接口担任的,用以让具体产品继承或实现
  • 具体产品:在 Java 中,具体产品是工厂类创建的主要对象。
静态工厂的通用写法

202306152220035742.png

工厂角色

    public class CandyFactory {
    	public enum CandyKind{
    		FRUITCANDY("fruitCandy"),COLACANDY("COLACANDY");
    		private String kind;
    		CandyKind(String kind){
    			this.kind = kind;
    		}
    		
    		public String getCandyKind() {
    			return this.kind;
    		}
    	}
    	
    	public Candy createCandy(String kind) {
    		if(kind.equals(CandyKind.COLACANDY.getCandyKind()))
    			return new ColaCandy();
    		if(kind.equals(CandyKind.FRUITCANDY.getCandyKind())) {
    			return new FruitCandy();
    		}
    		return null;
    	}
    
    }
复制代码

抽象产品

    public interface Candy {
    	public void testCandy();
    }
复制代码

具体产品

  1. FruitCandy
    public class FruitCandy implements Candy {
    
    	@Override
    	public void testCandy() {
    		System.out.println("Test FruitCandy");
    
    	}
    
    }
复制代码
  1. ColaCandy
    package com.stu.edu.part2.Factorypattern.demo2;
    
    public class ColaCandy implements Candy {
    
    	@Override
    	public void testCandy() {
    		System.out.println("Test ColaCandy");
    		
    	}
    
    }
复制代码

上述写法符合了迪米特法则,但是该种写法难以符合开闭原则,一旦有新的产品品种加入,就需要修改工厂类,因此该种写法使用与具体产品类不多,且具体产品种类长时间不改变的情况。

静态工厂与反射的结合

该方案采用一个 HashMap 存储创建的具体产品与 String 之间的映射,使用反射的方式来创建类。这样不仅代码代码更加精简,并且也符合了开闭原则

202306152220044423.png

工厂角色

    public class CandyFactory {
    	private static Map<String,Class> candyMap = new HashMap<>();
    	public void registerCandy(String kind,Class candyclass) {
    		candyMap.put(kind, candyclass);
    	}
    	
    	
    	public Candy createCandy(String kind) {
    		Candy candy = null;
    		if(candyMap.containsKey(kind)) {
    			try {
    				candy = (Candy)candyMap.get(kind).newInstance();
    			} catch (InstantiationException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			} catch (IllegalAccessException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}finally {
    				return candy;
    			}			
    		}
    		return candy;
    		
    	}
    
    }
复制代码

抽象产品

    public interface Candy {
    	public void enjoyCandy();
    }
复制代码

具体产品

  1. redCandy
    public class RedCandy implements Candy {
    	@Override
    	public void enjoyCandy() {
    		System.out.println("Enjoy RedCandy");
    		
    	}
    }
复制代码
  1. WhiteCandy
    public class WhiteCandy implements Candy {
    	@Override
    	public void enjoyCandy() {
    		System.out.println("Enjoy WdhiteCandy");
    		
    	}
    
    }
复制代码
静态工厂的进一步优化

当然,并非任何时候都适用反射的方式来创建对象,因此我们可以调用类自身的创建方式来实现。我们可以为每一个类创建一个 newInstance 方法,用于返回该类自身的对象。

202306152220054204.png

工厂角色

    public class CandyFactory {
    	
    	private static Map<String,Candy> candyMap = new HashMap<String,Candy>();
    	
    	public void RegisterCandy(String kind,Candy candy) {
    		candyMap.put(kind, candy);
    	}
    
    	public  Candy createCandy(String kind) {
    		if(candyMap.containsKey(kind)) {
    			candyMap.get(kind).newInstance();
    		}
    		return null;
    	}
    
    }
复制代码

抽象产品角色

    public interface Candy {
    	
    	public Candy newInstance();
    	public void showCandy();
    }
复制代码

具体产品角色

  1. SoftCandy
    public class SoftCandy implements Candy {
    	@Override
    	public SoftCandy newInstance() {
    		// TODO Auto-generated method stub
    		return new SoftCandy();
    	}
    	
    	@Override
    	public void showCandy() {
    		System.out.println("This is a SoftCandy");
    	}
    	
    }
复制代码
  1. HardCandy
    public class HardCandy implements Candy {
    	
    	@Override
    	public HardCandy newInstance() {
    		return new HardCandy();
    	}
    	@Override
    	public void showCandy() {
    		// TODO Auto-generated method stub
    		System.out.println("This is a HardCandy");
    	}
    }
复制代码
  1. MilkCandy
    public class MilkCandy implements Candy {
    	
    	@Override
    	public MilkCandy newInstance() {
    		// TODO Auto-generated method stub
    		return new MilkCandy();
    	}
    	@Override
    	public void showCandy() {
    		// TODO Auto-generated method stub
    		System.out.println("This is a MilkCandy");;
    	}
    }
复制代码
简单工厂模式的优缺点

优点:

  • 结构简单,调用方便
  • 共产和产品职责区分明确

缺点:

  • 工厂类单一,负责所有产品的创建,产品基数增多时工厂类会非常臃肿

2. 工厂方法模式

工厂方法模式又称为多态性工厂模式,指定一个创建对象的接口,但由实现这个接口的类来决定实例化哪一个类。

202306152220058675.png

在工厂方法模式中,共涉及到4个角色:

  • 抽象工厂角色:定义产品对象的产生
  • 具体工厂角色:实现了抽象共产,负责具体产品的创建
  • 抽象产品角色:定义具体产品的共性
  • 具体产品角色:具体产品的实例
工厂方法模式示例

202306152220067386.png

抽象工厂

    public abstract class CandyFactory {
    	
    	public abstract Candy productCandy();
    	public List<Candy> orderProduct(int number) {
    		List<Candy> candyList = new ArrayList<>();
    		int i=0;
    		do {
    			Candy candy = productCandy();
    			candyList.add(candy);
    			i++;
    		}while(i<number);
    		return candyList;
    	}
    }
复制代码

具体工厂

  1. HardCandyFactory
    public class HardCandyFactory extends CandyFactory {
    
    	@Override
    	public Candy productCandy() {
    		return new HardCandy();
    	}
    
    }
复制代码
  1. SoftCandyFactory
    public class SoftCandyFactory extends CandyFactory {
    
    	@Override
    	public Candy productCandy() {
    		return new OrangeSoftCandy();
    	}
    
    }
复制代码

抽象产品

    public interface Candy {
    	
    	public void enjoyCandy();
    
    }
复制代码

具体产品

1.SoftCandy

    public class OrangeSoftCandy implements Candy {
    
    	@Override
    	public void enjoyCandy() {
    		System.out.println("Enjoy Orange SoftCandy");
    	}
    
    }
复制代码
  1. OrangeHardCandy
    public class HardCandy implements Candy {
    
    	@Override
    	public void enjoyCandy() {
    		System.out.println("Enjoy Orange HardCandy");
    
    	}
    
    }
复制代码
工厂方法模式的优缺点

优点:

  • 良好的封装性
  • 优秀的可扩展性,灵活性,对于新产品或者产品类的创建,只需多写一个相应的工厂类,而无需修改工厂类,调用时也不会
  • 屏蔽产品类,产品类如何实现变化无需调用者都不用关心,只需关注接口即可

缺点:

  • 类产品过多,会增加复杂度
  • 增加了系统的抽象性和理解难度
  • 抽象产品只能生产一种产品

3. 抽象工厂模式

抽象工厂指提供一个创建一系列相关或相互依赖对象的接口,无需指定他们具体的类。意思是,客户端不必指定产品的具体类型,创建多个产品族中的具体对象。

抽象工厂和工厂方法一样拥有四个对象:

  • 抽象工厂:声明创建抽象产品对象的一个操作接口
  • 具体工厂:实现创建具体产品对象的操作
  • 抽象产品:为一类产品对象声明一个接口
  • 具体产品:定义一个将被相应的具体工厂的创建的产品对象,是实现 AbstractProduct 接口

202306152220074387.png

上图为 抽象工厂模式的一个 UML 图

我们可以借助下图帮助我们理解一下

202306152220085708.png

抽象工厂模式示例

抽象工厂

    public interface CandyFactory {
    	public HardCandy createHardCandy();
    	public SoftCandy createSoftCandy();
    
    }
复制代码

具体工厂

  1. AppleFlavorCandyFactory
    public class AppleFlavorCandyFactory implements CandyFactory {
    
    	@Override
    	public HardCandy createHardCandy() {
    		return new AppleHardCandy();
    	}
    
    	@Override
    	public SoftCandy createSoftCandy() {
    		return new AppleSoftCandy();
    	}
    
    }
复制代码
  1. OrangeFlavorCandyFactory
    public class OrangeFlavorCandyFactory implements CandyFactory {
    
    	@Override
    	public HardCandy createHardCandy() {
    		return new OrangeHardCandy();
    	}
    
    	@Override
    	public SoftCandy createSoftCandy() {
    		return new OrangeSoftCandy();
    	}
    
    }
复制代码

抽象产品

  1. SoftCandy
    public interface SoftCandy {
    	public void tasteSoftCandy();
    }
复制代码
  1. HardCandy
    public interface HardCandy {
    	public void tasteHardCandy();
    }
复制代码

具体产品
1.AppleHardCandy

    public class AppleHardCandy implements HardCandy {
    
    	@Override
    	public void tasteHardCandy() {
    		System.out.println("The Apple Hard Candy taste delicious");
    	}
    
    }
复制代码
  1. AppleSoftCandy
    public class AppleSoftCandy implements SoftCandy {
    
    	@Override
    	public void tasteSoftCandy() {
    		System.out.println("The Apple Soft Candy taste delicious");
    	}
        
    }
复制代码
  1. OrangeHardCandy
    public class OrangeHardCandy implements HardCandy {
    
    	@Override
    	public void tasteHardCandy() {
    		System.out.println("The Orange Hard Candy taste delicious");		
    	}
    
    }
复制代码
  1. OrangeSoftCandy
    public class OrangeSoftCandy implements SoftCandy {
    
    	@Override
    	public void tasteSoftCandy() {
    		System.out.println("The Orange Soft Candy taste delicious");
    	}
    
    }
复制代码
抽象工厂模式的优缺点

优点:

  1. 当需要产品族时,抽象共产可以保证客户端始终只使用一个产品的产品族
  2. 抽象工厂增强了程序的可扩展性,对于新产品族的增加,秩序实现一个新的具体工厂即可

缺点:

  1. 规定了所有可能被创建的产品的集合,产品族中添加新的扩展会更加困难
  2. 增加了系统的抽象性和理解难度

Java 面试宝典是大明哥全力打造的 Java 精品面试题,它是一份靠谱、强大、详细、经典的 Java 后端面试宝典。它不仅仅只是一道道面试题,而是一套完整的 Java 知识体系,一套你 Java 知识点的扫盲贴。

它的内容包括:

  • 大厂真题:Java 面试宝典里面的题目都是最近几年的高频的大厂面试真题。
  • 原创内容:Java 面试宝典内容全部都是大明哥原创,内容全面且通俗易懂,回答部分可以直接作为面试回答内容。
  • 持续更新:一次购买,永久有效。大明哥会持续更新 3+ 年,累计更新 1000+,宝典会不断迭代更新,保证最新、最全面。
  • 覆盖全面:本宝典累计更新 1000+,从 Java 入门到 Java 架构的高频面试题,实现 360° 全覆盖。
  • 不止面试:内容包含面试题解析、内容详解、知识扩展,它不仅仅只是一份面试题,更是一套完整的 Java 知识体系。
  • 宝典详情:https://www.yuque.com/chenssy/sike-java/xvlo920axlp7sf4k
  • 宝典总览:https://www.yuque.com/chenssy/sike-java/yogsehzntzgp4ly1
  • 宝典进展:https://www.yuque.com/chenssy/sike-java/en9ned7loo47z5aw

目前 Java 面试宝典累计更新 400+ 道,总字数 42w+。大明哥还在持续更新中,下图是大明哥在 2024-12 月份的更新情况:

想了解详情的小伙伴,扫描下面二维码加大明哥微信【daming091】咨询

同时,大明哥也整理一套目前市面最常见的热点面试题。微信搜[大明哥聊 Java]或扫描下方二维码关注大明哥的原创公众号[大明哥聊 Java] ,回复【面试题】 即可免费领取。

阅读全文