JavaScript系列----面向对象的JavaScript(1)

1.面向对象的编程

1.1.什么是面向对象编程

面向对象编程：即是把能够完成独立完成一部分功能的代码封装在一起，组成一个类。

　　举个例子来说：

这里有一把枪, 枪的种类很多，有步枪，机关枪，阻击枪....。但是无论怎么说，这些都是枪的概念，如果把这种抽象的概念剥离出来，就是我们经常说的“类”。那么枪有什么特点呢？ 威力大小,型号,长度,子弹型号，能承载子弹的数量，枪口半径......ok！ 这些一切的一切都是为了描素枪，把这些抽象出来，就组成了“枪类”的属性。枪又能干什么呢？  瞄准,开火,....这些描素都是枪的功能-----把这些抽象出来，即组成了一个类的方法。

　　所以，总体来说，面向对象的编程即是把一个程序模块化，每个模块承载一部分功能，各个模块协同合作，维持程序的正常执行;

　　而所谓的类的组成，无外乎三个部分：这个类的名称（对应着例子中的“枪”）,这个类的属性（对应着特点）,这个类的方法（对应着功能）。

就像我们描素一个人一样，无外乎，描素一个人的特点以及人的能力。所以，现实生活中的人，在程序中也可以抽象成类。

1.2.类，对象，实例的关系

• 类：是一个抽象概念，是对某一类相似对象的抽象。
• 对象：是类的一个实例化，因为类是一个抽象的概念，所以，在使用时必须落实到实物的身上。那么，对象就作为载体来完成某项功能。
• 实例：和对象是一个概念。一般说一个类的实例，指的就是这个类的某个对象。

举个例子来说明三者之间的关系：

//1.Person是一个类的名字，定义的是一个人，对这个人的描述一般就是姓名，年龄。
var Person = function (name, age) {
   //Person类的属性
  this.name = name;
  this.age = age;
}
//Person类的方法
Person.prototype.greet = function () {
  console.log('hello');
}
//这是一个类的实例化过程，lisi这里就是Person类的一个对象，也可以说其是Person类的一个实例
var lisi=new Person("lisi",18);

1.3.面向对象的四个特点

• 封装. 所谓的封装就是把一个类的对象的属性和方法封装在类的内部。封装的好处就是：类与类之间的属性和方法相互独立，互不干扰。
• 继承. 所谓的继承就是指的是一个类可以派生自另外一个类。比如，图形类，可以派生出三角形，正方形，圆....
• 重载. 重载就是指一个类的方法可以名字可以相同（JS不支持重载）.第二部分会给出解释。
• 多态.多态指的是父类的方法，子类可以重写该方法。那么，子类在调用该方法时调用的会是子类的方法。

请记住：面向对象，所有的一些都是为了代码的复用。

2.面向对象的四个特点在JS中的实现

2.1.JS中的封装

　　    JS类的封装即是把类的属性和方法封装在类的内部. 如果只是简单的实现封装，那么可以有多种方法。比如下面的两种

//第一种方法
var Person = function (name, age) {
  this.name = name;
  this.age = age;
  this.greet = function () {
    console.log('hello');
  }
}
//第二种方法
var Person = function (name, age) {
  this.name = name;
  this.age = age;
}
Person.prototype.greet = function () {
  console.log('hello');
}

这两种方法，虽然在使用效果上是一致的，但是在第一种方法中，每次new 一个对象的时候都要为该对象添加一个函数greet----这样就没有做到代码的复用。所以在使用的时候，一般都是使用第二种方式---也就是所谓的组合式创建。所以一般我们也推荐用第二种方式。

2.2.JS中不存在重载

什么是重载呢？ 重载的概念来源于强类型预言（C++，java，C#）中。我们先来看一些java中的重载

class Person{  //java语言, 定义一个Person类，该类中存在greet方法的重载。
    public String name;
    public int age;
     Person(String name,int age){
        this.name=name;
        this.age=age;
    }
     public void greet(){
         System.out.println("I am "+ this.name);

     }
    public void greet(String message){

        System.out.println("I am "+ this.name+ "\n This is your"+message);
    }
}

　　　　所谓的重载，就是一个同一个方法名在一个类中被出现了多次。那么在该方法被调用的时候,编译器如何区分具体调用哪个方法呢？

　　　　　　在强类型语言中，编译器先根据函数的名字选择函数，然后在根据调用时，形参和实参的类型，形参的个数和实参的个数是否一致来区分一个函数。

　　　　那么，问题来了....JS中的解释器是符合区分一个函数呢？ ok...JS中解释器只是根据函数的名称来选择函数，而函数的形参并不在考虑的范围----因为在编译时无法根据确定形参的类型，更无法确定实参的类型。

　　　　既然，JS不支持重载，那么如果一个函数被重写了，会出现什么情况呢？

var Person = function (name, age) {
  this.name = name;
  this.age = age;
  this.greet = function () {
    console.log('hello');
  }
}
var Person = function (name, age) {
  this.name = name;
  this.age = age;
}
Person.prototype.greet = function () {
  console.log('我被覆盖了');
}
Person.prototype.greet = function (message) {
  console.log("我是重写的方法");
}

var person=new Person("zhangsan",18);

person.greet(); //我是重写的方法

　　　　根据上面的例子，可以看出，无论函数的参数是什么，只要函数同名，那么被调用的肯定是最后一次被写的同名函数。

2.3.JS中的继承

　　继承这个概念的来源也是面向对象的编程。JS引荐强类型预言中的继承做到这一点。所以我们要从强类型语言中的继承来类推---JS中为什么要这么设计。

　　2.3.1.强类型语言中继承的实现

