设计模式--工厂模式（三种）

最新推荐文章于 2022-12-02 17:20:46 发布

霓乤

最新推荐文章于 2022-12-02 17:20:46 发布

阅读量147

点赞数

分类专栏： Java 设计模式文章标签： java 设计模式工厂方法模式抽象工厂模式

本文链接：https://blog.csdn.net/m0_46633875/article/details/120148105

版权

Java 同时被 2 个专栏收录

21 篇文章 1 订阅

订阅专栏

设计模式

14 篇文章 0 订阅

订阅专栏

工厂模式

概述
简单工厂
工厂方法模式
抽象工厂模式
jdk工厂模式应用

概述

在java中，万物皆对象，这些对象都需要创建，如果创建的时候直接new该对象，就会对该对象耦合严重。
假如我们要更换对象，所有new对象的地方都需要修改一遍，这显然违背了软件设计的开闭原则。
如果我们使用工厂来生产对象，我们就只和工厂打交道就可以了，彻底和对象解耦，如果要更换对象，直接在工厂里更换该对象即可，达到了与对象解耦的目的。
工厂模式最大的优点就是：解耦。

简单工厂

1.基本结构

简单工厂包含如下角色：
抽象产品：定义了产品的规范，描述了产品的主要特性和功能。
具体产品：实现或者继承抽象产品的子类
具体工厂（简单工厂）：提供了创建所有产品的方法，调用者通过该工厂来获取产品。

2.示例

这里我们以一个奖品派送为例：奖品有会员卡、优惠券、实物奖品，
我们通过一个简单地工厂去创建这些奖品的实例，用户只需要根据奖品的类名即可得到对应的奖品。

2.1 结构图
在这里插入图片描述

2.2 代码
2.2.1 bean

public interface ICommodity {
    /*
     * @Description //TODO 商品信息
     * @Date  
     * @Param 
     * @return 
     **/
    String info();
}

public class CardCommodity implements ICommodity {
    private Integer commodityId=1001;//商品id
    private String uId;//用户id
    private String name;//商品名称
    public CardCommodity(){
        commodityId+=1;
        name="会员卡";
    }

    public void setUId(String uId) {
        this.uId = uId;
    }

    @Override
    public String toString() {
        return "CardCommodity{" +
                ", uId='" + uId + '\'' +
                "commodityId=" + commodityId +
                ", name='" + name + '\'' +
                '}';
    }

    @Override
    public String info() {
        return toString();
    }
}

public class CouponCommodity implements ICommodity {
    private Integer commodityId=2001;//商品id
    private String uId;//用户id
    private String name;//商品名称
    public CouponCommodity(){
        commodityId+=1;
        name="淘宝优惠券";
    }

    public void setUId(String uId) {
        this.uId = uId;
    }

    @Override
    public String toString() {
        return "CouponCommodity{" +
                "uId='" + uId + '\'' +
                ",commodityId=" + commodityId +
                ", name='" + name + '\'' +
                '}';
    }

    @Override
    public String info() {
        return toString();
    }
}

public class GoodsCommodity implements ICommodity {
    private Integer commodityId=3001;//商品id
    private String uId;//用户id
    private String name;//商品名称
    private Map<String ,String > ext;//扩展信息
    public GoodsCommodity(){
        commodityId+=1;
        name="纪念品";
    }

    public void setUId(String uId) {
        this.uId = uId;
    }

    public Map<String, String> getExt() {
        return ext;
    }

    public void setExt(Map<String, String> ext) {
        this.ext = ext;
    }

    @Override
    public String toString() {
        return "GoodsCommodity{" +
                ", uId='" + uId + '\'' +
                "commodityId=" + commodityId +
                ", name='" + name + '\'' +
                ", ext=" + ext +
                '}';
    }

    @Override
    public String info() {
        return toString();
    }
}

2.2.2 工厂

