js面向对象特性

2024年4月13日 136次阅读 来源: me_zhazha

我们都晓得js面向对象具有三大特性，离别为封装、继续、多态，实在在javaScript脚本语言中是不存在多态的，然则能够用js的体式格局完成多态中的两种效果重载、重写，那下面我们就来讲一下面向对象的特性

封装

把笼统出的属性和对属性的要领封装在一起对外完成接口开放，说白了就是封装一个要领或是类能够传入参数，供雷同功用的外界运用，来到达雷同的目标，便于对代码的治理

  • 代码

       class Package {
       constructor (animal){
           this.animal = animal
       }
       zoo (animal) {
           console.log('this is'+ this.animal)
       }
       static private () {
           console.log('我是私有要领')
       }
   }

   let newPackage = new Package('大象')
   newPackage.zoo()
   newPackage.private() // Uncaught TypeError: newPackage.private is not a function

    上面的一个比较简朴的封装例子，经由过程animal参数通报来到达我们想要的效果，然则class类内里的静态要领是不会对外开放的所以会找不到这个函数

继续

继续能够使得子类具有父种别的种种属性和要领，而不需要再次编写雷同的代码。在令子种别继续父种别的同时，能够从新定义某些属性，并重写某些要领，即掩盖父种别的原有属性和要领，使其获得与父种别差别的功用。别的，为子类追加新的属性和要领也是罕见的做法。

  • 代码

    class PackageSon extends Package{
    constructor(animal, food){
        super(animal);
        this.food = food
    }
    zoo () {
        console.log('这是'+ this.animal)
    }
    eat () {
        console.log(this.animal+this.food)
    }
}

let newPackageSon = new PackageSon('大象', '吃草')
newPackageSon.zoo()
newPackageSon.eat()

上面的例子运用到了es6 class 语法糖内的super要领，实在它是完成了在这里指向了父类中的this对象，然后子类的组织函数再对其举行修正，然后zoo函数完成了对父类的重写，eat函数是子类新增的函数

多态

最最先我们已晓得了js严厉讲是没有多态的，多态能够表现出我们的代码的多种状况，统一操纵作用于差别的对象，能够有差别的诠释，发生差别的实行效果。

  • 重载表现 代码
    // 重载

    class overload {
    init (callback) {
        if (callback === 'go') {
            console.log('我是go')
        }else if(callback === 'eat') {
            console.log('我是eat')
        }else {
            console.log('我是sprot')
        }
    }
}

var newOverload = new overload()
newOverload.init('go')
newOverload.init('eat')
newOverload.init('sprot')

上面是一个重载的例子，它依据我们挪用组织函数传入差别的参数，来完成差别的效果，实在这里也运用上面讲到了的封装，所以面向对象的特性是无处不在

  • 重写表现 代码
    // 重写

    class  rewrite {
    go () {
        console.log('我在走路')
    }
    sport () {
        console.log('我在活动')
    }
}
class  rewriteSon extends rewrite{
    go () {
        console.log('我回家了')
    }
}

var newRewriteSon = new rewriteSon()
newRewriteSon.go()
newRewriteSon.sport()

上面是一个简朴的重写例子，我们这里用到了继续，经由过程建立rewrite父类，编写了两个函数离别完成差别的操纵，rewriteSon子类继续了父类上面的两个要领，子类中又从新写了雷同名字的go要领，所以子类会把继续过来父类中的go要领掩盖掉，从而完成本身想要的操纵，打印sport要领时会照旧得出继续父类要领的操纵，所以子类只重写了go要领

    原文作者：me_zhazha
    原文地址: https://segmentfault.com/a/1190000018245508
    本文转自网络文章，转载此文章仅为分享知识，如有侵权，请联系博主进行删除。
点赞