　　　　在强类型语言中，在假设有两个类 A 、B....A是B的父类。实现如下：

class A{//父类的构造函数
    protected int x;
    A(int x){
        this.x=x;
    }
}
class B extends A{
    protected int y;
     B(int x,int y){//子类的构造函数
         super(x);  //在子类的构造函数中，第一句话总是先调用父类的构造函数，
                    //如果不写 则默认调用super();如果父类中不存在无参构造函数，则编译时会报错。

         this.y=y; 

}

　　public String getPoint(){
　　　　return "("+this.x+","+this.y+")";  //返回坐标（x，y）
　　}

}

从上面的这些我们可以看出什么呢？ 就是对象初始化的顺序...先初始化父类，在初始化子类。

初始化的时候顺序为： 父类的属性----》父类的方法-----》子类的属性-----》子类的方法。（我们这里讲的是排除了类中静态数据和方法来说，因为静态数据和方法的初始化，在类第一次被加载的时候就已经初始化完毕）

　　 　下面我们看下，JS中是怎么实现和上述一样的功能的...

var A = function (x) {
  this.x = x;
}
var B = function (x, y) {
  A.call(this, x);  //相当于第一种的super()函数。
  this.y = y;
}
//实现继承
function extend(subClass, superClass) {
  var prototype = Object.create(superClass);
  subClass.prototype = prototype;
  subClass.constructor = subClass;
}
extend(B, A);
B.prototype.getPoint = function () {
  return '(' + this.x + ',' + this.y + ')';
}          

　　上面这两段代码，撇开语言的特性来说，他们实现的功能是等效的。只是第一种玩的是思想，第二种玩的是技巧。

　　  OK!下面我们开始详解JS的设计者为了JS语言能实现继承所做的努力。

2.3.2.JS语言支持继承的原理。

所有的函数均有一个prototype属性。就是这个属性帮我们做到了一些,首先要认识到一点这个属性是一个对象。

　　　　用上面我们创建的一个Person函数详解，那么这个函数的prototype属性如下表示：

　　　　这是这个函数在刚开始被初始化时候的固有形式，后来执行了一句

Person.prototype.greet = function () {
  console.log('hello');
}

　　在这句执行完毕的时候，Person.prototype变化为

Person  prototype
constructor	指向Person函数
greet	（greet函数）

　　　解释了这么多，貌似并没有解释继承是怎么实现的是吧....别慌...慢慢来！！！

　　　　来看一下，当一个函数被实例化的时候发生了什么？

var lisi=new Person("lisi",18); //看看Person实例化的对象发生了什么？

　　

　　到这里，我们看到了吧..当用new创建一个构造函数的对象的时候。这个对象会有一个【【__proto__】】内置属性，指向函数的prototype。------这就是对象lisi传说中的原型对象。

　　一个函数只有一个原型（prototype），这个函数在用new调用的时候会把这个原型赋值给当前对象的内置属性。

　　当查询一个对象的属性的时候，首先查询对象本身的属性，如果没有找到则根据对象内置属性层层向上查找。

　　所以一切的一切都归咎于，只要们修改一个函数的prototype属性，那么就可以实现继承。

下面图解，B继承A的过程。

//1. A类,和B类的构造函数　　　　

var A = function (x) {
  this.x = x;
}
var B = function (x, y) {
  A.call(this, x);  //相当于第一种的super()函数。
  this.y = y;
}

//2.修改B的prototype，使其指向A的prototype

//实现继承
function extend(subClass, superClass) {
  var prototype = Object.create(superClass);
  subClass.prototype = prototype;
  subClass.constructor = subClass;
}
extend(B, A);
B.prototype.getPoint = function () {
  return '(' + this.x + ',' + this.y + ')';
}

如此，便实现B类继承A类...关键点就在函数的prototype属性上。----在下一篇中会详解函数的prototype。

JS中实现多态

何谓多态？

首先一定要强调一点，只有在继承存在的情况下才可能出现多态! 这是为什么呢..因为多态指的是子类覆盖父类的方法.....子类覆盖父类的方法，这种情况就是所谓的多态。

在java中的多态

public class Test {
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        B b=new B(1,2);
        String result=b.getPoint();
        System.out.println(result);
    }
}
class A{
    protected int x;
    A(int x){
        this.x=x;
    }
     public String getPoint(){
         return "我是父类";
     }
}
class B extends A{
    protected int y;
     B(int x,int y){
         super(x);
         this.y=y;
     }
　　　　//多态，父类覆盖的方法
     public String getPoint(){
         return  "我是子类";
     }
}
 //输出结果 ：我是子类

　　在JS中的多态情况，也是指的的子类的方法覆盖父类的方法。 上面的功能在JS中是这么实现的。

var A = function (x) {
  this.x = x;
}
A.prototype.getPoint = function () {
  return '我是子类';
}
var B = function (x, y) {
  A.call(this, x); //相当于第一种的super()函数。
  this.y = y;
}
//实现继承

function extend(subClass, superClass) {
  var prototype = Object.create(superClass);
  subClass.prototype = prototype;
  subClass.constructor = subClass;
}
extend(B, A);
B.prototype.getPoint = function () {
  return '我是子类';
}
var b = new B(1, 2);
b.getPoint();

//输出结果 ：我是子类

　　在上述代码执行完毕后，函数B的结构如图所示

B类在实例化的时候，B类的对象会拥有一个内部属性指向B.prototype.当该实例调用函数的时候，会先在该对象内部查询该函数是否存在，如果不存在则沿着内置属性查询原型对象，即B.prototype。如果找到此属性，则停止查询，否则会接着沿着内置属性所指向的对象，一直找到最上级为止。