javascript 面向对象设计之 Function 普通类

Posted nDos

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了javascript 面向对象设计之 Function 普通类相关的知识,希望对你有一定的参考价值。



var test = "Class01";

function Class01(privateValue, publicValue) {

    var _this = this;
    if (this.constructor.name !== ‘Class01‘) { throw new Error(‘类只能被实例化‘); }

    /*统计实例化次数的自执行函数*/
    (function newClass() {
        Class01.count++; /*统计实例化的次数*/
        Class01.intances.push(_this); /*保存每个实例的引用*/
        console.log(Class01.count);
    })();

    /*私有变量和私有方法*/
    function privateMethod() { console.log(‘private method was called by publicMethod‘) } //
    var privateVal = privateValue;
    /*私有变量储存接口*/
    this.get = function () { return privateVal; };
    this.set = function (v) { privateVal = v; return this; };

    /*实例属性和实例方法(一般并不会创建实例方法,如果一定要定义实例方法,实例化之后自行添加)*/
    this.public = publicValue;
    this.publicMethod = function () {
        console.log(‘public method and then call private method‘);
        privateMethod();  /*内部使用私有方法*/
        return this;
    };
    /*实例方法可以使用类的静态属性和方法*/
    this.callClassStaticMethod = function () {
        console.log(Class01.staticValue);
        Class01.staticMethod();
    };
}

/* 原型属性和方法
 * 1、类被实例化次数和保存引用的数组也可以放在原型中
 * 2、每个实例都拥有其他实例的引用和实例化次数
 */
Class01.prototype.proValue = ‘this is Class01 prototype value‘;
Class01.prototype.proMethod = function () {
    console.log(‘this is Class01 prototype method‘);
};
Class01.prototype.proArray = [1, 2, 3, 4, 5];
Class01.prototype.proObject = { a:‘a‘ };

/* 静态属性和静态方法
 * 静态属性是否可用于储存该类被实例化的次数,通过在类中加入一个自执行函数即可。
 * 也可以在每次实例化的时候执行某种操作
 * 1、比如当实例化的数量超过某个值的时候,抛出错误,告诉程序内存占用过高。
 * 2、可以在类的静态属性中,保存每个实例的引用(肯定造成内存泄漏)。
 */
Class01.staticValue = ‘this is class static value‘;
Class01.staticMethod = function () { console.log(‘this is class static method‘) };
Class01.count = 0;
Class01.intances = [];

