Kelas Tipe dan Implisit
Pelajari penggunaan kelas tipe untuk polimorfisme ad hoc dan manfaatkan sistem implisit Scala untuk abstraksi yang andal.
Kelas Tipe dan Implisit adalah pelajaran Scala for Backend Engineering & Functional Programming gratis di CoddyKit. Ini adalah pelajaran 3 dari 3. 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 3 pelajaran total.
Penjelasan Polimorfisme Ad-hoc
Di Scala, polimorfisme berarti menulis kode yang dapat bekerja dengan berbagai tipe. Anda telah melihat polimorfisme subtipe melalui pewarisan, ketika suatu metode dapat bekerja untuk kelas dasar beserta semua subkelasnya.
Polimorfisme ad-hoc berbeda. Polimorfisme ini memungkinkan satu fungsi berperilaku secara berbeda berdasarkan tipe spesifik yang diberikan kepadanya, meskipun tipe-tipe tersebut tidak memiliki hubungan pewarisan. Di sinilah kelas tipe sangat berguna!
Apa Itu Kelas Tipe?
Kelas Tipe adalah pola desain yang menyediakan cara untuk menambahkan perilaku baru ke tipe yang sudah ada tanpa memodifikasinya dan tanpa menggunakan pewarisan.
- Kelas ini mendefinisikan kontrak (sebuah trait) untuk perilaku tertentu.
- Kelas ini menyediakan "instance" (objek) yang menerapkan kontrak tersebut untuk berbagai tipe.
- Kelas ini menggunakan mekanisme implicit Scala untuk secara otomatis memasukkan perilaku yang tepat ke dalam cakupan.
Mendefinisikan Trait Kelas Tipe
Pertama, kita mendefinisikan sebuah trait yang menjelaskan perilaku yang diinginkan. Trait ini menerima parameter tipe, A, yang mewakili tipe yang akan dikenai perilaku tersebut.
Mari kita buat kelas tipe Printable yang dapat mengonversi tipe apa pun menjadi string yang mudah dibaca manusia.
package com.coddykit
trait Printable[A] {
def format(value: A): String
}Membuat Instance Kelas Tipe
Sekarang, kita perlu memberi tahu Scala cara membuat tipe tertentu menjadi Printable. Kita melakukannya dengan membuat objek implicit (atau nilai) yang memperluas trait Printable untuk setiap tipe.
Objek-objek ini disebut instance kelas tipe.
package com.coddykit
trait Printable[A] {
def format(value: A): String
}
object PrintableInstances {
implicit object StringPrintable extends Printable[String] {
def format(value: String): String = s"'${value}'"
}
implicit object IntPrintable extends Printable[Int] {
def format(value: Int): String = s"${value}i"
}
}Menggunakan Kelas Tipe dengan Implicit
Untuk menggunakan kelas tipe kita, kita mendefinisikan fungsi yang menerima parameter implicit dari kelas tipe tersebut. Kompilator Scala akan secara otomatis mencari instance implicit yang tersedia dari Printable[A] saat fungsi ini dipanggil.
Jika menemukannya, kompilator akan memasukkannya ke dalam fungsi!
package com.coddykit
trait Printable[A] {
def format(value: A): String
}
object PrintableInstances {
implicit object StringPrintable extends Printable[String] {
def format(value: String): String = s"'${value}'"
}
implicit object IntPrintable extends Printable[Int] {
def format(value: Int): String = s"${value}i"
}
}
object PrintableSyntax {
def print[A](value: A)(implicit p: Printable[A]): Unit = {
println(p.format(value))
}
}
object Main {
import PrintableInstances._
import PrintableSyntax._
def main(args: Array[String]): Unit = {
print("hello")
print(123)
}
}Batas Konteks: Sintaks yang Lebih Sederhana
Scala menyediakan bentuk singkat yang disebut batas konteks untuk parameter implicit. Daripada menulis (implicit p: Printable[A]), Anda dapat menulis [A: Printable].
Hal ini membuat kode lebih rapi, terutama ketika Anda memiliki beberapa parameter implicit.
package com.coddykit
trait Printable[A] {
def format(value: A): String
}
object PrintableInstances {
implicit object StringPrintable extends Printable[String] {
def format(value: String): String = s"'${value}'"
}
implicit object IntPrintable extends Printable[Int] {
def format(value: Int): String = s"${value}i"
}
}
object PrintableSyntax {
// Using context bound: [A: Printable] is shorthand for (implicit p: Printable[A])
def print[A: Printable](value: A): Unit = {
// To access the implicit instance, use implicitly[Printable[A]]
val p = implicitly[Printable[A]]
println(p.format(value))
}
}
object Main {
import PrintableInstances._
import PrintableSyntax._
def main(args: Array[String]): Unit = {
print("world")
print(456)
}
}Memperluas ke Tipe Kustom
Kekuatan kelas tipe terletak pada kemampuannya menambahkan perilaku baru ke tipe apa pun, bahkan tipe yang bukan milik Anda (seperti Int atau String), maupun tipe kustom Anda sendiri seperti kelas case.
Mari kita jadikan kelas case Person sebagai Printable.
package com.coddykit
trait Printable[A] {
def format(value: A): String
}
case class Person(name: String, age: Int)
object PrintableInstances {
implicit object StringPrintable extends Printable[String] {
def format(value: String): String = s"'${value}'"
}
implicit object IntPrintable extends Printable[Int] {
def format(value: Int): String = s"${value}i"
}
// New instance for our custom Person type
implicit object PersonPrintable extends Printable[Person] {
def format(person: Person): String =
s"Person(name: ${person.name}, age: ${person.age})"
}
}
object PrintableSyntax {
def print[A: Printable](value: A): Unit = {
val p = implicitly[Printable[A]]
println(p.format(value))
}
}
object Main {
import PrintableInstances._
import PrintableSyntax._
def main(args: Array[String]): Unit = {
val alice = Person("Alice", 30)
print(alice)
}
}Implicit: Lebih dari Sekadar Kelas Tipe
Meskipun kelas tipe merupakan salah satu penggunaan utama, kata kunci implicit di Scala adalah mekanisme yang lebih luas. Mekanisme ini dapat digunakan untuk:
- Parameter Implicit: Seperti pada kelas tipe, untuk menyediakan nilai secara otomatis.
- Konversi Implicit: Untuk mengonversi satu tipe ke tipe lain secara otomatis (gunakan dengan hati-hati karena dapat membuat alur kode lebih sulit diikuti).
- Nilai Implicit: Untuk menyediakan nilai bawaan bagi tipe tertentu, yang sering digunakan untuk hal-hal seperti konteks eksekusi.
Gagasan utamanya adalah kompilator mencari definisi implicit yang sesuai dalam cakupan.
Manfaat Kelas Tipe
Kelas tipe menawarkan beberapa keunggulan:
- Ekstensibilitas: Menambahkan perilaku baru ke tipe yang sudah ada tanpa mengubahnya.
- Pemisahan Ketergantungan: Memisahkan definisi tipe dari perilakunya.
- Polimorfisme Ad-hoc: Fungsi dapat bekerja dengan tipe apa pun yang menyediakan perilaku yang diperlukan.
- Kemudahan Pengujian: Perilaku lebih mudah diuji secara terpisah.
- Tanpa Beban Pewarisan: Menghindari kerumitan hierarki pewarisan yang dalam.
Pemeriksaan Singkat
Perhatikan kelas tipe Printable dan instance-nya dari pelajaran kita. Jika Anda memanggil print(10.5), dengan asumsi tidak ada instance DoublePrintable, apa yang akan terjadi?
Ringkasan dan Langkah Berikutnya
Anda telah menguasai Kelas Tipe dan sistem implicit Scala yang kuat!
- Kelas Tipe memungkinkan polimorfisme ad-hoc, sehingga Anda dapat mendefinisikan perilaku untuk berbagai tipe tanpa pewarisan.
- Kelas tipe terdiri dari sebuah trait (kontrak) dan objek/nilai implicit (instance).
- Parameter implicit dan batas konteks digunakan oleh fungsi untuk menemukan dan menggunakan instance tersebut secara otomatis.
Kelas tipe merupakan salah satu dasar penting pemrograman fungsional dalam Scala. Kelas tipe banyak digunakan dalam pustaka seperti Cats dan ZIO untuk membangun aplikasi yang fleksibel dan tangguh. Teruslah berlatih untuk memperkuat pemahaman Anda!
Pertanyaan yang Sering Diajukan
Apakah pelajaran “Kelas Tipe dan Implisit” gratis?
Ya — teks lengkap “Kelas Tipe dan Implisit” 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 3 pelajaran total.
Apa yang akan aku pelajari di “Kelas Tipe dan Implisit”?
Pelajari penggunaan kelas tipe untuk polimorfisme ad hoc dan manfaatkan sistem implisit Scala untuk abstraksi yang andal. 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 3 dari 3.
Berapa lama pelajaran “Kelas Tipe dan Implisit” 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
- Generik dan Parameter Tipe
- Varians: Kovarians & Kontravarians
- Kelas Tipe dan Implisit