ES5+ES6全部语法包含案例

面向对象：

面向过程 POP：

分析解决问题的步骤，然后用函数把这些步骤一步一步的实现，使用的时候在一个一个依次调用

优点：性能比面向对象高，适合跟硬件联系很紧密的东西，例如单片机

缺点：没有面向对象易维护、易复用、易扩展

面向对象OPP：

把事务分解成对象的形式，看看对象有什么功能，再把功能使用起来

优点：灵活、代码可复用、容易维护和开发，适合多人合作的大型项目

特性：封装性、继承性、多态性

类和对象：

类：ES6新增加的概念，可以使用class关键字声明一个类，之后以这个类来实例化对象

类抽象了对象的公共部分，它泛指某一大堆（class）

1.创建类：

 class Star{
     constructor(uname,age){
         this.uname=uname;
         this.age=age;
     }
 }

.利用类创建对象new,new会自动执行constructor构造函数

var ldh=new Star('刘德华');
console.log(ldh.uname) //刘德华

var zxy=new Star('张学友',20)
console.log(zxy)//uname:张学友，age:20

(1) 通过class 关键字创建类, 类名我们还是习惯性定义首字母大写

(2) 类里面有个constructor 函数,可以接受传递过来的参数,同时返回实例对象

(3) constructor 函数 只要 new 生成实例时,就会自动调用这个函数, 如果我们不写这个函数,类也会自动生成这个函数

(4) 生成实例 new 不能省略

(5) 最后注意语法规范, 创建类 类名后面不要加小括号,生成实例 类名后面加小括号, 构造函数不需要加function

2.类中添加方法

class Star{
     constructor(uname,age){
         this.uname=uname;
         this.age=age;
     }
       sing(song){
         console.log(this.uname+song);
     }
 }
    var ldh=new Star('刘德华');
	console.log(ldh.uname)

	var zxy=new Star('张学友',20)
	console.log(zxy)

	ldh.sing('冰雨')//刘德华冰雨
	zyx.sing('李香兰')//张学友李香兰

(1)类里面不需要写function

(2)多个函数方法之间不需要添加逗号分隔

3.类的继承

        class Father {
             constructor() {

             }
            money() {
                console.log(100);

            }
         }
         class Son extends Father { //使用extends继承 

         }
         var son = new Son();
         son.money();

	class Father {
            constructor(x, y) {
                this.x = x;
                this.y = y;
            }
            sum() {
                console.log(this.x + this.y);

            }
        }
        class Son extends Father {
            constructor(x, y) {
                super(x, y); //调用了父类中的构造函数
            }
        }
        var son = new Son(1, 2);
        var son1 = new Son(11, 22);
        son.sum();
        son1.sum();

super关键字用于访问和调用父类上的函数，可以调用父类的构造函数，也可以调用父类的普通函数

 class Father {
            say() {
                return '我是爸爸';
            }
        }
        class Son extends Father {
            say() {
                // console.log('我是儿子');
                console.log(super.say() + '的儿子');
                // super.say() 就是调用父类中的普通函数 say()
            }
        }
        var son = new Son();
        son.say();
        // 继承中的属性或者方法查找原则: 就近原则
        // 1. 继承中,如果实例化子类输出一个方法,先看子类有没有这个方法,如果有就先执行子类的
        // 2. 继承中,如果子类里面没有,就去查找父类有没有这个方法,如果有,就执行父类的这个方法(就近原则)

扩展运算符继承

class Father {
            constructor(x, y) {
                this.x = x;
                this.y = y;
            }
            sum() {
                console.log(this.x + this.y);
            }
        }
        // 子类继承父类加法方法 同时 扩展减法方法
        class Son extends Father {
            constructor(x, y) {
                // 利用super 调用父类的构造函数
                // super 必须在子类this之前调用
                super(x, y);
                this.x = x;
                this.y = y;

            }
            subtract() {
                console.log(this.x - this.y);

            }
        }
        var son = new Son(5, 3);
        son.subtract();
        son.sum();

类的注意事项：

1. 在 ES6 中类没有变量提升，所以必须先定义类，才能通过类实例化对象

2. 类里面的共有的属性和方法一定要加this使用

构造函数和原型：

1、利用构造函数创建对象

// 1. 利用 new Object() 创建对象

        var obj1 = new Object();

        // 2. 利用 对象字面量创建对象

        var obj2 = {};

        // 3. 利用构造函数创建对象
        function Star(uname, age) {
            this.uname = uname;
            this.age = age;
            this.sing = function() {
                console.log('我会唱歌');

            }
        }

        var ldh = new Star('刘德华', 18);
        var zxy = new Star('张学友', 19);
        console.log(ldh);
        ldh.sing();
        zxy.sing();

构造函数是一种特殊的函数，主要用来初始化对象，即为对象成员变量初始值，它总与new一起使用，我们可以把对象中一些公共的属性和方法抽取出来，然后封装到这个函数里面

在JS中，使用构造函数时，要注意以下两点：

1.构造函数用于创建某一类对象，其首字母要大写

2.构造函数要和new一起使用才有意义

new在执行时会做四件事情：

1.在内存中创建一个新的空对象

2.让this指向这个新的对象

3.执行构造函数里面的代码，给这个新对象添加属性和方法

4.返回这个新对象（所以构造函数里面不需要return）

原型,原型链：

构造函数通过原型分配的函数是所有对象所共享的

JS规定，每一个构造函数都有一个prototype属性，指向另一个对象，prototype就是一个对象，这个对象的所有属性和方法都会被构造函数所拥有；

我们可以把那些不变的方法，直接定义在prototype对象上，这样所有对象的实例就可以共享这些方法；

原型是一个对象，它可以共享方法，不会浪费内存

  // 1. 构造函数的问题. 
        function Star(uname, age) {
            this.uname = uname;
            this.age = age;
            // this.sing = function() {
            //     console.log('我会唱歌');

            // }
        }
        Star.prototype.sing = function() {
            console.log('我会唱歌');
        }
        var ldh = new Star('刘德华', 18);
        var zxy = new Star('张学友', 19);
        console.log(ldh.sing === zxy.sing);
        // console.dir(Star);
        ldh.sing();
        zxy.sing();
        // 2. 一般情况下,我们的公共属性定义到构造函数里面, 公共的方法我们放到原型对象身上

对象原型proto：

对象都会有一个属性proto指向构造函数的prototype原型对象，之所以我们对象可以使用构造函数prototype 原型对象的属性和方法，就是因为有proto的存在

proto和prototype是等价的

原型constructor：

function Star(uname, age) {
            this.uname = uname;
            this.age = age;
        }
        // 很多情况下,我们需要手动的利用constructor 这个属性指回 原来的构造函数
        // Star.prototype.sing = function() {
        //     console.log('我会唱歌');
        // };
        // Star.prototype.movie = function() {
        //     console.log('我会演电影');
        // }
        Star.prototype = {
            // 如果我们修改了原来的原型对象,给原型对象赋值的是一个对象,则必须手动的利用constructor指回原来的构造函数
            constructor: Star,
            sing: function() {
                console.log('我会唱歌');
            },
            movie: function() {
                console.log('我会演电影');
            }
        }
        var ldh = new Star('刘德华', 18);
        var zxy = new Star('张学友', 19);
        console.log(Star.prototype);
        console.log(ldh.__proto__);
        console.log(Star.prototype.constructor);
        console.log(ldh._