Pewarisan dan Polimorfisme
Jelajahi prinsip pemrograman berorientasi objek seperti pewarisan, kelas abstrak, dan polimorfisme di Scala.
Pewarisan dan Polimorfisme adalah pelajaran Scala for Backend Engineering & Functional Programming gratis di CoddyKit. Ini adalah pelajaran 2 dari 2. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Scala for Backend Engineering & Functional Programming, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Scala for Backend Engineering & Functional Programming mencakup 2 pelajaran total.
Apa Itu Pewarisan?
Pewarisan adalah konsep dasar dalam Pemrograman Berorientasi Objek (OOP) yang memungkinkan kelas baru mewarisi properti dan perilaku (metode) dari kelas yang sudah ada.
Bayangkan ini sebagai hubungan “induk-anak”. Kelas “anak” (subkelas) menggunakan kembali kode dari kelas “induk” (superkelas), sehingga menghemat waktu dan memastikan konsistensi.
- Mendorong penggunaan kembali kode.
- Membangun hubungan “adalah” (misalnya, Dog adalah Animal).
- Membantu mengatur kode ke dalam hierarki.
Kelas Dasar Pertama Anda
Mari kita mendefinisikan kelas Animal sederhana. Ini akan menjadi kelas dasar kita, yang juga dikenal sebagai superkelas atau kelas induk. Kelas ini memiliki satu perilaku dasar: berbicara.
Jalankan kode tersebut untuk melihat hewan umum kita beraksi!
class Animal {
val name: String = "Generic Animal"
def speak(): Unit = {
println(s"$name makes a sound.")
}
}
object Main {
def main(args: Array[String]): Unit = {
val myAnimal = new Animal()
myAnimal.speak()
}
}Memperluas dengan `extends`
Sekarang, mari kita membuat hewan yang lebih spesifik, yaitu Dog. Dog adalah Animal, sehingga dapat mewarisi dari kelas Animal menggunakan kata kunci extends.
Kita juga dapat mengganti metode speak untuk memberikan suara unik milik Dog. Perhatikan kata kunci override.
class Animal {
val name: String = "Generic Animal"
def speak(): Unit = {
println(s"$name makes a sound.")
}
}
class Dog extends Animal {
override val name: String = "Dog"
override def speak(): Unit = {
println(s"$name barks!")
}
}
object Main {
def main(args: Array[String]): Unit = {
val myAnimal = new Animal()
val myDog = new Dog()
myAnimal.speak() // Generic Animal makes a sound.
myDog.speak() // Dog barks!
}
}Kehebatan `override`
Kata kunci override sangat penting di Scala karena beberapa alasan:
- Kejelasan: Kata kunci ini secara jelas memberi tahu pengembang lain bahwa metode atau bidang ini menggantikan anggota dari superkelas.
- Keamanan: Kompilator memeriksa apakah Anda benar-benar mengganti anggota yang sudah ada. Jika Anda salah mengetik atau metode superkelas berubah, kompilator akan memberi tahu Anda.
- Maksud: Kata kunci ini menyatakan dengan jelas maksud Anda untuk mengkhususkan atau mengubah perilaku yang diwarisi.
Selalu gunakan override saat mendefinisikan ulang anggota yang diwarisi!
Polimorfisme: Banyak Bentuk
Polimorfisme berarti “banyak bentuk”. Dalam OOP, polimorfisme memungkinkan objek dari kelas yang berbeda diperlakukan sebagai objek dari superkelas yang sama.
Artinya, Anda dapat memiliki variabel bertipe Animal yang menyimpan objek Dog, objek Cat, atau subkelas Animal lainnya. Saat Anda memanggil metode pada variabel tersebut, metode yang tepat untuk tipe objek sebenarnya akan dijalankan.
- Memungkinkan kode yang fleksibel dan dapat diperluas.
- Menyediakan satu antarmuka untuk berbagai tipe data.
- Dicapai melalui penggantian metode.
Polimorfisme dalam Praktik
Mari kita melihat polimorfisme dalam praktik. Kita akan membuat kelas Cat yang mirip dengan Dog. Kemudian, kita dapat menempatkan berbagai tipe hewan ke dalam daftar dengan supertipe bersama, yaitu Animal, lalu memanggil metode speak mereka.
Perhatikan bagaimana setiap hewan berbicara dengan caranya sendiri, meskipun semuanya diperlakukan sebagai tipe Animal dalam daftar.
class Animal {
val name: String = "Generic Animal"
def speak(): Unit = {
println(s"$name makes a sound.")
}
}
class Dog extends Animal {
override val name: String = "Dog"
override def speak(): Unit = {
println(s"$name barks!")
}
}
class Cat extends Animal {
override val name: String = "Cat"
override def speak(): Unit = {
println(s"$name meows!")
}
}
object Main {
def main(args: Array[String]): Unit = {
val animals: List[Animal] = List(
new Animal(),
new Dog(),
new Cat()
)
animals.foreach(_.speak())
}
}Memperkenalkan Kelas Abstrak
Terkadang, Anda ingin memiliki kelas dasar yang mendefinisikan antarmuka umum, tetapi tidak menyediakan implementasi lengkap untuk sebagian anggotanya. Di sinilah kelas abstrak digunakan.
Sebuah kelas abstrak:
- Tidak dapat dibuat instansnya secara langsung (Anda tidak dapat membuat objek dari kelas abstrak).
- Dapat berisi metode abstrak (metode tanpa implementasi) dan metode konkret (metode dengan implementasi).
- Berfungsi sebagai cetak biru yang harus dilengkapi oleh subkelasnya.
Membangun Cetak Biru Abstrak
Mari kita mendefinisikan abstract class Shape. Setiap bentuk memiliki luas, tetapi rumus untuk menghitungnya berbeda untuk setiap bentuk tertentu (lingkaran, persegi panjang, dan sebagainya).
Jadi, kita mendeklarasikan area sebagai metode abstrak. Perhatikan bahwa metode ini tidak memiliki isi (tidak ada = { ... }). Subkelas bertanggung jawab menyediakan implementasinya.
abstract class Shape {
def area: Double // Abstract method, no implementation
def describe(): Unit = {
println("This is a geometric shape.")
}
}
// You cannot do: new Shape() - it's abstract!
object Main {
def main(args: Array[String]): Unit = {
println("Abstract class Shape defined.")
println("Cannot instantiate Shape directly.")
}
}Implementasi Konkret
Sekarang, mari kita membuat subkelas konkret seperti Circle dan Rectangle yang memperluas abstract class Shape kita. Subkelas ini harus menyediakan implementasi untuk metode abstrak area.
Subkelas tersebut juga mewarisi metode konkret describe() dari Shape.
abstract class Shape {
def area: Double
def describe(): Unit = {
println("This is a geometric shape.")
}
}
class Circle(radius: Double) extends Shape {
override def area: Double = math.Pi * radius * radius
}
class Rectangle(width: Double, height: Double) extends Shape {
override def area: Double = width * height
}
object Main {
def main(args: Array[String]): Unit = {
val circle = new Circle(5)
val rectangle = new Rectangle(4, 6)
println(s"Circle area: ${circle.area}")
circle.describe()
println(s"Rectangle area: ${rectangle.area}")
rectangle.describe()
}
}Pemeriksaan Pewarisan & Polimorfisme
Pernyataan manakah berikut ini tentang pewarisan dan polimorfisme di Scala yang BENAR?
Ringkasan: Pewarisan & Polimorfisme
Kerja bagus! Dalam pelajaran ini, kita telah mempelajari konsep inti OOP di Scala:
- Pewarisan: Cara subkelas menggunakan kembali kode dan membangun hubungan “adalah” dengan superkelas menggunakan
extends. - Kata kunci
override: Penting untuk mendefinisikan ulang metode dan bidang yang diwarisi secara jelas, serta memastikan keamanan tipe dan kejelasan kode. - Polimorfisme: Kemampuan untuk memperlakukan objek dari subkelas yang berbeda sebagai objek dari superkelas yang sama, sehingga memungkinkan kode yang fleksibel dan dapat diperluas.
- Kelas abstrak: Cetak biru yang tidak dapat dibuat instansnya secara langsung, digunakan untuk mendefinisikan antarmuka umum dan anggota abstrak yang harus diimplementasikan oleh subkelas.
Konsep-konsep ini penting untuk membangun aplikasi Scala yang terstruktur dengan baik dan mudah dipelihara!
Pertanyaan yang Sering Diajukan
Apakah pelajaran “Pewarisan dan Polimorfisme” gratis?
Ya — teks lengkap “Pewarisan dan Polimorfisme” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Scala for Backend Engineering & Functional Programming, upgrade ke CoddyKit PRO. Kursus Scala for Backend Engineering & Functional Programming mencakup 2 pelajaran total.
Apa yang akan aku pelajari di “Pewarisan dan Polimorfisme”?
Jelajahi prinsip pemrograman berorientasi objek seperti pewarisan, kelas abstrak, dan polimorfisme di Scala. Kamu berlatih Scala for Backend Engineering & Functional Programming dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.
Apakah aku perlu pengalaman untuk memulai Scala for Backend Engineering & Functional Programming?
Tidak diperlukan pengalaman sebelumnya. Scala for Backend Engineering & Functional Programming di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 2 dari 2.
Berapa lama pelajaran “Pewarisan dan Polimorfisme” memakan waktu?
Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.
Bisakah aku menulis dan menjalankan kode dalam pelajaran Scala for Backend Engineering & Functional Programming ini?
Ya. Setiap pelajaran Scala for Backend Engineering & Functional Programming menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.
Semua pelajaran dalam kursus ini
- Kelas, Objek, dan Pengemasan
- Pewarisan dan Polimorfisme