/* 测试 Class01 */
if (test === "Class01") {

    var instance01 = new Class01(‘private value1‘, ‘public value1‘);
    var instance02 = new Class01(‘private value2‘, ‘public value2‘);

    console.log(Class01.intances);

    console.log(‘实例私有属性‘);
    console.log(instance01.get());
    console.log(instance01.set(‘change private value1‘).get());
    console.log(instance02.get());
    console.log(instance02.set(‘change private value2‘).get());

    console.log(‘实例属性‘);
    console.log(instance01.public);
    console.log(instance02.public);

    console.log(‘实例方法‘);
    instance01.publicMethod();
    instance02.publicMethod();
    console.log(instance01.publicMethod === instance02.publicMethod);

    console.log(‘实例原型属性‘);
    console.log(instance01.proValue);
    instance01.proValue = ‘instance01 change proto value‘;
    console.log(instance01.proValue);
    console.log(instance02.proValue);
    /*instance01并没有能够修改原型属性,而是在实例上创建了实例属性*/

    try {
        /*无法在实例上改变原型上的属性*/
        instance01.prototype.proValue = ‘class static value changed‘;
    } catch (e) {
        console.error(e);
    }

    try {
        /*总之实例不允许使用prototype来使用属性和方法*/
        console.log(instance02.prototype.proValue);
    } catch (e) {
        console.error(e);
    }

    /*若原型属性是数值/字符串/布尔值,实例是没有手段可以修改。当原型属性是引用时(数值/对象)时,便可以修改从而在所有的实例对象上会反应出来。*/
    console.log(instance01.proArray);
    instance01.proArray.push(6);
    console.log(instance02.proArray);

    console.log(‘类静态方法‘);
    instance01.callClassStaticMethod();
    instance02.callClassStaticMethod();

    try {
        /*不能在实例上设置 prototype 方法(原因很简单,十几个人做一个项目,每个人都想往实例原型上添加方法,项目则无法完成)*/
        instance01.prototype.print = function () {
            console.log(‘prototype‘);
        };
    } catch (e) {
        console.error(e);
    }
    try {
        /*尽管 Class01 是 function 但是并不能执行*/
        Class01();
    } catch (e) {
        console.error(e);
    }

    try {
        /*显然也不能采用 call 的方式。*/
        var instance03 = {};
        Class01.call(instance03, ‘private value3‘, ‘public value3‘);
    } catch (e) {
        console.error(e);
    }

    /*以下这种方法,能够使用 Class01 进行函数式"实例化",但是原型都消失了。*/
    function Class01_t() {
    }

    Class01_t.prototype.constructor = {name: ‘Class01‘};
    var instance04 = new Class01_t();
    Class01.call(instance04, ‘private value4‘, ‘public value4‘);
    console.log(instance04);

    /* 下面这种方法能够完美模拟 Class01 实例化
     * 1、以下例子可以看出,在Class01_t2中,可以添加实例新的属性和方法。
     * 下面从继承的角度去看。
     * 2、Class01_t2中定义的属性和方法,显然会被 Class01中的覆盖掉。
     * 3、在Class01_t2原型上添加方法和属性,显然会覆盖Class01的。从而影响所有的由Class01创建的实例
     * 4、无论如何,Class01静态方法和属性都在constructor中
     * 目前的主题并不是类的继承,关于function类的实例化和相关知识目前先介绍这么多。
     */
    function Class01_t2() {
        console.log(‘Class01_t2 was called‘);
        Class01.call(this, ‘private value5‘, ‘public value5‘);
        /* 从此处开始可以劫持Class01的公有属性和方法,无法劫持私有的属性和方法(无法取得其引用,自然无法调用)。
         * 使用 Function.prototype.after 的方式可以实现劫持各种方法。
         */
    }

    Class01_t2.prototype = Class01.prototype;
    var instance05 = new Class01_t2();
    console.log(instance05);
    instance05.constructor.staticMethod();
    console.log(instance05.constructor === Class01);
    /*构造函数指向 Class01;*/

    console.log(instance05.prototype);
    /*undefined*/
    console.log(instance04.prototype);
    /*undefined*/
    console.log(instance01.prototype);
    /*undefined*/
    console.log(Class01_t2.constructor === Class01.constructor);
    /*构造函数相等*/
    console.log(Class01_t2.__proto__ === Class01.__proto__);
    /*true*/
    console.log(instance05.__proto__ === instance01.__proto__);
    /*true*/
    console.log(instance05.constructor.name);
    /*Class01*/
    /*通过实例的 constructor 可以找到类。可以通过new constructor 从而可以从类实例化。*/
    console.log(instance05.__proto__.constructor === Class01);
    /*true*/
    console.log(instance05.constructor === Class01);
    /*true*/

    var instance06 = new instance05.constructor(‘private value6‘, ‘public value6‘);
    console.log(instance06.get());

    /* 总结
     * 1、只有函数才能被实例化,实例化之后得到的变量是实例并不是函数,或者说是object
     * 2、有一种可以不修改 Class01 也可以扩充变量或方法(公有或私有)的方式,上述 Class01_t2
     * 对于这种方式,由相当多的内容可以想象:比如是否可以劫持Class01中的公有方法
     */
}

以上是关于javascript 面向对象设计之 Function 普通类的主要内容,如果未能解决你的问题,请参考以下文章

JavaScript高级程序设计笔记之面向对象

JavaScript 面向对象的程序设计之理解对象属性

JavaScript之面向对象的程序设计

JavaScript设计模式基础之面向对象的JavaScript

JavaScript设计模式基础之面向对象的JavaScript

javascript 面向对象设计之 Function 普通类