Javascript 类

　　Javascript中定义类的方式网上流传有很多种，什么工厂方式、构造函数方式、原型方式等等，这里拿我一般用的比较多的方式说说。

　　1.创建一个类，定义一些属性和简单方法

　　

    /*演示一个简单类，具有一些属性和简单方法
    //一般来说，最熟悉的定义的方式：跟定义一个函数相似
    */
    function o() {
        this.Author = "Eson";
        this.Edition = "1.0";
        this.publishTimes = 0;
        this.publish = function () {
            this.publishTimes++;
        }
    }
    var obj = new o();
    alert(obj.Author);
    obj.Edition = "1.1";
    alert(obj.Edition);
    alert("publishTimes:" + obj.publishTimes);
    obj.publish();
    alert("publishTimes:" + obj.publishTimes);

 

　　2.静态属性、静态方法、构造函数

　　静态属性和静态方法使用到关键字prototype，定义方式：classname.prototype.属性名=value ，classname.prototype.Method=function(){...}，

　　构造函数实质就是上面定义类的另外一个说法

　　静态属性：

    /*静态属性
    //静态属性按照理论上来说是属于某个类的，而不是某个对象；
    //在javascript中，如果类具有静态属性，那么只有通过classname.prototype.staticAttribute来更改静态属性的值，
    //任何以 实例.staticAttribute来更改的，只会将更改应用到对象本身，而不是类或其他对象的属性值。
    //可以发现：即使使用classname.prototype.staticAttribute来更改类的属性值，也不能完全更改所有实例的值，
    //而只能更改静态属性未被修改过的实例的静态属性值，如果某些实例更改过静态属性，则这些实例的值会一直保存，而不会随着类的变化而改变。
    //总结：①类的静态属性会保留在其实例对象中，作为实例对象的私有属性存在；
    //     ②任何时候要改变类的静态属性值，都只能用：classname.prototype.staticAttribute来调用或更改；
    //     ③实例化类后，静态属性变成实例的私有属性，在实例更改过此属性后，类再次更改静态属性时，此实例的静态属性值不会再改变。
    */

    function school() {
        this.name = "GS.com";
        school.prototype.studentCount = 3;//static attribute
    }
    var s = new school();
    var t = new school();
    alert(s.name);
    //s.studentCount++;//这句代码说明了关键，如果执行了这句代码，则以下alert的三个值会有一定的变化
    alert(s.studentCount);//执行s.studentCount++后，这里变为4，不执行为3
    alert(t.studentCount);//3
    alert(school.prototype.studentCount); //3

    school.prototype.studentCount = 9;//改变类的静态属性，其余为被修改过的对象的此属性值会随着这里而变化。

    alert(s.studentCount); //执行s.studentCount++后，这里的值仍然是4(保留的是对象本身的属性值)，不执行为9(随着类的变化而变化)
    alert(t.studentCount);//9
    alert(school.prototype.studentCount);//9

　　静态方法：

 

    /*静态方法，构造函数
    //构造函数实质就是方法本身，可进行字段初始化，以及一些其他的操作。
    //静态方法的指定与静态属性的指定相同，class.prototype.Method=function(){...}，可后续增加属性或方法
    //与静态属性一样，在实例 改变/重写 方法后，将始终保持实例对象的最终结果，而不是类的方法
    //在为类添加方法或属性后，原来创建的对象也会被加上相应的属性或方法
    */

    function person(name) {
        this.name = name ? name : "NoName";
        this.sex = 1; //valide value:0(girl),1(boy)
        person.prototype.hello = function () {
            alert("hello,i'm " + this.name + ",and i'm a " + (this.sex ? "boy" : "girl"));
        }
    }
    person.prototype.IsClever = true;
    person.prototype.DressOn = function () {
    //写成person.DressOn也可以，但是为了规范，还是加上prototype好，省略了不知道会出个啥问题
        alert("this is person.DressOn");
    }
    var a = new person();
    var b = new person();
    b.name = "Aliy";
    a.name = "Eson";
    a.hello();//调用实例a的hello方法。
    a.DressOn = function () {//覆写实例a的DressOn方法，而不是person类的DressOn方法
        alert("this is Eson.DressOn");
    }
    a.DressOn();
    person.prototype.DressOn = function () { alert("person's new DressOn!"); }//重写类的DressOn方法
    a.DressOn();//通过类重写DressOn方法后，a实例的DressOn没有随之改变，而是保留了a实例最后一次修改的值，跟静态属性规则一致
    b.DressOn();//由于实例b创建后，DressOn方法未曾被修改过，因此当类改变DressOn后，b的DressOn方法也随之改变。
    person.prototype.DressOn();
    //add another new method and attribute
    person.prototype.oh = function () { alert("surprise"); }
    person.prototype.ok = "YES";
    person.prototype.oh();
    alert(person.prototype.ok);
    var c = new person();
    c.oh();
    a.oh(); //a实例同样具备了person类后来添加的一个方法
    alert(a.ok + c.ok); //a实例同样具备了person类后来添加的一个属性

 

 

 

其实不知道说成静态属性和静态方法是否合适，知道怎么用就可以了，这是我一直以来写代码的习惯，不管怎么写，知道实现原理即可，

上面的注释里面说道：

　　任何以 实例.staticAttribute来更改的，只会将更改应用到对象本身，而不是类或其他对象的属性值。

　　可以发现：即使使用classname.prototype.staticAttribute来更改类的属性值，也不能完全更改所有实例的值

其实，实例是没有静态属性的，所以说 实例.静态方法 或者 实例.静态属性 都不太合适，因为静态的东西不能这样调用，而只能通过类来调用，所以可以解释为js中实例化一个类后，自动将静态属性或方法实例化到具体的实例当中去了。这样就可以解释：为什么当一个实例的"静态方法/属性"改变后，类再改变它的静态属性/方法时，此实例的值不会变化了。不过又该怎么解释其余的未曾发生过变化的实例中的这些"静态属性/方法"呢？Javascript确实有点意思。

　　

　　3.继承：这个一般没怎么用上，所以就简单的了解了一下

 

/*继承：子类.prototype = new 父类();一般不作为重点研究
    //可以根据继承的特点，在子类中覆写父类的方法
    */
    function A() {
    this.name = "Eson";
    this.Father = "Yes";
    this.show = function () { alert(this.name); }
    this.Say = function () { alert("this is A's Say Function"); }
    }
    function B() {
        this.show = function () {//覆写A类的show方法，如果不覆写，则B.show()会调用到A类的show方法
            alert("this is B's Show");
        }
    }
    B.prototype = new A();//让B继承于A
    var obj = new B();
    obj.show();//B类覆写
    obj.Say(); //从A类继承