Javascript adalah berdasarkan tiga ciri utama objek (enkapsulasi, pewarisan, polimorfisme)

Tiga ciri berasaskan objek utama Javascript adalah sama dengan tiga ciri utama berorientasikan objek C dan Java, iaitu enkapsulasi, pewarisan dan polimorfisme. Cuma kaedah pelaksanaannya berbeza, tetapi konsep asasnya hampir sama. Malah, sebagai tambahan kepada tiga ciri utama, terdapat satu lagi ciri umum yang dipanggil abstrak, itulah sebabnya kita kadang-kadang melihat empat ciri utama berorientasikan objek dalam beberapa buku.
1. Enkapsulasi
Enkapsulasi adalah untuk merangkum data dan operasi yang diabstrakkan pada data Data dilindungi secara dalaman Bahagian lain program hanya boleh beroperasi pada data melalui operasi yang dibenarkan (kaedah ahli).
Kes:

<html> 
  <head> 
    <script type="text/javascript"> 
      function Person(name, agei, sal){ 
        // 公开 
        this.name = name; 
        // 私有 
        var age = agei; 
        var salary = sal; 
      } 
      var p1 = new Person('zs', 20, 10000); 
      window.alert(p1.name + p1.age); 
    </script> 
  </head> 
  <body> 
  </body> 
</html>

Salin selepas log masuk

PS: Enkapsulasi JS hanya mempunyai dua keadaan, satu adalah awam dan satu lagi adalah peribadi.

Perbezaan antara menambah kaedah ahli melalui pembina dan menambah kaedah ahli melalui kaedah prototaip
1. Fungsi yang diperuntukkan melalui kaedah prototaip dikongsi oleh semua objek.
2. Atribut yang diberikan melalui kaedah prototaip adalah bebas (Jika anda tidak mengubah suai atribut, ia akan dikongsi)
3. Adalah disyorkan bahawa jika kita mahu semua objek menggunakan fungsi yang sama, sebaiknya gunakan kaedah prototaip untuk menambah fungsi, yang menjimatkan memori.

Kes:

function Person(){
  this.name="zs";
  var age=20;
  this.abc=function(){
    window.alert("abc");
  }
  function abc2(){
    window.alert("abc");
  }
}
Person.prototype.fun1=function(){
  window.alert(this.name);//ok
  //window.alert(age);//no ok
  //abc2();//no ok
  this.abc();//ok
}
var p1=new Person();
p1.fun1();

Salin selepas log masuk

Penekanan khas: Kami belajar lebih awal untuk menambah kaedah pada semua objek melalui prototaip, tetapi kaedah ini tidak boleh mengakses pembolehubah peribadi dan kaedah kelas.

2
Warisan boleh menyelesaikan penggunaan semula kod dan menjadikan pengaturcaraan lebih dekat dengan pemikiran manusia. Apabila berbilang kelas mempunyai atribut (pembolehubah) dan kaedah yang sama, anda boleh mengabstrak kelas induk daripada kelas ini dan mentakrifkan atribut dan kaedah yang sama ini dalam kelas induk Semua subkelas tidak perlu mentakrifkan semula atribut dan kaedah ini dan kaedah daripada kelas induk. Bagaimana untuk melaksanakan warisan dalam JS

1. Penyamaran objek
Kes:

<html> 
  <head> 
    <script type="text/javascript"> 
      function Stu(name, age){ 
        this.name = name; 
        this.age = age; 
        this.show = function(){ 
          window.alert(this.name + " " + this.age); 
        } 
      } 
      function MidStu(name, age) { 
        this.stu = Stu; 
        // 通过对象冒充来实现继承的 
        // 对象冒充的意思就是获取那个类的所有成员，因为js是谁调用那个成员就是谁的，这样MidStu就有了Stu的成员了 
        this.stu(name, age); 
        this.payFee = function(){ 
          window.alert("缴费" + money * 0.8); 
        } 
      } 
      function Pupil(name, age) { 
        this.stu = Stu; 
        // 通过对象冒充来实现继承的 
        this.stu(name, age); 
        this.payFee = function(){ 
          window.alert("缴费" + money * 0.5); 
        } 
      } 
 
      var midStu = new MidStu("zs", 13); 
      midStu.show(); 
      var pupil = new Pupil("ls", 10); 
      pupil.show(); 
    </script> 
  </head> 
  <body> 
  </body> 
</html>

Salin selepas log masuk

2. Melalui panggilan atau mohon
Kes:

<html> 
<head> 
<script type="text/javascript"> 
  //1. 把子类中共有的属性和方法抽取出，定义一个父类Stu 
  function Stu(name,age){ 
    // window.alert("确实被调用."); 
    this.name=name; 
    this.age=age; 
    this.show=function(){ 
      window.alert(this.name+"年龄是="+this.age); 
    } 
  } 
  //2.通过对象冒充来继承父类的属性的方法 
  function MidStu(name,age){ 
    //这里这样理解: 通过call修改了Stu构造函数的this指向, 
    //让它指向了调用者本身. 
    Stu.call(this,name,age); 
    //如果用apply实现，则可以 
    //Stu.apply(this,[name,age]); //说明传入的参数是 数组方式 
    //可以写MidStu自己的方法. 
    this.pay=function(fee){ 
      window.alert("你的学费是"+fee*0.8); 
    } 
  } 
  function Pupil(name,age){ 
    Stu.call(this,name,age);//当我们创建Pupil对象实例,Stu的构造函数会被执行,当执行后，我们Pupil对象就获取从 Stu封装的属性和方法 
    //可以写Pupil自己的方法. 
    this.pay=function(fee){ 
      window.alert("你的学费是"+fee*0.5); 
    } 
  } 
  //测试 
  var midstu=new MidStu("zs",15); 
  var pupil=new Pupil("ls",12); 
  midstu.show(); 
  midstu.pay(100); 
  pupil.show(); 
  pupil.pay(100); 