public class StoreFactory {
    /*
     * @Description //TODO 根据不同的商品类得到对应的商品
     * @Date
     * @Param  用户id 额外信息  所需的商品工厂类型
     * @return
     **/
    public static ICommodity send(String uId, Map<String,String> ext, Class<?extends ICommodity> clazz) throws IllegalAccessException, InstantiationException {
        ICommodity iCommodity = clazz.newInstance();
        if(iCommodity instanceof CardCommodity){
            CardCommodity cardCommodity = (CardCommodity) iCommodity;
            cardCommodity.setUId(uId);
            return cardCommodity;
        }else if(iCommodity instanceof CouponCommodity){
            CouponCommodity couponCommodity=(CouponCommodity)iCommodity;
            couponCommodity.setUId(uId);
            return couponCommodity;
        }else  if(iCommodity instanceof GoodsCommodity){
            GoodsCommodity goodsCommodity=(GoodsCommodity)iCommodity;
            goodsCommodity.setUId(uId);
            goodsCommodity.setExt(ext);
            return  goodsCommodity;
        }else {
            throw new RuntimeException("没有该奖品！");
        }
    }

}

2.2.3 客户

public class Client {
    private String uId;
    private String uName;
    private String address;
    private String phone;

    public Client(String uId, String uName, String address, String phone) {
        this.uId = uId;
        this.uName = uName;
        this.address = address;
        this.phone = phone;
    }

    public void setUId(String uId) {
        this.uId = uId;
    }

