Kelas Jenis dan Implicit
Pelajari cara menggunakan kelas jenis untuk polimorfisme ad hoc dan memanfaatkan sistem implicit Scala bagi menghasilkan abstraksi yang berkuasa.
Kelas Jenis dan Implicit ialah pelajaran Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian percuma di CoddyKit. Ini ialah pelajaran 3 daripada 3. Anda boleh membaca keseluruhan pelajaran di bawah secara percuma — kemudian berlatih secara praktikal dalam pelayar menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian merangkumi sejumlah 3 pelajaran.
Polimorfisme Ad Hoc Diterangkan
Dalam Scala, polimorfisme bermaksud menulis kod yang berfungsi dengan jenis yang berbeza. Anda telah melihat polimorfisme subjenis melalui pewarisan, apabila sesuatu kaedah berfungsi untuk kelas asas dan semua subkelasnya.
Polimorfisme ad hoc berbeza. Polimorfisme ini membolehkan satu fungsi berkelakuan secara berbeza berdasarkan jenis khusus yang diberikan kepadanya, walaupun jenis tersebut tidak berkaitan melalui pewarisan. Di sinilah kelas jenis amat berguna!
Apakah Kelas Jenis?
Kelas Jenis ialah corak reka bentuk yang menyediakan cara untuk menambahkan tingkah laku baharu pada jenis sedia ada tanpa mengubahnya dan tanpa menggunakan pewarisan.
- Ia mentakrifkan kontrak (trait) untuk tingkah laku tertentu.
- Ia menyediakan 'instance' (objek) yang melaksanakan kontrak ini untuk jenis yang berbeza.
- Ia menggunakan mekanisme implicit Scala untuk membawa tingkah laku yang betul ke dalam skop secara automatik.
Mentakrifkan Trait Kelas Jenis
Mula-mula, kita mentakrifkan trait yang menerangkan tingkah laku yang kita inginkan. Trait ini mengambil parameter jenis, A, yang mewakili jenis yang akan dikenakan oleh tingkah laku kita.
Mari kita cipta kelas jenis Printable yang tahu cara menukar apa-apa jenis kepada rentetan yang boleh dibaca manusia.
package com.coddykit
trait Printable[A] {
def format(value: A): String
}Mencipta Instance Kelas Jenis
Sekarang, kita perlu memberitahu Scala cara menjadikan jenis tertentu sebagai Printable. Kita melakukannya dengan mencipta objek implicit (atau nilai) yang melanjutkan trait Printable kita untuk setiap jenis.
Objek ini dipanggil instance kelas jenis.
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 Jenis dengan Implicit
Untuk menggunakan kelas jenis kita, kita mentakrifkan fungsi yang mengambil parameter implicit bagi kelas jenis tersebut. Pengkompil Scala akan mencari instance implicit Printable[A] yang tersedia secara automatik apabila fungsi ini dipanggil.
Jika menemuinya, pengkompil 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)
}
}Had Konteks: Sintaks yang Lebih Kemas
Scala menawarkan bentuk ringkas yang dipanggil had konteks untuk parameter implicit. Daripada (implicit p: Printable[A]), anda boleh menulis [A: Printable].
Ini menjadikan kod lebih kemas, terutamanya apabila anda mempunyai berbilang 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)
}
}Melanjutkan kepada Jenis Tersuai
Kekuatan kelas jenis ialah anda boleh menambahkan tingkah laku baharu pada mana-mana jenis, termasuk jenis yang bukan milik anda (seperti Int atau String), atau jenis tersuai anda sendiri seperti kelas kes.
Mari kita jadikan kelas kes Person kita 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 Daripada Kelas Jenis
Walaupun kelas jenis ialah kes penggunaan utama, kata kunci implicit dalam Scala merupakan mekanisme yang lebih luas. Ia boleh digunakan untuk:
- Parameter Implicit: Seperti yang dilihat pada kelas jenis, untuk menyediakan nilai secara automatik.
- Penukaran Implicit: Untuk menukar satu jenis kepada jenis lain secara automatik (gunakan dengan berhati-hati kerana penukaran ini boleh menyebabkan kod lebih sukar difahami).
- Nilai Implicit: Untuk menyediakan nilai lalai bagi jenis tertentu, yang sering digunakan untuk perkara seperti konteks pelaksanaan.
Idea utamanya ialah pengkompil mencari takrifan implicit yang sesuai dalam skop.
Faedah Kelas Jenis
Kelas jenis menawarkan beberapa kelebihan:
- Kebolehkembangan: Tambahkan tingkah laku baharu pada jenis sedia ada tanpa mengubahnya.
- Pemisahan gandingan: Asingkan takrifan jenis daripada tingkah lakunya.
- Polimorfisme ad hoc: Fungsi boleh berfungsi dengan apa-apa jenis yang menyediakan tingkah laku yang diperlukan.
- Kebolehujian: Lebih mudah menguji tingkah laku secara berasingan.
- Tanpa Beban Pewarisan: Mengelakkan kerumitan hierarki pewarisan yang mendalam.
Semakan Pantas
Pertimbangkan kelas jenis Printable dan instance-nya daripada pelajaran kita. Jika anda memanggil print(10.5), dengan mengandaikan tiada instance DoublePrintable wujud, apakah yang akan berlaku?
Imbas Kembali dan Langkah Seterusnya
Anda telah menguasai Kelas Jenis dan sistem implicit Scala yang berkuasa!
- Kelas Jenis membolehkan polimorfisme ad hoc, yang membolehkan anda mentakrifkan tingkah laku untuk jenis tanpa pewarisan.
- Ia terdiri daripada trait (kontrak) dan objek/nilai implicit (instance).
- Parameter implicit dan had konteks digunakan oleh fungsi untuk mencari dan menggunakan instance ini secara automatik.
Kelas jenis ialah asas penting pengaturcaraan berfungsi dalam Scala. Ia digunakan secara meluas dalam pustaka seperti Cats dan ZIO untuk membina aplikasi yang fleksibel dan teguh. Teruskan berlatih untuk mengukuhkan pemahaman anda!
Pelajari Scala dengan tutor kecerdasan buatan — percuma
Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.
- Kursus
- 39
- Pelajaran
- 143
Soalan Lazim
Adakah pelajaran “Kelas Jenis dan Implicit” percuma?
Ya — teks penuh “Kelas Jenis dan Implicit” boleh dibaca secara percuma di web ini. Untuk berlatih secara interaktif menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7, serta membuka kunci baki kursus Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian, tingkat taraf kepada CoddyKit PRO. Kursus Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian merangkumi sejumlah 3 pelajaran.
Apakah yang akan saya pelajari dalam “Kelas Jenis dan Implicit”?
Pelajari cara menggunakan kelas jenis untuk polimorfisme ad hoc dan memanfaatkan sistem implicit Scala bagi menghasilkan abstraksi yang berkuasa. Anda berlatih Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.
Adakah saya memerlukan pengalaman untuk memulakan Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian?
Tiada pengalaman terdahulu diperlukan. Pembelajaran Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 3 daripada 3.
Berapa lamakah pelajaran “Kelas Jenis dan Implicit” diambil?
Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.
Bolehkah saya menulis dan menjalankan kod dalam pelajaran Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian ini?
Ya. Setiap pelajaran Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.
Semua pelajaran dalam kursus ini
- Generik dan Parameter Jenis
- Varians: Kovarians & Kontravarians
- Kelas Jenis dan Implicit