单信js——2原型（重点）

面向对象

编程语言中，分为“面向过程”和“面向对象”两大类。面向过程就如自己造一台电脑，面向对象则是用现有的配件组装电脑。
在面向对象中就有两个重要的概念：类型（class）和对象实例（object）
一个类，通常具有两大特征：属性 和 方法。
属性：是指一个类型具有的共同“特征”。如人有2个眼睛，汽车有4个轮子等。
值是各种基本类型，引用类型
方法：是指一个类型具有的共同“行为”。如人能说话，狗能吃骨头等。
值是一个函数
如果想创建属于自己的对象，那么首先要体验分析。分析身边2件事物，抽取出他的属性和方法。
JavaScript的所有类型，都源于一个Object，也就是我们常说的万物皆对象。

JS提供了非常多内置的类：
Number（数字类）、String（字符串类）、Date（日期类）、Math（数学类）、Array（数组类）、Function（函数类）、Object（对象类）
new关键字:
使用new关键词可以将一个类进行实例化，根据类的特征和行为制作一个具体实例。
//可以使用new关键词用函数类实例化一个函数 : new Function('参数','函数体');
var show=new Function('a','alert(a);')
show(10);
console.log(show instanceof Function);

自定义类：

1.字面量对象
var obj2={name:'李白',age:999};

2. 工厂模式
   就是设计中的工厂模式，给定一些值，创造一个结果

3. 构造函数/类
   //ES5 【掌握】
   function Person(参数){
   this.属性=参数值;
   this.方法=function(){
   //方法体
   }
   }
   //使用构造函数实例化一个对象
   var p1=new Person('小强',19);

类/构造函数的特征：
1) 构造函数的函数名（类名）首字母大写
2) 属性和方法都挂在this上
3) 没有return 语句

new关键字的实现机制：
1) 创建一个新对象
2) 将构造函数中的this指向新对象
3) 执行构造函数中的语句，将所有属性都挂到新对象（this指向新对象）

为每一个对象都创建一个单独的方法，就会占用过多的内容，就叫做过载。解决的办法是，在原型对象prototype上添加方法，给每个实例对象使用。

原型prototype：

1. 什么是原型？
   原型就是 prototype属性，所有function定义的函数都拥有这个属性。
   prototype属性是一个对象，可以添加属性和方法

2. 原型有什么用？

   1. 解决方法过载的问题
   2. 扩展类的功能

3. 原型的写法
   //定义原型方法
   类名.prototype.属性名或方法名=值;

   //使用原型方法
   对象.方法名();
   function Person(name,age){
   this.name=name;
   this.age=age;
   }

//将所有的方法都放在原型上
Person.prototype.run=function(){
    console.log(this.name + '以每小时80公里的速度奔跑...');
};
Person.prototype.eat=function(){
    console.log(this.name+'吃了一惊！！');
};
//为Person添加一个新功能——学习方法
Person.prototype.study=function(){
    console.log(this.name+'正在努力学习！！！');
}
var p1=new Person('刘备',18);
var p2=new Person('张飞',16);
console.log(p1.run === p2.run);   //true
console.log(p1);    //刘备的对象
p1.study();   //刘备正在努力学习！！！

var Car = function (band,price) {
            this.band=band;
            this.price=price
        }
        var bens=new Car("meisai",56);
        console.log(bens);
        console.log(typeof bens);
        console.log(bens instanceof Car);        //true
        console.log(bens instanceof Object);     //true
        console.log(bens instanceof Function);   //false
        console.log(Car instanceof Object);      //true
        console.log(Car instanceof Function);    //true
        //此时，如果Car的原型上添加东西，即可扩展到bens上
        Car.prototype.color="white";
        console.log(bens.color);//父亲的属性或方法，都可以被儿子继承
        console.log(bens.constructor==Car);      //true
        console.log(bens.constructor==Car.prototype.constructor);   //true

        console.log(Car.prototype.color);    //white

扩展内置类

扩展String类，编写方法实现获取字符串的第一个字
var str="我们在上课，好海哦~~~";         
//对字符串类进行扩展（编写插件）
var str="我们在上课，好海哦~~~";
//对字符串类进行扩展（编写插件）
String.prototype.findFirst=function(){
    return this.substr(0,1);
}
console.log( str.findFirst() );
console.dir(String); //查看对象的结构

扩展Array类型，提供inArray方法用来检查数组中是否包含”张三”
Array.prototype.inArray=function(name){
//找到数组 this
for(var i=0;i<this.length;i++){
    if(this[i] === name){
        return true;
    }
}
//将数据遍历完还找不到，就返回false
return false;
}
var arr=['刘备','张飞','张三','关羽'];
console.log( arr.inArray('张三') );  //true

对象属性的优先级：
对象 > 构造函数 > 原型 > 原型链（父类原型）

神秘的proto：

proto实际上是对类的prototype属性进行引用！！！

proto出现在【对象】上，
prototype出现在【类/构造函数】上， 对象上的_proto实际上是对类的prototype进行引用（内存地址都一样）

常见属性：constructor    在原型上声明构造函数
function User(username,password){
this.username=username;
this.password=password;
}
User.prototype.login=function(){
console.log(this.username+'登陆了系统');
}
var u1=new User('曹操','123456');
console.log(u1.__proto__ === User.prototype); //true
console.dir(u1);

下面是前两天的复习：

1. 变量高级

   1. 按数据类型进行划分，将变量划分为：
      Number String Boolean Undefined NULL Array Function Object

   2. 按数据在内存中的存储位置划分：
      基本类型（简单类型）：
      存储在内存的栈里面，在赋值时直接将变量的值复制一份给另外一个变量，两个变量相互不影响。
      包含： Number String Boolean Undefined NULL

      引用类型（复杂类型）：
      存储在内存堆里面，在赋值时将变量指向的内存地址（指针）赋值给另外一个变量，两个变量指向同一个内存空间，相互会影响
      包含：Array Function Object

   3. 检测变量
      typeof 检测变量自身的类型
      instanceof 检测变量属性哪种类型

2. 函数进阶

   1. 函数的内置对象 arguments
      a. 什么是arguments
      arguments是函数的内置对象，只能在函数内部使用，不能在外部使用。
      是一个对象，表现起来像一个数组，就是伪数组。

      b. arguments的作用
      获取函数的所有实际参数
      调用到函数本身（开发测试时使用）

      c. 写法
      function show(){
      console.log(arguments);
      //arguments[0]
      //注意：遍历arguments不能用for in，使用传统的for循环
      }

3. 面向对象
   面向过程POP： 关注每一个过程和细节
   面向对象OOP： 关注结果，找一个具备相关能力的对象，使用这个能力实现目标
   $('div').html('Hello world')

   类（class）：类是一个抽象化的概念， 将一类事物共有的特征进行抽取，得到类（对一类事物进行描述）
   对象（object）：对象是一个具体的实例，可以将类进行实例化产生一个对象，对象具备类上面描述的所有特征

4. 构造函数/类

   1. 创建类/构造函数
      function Person(name,age){
      //定义成员属性 => 特征 => 普通变量
      this.name=name;
      this.age=age;
      //定义成员方法 => 行为 => 函数
      this.showName=function(){
      }
      }

   2. 使用构造函数
      var p1=new Person('张三',1);

   3. 构造函数的特征
      a. 类名就是构造函数名 首字母必须大写
      b. 所有属性和方法都挂载到this上
      c. 没有返回值 return

5. 原型prototype

   1. 什么是原型？
      原型就是prototype属性，
      所有的函数都拥有这个属性，
      prototype属性是一个对象，可以添加属性和方法，称为原型属性和原型方法，
      prototype属性会被实例化出来的对象所引用

   2. 原型的作用
      a. 解析方法过载的问题
      b. 对已有的类进行扩展（内置类、自定义类）

   3. 原型的写法
      function Person(name,age){
      this.name=name;
      this.age=age;
      }

      //将所有类的方法都定义在原型上
      Person.prototype.showName=function(){
      //...
      }