JavaScript高级教程（ES6）——（18）类和继承

最新推荐文章于 2024-05-08 11:57:12 发布

脸红流氓兔

最新推荐文章于 2024-05-08 11:57:12 发布

阅读量281

点赞数 2

分类专栏： JavaScript 文章标签： javascript

本文链接：https://blog.csdn.net/qq_41860287/article/details/105929060

版权

JavaScript 专栏收录该内容

25 篇文章 0 订阅

订阅专栏

1.面向对象编程介绍

1.1两大编程思想

面向过程
面向对象

1.2面向过程编程POP（process-oriented Programming）

面向过程就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候再一个一个的一次调用就可以了。

1.3面向对象编程OOP（Object Oriented Programming）

面向对象是把事务分解成为一个个对象，然后由对象之间分工与合作。

在面向对象程序开发思想中，每一个对象都是功能中心，具有明确分工。

面向对象编程具有灵活、代码可复用、容易维护和开发的优点，更适合多人合作的大型软件项目。

面向对象的特性：

封装性
继承性
多态性

1.4面向过程和面向对象的对比

面向过程：

优点：性能比面向对象高，适合跟硬件联系很密切的东西，例如单片机就采用面向过程编程
缺点：没有面向对象易维护、易复用、易扩展

面向对象

优点：易维护、易复用、易扩展，由于面向对象有封装、继承、多态性的特征，可以设计出低耦合的系统，使系统更加灵活、更加易于维护
缺点：性能比面向过程低

2.ES6中的类和对象

面向对象思维特点：

1.抽取（抽象）对象共用的属性和行为组织（封装）成一个类（模板）

2.对类进行实例化，获取类对象

面向对象编程我们考虑的是有哪些对象，按照面向对象的思维特点，不断的创建对象，使用对象，指挥对象做事情

2.1对象

现实生活中：万物皆对象，对象是一个具体的事物，看得见摸得着的实物，例如：一本书、一辆汽车、一个人、可以是“对象”，一个数据库、一张网页、一个与远程服务器的连接也可以是“对象”。

在JavaScript中，对象是一组无序的相关属性和方法的集合，所有的事物都是对象，例如：字符串、数值、数组、函数等。

对象是由属性和方法组成的：

属性：事物的特性，在对象中用属性来表示（常用名词）
方法：事物的行为，在对象中用方法来表示（常用动词）

2.2类class

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

类抽象了对象的公共部分，它泛指某一大类（class）对象特指某一个，通过类实例化一个具体的对象

2.3创建类

语法：
在这里插入图片描述
创建实例：

注意：类必须使用new实例化对象

2.4类constructor构造函数

constructor()方法是类的构造函数（默认方法），用于传递参数，返回实例对象，通过new命令生成对象实例时，自动调用该方法，如果没有显示定义，类内部会自动给我们创建一个constructor()

2.5类添加方法

语法：
在这里插入图片描述

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>

<body>
    <script>
        //1.创建一个类  class  创建一个  明星类
        class Star {
            //类的共有属性放到constructor里面
            constructor(uname, age) {
                this.uname = uname;
                this.age = age;
            }
            sing(song) {
                console.log(this.uname + song);


            }

        }
        //2.利用类创建对象  new
        var ldh = new Star("刘德华", 18);
        var zxy = new Star("张学友", 20);
        console.log(ldh);
        console.log(zxy);
        //(1).通过class关键字创建类，类名我们还是习惯定义首字母大写
        //(2)类里面有个constructor函数  可以接收传递过来的参数  同时返回实例对象
        //(3)constructor函数  只要new生成实例时 就会自动调用这个函数  如果我们不写这个函数
        //类也会自动生成这个函数
        //(4)生成实例new  不能省略
        //(5)最后注意语法规范，创建类  类名后面不要加小括号  生成实例  类名后面加小括号  构造函数不需要加  function
        ldh.sing("冰雨");
        zxy.sing("李香兰");
    </script>
</body>

</html>

3.类的继承

3.1继承

现实中的继承：子承父业，比如我们都继承了父亲的姓。

程序中的继承：子类可以继承父类的一些属性和方法

语法：
在这里插入图片描述
3.2super关键字

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

子类调用父类构造函数：

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>

<body>
    <script>
        //1.类的继承
        // class Father {
        //     constructor() {

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

        //     }
        // }
        // class Son extends Father {}
        // 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();
    </script>
</body>

</html>

子类调用父类普通函数：

语法：

在这里插入图片描述

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>

<body>
    <script>
        //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.继承中，如果子类里面没有，就去查找父类有没有这个方法，如果有，就执行父类的这个方法（就近原则）
    </script>
</body>

</html>

子类继承父类的方法同时扩展自己的方法：

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>

<body>
    <script>
        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();
    </script>
</body>

</html>

注意：子类在构造函数中使用super，必须放到this前面（必须先调用父类的构造方法，再使用子类构造方法）

4.ES6中的类和对象

三个注意点：

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

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

3.类里面的this指向问题

4.constructor里面的this指向实例对象，方法里面的this指向这个方法的调用者

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>

<body>
    <button>点击</button>
    <script>
        var that;
        var _that;
        class Star {
            constructor(uname, age) {
                //constructor里面this  指向的是  创建的实例对象
                that = this;
                console.log(this);

                this.uname = uname;
                this.age = age;
                // this.sing();
                this.btn = document.querySelector('button');
                this.btn.onclick = this.sing;
            }
            sing() {
                // console.log('hi');
                //这个sing方法中的this指向的是btn这个按钮  因为这个按钮调用了这个函数
                console.log(this);

                // console.log(this.uname); //输出undefined， 因为sing（）被btn调用，  this指向btn， 而btn没有uname属性
                console.log(that.uname); //that里面存储的是constructor里面的this

            }
            dance() {
                //这个dance里面的this  指向的是实例对象   ldh  因为ldh调用了这个函数
                _that = this;
                console.log(this);

            }
        }
        var ldh = new Star("刘德华");
        console.log(that === ldh); //返回true
        // ldh.sing();
        ldh.dance();
        console.log(_that === ldh); //返回true

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

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

</html>