    public void setuName(String uName) {
        this.uName = uName;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public void setPhone(String phone) {
        this.phone = phone;
    }

    public String getuId() {
        return uId;
    }

    public String getuName() {
        return uName;
    }

    public String getAddress() {
        return address;
    }

    public String getPhone() {
        return phone;
    }
}

2.2.4 测试

@Test
    public void test() throws InstantiationException, IllegalAccessException {
        //创建一个客户，根据当前客户选择的奖品类型得到对应的奖品
        Client user=new Client("C18888","陈先生","江苏-镇江","12345678988");
        ICommodity commodity = StoreFactory.send(user.getuId(), null, CardCommodity.class);
        System.out.println(commodity.info());
    }
    @Test
    public void test02()throws InstantiationException, IllegalAccessException {
        //创建一个客户，根据当前客户选择的奖品类型得到对应的奖品
        Client user=new Client("C26666","王先生","江苏-镇江","12345678988");
        //假设选择实物商品，事务发送需要具体的用户信息
        Map<String,String> ext=new HashMap<>();
        ext.put("uName",user.getuName());
        ext.put("address",user.getAddress());
        ext.put("phone",user.getPhone());
        ICommodity commodity = StoreFactory.send(user.getuId(), ext, GoodsCommodity.class);
        System.out.println(commodity.info());
    }

2.2.5 结果

CardCommodity{, uId='C18888'commodityId=1002, name='会员卡'}
----------------------------------------------------------------
GoodsCommodity{, uId='C26666'commodityId=3002, name='纪念品', ext={address=江苏-镇江, uName=王先生, phone=12345678988}}

2.3 分析

工厂（factory）处理创建对象的细节，一旦有了SimpleFactory，后期如果需要奖品对象直接从工厂中获取即可。但是此时增加了工厂对象和商品对象的耦合。后期如果再加新的奖品，我们势必要需求修改SimpleFactory的代码，违反了开闭原则。工厂类的客户端可能有很多，比如京东、淘等，这样只需要修改工厂类的代码，省去其他的修改操作。

3.优缺点

优点：
封装了创建对象的过程，可以通过参数直接获取对象。把对象的创建和业务逻辑层分开，这样以后就避免了修改客户代码，如果要实现新产品直接修改工厂类，而不需要在原代码中修改，这样就降低了客户代码修改的可能性，更加容易扩展。
缺点：
增加新产品时还是需要修改工厂类的代码，违背了“开闭原则”。

4.简单工厂+配置文件解除耦合

通过上面的简单工厂提供对象的操作，但是我们在增加新的奖品时，就需要修改工厂中代码，可能就会出现某些错误。

可以通过工厂模式+配置文件的方式解除工厂对象和产品对象的耦合。在工厂类中加载配置文件中的全类名，并创建对象进行存储，客户端如果需要对象，直接进行获取即可。这样在新增奖品时，只需在配置文件中添加即可，不需要修改工厂类。

4.1 代码
bean.proerties

design23.factory.simpleFactory.pojo.imp.CardCommodity=design23.factory.simpleFactory.pojo.imp.CardCommodity
design23.factory.simpleFactory.pojo.imp.CouponCommodity=design23.factory.simpleFactory.pojo.imp.CouponCommodity
design23.factory.simpleFactory.pojo.imp.GoodsCommodity=design23.factory.simpleFactory.pojo.imp.GoodsCommodity

public class StoreFactoryNew {
	/*
	静态成员变量用来存储创建的对象（键存储的是名称，值存储的是对
	应的对象），而读取配置文件以及创建对象写在静态代码块中，目的
	就是只需要执行一次。
	*/
    //根据配置创造的对象集合
    private static Map<String, ICommodity> beans=new HashMap<>();
    //读取配置，创建对象，存入集合,
    static {

        try {
            InputStream inputStream = StoreFactoryNew.class.getClassLoader().getResourceAsStream("bean1.properties");
            Properties p=new Properties();
            p.load(inputStream);
            //获取所有的key
            Set<Object> keys = p.keySet();
            for(Object key:keys){
                //根据每个key取得对应的值（类名）
                String className = p.getProperty((String) key);
                //获取字节码对象
                Class<?> clazz = Class.forName(className);
                //创建实例
                ICommodity commodity =(ICommodity) clazz.newInstance();
                beans.put(className,commodity);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

    /*
     * @Description //TODO 根据全类名获取对应的实例
     * @Date
     * @Param
     * @return
     **/
    public static  ICommodity getInstance(String name){
        return beans.get(name);
    }
}

测试

@Test
    public void testNew(){
        Client user=new Client("C18888","陈先生","江苏-镇江","12345678988");
        CardCommodity commodity = (CardCommodity) StoreFactoryNew.getInstance("design23.factory.simpleFactory.pojo.imp.CardCommodity");
        commodity.setUId(user.getuId());
        System.out.println(commodity.info());
    }

CardCommodity{, uId='C18888'commodityId=1002, name='会员卡'}

工厂方法模式

针对上面例子的缺点，再不采用配置文件的解耦，新增奖品就需要修改工厂类，接下来我们采用工厂方法模式(每个奖品对应一个工厂)，就可以完美的解决，完全遵循开闭原则。

1.概念

定义一个用于创建工厂对象的接口，让子类决定实例化哪个产品类对象。工厂方法使一个产品类的实例化延迟到其工厂的子类。

2.基本结构

工厂方法模式的主要角色：

抽象工厂（Abstract Factory）：提供了创建产品的接口，调用者通过它访问具体工厂的工厂
方法来创建产品。
具体工厂（ConcreteFactory）：主要是实现抽象工厂中的抽象方法，完成具体产品的创建。
抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能。
具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同
具体工厂之间一一对应。

3.示例

3.1 我们仍采用奖品派发进行研究
3.2 结构
在这里插入图片描述
3.3 工厂


```cpp
public interface ICommodityService {
    /*
     * @Description //TODO 发送奖励
     * @Date
     * @Param 用户id，用户的额外信息（可以没有）
     * @return 得到一个奖励
     **/
    ICommodity sendCommodity(String uId, Map<String, String> ext);
}


```cpp
public class CardCommodityService implements ICommodityService {
    private CardCommodity cardCommodity;

    @Override
    public ICommodity sendCommodity(String uId, Map<String, String> ext) {
        cardCommodity=new CardCommodity();
        cardCommodity.setUId(uId);
        return cardCommodity;
    }
}

public class CouponCommodityService  implements ICommodityService {
    private CouponCommodity couponCommodity;

    @Override
    public ICommodity sendCommodity(String uId, Map<String, String> ext) {
        couponCommodity=new CouponCommodity();
        couponCommodity.setUId(uId);
        return couponCommodity;
    }
}

public class GoodsCommodityService implements ICommodityService {
    private GoodsCommodity goodCommodity;
    @Override
    public ICommodity sendCommodity(String uId, Map<String, String> ext) {
        goodCommodity=new GoodsCommodity();
        goodCommodity.setExt(ext);
        return goodCommodity;
    }
}

3.4 商店

public class Store {

    /*
     * @Description //TODO 根据不同的工厂得到对应的商品
     * @Date
     * @Param  用户id 额外信息  所需的商品工厂类型
     * @return
     **/
    public static ICommodity send(String uId, Map<String,String> ext, Class<?extends ICommodityService> clazz) throws IllegalAccessException, InstantiationException {
        return clazz.newInstance().sendCommodity(uId,ext);
    }
}

3.5 测试

 public  void test01() throws InstantiationException, IllegalAccessException {
        //创建一个客户，根据当前客户选择的奖品类型得到对应的奖品
        Client user=new Client("C18888","陈先生","江苏-镇江","12345678988");
        //假设选择优惠券
        ICommodity commodity = Store.send(user.getuId(), null, CouponCommodityService.class);
        System.out.println(commodity.info());

    }
    @Test
    public  void test02() throws InstantiationException, IllegalAccessException {
        //创建一个客户，根据当前客户选择的奖品类型得到对应的奖品
        Client user=new Client("C26666","李先生","江苏-镇江","12345678988");
        //假设选择实物商品，事务发送需要具体的用户信息
        Map<String,String> ext=new HashMap<>();
        ext.put("uName",user.getuName());
        ext.put("address",user.getAddress());
        ext.put("phone",user.getPhone());
        ICommodity commodity = Store.send(user.getuId(), ext, GoodsCommodityService.class);
        System.out.println(commodity.info());
    }

CouponCommodity{uId='C18888',commodityId=2002, name='淘宝优惠券'}
----------------------------------------------------------------------
GoodsCommodity{, uId='null'commodityId=3002, name='纪念品', ext={address=江苏-镇江, uName=李先生, phone=12345678988}}

3.6 分析

从以上的编写的代码可以看到，要增加产品类时也要相应地增加工厂类，不需要修改工厂类的代码了，这样就解决了简单工厂模式的缺点。
工厂方法模式是简单工厂模式的进一步抽象。由于使用了多态性，工厂方法模式保持了简单工厂模式的优点，而且克服了它的缺点。

4.优缺点

优点：

用户只需要知道具体工厂的名称就可得到所要的产品，无须知道产品的具体创建过程；
在系统增加新的产品时只需要添加具体产品类和对应的具体工厂类，无须对原工厂进行任何修改，满足开闭原则；

缺点：

每增加一个产品就要增加一个具体产品类和一个对应的具体工厂类，这增加了系统的复杂度。当要增加更多产品时，就需要创建更多的工厂类，容易产生类爆炸。

抽象工厂模式

前面介绍的工厂方法模式中考虑的是一类产品的生产，如畜牧场只养动物、电视机厂只生产电视机、传智播客只培养计算机软件专业的学生等。

这些工厂只生产同种类产品，同种类产品称为同等级产品，也就是说：工厂方法模式只考虑生产同等级的产品，但是在现实生活中许多工厂是综合型的工厂，能生产多等级（种类）的产品，如电器厂既生产电视机又生产洗衣机或空调，大学既有软件专业又有生物专业等。

本节要介绍的抽象工厂模式将考虑多等级（多种）产品的生产，将同一个具体工厂所生产的位于不同等级的一组产品称为一个产品族，下图所示横轴是产品等级，也就是同一类产品；纵轴是产品族，也就是同一品牌的产品，同一品牌的产品产自同一个工厂。

在这里插入图片描述

1.概念

一种为访问类提供一个创建一组相关或相互依赖对象的接口，且访问类无须指定所要产品的具体类就能得到同族的不同等级的产品的模式结构。
抽象工厂模式是工厂方法模式的升级版本，工厂方法模式只生产一个等级的产品，而抽象工厂模式可生
产多个等级的产品。

2.基本结构

抽象工厂模式的主要角色如下：

抽象工厂（Abstract Factory）：提供了创建产品的接口，它包含多个创建产品的方法，可以创建多个不同等级的产品。
具体工厂（Concrete Factory）：主要是实现抽象工厂中的多个抽象方法，完成具体产品的创建。
抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能，抽象工厂模式有多个抽象产品。
具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间是多对一的关系。

3.示例

3.1 我们采用如下两个产品族（商务、休闲）来进行研究
在这里插入图片描述
3.2 结构

3.3 bean

public interface Coat {
    String info();
}

public interface  Pant{
    String info();
}

public interface Shoe{
    String info();
}

public class BusinessCoat implements Coat {
    private Integer id=20000;//商品编号
    private String name;//商品名称
    private String Size;//商品尺寸
    private String uId;//用户id
    public BusinessCoat(){
        id+=1;
        name="商务衣";
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setSize(String size) {
        Size = size;
    }

    public void setuId(String uId) {
        this.uId = uId;
    }

    @Override
    public String toString() {
        return   "{name=" + name +
                ",id=" + id +
                ", Size='" + Size +
                '}'+"\n";
    }

    @Override
    public String info() {
        return toString();
    }
}

public class LeisureCoat implements Coat {
    private Integer id=10000;//商品编号
    private String name;//商品名称
    private String Size;//商品尺寸
    private String uId;//用户id
    public LeisureCoat(){
        id+=1;
        name="休闲衣";
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setSize(String size) {
        Size = size;
    }

    public void setuId(String uId) {
        this.uId = uId;
    }

    @Override
    public String toString() {
        return   "{name=" + name +
                ",id=" + id +
                ", Size='" + Size +
                '}'+"\n";
    }

    @Override
    public String info() {
        return toString();
    }
}

public class BusinessPant implements Pant {
    private Integer id=21000;//商品编号
    private String name;//商品名称
    private String Size;//商品尺寸
    private String uId;//用户id
    public BusinessPant(){
        id+=1;
        name="商务裤";
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setSize(String size) {
        Size = size;
    }

    public void setuId(String uId) {
        this.uId = uId;
    }

    @Override
    public String toString() {
        return   "{name=" + name +
                ",id=" + id +
                ", Size='" + Size +
                '}'+"\n";
    }

    @Override
    public String info() {
        return toString();
    }
}

public class LeisurePant implements Pant {
    private Integer id=11000;//商品编号
    private String name;//商品名称
    private String Size;//商品尺寸
    private String uId;//用户id
    public LeisurePant(){
        id+=1;
        name="休闲裤";
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setSize(String size) {
        Size = size;
    }

    public void setuId(String uId) {
        this.uId = uId;
    }

    @Override
    public String toString() {
        return   "{name=" + name +
                ",id=" + id +
                ", Size='" + Size +
                '}'+"\n";
    }

    @Override
    public String info() {
        return toString();
    }
}

public class BusinessShoe implements Shoe {
    private Integer id=23000;//商品编号
    private String name;//商品名称
    private String Size;//商品尺寸
    private String uId;//用户id
    public BusinessShoe(){
        id+=1;
        name="商务鞋";
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setSize(String size) {
        Size = size;
    }

    public void setuId(String uId) {
        this.uId = uId;
    }

    @Override
    public String toString() {
        return   "{name=" + name +
                ",id=" + id +
                ", Size='" + Size +
                '}'+"\n";
    }

    @Override
    public String info() {
        return toString();
    }
}

public class LeisureShoe  implements Shoe {
    private Integer id=13000;//商品编号
    private String name;//商品名称
    private String Size;//商品尺寸
    private String uId;//用户id
    public LeisureShoe(){
        id+=1;
        name="休闲鞋";
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setSize(String size) {
        Size = size;
    }

    public void setuId(String uId) {
        this.uId = uId;
    }

    @Override
    public String toString() {
        return   "{name=" + name +
                ",id=" + id +
                ", Size='" + Size +
                '}'+"\n";
    }

    @Override
    public String info() {
        return toString();
    }
}

3.4 工厂

public interface ClothesFactory {
    Coat createCoat(String uId, String size);
    Pant creatPant(String uId, String size);
    Shoe creatShoe(String uId, String size);

}

public class BusinessClothesFactory implements ClothesFactory {
    // 商务工厂生产商务产品族
    @Override
    public Coat createCoat(String uId, String size) {
        BusinessCoat coat = new BusinessCoat();
        coat.setuId(uId);
        coat.setSize(size);
        return coat;
    }

    @Override
    public Pant creatPant(String uId, String size) {
        BusinessPant pant = new BusinessPant();
        pant.setuId(uId);
        pant.setSize(size);
        return pant;

    }

    @Override
    public Shoe creatShoe(String uId, String size) {
        BusinessShoe shoe = new BusinessShoe();
        shoe.setuId(uId);
        shoe.setSize(size);
        return shoe;
    }
}

public class LeisureClothesFactory implements ClothesFactory {
    // 休闲工厂生产休闲产品族
    @Override
    public Coat createCoat(String uId, String size) {
        LeisureCoat coat = new LeisureCoat();
        coat.setuId(uId);
        coat.setSize(size);
        return coat;
    }

    @Override
    public Pant creatPant(String uId, String size) {
        LeisurePant pant = new LeisurePant();
        pant.setuId(uId);
        pant.setSize(size);
        return pant;
    }

    @Override
    public Shoe creatShoe(String uId, String size) {
        LeisureShoe shoe = new LeisureShoe();
        shoe.setuId(uId);
        shoe.setSize(size);
        return shoe;
    }
}

3.5 商店

public class Store {
    /*
     * @Description //TODO 选择上衣类型
     * @Date
     * @Param
     * @return
     **/
    public static Coat sellCoat(String uId, String size, Class<? extends ClothesFactory>clazz) throws IllegalAccessException, InstantiationException {
        return clazz.newInstance().createCoat(uId,size);
    }
    /*
     * @Description //TODO 选择裤子类型
     * @Date
     * @Param
     * @return
     **/
    public static Pant sellPant(String uId, String size, Class<? extends  ClothesFactory>clazz) throws IllegalAccessException, InstantiationException {
        return clazz.newInstance().creatPant(uId,size);
    }
    /*
     * @Description //TODO 选择鞋子类型
     * @Date
     * @Param
     * @return
     **/
    public static Shoe sellShoe(String uId, String size, Class<? extends  ClothesFactory>clazz) throws IllegalAccessException, InstantiationException {
        return clazz.newInstance().creatShoe(uId,size);
    }
    /*
     * @Description //TODO 选择一个套装（产品族）
     * @Date
     * @Param
     * @return
     **/
    public static String sellClothes(String uId,String size,Class<? extends ClothesFactory>clazz) throws IllegalAccessException, InstantiationException {
        ClothesFactory clothesFactory = clazz.newInstance();
        Coat coat = clothesFactory.createCoat(uId,size);
        Pant pant=clothesFactory.creatPant(uId,size);
        Shoe shoe=clothesFactory.creatShoe(uId,size);
        return "用户:"+uId+"\n"+coat.info()+pant.info()+shoe.info();
    }
}

3.6 客户

public class Client {
    private String uId;
    private String size;

    public Client(String uId, String size) {
        this.uId = uId;
        this.size = size;
    }

    public String getuId() {
        return uId;
    }

    public String getSize() {
        return size;
    }
}

3.7 测试

//自由选择
@Test
    public void test01() throws InstantiationException, IllegalAccessException {
        Client user=new Client("U1001","xL'");
        Coat coat = Store.sellCoat(user.getuId(), user.getSize(), LeisureClothesFactory.class);
        Pant pant=Store.sellPant(user.getuId(),user.getSize(), LeisureClothesFactory.class);
        Shoe shoe=Store.sellShoe(user.getuId(),user.getSize(), LeisureClothesFactory.class);
        System.out.println("用户:"+user.getuId()+"\n"+coat.info()+pant.info()+shoe.info());

    }
	//选择套装
    @Test
    public void test02() throws InstantiationException, IllegalAccessException {
        Client user=new Client("U2001","XL'");
        String clothes = Store.sellClothes(user.getuId(), user.getSize(), BusinessClothesFactory.class);
        System.out.println(clothes);
    }

结果

用户:U1001
{name=休闲衣,id=10001, Size='xL'}
{name=休闲裤,id=11001, Size='xL'}
{name=休闲鞋,id=13001, Size='xL'}
------------------------------------------------------------
用户:U2001
{name=商务衣,id=20001, Size='XL'}
{name=商务裤,id=21001, Size='XL'}
{name=商务鞋,id=23001, Size='XL'}

3.8 分析
如果要加同一个产品族的话，只需要再加一个对应的工厂类即可，不需要修改其他的类。

4.优缺点

优点：
当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。
缺点：
当产品族中需要增加一个新的产品时，所有的工厂类都需要进行修改。

5.使用场景

当需要创建的对象是一系列相互关联或相互依赖的产品族时，如电器工厂中的电视机、洗衣机、空调等。
系统中有多个产品族，但每次只使用其中的某一族产品。如有人只喜欢穿某一个品牌的衣服和鞋。
系统中提供了产品的类库，且所有产品的接口相同，客户端不依赖产品实例的创建细节和内部结构。
如：输入法换皮肤，一整套一起换。生成不同操作系统的程序。

jdk工厂模式应用

1.Collection.iterator方法
在这里插入图片描述

Collection接口是抽象工厂类，ArrayList是具体的工厂类；Iterator接口是抽象商品类，ArrayList类中的Iter内部类是具体的商品类。在具体的工厂类中iterator()方法创建具体的商品类的对象。
2.Calendar类中的gentInstance（）就使用了简单工厂模式

    public static Calendar getInstance(TimeZone zone)
    {
        return createCalendar(zone, Locale.getDefault(Locale.Category.FORMAT));
    }

    /**
     * Gets a calendar using the default time zone and specified locale.
     * The <code>Calendar</code> returned is based on the current time
     * in the default time zone with the given locale.
     *
     * @param aLocale the locale for the week data
     * @return a Calendar.
     */
    public static Calendar getInstance(Locale aLocale)
    {
        return createCalendar(TimeZone.getDefault(), aLocale);
    }

    /**
     * Gets a calendar with the specified time zone and locale.
     * The <code>Calendar</code> returned is based on the current time
     * in the given time zone with the given locale.
     *
     * @param zone the time zone to use
     * @param aLocale the locale for the week data
     * @return a Calendar.
     */
    public static Calendar getInstance(TimeZone zone,
                                       Locale aLocale)
    {
        return createCalendar(zone, aLocale);
    }

    private static Calendar createCalendar(TimeZone zone,
                                           Locale aLocale)
    {
        CalendarProvider provider =
            LocaleProviderAdapter.getAdapter(CalendarProvider.class, aLocale)
                                 .getCalendarProvider();
        if (provider != null) {
            try {
                return provider.getInstance(zone, aLocale);
            } catch (IllegalArgumentException iae) {
                // fall back to the default instantiation
            }
        }

        Calendar cal = null;

        if (aLocale.hasExtensions()) {
            String caltype = aLocale.getUnicodeLocaleType("ca");
            if (caltype != null) {
                switch (caltype) {
                case "buddhist":
                cal = new BuddhistCalendar(zone, aLocale);
                    break;
                case "japanese":
                    cal = new JapaneseImperialCalendar(zone, aLocale);
                    break;
                case "gregory":
                    cal = new GregorianCalendar(zone, aLocale);
                    break;
                }
            }
        }
        if (cal == null) {
            // If no known calendar type is explicitly specified,
            // perform the traditional way to create a Calendar:
            // create a BuddhistCalendar for th_TH locale,
            // a JapaneseImperialCalendar for ja_JP_JP locale, or
            // a GregorianCalendar for any other locales.
            // NOTE: The language, country and variant strings are interned.
            if (aLocale.getLanguage() == "th" && aLocale.getCountry() == "TH") {
                cal = new BuddhistCalendar(zone, aLocale);
            } else if (aLocale.getVariant() == "JP" && aLocale.getLanguage() == "ja"
                       && aLocale.getCountry() == "JP") {
                cal = new JapaneseImperialCalendar(zone, aLocale);
            } else {
                cal = new GregorianCalendar(zone, aLocale);
            }
        }
        return cal;
    }

霓乤

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
设计模式--工厂模式（三种）

工厂模式概述简单工厂1.基本结构2.示例3.优缺点4.简单工厂+配置文件解除耦合工厂方法模式1.概念2.基本结构3.示例4.优缺点抽象工厂模式1.概念2.基本结构3.示例4.优缺点概述简单工厂1.基本结构2.示例3.优缺点4.简单工厂+配置文件解除耦合工厂方法模式1.概念2.基本结构3.示例4.优缺点抽象工厂模式1.概念2.基本结构3.示例4.优缺点...
复制链接

扫一扫