前言

面向对象编程:

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

面向过程编程:

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

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

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关键字而出错~~

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