关于ES6中的面向对象

面向对象是一种编程思想和方法，它把数据和对数据的操作封装成一个个的对象，并通过对象之间的消息传递来完成程序的功能。面向对象的程序设计主要包括三大特征：封装、继承和多态。

封装是指把数据和操作数据的方法封装在一起，形成一个对象，对象对外部只暴露必要的接口，从而保证对象的数据的安全性和正确性。

class 类的实例化，构造器，不能被直接调用，当类被实例化的时候，会自动执行构造器，每一个class 都会有一个构造器(若没有显示的声明，则实例化是，系统会自动执行一个无参的构造器)，在构造器中，一般完成属性的绑定。

封装

constructor是一个类中的特殊方法，用于创建对象并初始化对象的属性。当创建一个类的实例时，会自动调用其constructor方法。开发者可以在constructor中指定对象的属性，也可以在其中执行其它初始化工作。例如，以下是一个简单的JavaScript类的构造函数：

class Person {
            constructor(name, age, gender) {
                this.name = name;
                this.age = age;
                this.gender = gender;
            }

            //方法
            say() {
                console.log(this.name + "哈哈哈哈");
            }
        }

        let p=new Person('小兰',18,'女');
        let p1=new Person('小强',19,'男');

在class类中有成员属性和静态属性两种：

 成员属性：在构造器中声明；通过对象调用

class Monkey{
            //成员属性
            constructor(name,lb){
                this.name=name;
                this.lb=lb;                
            }
        }


        let m=new Monkey('小花','峨眉山猴');

 静态属性：通过static声明(在构造器外)，通过类调用

  class Monkey{
            //静态属性
            static leg=2;
            static hands=2;
        }

        console.log(Monkey.leg);//静态属性
        console.log(Monkey.hands);//静态属性

在class中不仅有成员属性和静态属性还有私有属性：

在Python中，类中以#号开头的属性是私有属性。这意味着这些属性只能在类的内部使用，而不能从类的外部访问或修改。这种封装的思想可以保护类中的数据不被误修改或意外访问。

   class Man {
            #age = 0;//私有属性
            constructor(age) {
                this.#age = age;
            }

            getAge(){
                return this.#age
            }

            setAge(age) {
                if (age > 0 && age < 150)   //过滤
                    this.#age = age;
            }

            //私有方法
            #sayGoodNight(){
                console.log('晚安');
            }

        }

        let m = new Man(100);

 get和set对属性进行存取

        get和set访问器（不能当做函数来调用）

        当出现属性赋值时，自动执行set         setter函数需要有参数

        当出现属性取值时，自动执行get         getter函数需要有返回值

 

   class Cat {
            constructor(name, age) {
                this.name = name;
                this._age = age;
            }

            set age(v) {
                // console.log(v);
                if (v < 0) v = 0;
                if (v > 20) v = 20;
                console.log(11111111);
                this._age=v;//赋值
            }

            get age() {
                console.log('get');
                return 30
            }
        }


        let c = new Cat('三三', 3);
        c.age=30;
        console.log(c);//Cat {name: '三三', _age: 20}

继承性 

继承是指子类可以继承父类的属性和方法，而且可以扩展新的属性和方法。继承可以减少代码冗余，提高代码的可复用性。

在ES6中使用extends来实现继承；

            1）继承是单向的

            2）父类(基类、超类) 、子类(派生类)

            3）单继承

    class Animal{
            heart=1;//心脏
            eat(){
                console.log('吃饭中...');
            }

            say(){
                console.log('叫.....');
            }
        }


        class Person extends Animal{
            static leg=2;
        }

        class Man extends Person {
            eat(){//覆盖父类的方法
                console.log('我用手吃饭....');
            }
        }


        class Women extends Person{
            eat(){//覆盖父类的方法
                console.log('我优雅的吃饭....');
            }
        }

        let m=new Man();
        m.eat();//我用手吃饭....



        let wm=new Women();

        console.log(wm.heart);//1

多态性 

多态可以通过继承来实现，即子类可以重写父类的方法，从而改变方法的实现方式。也可以通过接口来实现，即不同的对象实现同一个接口的方法，但是具体的实现方式不同。

多态在面向对象编程中的应用非常广泛，比如通过多态可以实现不同类型的对象之间的统一处理，也可以在运行时动态地选择相应的方法，从而实现更加灵活的程序设计。