JavaScript面向对象和类

面向对象:

面向对象是一种编程思想（oop）。很多个具有相同属性和行为的对象就可以抽象为类，对象是类的一个实例。JavaScript在ECMAScript 6中引入了类的概念。

面向对象的三个基本特征:

• 封装：
  • 就是将一类事物的属性和行为抽象成一个类，使其属性私有化，行为公开化，隐藏对象属性和实现细节，仅对外提供访问形式,提高安全性和代码复用性。
• 继承：
  • 则是进一步将一类事物共有的属性和行为抽象成一个父类，而每个子类拥有父类的行为和属性，也有自己特有的行为和属性,扩展了已存在的代码块，进一步提高了代码的复用性。
• 多态：
  • 是指允许不同类的对象对同一消息做出不同响应，从一定角度来 看，封装和继承几乎都是为多态而准备的，类中多个方法的重载叫多态，父子类中方法的覆盖也叫多态。提高了软件 的可重用性和可扩充性。

通过类来区分构造对象(区分对应的类型):

class Person{

            constructor(username){  //构造器 他是一个函数new的时候会调用对应的构造器

                this.name=username //this指向当前实例对象

            }

        }

        var person=new Person('jack') //实际调用的类里面的构造函数

        //类从根本来说是一个构造函数

        console.log(person);

        //以构造函数构建 首字母大写 es3

        function Dog(name){

            this.name =name //函数里面的this指向

        }

        var dog =new Dog('旺财')

        console.log(dog);

通过构造函数构建做了什么操作:      

            1.自动新建一个新的对象

            2.手动给对象的属性进行赋值

            3.自动返回这个对象

            4.以工厂模式来构建 (不能区分类型)

            5.工厂里面要传入对应的属性 返回对应的对象

            6.工厂模式构建出来的 全是object对象

function factory(name){

                //Object是最大的对象 手动构建对象

                var obj=new Object()

                //手动给obj设置相关的属性

                obj.name=name

                //手动返回对应的对象

                return obj

            }

            //调用

            var obj=factory('旺财')

            var obj1=factory('jack')

            console.log(obj,obj1);

继承与重写:

class Person {

            constructor() {

                this.name = 'jack'

                this.say = () => {

                    console.log('你好你好');

                }

            }

        }

        class Son extends Person {  //(继承,子类继承父类的属性和方法)

            constructor(age) {

                super() //调用person的constructor (指向父类)

                this.age = age

                //重写

                this.say=()=>{

                    console.log('哈哈哈');

                }

            }

        }

        var son=new Son()

        console.log(son); //name say age

        son.say()  //调用重写

注意:JavaScript没有重载

使用工厂模式来构建对象

我们可以写一个工厂函数，手动初始化一个对象，给这个对象添加属性和方法，将这个对象返回，解决代码重复的问题。

function factory(age){
    //声明一个对象
    var obj = new Object()
    obj.age = age
    return obj
}

然后生成实例对象，就等于是在调用函数：

var person1 = factroy(18)
var person2 = factroy(20)

构造函数模式

为了解决从原型对象生成实例的问题，Javascript提供了一个构造函数(Constructor)模式。

所谓"构造函数"，其实就是一个普通函数，但是内部使用了this变量。对构造函数使用new运算符，就能生成实例，并且this变量会绑定在实例对象上。

比如，人的原型对象现在可以这样写

function Person(age, name){
    this.age = age
    this.name = name
}

我们现在就可以生成实例对象了。

//new关键词来构建
var person1 = new Person(18,'zhangsan')
var person2 = new Person(20,'lisi')
console.log(person1.name) //zhangsan
console.log(person2.name) //lisi

这时person1和person2会自动含有一个constructor属性，指向它们的构造函数。

console.log(person1.constructor == Person); //true
console.log(person2.constructor == Person); //true

Javascript还提供了一个instanceof运算符，验证原型对象与实例对象之间的关系。

console.log(person1 instanceof Person); //true
console.log(person2 instanceof Person); //true

New操作符具体做了些什么?(重点)

1.在构造函数内部创建一个空对象

2.空对象的指针指向构造函数的原型

3.把空构造函数的this指向空对象

4.让空对象拥有自定义的属性和方法

5.隐式的返回return this

例子:

        

function Person(name, age) {

        //1.在构造函数内部创建一个空对象

        // var obj = new Object();

        //2.this,指向空对象

        // Person.bind(obj);

        //3.往空对象上添加属性和方法

        // this.name = name;

        // this.age = age;

        // this.run = function () {};

        // //4.空对象的指针执行构造函数的原型

        // this.__proto__ = Person.prototype;

        // //5.隐式的return this

        // return this;

        // return {}; //{} 新的对象

      }

      var p1 = new Person("刘德华", 20);

      console.log(p1);

类:

语法:

在JavaScript中类是对象的模板,对象是类的实例化.

使用关键字 class 创建一个类。并添加 constructor() 方法

 实例:

一个名为Person的类,name和Perso是它的两个属性

 对类的实例化Person

 类的应用:

 需要向类中传递参数: