了解23种设计模式之工厂模式

最新推荐文章于 2024-08-05 14:28:44 发布

可乐cc呀

最新推荐文章于 2024-08-05 14:28:44 发布

阅读量467

点赞数 1

分类专栏：设计模式文章标签：设计模式工厂模式

本文链接：https://blog.csdn.net/Crazy_Cw/article/details/103555692

版权

设计模式专栏收录该内容

23 篇文章 4 订阅

订阅专栏

一，简单介绍：

1.1：前言：

古人云：三人行，必有我师焉。

二，简单的工厂模式

简单的工厂模式属于类的创建型模式，又叫静态工厂方法模式，通过专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类，语句意思也很容易懂。接下来，我们来用最简单的代码来实现：

工厂（Creator）角色;

简单工厂模式的核心，它负责实现创建所有实例的内部逻辑，工厂类可以被外界直接调用，创建所需的产品对象。

抽象（Product）角色；

简单工厂模式所创建的所有对象的父类，它负责描述所有实例所有的公共接口。

具体产品（Concenter Product）角色；

简单工厂模式所创建的具体实例对象

2.1: 创建两个娃娃基类共同实现接口 CqwwCall，创建一个父类使用多态来实现简单的工厂模式：

America 类
Japan 类
CqwwCall 接口

public class America implements CqwwCall{

    @Override
    public void call(){
        System.out.println("o,yes....o, no, o,yes,o,no");
    }

}

public class Japan implements  CqwwCall{

    @Override
    public void call(){
        System.out.println("o,亚麻跌。。。。。");
    }
}

public interface CqwwCall {

     void  call();
}

WawaFactory 类工厂

public class WawaFactory {

    /**
     * 得到美国娃娃的实例
     * @return
     */
    public static CqwwCall getAmericaWawa(){
       return new America();
    }

    /**
     * 得到日本娃娃的实例
     * @return
     */
    public static CqwwCall getJapanWawa(){
        return new Japan();
    }


}

测试

public class TestWawa {

    public static void main(String[] args){
        CqwwCall america =  WawaFactory.getAmericaWawa();
        CqwwCall japan = WawaFactory.getJapanWawa();

        america.call();
        japan.call();
    }
}

2.2 这样的工厂类太简单了，接下来我们来做升级改造一下工厂类：

WawaFactory 工厂类

public class WawaFactory {

   /* *//**
     * 得到美国娃娃的实例
     * @return
     *//*
    public static CqwwCall getAmericaWawa(){
       return new America();
    }

    *//**
     * 得到日本娃娃的实例
     * @return
     *//*
    public static CqwwCall getJapanWawa(){
        return new Japan();
    }*/

    /**
     * 通过传来的类名来实例化对象
     * @param type
     * @return
     */
    public static CqwwCall getWawa(String type) {
        try {
            //判断类型
            if(type.equalsIgnoreCase("japan")){
                    return  Japan.class.newInstance();
            }else if(type.equalsIgnoreCase("america")){
                    return  America.class.newInstance();
            }
        } catch (InstantiationException e) {
            e.printStackTrace();
            System.out.println("找不到对象");
        } catch (IllegalAccessException e) {
            e.printStackTrace();
            System.out.println("找不到对象");
        }
        return  null;
    }


}

测试

public class TestWawa {

    public static void main(String[] args){
//        CqwwCall america =  WawaFactory.getAmericaWawa();
//        CqwwCall japan = WawaFactory.getJapanWawa();
//        america.call();
//        japan.call();

        CqwwCall america = WawaFactory.getWawa("america");
        america.call();
        CqwwCall japan = WawaFactory.getWawa("japan");
        japan.call();
    }
}

1.2.2 那如果基类太多我们不是要频繁判断创建，但是这样将方法创建变得不太灵活，接下来我们来做继续升级改造一下工厂类：

public class WawaFactory {

   /* *//**
     * 得到美国娃娃的实例
     * @return
     *//*
    public static CqwwCall getAmericaWawa(){
       return new America();
    }

    *//**
     * 得到日本娃娃的实例
     * @return
     *//*
    public static CqwwCall getJapanWawa(){
        return new Japan();
    }*/

    /**
     * 通过传来的类名来实例化对象
     * @param type
     * @return
     */
    public static CqwwCall getWawa(String type) {
        try {
            //判断类型
            if(type.equalsIgnoreCase("japan")){
                    return  Japan.class.newInstance();
            }else if(type.equalsIgnoreCase("america")){
                    return  America.class.newInstance();
            }
        } catch (InstantiationException e) {
            e.printStackTrace();
            System.out.println("找不到对象");
        } catch (IllegalAccessException e) {
            e.printStackTrace();
            System.out.println("找不到对象");
        }
        return  null;
    }

    public static CqwwCall getWawa2(String type) {
        try {
            Class  cqwwCall= Class.forName(type);
            return (CqwwCall)cqwwCall.newInstance();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
            System.out.println("找不到对象");
        }catch (InstantiationException e){
            e.getMessage();
            System.out.println("实例化错误");
        }catch (IllegalAccessException e){
            e.getMessage();
            System.out.println("非法访问异常");
        }
        return  null;
    }
}

