工厂模式用于实现逻辑的封装,并通过公共的忌口提供对象的实例化服务,在添加新类时只需要做少量的修改。
静态工厂属于创建者模式,静态工厂模式的实现需要三个角色
工厂角色
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();
}
具体产品
public class FruitCandy implements Candy {
@Override
public void testCandy() {
System.out.println("Test FruitCandy");
}
}
package com.stu.edu.part2.Factorypattern.demo2;
public class ColaCandy implements Candy {
@Override
public void testCandy() {
System.out.println("Test ColaCandy");
}
}
上述写法符合了迪米特法则,但是该种写法难以符合开闭原则,一旦有新的产品品种加入,就需要修改工厂类,因此该种写法使用与具体产品类不多,且具体产品种类长时间不改变的情况。
该方案采用一个 HashMap 存储创建的具体产品与 String 之间的映射,使用反射的方式来创建类。这样不仅代码代码更加精简,并且也符合了开闭原则
工厂角色
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();
}
具体产品
public class RedCandy implements Candy {
@Override
public void enjoyCandy() {
System.out.println("Enjoy RedCandy");
}
}
public class WhiteCandy implements Candy {
@Override
public void enjoyCandy() {
System.out.println("Enjoy WdhiteCandy");
}
}
当然,并非任何时候都适用反射的方式来创建对象,因此我们可以调用类自身的创建方式来实现。我们可以为每一个类创建一个 newInstance 方法,用于返回该类自身的对象。
工厂角色
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();
}
具体产品角色
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");
}
}
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");
}
}
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");;
}
}
优点:
缺点:
工厂方法模式又称为多态性工厂模式,指定一个创建对象的接口,但由实现这个接口的类来决定实例化哪一个类。
在工厂方法模式中,共涉及到4个角色:
抽象工厂
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;
}
}
具体工厂
public class HardCandyFactory extends CandyFactory {
@Override
public Candy productCandy() {
return new HardCandy();
}
}
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");
}
}
public class HardCandy implements Candy {
@Override
public void enjoyCandy() {
System.out.println("Enjoy Orange HardCandy");
}
}
优点:
缺点:
抽象工厂指提供一个创建一系列相关或相互依赖对象的接口,无需指定他们具体的类。意思是,客户端不必指定产品的具体类型,创建多个产品族中的具体对象。
抽象工厂和工厂方法一样拥有四个对象:
上图为 抽象工厂模式的一个 UML 图
我们可以借助下图帮助我们理解一下
抽象工厂
public interface CandyFactory {
public HardCandy createHardCandy();
public SoftCandy createSoftCandy();
}
具体工厂
public class AppleFlavorCandyFactory implements CandyFactory {
@Override
public HardCandy createHardCandy() {
return new AppleHardCandy();
}
@Override
public SoftCandy createSoftCandy() {
return new AppleSoftCandy();
}
}
public class OrangeFlavorCandyFactory implements CandyFactory {
@Override
public HardCandy createHardCandy() {
return new OrangeHardCandy();
}
@Override
public SoftCandy createSoftCandy() {
return new OrangeSoftCandy();
}
}
抽象产品
public interface SoftCandy {
public void tasteSoftCandy();
}
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");
}
}
public class AppleSoftCandy implements SoftCandy {
@Override
public void tasteSoftCandy() {
System.out.println("The Apple Soft Candy taste delicious");
}
}
public class OrangeHardCandy implements HardCandy {
@Override
public void tasteHardCandy() {
System.out.println("The Orange Hard Candy taste delicious");
}
}
public class OrangeSoftCandy implements SoftCandy {
@Override
public void tasteSoftCandy() {
System.out.println("The Orange Soft Candy taste delicious");
}
}
优点:
缺点: