前言

面向对象编程:

　　就是将你的需求抽象成一个对象,然后针对这个对象分析其特征(属性)与动作(方法)--这个对象就称之为类

面向过程编程:

　　特点:封装,就是将你需要的功能放在一个对象里面

-----------创建一个类

var Person = function(name, height, weight){
　　this.name = name;
　　this.height = height;
　　this.weight = weight;
　　this.say = function(){
　　　　console.log("hello world");
　　}
}

这样我们就创建了一个 Person 类,他有三个属性,但是我们同样也可以在类的原型添加属性和方法:

Person.prototye.work = function(){
   console.log('Java')      
}
或者你也可以这样写:
Person.prototype = {
　　work: function(){
　　　　console.log('Java')
　　}
}

这是通常我们用来封装类的方式,把我们常用的属性和方法已经封装到我们抽象的Person这个类里面了~

在使用这个Person这个类的时候我们不能直接使用person类,需要用 new 关键字去实例化(创建)一个新的对象,这样我们就可以通过对象点属相或者方法去访问

var peopleOne = new Person('Mike','180cm','60kg')
console.log(peopleOne.name)   // Mike

Js是一种基于原型prototype的语言,在原型上添加方法和属性,都可以通过创建的对象去访问.

原因就在于每创建一个对象时,都有一个原型prototype用于指向其集成的属性和方法~

所以,我们创建的对象去使用类自身没有封装的方法时,就会通过prototype一级一级查找,通过prototype继承的属性和方法都可以被访问而不会再创建~

　　constructor大家都不陌生,是构造函数,Js中,当创建一个函数或者对象时都会为其创建一个原型对象prototype,而prototype对象又会像函数中的额this一样创建一个constructor属性,那么这个属性指向的就是拥有整个原型对象的函数或对象..(另外:Js中,万物兼对象,函数function也是对象)..新创建的对象访问类的原型指向的对象可以通过 __proto__ 但是实际开发中,这个并不会使用...

　　prototype对象中的属性和方法被称为共有属性和共有方法.类也有私有属性和私有方法,通过该类实例的对象不能访问~

var Person(name,age){
　　//对象公有属性
　　this.name = name;
　　this.age = age
　　//对象公有属性
　　this.say = function () {
　　　　alert('hello')
　　}
   //特权方法
　　this.getName = function(){
　　　　return this.name
　　}
　　this.setName = function(newName){
　　　　this.name = newName
　　}
　　
　　//私有属性
　　var num = 100
　　//私有方法
　　function ill(){}
　　
　　//构造器
　　this.setName('mike')
　　}
}
//类静态公有属性
Person.isChinese = true;
//类静态方法
Person.run = function () {
　　console.log('running')
}

Person.prototype = {
　　//公有属性
　　isYoung: true,
　　//公有方法
　　sing: function(){
　　　　console.log('singing')
　　}
}

当然我们也可以将类的静态变量通过闭包来实现,例如

var Person = (function(){
　　//静态私有变量
　　var isCute = true
　　//静态私有方法
　　function run() {}

　　//返回构造函数
　　return function(name,age){
　　　　//私有变量
　　　　var num = 100
　　　　//私有方法
　　　　function ill(){}

　　　　//特权方法
　　　　this.getName=function(){}
　　　　this.setName=function(newName){}
　　　　//公有属性
　　　　this.name=name;
　　　　//公有方法
　　　　this.draw=function(){}
　　　　//构造器
　　　　this.setName(newName)
　　}
})()

Person.prototype={
　　//静态公有属性
　　isYoung:true,
　　//静态公有方法
　　run:function(){}
}

 闭包时有限访问弄一个函数作用域中变量的函数,即在一个函数内部创建另一个函数

我们将这个闭包作为创建对象的构造函数,这样它既是闭包,又是可实例对象的函数,即可访问到类函数作用域中的变量,例如 isCute 这个变量,此时就是静态私有变量, run 方法为静态私有方法...当然闭包内部有自己的私有变量 num ,私有方法 ill ...(以上面闭包为例)

当然,也可以在闭包内部实现完整的类然后将其返回(return)出去,这里不做示例~

 

既然有了类,但是有些人总会不可避免的忘记 new 关键字,这时候,我们需要可以手动为其加个判断,以防没有 new 而出错

var Person = function(name){
　　if(this instanceof Person){
　　　　this.name = name
　　}else{
　　　　return new Person(name)
　　}
}

此时,你就不必再为少了new关键字而出错~~

本篇结束,后续更新...