• <bdo id='87QYL'></bdo><ul id='87QYL'></ul>
    <legend id='87QYL'><style id='87QYL'><dir id='87QYL'><q id='87QYL'></q></dir></style></legend>

  • <i id='87QYL'><tr id='87QYL'><dt id='87QYL'><q id='87QYL'><span id='87QYL'><b id='87QYL'><form id='87QYL'><ins id='87QYL'></ins><ul id='87QYL'></ul><sub id='87QYL'></sub></form><legend id='87QYL'></legend><bdo id='87QYL'><pre id='87QYL'><center id='87QYL'></center></pre></bdo></b><th id='87QYL'></th></span></q></dt></tr></i><div id='87QYL'><tfoot id='87QYL'></tfoot><dl id='87QYL'><fieldset id='87QYL'></fieldset></dl></div>
  • <small id='87QYL'></small><noframes id='87QYL'>

        <tfoot id='87QYL'></tfoot>
      1. Javascript 面向对象特性

        时间:2023-12-11

          • <bdo id='YuFjp'></bdo><ul id='YuFjp'></ul>

                  <small id='YuFjp'></small><noframes id='YuFjp'>

                1. <legend id='YuFjp'><style id='YuFjp'><dir id='YuFjp'><q id='YuFjp'></q></dir></style></legend>
                  <i id='YuFjp'><tr id='YuFjp'><dt id='YuFjp'><q id='YuFjp'><span id='YuFjp'><b id='YuFjp'><form id='YuFjp'><ins id='YuFjp'></ins><ul id='YuFjp'></ul><sub id='YuFjp'></sub></form><legend id='YuFjp'></legend><bdo id='YuFjp'><pre id='YuFjp'><center id='YuFjp'></center></pre></bdo></b><th id='YuFjp'></th></span></q></dt></tr></i><div id='YuFjp'><tfoot id='YuFjp'></tfoot><dl id='YuFjp'><fieldset id='YuFjp'></fieldset></dl></div>

                    <tbody id='YuFjp'></tbody>
                  <tfoot id='YuFjp'></tfoot>

                  JavaScript面向对象特性

                  JavaScript是一门支持面向对象编程思想的语言,它提供了很多面向对象特性,如类、对象、继承、封装、多态等。接下来我们将详细讲解JavaScript面向对象特性的完整攻略。

                  在JavaScript中,我们可以使用构造函数来定义一个类,构造函数中包含了初始化对象的属性和方法。例如,下面是一个Person类的定义:

                  function Person(name, age) {
                      this.name = name;
                      this.age = age;
                  }
                  
                  Person.prototype.sayHello = function() {
                      console.log("Hello, my name is " + this.name + ", I'm " + this.age + " years old.");
                  }
                  

                  在上面的例子中,我们使用了构造函数来定义一个Person类,它有两个属性name和age,以及一个方法sayHello。同时,我们还通过给Person类的原型对象添加方法,实现了方法的复用。

                  对象

                  我们可以使用new关键字来创建一个对象,借助构造函数,我们可以通过定义不同的属性和方法,来创建不同的对象。例如,我们可以创建一个张三对象:

                  var zhangsan = new Person("张三", 18);
                  zhangsan.sayHello(); // Hello, my name is 张三, I'm 18 years old.
                  

                  上面的例子中,我们使用了Person类的构造函数来创建了一个名为zhangsan的对象,并且调用了对象的方法sayHello。

                  继承

                  继承是面向对象编程中非常重要的一个特性,它使得我们可以从一个类派生出另一个类,并且在派生类中添加或覆盖一些属性和方法。在JavaScript中,继承可以通过原型链来实现。例如,我们可以定义一个Student类,它继承自Person类:

                  function Student(name, age, grade) {
                      Person.call(this, name, age);
                      this.grade = grade;
                  }
                  
                  Student.prototype = Object.create(Person.prototype);
                  Student.prototype.constructor = Student;
                  Student.prototype.sayHello = function() {
                      console.log("Hello, my name is " + this.name + ", I'm " + this.age + " years old, and my grade is " + this.grade + ".");
                  }
                  

                  在以上代码中,我们使用了call函数来调用了Person类的构造函数,并且使用了Object.create函数来创建了Student类的原型对象,并设置其构造函数为Student。同时,我们还覆盖了Student类的sayHello方法,并添加了一个grade属性。

                  现在,我们可以像创建Person类一样来创建Student类的对象:

                  var lisi = new Student("李四", 19, "大一");
                  lisi.sayHello(); // Hello, my name is 李四, I'm 19 years old, and my grade is 大一.
                  

                  在上面的例子中,我们使用Student类的构造函数来创建了一个名为lisi的对象,并且调用了对象的方法sayHello。

                  封装

                  封装是面向对象编程中的一个重要原则,它将对象的属性和方法封装在一起,只暴露给外界必要的接口。在JavaScript中,我们可以使用闭包来实现封装。例如,我们可以创建一个私有成员的Person类:

                  var Person = (function() {
                  
                      var nameSymbol = Symbol('name');
                      var ageSymbol = Symbol('age');
                      var sayHelloSymbol = Symbol('sayHello');
                  
                      function Person(name, age) {
                          this[nameSymbol] = name;
                          this[ageSymbol] = age;
                          this[sayHelloSymbol] = function() {
                              console.log("Hello, my name is " + this[nameSymbol] + ", I'm " + this[ageSymbol] + " years old.");
                          }
                      }
                  
                      Person.prototype.sayHello = function() {
                          this[sayHelloSymbol]();
                      }
                  
                      return Person;
                  })();
                  

                  在以上代码中,我们使用了闭包来创建了一个私有成员的Person类,其中nameSymbol、ageSymbol和sayHelloSymbol都是Symbol类型,表示私有的属性和方法。同时,我们也在闭包内定义了类的构造函数和原型方法sayHello,在构造函数中初始化了对象的私有属性和方法。

                  现在,我们可以创建一个Person类的对象,并且调用对象的公共方法sayHello:

                  var zhangsan = new Person("张三", 18);
                  zhangsan.sayHello(); // Hello, my name is 张三, I'm 18 years old.
                  

                  在上面的例子中,我们无法直接访问对象的私有属性和方法,只能通过暴露出来的公共方法sayHello来访问私有成员。

                  多态

                  多态是面向对象编程中的一个重要特性,它使得不同的派生类可以使用相同的基类方法,提高了代码的复用性和扩展性。在JavaScript中,多态也可以使用原型链来实现。例如,我们可以创建一个输出信息的函数:

                  function printInfo(object) {
                      if(object instanceof Person) {
                          object.sayHello();
                      }
                      else {
                          console.log("Unknown object.");
                      }
                  }
                  

                  在以上代码中,我们定义了一个函数printInfo,它接受一个对象作为参数,并且调用对象的sayHello方法。如果对象是Person类的实例,则输出Hello, my name is ...,否则输出Unknown object.。

                  现在,我们可以通过这个函数来操作不同的对象:

                  var zhangsan = new Person("张三", 18);
                  var lisi = new Student("李四", 19, "大一");
                  
                  printInfo(zhangsan); // Hello, my name is 张三, I'm 18 years old.
                  printInfo(lisi); // Unknown object.
                  

                  在以上代码中,我们分别将zhangsan和lisi对象传递给printInfo函数,并且输出了相应的信息。可以看到,printInfo函数可以操作多个不同的对象,并且输出不同的信息。

                  以上就是JavaScript面向对象特性的完整攻略,包括类、对象、继承、封装、多态等。通过学习这些特性,我们可以更好地使用面向对象编程思想来实现复杂的应用程序。

                  上一篇:《javascript设计模式》学习笔记一:Javascript面向对象程序设计对象成员的定义分析 下一篇:详解SpringBoot修改启动端口server.port的四种方式

                  相关文章

                  <i id='21JHq'><tr id='21JHq'><dt id='21JHq'><q id='21JHq'><span id='21JHq'><b id='21JHq'><form id='21JHq'><ins id='21JHq'></ins><ul id='21JHq'></ul><sub id='21JHq'></sub></form><legend id='21JHq'></legend><bdo id='21JHq'><pre id='21JHq'><center id='21JHq'></center></pre></bdo></b><th id='21JHq'></th></span></q></dt></tr></i><div id='21JHq'><tfoot id='21JHq'></tfoot><dl id='21JHq'><fieldset id='21JHq'></fieldset></dl></div>

                      <bdo id='21JHq'></bdo><ul id='21JHq'></ul>

                      <legend id='21JHq'><style id='21JHq'><dir id='21JHq'><q id='21JHq'></q></dir></style></legend><tfoot id='21JHq'></tfoot>

                    1. <small id='21JHq'></small><noframes id='21JHq'>