cari

Rumah  >  Soal Jawab  >  teks badan

javascript - 关于抽象工厂模式的一个问题

有咩有看过张容铭的javascript设计模式这一本书的?

其中见到抽象工厂模式

抽象工厂模式(abstract Fctory):通过对类的工厂抽象使其业务用于对产品类鏃的创建,而不负责创建某一类产品的实例.

1

2

3

4

5

6

7

8

9

10

11

<code>//汽车抽象类,当使用其实例对象的方法时会抛出错误

    var Car = function(){};

    Car.protorype = {

        getPrice : function(){

            return new Error('抽象方法不能调用!');

        },

        getSpeed : function(){

            return new Error('抽象方法不能调用!');

        }

    }

</code>

我们不能使用它来创建一个真实的对象,一般用来作为父类来创建一些子类

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

<code>//抽象工厂方法

    var AbstractFactory = function(subType,superType){

        //判断抽象工厂种是否有这个抽象类\

        if(typeof(AbstractFactory[superType])=='function'){

            //缓存类

            function F(){};

            //继承父类属性和方法

            F.protorype = new AbstractFactory[superType]();

            //将子类constructor指向子类

            subType.constructor = subType;

            //子类原型继承"父类"

            subType.prototype = new F();

        }else{

            //不存在该抽象类抛出错误

            throw new Error('未创建该抽象类');

        }

    }

    //小汽车抽象类

    AbstractFactory.Car = function(){

        this.type = 'Car';

    }

    AbstractFactory.Car.prototype = {

        getPrice : function(){

            return new Error('抽象方法不能调用!');

        }

    }

     

    </code>

抽象工厂其实是一个实现子类继承父类的方法,在这个方法种我我们需要传入子类以及要继承父类的名称.
过渡类的原型继承,不是继承父类的原型,而是通过new 复制一个父类的实例,过渡类不仅仅继承了父类的原型方法,还继承了父类的对象属性.
使用方法

1

2

3

4

5

6

7

8

9

10

11

<code>//宝马汽车类

    var BMW = function(price,speed){

        this.price = price;

        this.speed = speed;

    }

    //抽象工厂实现对Car抽象类的继承

    AbstractFactory(BMW,'Car');

    BMW.prototype.getPrice = function(){

        return this.price;

    }

    </code>

我的问题是:这一句

1

2

3

<code>//将子类constructor指向子类

                subType.constructor = subType;

                </code>

意义何在?
还有,为什么要弄个F函数来缓存?直接

1

2

<code>subType.prototype = new AbstractFactory[superType]();

</code>

不是更省事吗?很疑惑

伊谢尔伦伊谢尔伦2908 hari yang lalu943

membalas semua(1)saya akan balas

  • 高洛峰

    高洛峰2017-04-11 09:01:16

    1:首先,为什么这个的constructer要指向subType?
    实例化一个对象的时候,会产生一个指针属性:_protol_,指向实例的原型对象。我们的原型对象内会产生constructor属性,指向它的构造函数。
    我们的实例能从原型对象上继承属性与方法。同时,我们原型对象内的constructor属性自然也能够继承到。
    现在来看问题中的例子:

    1

    2

    3

    4

    5

    6

    7

    8

    <code>if(typeof(AbstractFac[superType]) == 'function'){

        function F(){}

        F.prototype = new AbstractFac[superType]();

        console.log(subType);

        console.log(subType.constructor);

    }else{

        throw new Error('null');

    }</code>

    在重新指定constructor和进行继承前来看看 传入的subType 和 它的构造函数是什么:

    1

    2

    3

    4

    5

    <code>function(price,speed){

        this.price = price;

        this.speed = speed;

    }

    function Function() { [native code] }</code>

    即我们下面传入子类的构造函数,此时的子类还没有实例化,所以它还并没有从其原型对象上获取到constructor属性。
    此时,
    subType : 我们定义的子类函数
    subType.constructor(即一个函数的构造函数): 当然就是我们的Function对象了!
    那么我们的抽象工厂为了创建出这个子类实例,需要做什么呢?
    也就是例子中写的啦:

    1

    2

    <code> subType.constructor = subType;

     subType.prototype = new F();</code>

    这样一来,我们定义的未实例化的子类函数,通过这个抽象工厂,进行了实例化;通过subType.constructor = subType得到了本身应该有的constructror属性,通过原型继承到了父类的属性和方法。
    2:为什么要弄个F函数来缓存?
    因为数组,对象,函数(方法),作为引用类型,它们的名称只是指向堆内存的指针。如果直接subType.prototype = new AbstractFactory[superType]();那么我们可以通过子类去修改堆内存中的内容。进而改变父类的引用类型的值了。
    缓存的话,能够 阻止我们的子类对父类可能发生的更改。

    balas
    0
  • Batalbalas