Turunan Kelas adalah cara satu kelas untuk memperluas kelas lainnya.
Jadi kita bisa membuat fungsionalitas baru di atas yang sudah ada.
Kata kunci “extends”
Katakanlah kita mempunyai kelas Animal:
class Animal {
constructor(name) {
this.speed = 0;
this.name = name;
}
run(speed) {
this.speed = speed;
alert(`${this.name} runs with speed ${this.speed}.`);
}
stop() {
this.speed = 0;
alert(`${this.name} stands still.`);
}
}
let animal = new Animal('My animal');
Inilah cara kita mewakili objek animal dan kelas Animal secara grafis:
…Dan kita akan membuat yang lain class Rabbit.
Karena kelinci adalah binatang, kelas Rabbit harus didasarkan pada Animal, memiliki akses ke metode animal, sehingga rabbits dapat melakukan apa yang dapat dilakukan hewan “pada umumnya”.
Sintaks untuk memperluas kelas lain adalah: class Child extends Parent.
Mari buat class Rabbit yang diwarisi dari Animal:
class Rabbit extends Animal {
hide() {
alert(`${this.name} hides!`);
}
}
let rabbit = new Rabbit("White Rabbit");
rabbit.run(5); // White Rabbit runs with speed 5.
rabbit.hide(); // White Rabbit hides!
Objek dari kelas Rabbit mempunyai akses kedua metode Rabbit, seperti rabbit.hide(), dan juga untuk metode Animal, seperti rabbit.run().
Secara internal, kata kunci extends bekerja menggunakan mekanik prototipe lama yang bagus. Ini mengatur Rabbit.prototype.[[Prototype]] untuk Animal.prototype. Jadi, jika metode tidak ditemukan di Rabbit.prototype, JavaScript mengambilnya dari Animal.prototype.
Misalnya, untuk menemukan metode rabbit.run, mesin mengecek (dari bawah ke atas pada gambar):
- Objek
rabbit(tidak punyarun). - Prototipenya, yaitu
Rabbit.prototype(mempunyaihide, tapi tidakrun). - Prototipenya, yaitu (disebabkan oleh
extends)Animal.prototype, yang akhirnya mempunyai metoderun.
Seperti yang bisa kita ingat dari bab *Prototype* asli, JavaScript sendiri menggunakan pewarisan prototypal untuk objek bawaan. Misalnya. Date.prototype.[[Prototype]] adalah Object.prototype. Itulah mengapa tanggal memiliki akses ke metode objek umum.
extends Misalnya, panggilan fungsi yang menghasilkan kelas induk:
function f(phrase) {
return class {
sayHi() { alert(phrase); }
};
}
class User extends f("Hello") {}
new User().sayHi(); // Hello
Di sini class User mewarisi dari hasil f("Hello").
Itu mungkin berguna untuk pola pemrograman tingkat lanjut saat kita menggunakan fungsi untuk menghasilkan kelas bergantung pada banyak kondisi dan dapat mewarisinya.
Mengganti metode
Sekarang mari bergerak maju dan mengganti metode. Secara default, semua metode yang tidak dispesifikasikan dalam class Rabbit diambil secara langsung “sebagaimana adanya” dari class Animal.
Tetapi jika kita menentukan metode kita sendiri di Rabbit, seperti stop() maka itu akan digunakan sebagai gantinya:
class Rabbit extends Animal {
stop() {
// ...sekarang ini akan digunakan untuk rabbit.stop()
// Bukan stop() dari kelas Animal
}
}
Biasanya kita tidak ingin sepenuhnya mengganti metode induk, melainkan untuk membangun di atasnya untuk mengubah atau memperluas fungsinya. Kita melakukan sesuatu dalam metode kita, tetapi memanggil metode induk sebelum/sesudahnya atau dalam proses.
Kelas menyediakan kata kunci "super" untuk itu.
super.method(...)untuk memanggil metode induk.super(...)untuk memanggil konstruktor induk (hanya di dalam konstruktor kita).
Misalnya, biarkan kelinci kita bersembunyi otomatis saat dihentikan:
class Animal {
constructor(name) {
this.speed = 0;
this.name = name;
}
run(speed) {
this.speed = speed;
alert(`${this.name} runs with speed ${this.speed}.`);
}
stop() {
this.speed = 0;
alert(`${this.name} stands still.`);
}
}
class Rabbit extends Animal {
hide() {
alert(`${this.name} hides!`);
}
stop() {
super.stop(); // memanggil stop induk
this.hide(); // dan lalu bersembunyi
}
}
let rabbit = new Rabbit("White Rabbit");
rabbit.run(5); // White Rabbit runs with speed 5.
rabbit.stop(); // White Rabbit stands still. White Rabbit hides!
Sekarang Rabbit mempunyai metode stop yang memanggil induk super.stop() di dalam proses.
superSeperti yang disebutkan di bab Membahas Kembali Fungsi Arrow, arrow functions tidak memiliki super.
Jika diakses, itu diambil dari fungsi luar. Misalnya:
class Rabbit extends Animal {
stop() {
setTimeout(() => super.stop(), 1000); // memanggil stop induk setelah 1 detik
}
}
super di arrow function sama dengan di stop(), jadi berfungsi seperti yang diinginkan. Jika kita menetapkan fungsi “biasa” di sini, akan ada kesalahan:
// Unexpected super
setTimeout(function() { super.stop() }, 1000);
Mengganti konstruktor
Dengan konstruktor, ini menjadi sedikit rumit.
Sampai sekarang, Rabbit tidak mempunyai constructor sendiri.
Menurut spesifikasi, jika sebuah kelas memperluas kelas lain dan tidak memiliki constructor, maka constructor “kosong” berikut akan dibuat:
class Rabbit extends Animal {
// dihasilkan untuk memperluas kelas tanpa konstruktor sendiri
constructor(...args) {
super(...args);
}
}
Seperti yang bisa kita lihat, ini pada dasarnya memanggil constructor induk dengan meneruskan semua argumen. Itu terjadi jika kita tidak menulis konstruktor kita sendiri.
Sekarang mari tambahkan konstruktor kustom ke Rabbit. Ini akan menentukan earLength selain name:
class Animal {
constructor(name) {
this.speed = 0;
this.name = name;
}
// ...
}
class Rabbit extends Animal {
constructor(name, earLength) {
this.speed = 0;
this.name = name;
this.earLength = earLength;
}
// ...
}
// Tidak bekerja!
let rabbit = new Rabbit("White Rabbit", 10); // Error: this is not defined.
Ups! Kita mendapat kesalahan. Sekarang kita tidak bisa membuat rabbits. Apa yang salah?
Jawaban singkatnya adalah:
- Konstruktor dalam kelas mewarisi harus memanggil
super(...), dan (!) lakukan sebelum menggunakanthis.
…Tapi kenapa? Apa yang terjadi di sini? Memang, persyaratannya tampak aneh.
Tentu saja ada penjelasannya. Mari kita bahas detailnya, jadi kamu akan benar-benar mengerti apa yang terjadi.
Dalam JavaScript, ada perbedaan antara fungsi konstruktor dari kelas yang mewarisi (disebut “konstruktor turunan”) dan fungsi lainnya. Konstruktor turunan memiliki properti internal khusus [[ConstructorKind]]:"turunan". Itu label internal khusus.
Label itu mempengaruhi perilakunya dengan new.
- Saat fungsi reguler dijalankan dengan
new, itu membuat objek kosong dan menugaskannya kethis. - Tetapi ketika konstruktor turunan berjalan, ia tidak melakukan ini. Ia mengharapkan konstruktor induk untuk melakukan pekerjaan ini.
Jadi, konstruktor turunan harus memanggil super untuk menjalankan konstruktor induknya, jika tidak, objek untuk this tidak akan dibuat. Dan kita akan mendapatkan kesalahan.
Agar konstruktor Rabbit bekerja, ia perlu memanggilsuper()sebelum menggunakan this, seperti di sini:
class Animal {
constructor(name) {
this.speed = 0;
this.name = name;
}
// ...
}
class Rabbit extends Animal {
constructor(name, earLength) {
super(name);
this.earLength = earLength;
}
// ...
}
// sekarang baik-baik saja
let rabbit = new Rabbit("White Rabbit", 10);
alert(rabbit.name); // White Rabbit
alert(rabbit.earLength); // 10
Mengganti bidang kelas: catatan rumit
Catatan ini mengasumsikan kamu memiliki pengalaman tertentu dengan kelas, mungkin dalam bahasa pemrograman lain.
Ini memberikan wawasan yang lebih baik tentang bahasa dan juga menjelaskan perilaku yang mungkin menjadi sumber kesalahan (tetapi tidak terlalu sering).
Jika kamu merasa kesulitan untuk memahaminya, lanjutkan saja, lanjutkan membaca, kemudian kembali lagi nanti.
Kita tidak hanya dapat mengganti metode, tetapi juga bidang kelas.
Meskipun, ada perilaku rumit saat kami mengakses kolom yang diganti di konstruktor induk, sangat berbeda dari kebanyakan bahasa pemrograman lainnya.
Pertimbangkan contoh ini: