javascript的属性与方法

【私有变量】 在对象内部使用'var'关键字来声明，而且它只能被私有函数和特权方法访问。

【私有方法】 在对象的构造函数里声明（或者是通过var functionName=function(){...}来定义），
它能被特权方法调用（包括对象的构造方法）和私有方法调用,私有函数只能访问私有的方法和属性。
【特权方法】通过this.methodName=function(){...}来声明而且可能被对象外部的代码调用。
它可以使用：this.特权函数() 方式来调用特权函数，使用 ：私有函数()方式来调用私有函数。

【公共属性】 通过this.variableName来定义而且在对象外部是可以读写的。不能被私有函数所调用。
【公共方法】 通过ClassName.prototype.methodName=function(){...}来定义可以从对象外部来调用。
【原型属性】 通过ClassName.prototype.propertyName=someValue 来定义。
【静态属性】 通过ClassName.propertyName=someValue 来定义。

【静态方法】 通过ClassName.funName=function(){...} 来定义。

实例代码：

//定义Person 类
        function Person(name) {
            //私有属性 MyTime ,ID
            var MyTime = "2014-5-6";
            var ID = "7792DC03ACTFDCF";

            var sex = "male";//私有属性，
            var showsex = function () {//私有方法或者说是私有属性
                alert(sex);
            }

            //公有属性MyName
            this.MyName = name;
            //对象方法（实例化后才能调用）位置：Person类的内部
            //语法格式：this.方法名称 = function([参数...]){语句行;};
            this.showMyName = function () {
                alert("My Name is " + this.MyName + MyTime);
            }
            this.showSex = function () {
                showsex();
            }
            //this.Init();
        }
        //公有静态属性 位置：Person类的外部
        Person.NAME = "xiao wang";
        Person.ENGLISH = "in english";
        Person.CHINESE = "in chinese";

        //原型属性（当作公有静态属性使用 语法格式：类名称.prototype.公有静态属性；不能使用语法格式：this.公有静态属性）
        //原型属性 (当作公有属性使用 语法格式：类名称.prototype.公有属性； 或者使用语法格式：this.公有属性；)
        Person.prototype.FRENCH = "in french";

        //类方法（静态方法直接调用）
        //位置:Person类的外部
        //语法格式：类名称.方法名称 = function([参数...]){语句行；};
        Person.EnglishandFrench = function () {
            //访问静态属性 语法格式：类名称。公有静态属性;
            //或者使用语法格式：this.公有静态属性
            alert(Person.NAME + " can speak " + this.ENGLISH + " and "+ Person.prototype.FRENCH);
        }

        //原型方法(实例化后调用或者直接调用)
        //位置：Person类的外部
        //语法格式：类名称.prototype.方法名称 = function([参数...]){语句行;}
        Person.prototype.ChineseandFrench = function(){
            //编写一个原型方法相当于扩充了一个对象方法，稍作变化可复制到类的内部成为一个对象方法;
            //访问公有属性 语法格式： this.公有属性
            //访问公有静态属性 语法格式：类名称.公有静态属性
            alert(this.MyName +　" can speak " + Person.CHINESE + " and " + this.FRENCH +"," + Person.prototype.FRENCH + "do better.");
        }

        //只有原型方法执行后内部扩充到Person类的属性才能生效
        Person.prototype.Init = function(){
            //定义公有属性PersonNo
            this.PersonNo = "";
            //定义公有数组属性 [] 等价于new Array();它现在是几维数组或是混合数组要根据赋值后才知道
            this.ArrInfo = [];
            //定义一个json对象属性
            this.jsonData = {};
        }

		
		 var p = new Person("Robbin");
            p.showMyName();
            Person.EnglishandFrench();
            p.ChineseandFrench();
            alert(p.MyName);
            //p.sex 于p.showsex()运行出错
            //ChineseandFrech()当作静态方法直接调用，请注意 MyName是对象属性 原型方法内不能调用它
            //当作静态方法直接调用时内部成员必须都是静态属性，下面这样调用是错误的;
            //Person.prototype.ChineseandFrech();

            //this.Init();这行代码放在Person类内部也一样初始化
           p.Init();
           p.PersonNo = "20101010";
           alert(p.PersonNo);

           p.ArrInfo[0] = "123";
           alert(p.ArrInfo[0]);

           p.ArrInfo[1] = ["111","222","333"];
           alert(p.ArrInfo[1][2]);
            
           p.jsonData = {
               url: "../view.html",
               common_setting: {
                   upload_target:"divContainer"
               },
               debug:true}
            
           alert(p.jsonData.url + "  " + p.jsonData.common_setting.upload_target + "  " + p.jsonData.debug);
          //尽量将方法定义为原型方法，原型方法避免了每次调用构造函数时对属性或方法的构造，节省空间,创建对象快.
		
		 function Bird() {
         }
        Bird.age = 2;//静态属性
        Bird.info = function () {//静态方法
            alert(Bird.age);
        }
        Bird.prototype.speed = function () {//实例方法
            alert("100");
        };
        var bird = new Bird();
        bird.speed();
        Bird.info();
		
		var Man = function () {
        };
		//原型方法与属性
        Man.prototype = {
            age: 12,//属性
            arr:new Array(1,2,3),
            showName: function () {//实例方法
                alert("xiao zhang");
            },
        };
		
		 var man = new Man();
            man.showName();
            alert(man.age);
		
		//静态私有成员
        var Car = (function () {
            function privateproperty() {

            }
            privateproperty.price = "18";//静态私有成员
            privateproperty.showprice = function () {//静态私有方法
                alert(privateproperty.price);
            }
            //privateproperty.showprice();
            return privateproperty;
        })();
  //此时Car 等于privateproperty,可以调用price属性以及showprice方法。

 //静态类
        var count = 0;
        var man = new function () {
            count++;
            this.printcount = function () {
                alert(count);
            }
        };
         /*
        man.prototype.amethod = function () {
            alert("原型对象");
        }//运行出错
        */
		man.printcount();
        man.printcount();
		
		 //原型继承
        var Animal = function () {

        };
        Animal.prototype.eat_extend = function () {
            alert("原型继承");
        }
        var Cat = function () {

        };
        Cat.prototype = new Animal();
		 var cat = new Cat();
         cat.eat_extend();//这是原型继承
		 
		 //调用继承
        var Father = function () {
            this.ShowFirstName = function () {
                alert("这是调用继承");
            }
        };
        var Son = function () {
            Father.call(this);
        }
		 var son = new Son();
            son.ShowFirstName();//这是调用继承
			
			 //覆盖 
        var Mother = function () {
            this.Sing = function () {
                alert("母亲唱歌");
            }
        }
        var Daughter = function(){
            this.Sing = function () {
                alert("女儿唱歌");
            }
        };
        Daughter.prototype = new Mother();
		 var daughter = new Daughter();
            daughter.Sing();//这个是子方法，父对象方法被覆盖了
			
			 //多态
        function Calc(a, b) {
            if (typeof a == "number" && typeof b == "number") {
                alert(a * b);
            } else if (typeof a == "string" && typeof b == "string") {
                alert(a + b);
            } else {
                alert("输入出错了");
            }
        }
		    Calc(3, 4);
            Calc("hello， ", "你好");
            Calc("hi", 5);

function baseInfo() {
            return {
                init: function () {

                },
                dispose: function () {

                }
            }
        }

        function OtherPart() {
            this.vaue = "300";
        }

        OtherPart.prototype = baseInfo();//(可以理解为返回一个对象的方法)等价如下面的方法
        /* 如果使用了上面的定义在使用下面的定义，会将上面的覆盖掉
        OtherPart.prototype = {
            create: function () {

            }
        }
        */
        OtherPart.prototype.run = function () {

        }
        //直接给对象定义一个方法
        var Fly = {};
        Fly.ShowInfo = function () {
            alert("info");
        };
        //调用如下
        Fly.ShowInfo();