测试

public class TestWawa {

    public static void main(String[] args){
//        CqwwCall america =  WawaFactory.getAmericaWawa();
//        CqwwCall japan = WawaFactory.getJapanWawa();
//        america.call();
//        japan.call();

        CqwwCall america = WawaFactory.getWawa2("com.enjoy.cap13.America");
        america.call();
        CqwwCall japan = WawaFactory.getWawa2("com.enjoy.cap13.Japan");
        japan.call();
    }
}

三，工厂方法模式：

工厂方法模式同样属于类的创建型模式又被称为多态工厂模式。工厂方法模式的意义是定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类当中。核心工厂类不在负责产品的创建，这样核心类称为一个抽象工厂的角色，仅负责具体工厂子类必须实现的接口，这样进一步抽象化的好处是使得工厂方法模式可以系统在不修改具体工厂角色的情况下引进新的产品。

基类 America Japan (同上简单工厂方法模式)
接口 CqwwCall （同上）
创建产品对象的工厂抽象接口（核心） WawaInFactory

public interface WawaInFactory {
      CqwwCall getCawwCall();
}

子类工厂 AmericaFactory ，JapanFactory 去实现创建实例化

public class AmericaFactory implements WawaInFactory{
    @Override
    public CqwwCall getCawwCall() {
        return new America();
    }
}

public class JapanFactory implements  WawaInFactory {
    @Override
    public CqwwCall getCawwCall() {
        return  new Japan();
    }
}

测试

public class TestWawa {

    public static void main(String[] args){

        AmericaFactory ambientProperty = new AmericaFactory();
        America america = (America) ambientProperty.getCawwCall();
        america.call();

        JapanFactory japanFactory =new JapanFactory();
        Japan japan = (Japan)japanFactory.getCawwCall();
        japan.call();
    }
}

这样符合软件设计开闭原则，开放让后面随意进行扩展，关闭修改以前的代码。

工厂方法模式比较简单工厂模式，工厂方法模式与简单工厂模式在结果上的不同不是很明显。

工厂方法模式的核心是一个抽象工厂接口类，
简单工厂模式是把核心放在一个具体类上。

工厂方法模式之所以有一个别名叫多态性工厂模式是因为具体工厂模式都有共同的接口，或者有共同的抽象方法。

当系统扩展需要添加新的产品对象时仅仅需要添加一个具体对象以及一个具体工厂对象，原有工厂对象不需要进行任何修改，也不需要修改客户端。

四，抽象工厂模式

抽象工厂模式：

抽象工厂模式是所有形态的工厂模式中最为抽象和最其一般性的，抽象工厂模式可以向客户端提供一个接口，使得客户端在不必指定产品具体的情况下，能够创建多个产品对象。

抽象工厂模式的核心，任何工厂都必须实现这个接口 (CqwwCallFactroy)
具体工厂是抽象工厂的一个实现，负责实例化（WawaFactroy）
具体产品，抽象模式所创建的具体事例对象（SpecificJapan, SpencificAmerica）

public interface CqwwCall {

     void call();
}

public abstract class America  implements CqwwCall {

    public abstract void call();

}

public class SpecificAmerica extends America {
    @Override
    public void call() {
        System.out.println("o,yes....o, no, o,yes,o,no");
    }
}

public abstract  class Japan  implements CqwwCall {

     public abstract void call();
}

public class SpecificJapan extends  Japan {
    @Override
   public void call() {
        System.out.println("o,亚麻跌。。。。。");
    }
}

public interface CqwwCallFactroy  {

    /**
     * 创建实例
     * @return
     */
    CqwwCall getAmericaFactory();

    CqwwCall getJapanFactory();
}

public class WawaFactroy implements  CqwwCallFactroy {

    @Override
    public CqwwCall getAmericaFactory() {
        return new SpecificAmerica();
    }

    @Override
    public CqwwCall getJapanFactory() {
        return new SpecificJapan();
    }
}

五，使用工厂模式简单实现一个计算器

5.1 编写一个抽象类：（抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。）

public abstract class Operation {

    private Double num1;
    private Double num2;

    public Double getNum1() {
        return num1;
    }

    public void setNum1(Double num1) {
        this.num1 = num1;
    }

    public Double getNum2() {
        return num2;
    }

    public void setNum2(Double num2) {
        this.num2 = num2;
    }

    /**
     * 抽象方法
     * @return
     */
    public  abstract  Double getResult();
}

5.2 编写，继承抽象类，重写方法实现两个数的加法

public class AddOperation  extends Operation{

    @Override
    public Double getResult() {
        return this.getNum1() + this.getNum2();
    }
}

5.3 编写，工厂类

public class OperationFactory {

    public static Operation getOperation(String oper) {

        if ("+".equals(oper)) {
            return new AddOperation();
        } else if ("-".equals(oper)) {
            return new SubtractionOperation();
        }
        return null;
    }
}

5.4编写，测试类

public class Test {

    public static void main(String[] args) {

        Operation operation = OperationFactory.getOperation("+");
        operation.setNum2(2.0);
        operation.setNum1(2.0);
        Double result = operation.getResult();

        System.out.println(result);
    }
}

5.5执行结果