</script> 
</html>

Salin selepas log masuk

Ringkasan:

1. Objek JS boleh ditiru melalui objek untuk mencapai pelbagai warisan
2. Kelas Objek ialah kelas asas semua kelas Js

3. Polimorfisme Fungsi JS terlebih beban
Ini adalah asas polimorfisme Seperti yang dinyatakan dalam pengenalan sebelumnya kepada Javascript, fungsi JS tidak menyokong polimorfisme, tetapi sebenarnya fungsi JS adalah tanpa kewarganegaraan dan senarai parameter sokongan dari sebarang panjang dan jenis. Jika berbilang fungsi dengan nama yang sama ditakrifkan pada masa yang sama, fungsi terakhir akan diguna pakai.
Kes:

<html> 
<head> 
<script type="text/javascript"> 
  //*****************说明js不支持重载***** 
  /*function Person(){ 
    this.test1=function (a,b){ 
      window.alert('function (a,b)');  
    } 
    this.test1=function (a){ 
      window.alert('function (a)'); 
    } 
  } 
  var p1=new Person(); 
  //js中不支持重载. 
  //但是这不会报错，js会默认是最后同名一个函数，可以看做是后面的把前面的覆盖了。 
  p1.test1("a","b"); 
  p1.test1("a");*/ 
   
  //js怎么实现重载.通过判断参数的个数来实现重载 
  function Person(){ 
    this.test1=function (){ 
      if(arguments.length==1){ 
        this.show1(arguments[0]); 
      }else if(arguments.length==2){ 
        this.show2(arguments[0],arguments[1]); 
      }else if(arguments.length==3){ 
        this.show3(arguments[0],arguments[1],arguments[2]); 
      } 
    } 
    this.show1=function(a){ 
      window.alert("show1()被调用"+a); 
    } 
    this.show2=function(a,b){ 
      window.alert("show2()被调用"+"--"+a+"--"+b); 
    } 
    function show3(a,b,c){ 
      window.alert("show3()被调用"); 
    } 
  } 
  var p1=new Person(); 
  //js中不支持重载. 
  p1.test1("a","b"); 
  p1.test1("a"); 
</script> 
</html>

Salin selepas log masuk

1. Konsep asas polimorfisme

Polimorfisme merujuk kepada keadaan berbilang rujukan (jenis) di bawah keadaan yang berbeza. Ia juga boleh difahami sebagai: Polimorfisme merujuk kepada kaedah panggilan yang dilaksanakan dalam subkelas yang berbeza melalui rujukan yang menunjuk kepada kelas induk.
Kes:

<script type="text/javascript"> 
  // Master类 
  function Master(name){ 
    this.nam=name; 
    //方法[给动物喂食物] 
  } 
  //原型法添加成员函数 
  Master.prototype.feed=function (animal,food){ 
    window.alert("给"+animal.name+" 喂"+ food.name); 
  } 
  function Food(name){ 
    this.name=name; 
  } 
  //鱼类 
  function Fish(name){ 
    this.food=Food; 
    this.food(name); 
  } 
  //骨头 
  function Bone(name){ 
    this.food=Food; 
    this.food(name); 
  } 
  function Peach(name){ 
    this.food=Food; 
    this.food(name); 
  } 
  //动物类 
  function Animal(name){ 
    this.name=name; 
  } 
  //猫猫 
  function Cat(name){ 
    this.animal=Animal; 
    this.animal(name); 
  } 
  //狗狗 
  function Dog(name){ 
    this.animal=Animal; 
    this.animal(name); 
  } 
  //猴子 
  function Monkey(name){ 
    this.animal=Animal; 
    this.animal(name); 
  } 
  var cat=new Cat("猫"); 
  var fish=new Fish("鱼"); 
 
  var dog=new Dog("狗"); 
  var bone=new Bone("骨头"); 
 
  var monkey=new Monkey("猴"); 
  var peach=new Peach("桃"); 
 
  //创建一个主人 
  var master=new Master("zs"); 
  master.feed(dog,bone); 
  master.feed(cat,fish); 
  master.feed(monkey,peach); 
</script>

Salin selepas log masuk

Polymorphism adalah kondusif untuk penyelenggaraan dan pengembangan kod Apabila kita perlu menggunakan objek pada jenis pokok yang sama, kita hanya perlu menghantar parameter yang berbeza tanpa perlu mencipta objek baharu.

Di atas adalah tiga ciri utama Javascript berdasarkan objek. Saya harap ia akan membantu pembelajaran semua orang.