Kelas, Objek, dan Pengemasan
Pahami cara mendefinisikan kelas, membuat objek, dan menata kode menggunakan paket di Scala.
Kelas, Objek, dan Pengemasan adalah pelajaran Scala for Backend Engineering & Functional Programming gratis di CoddyKit. Ini adalah pelajaran 1 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.
Selamat Datang di OOP dalam Scala
Dalam pelajaran ini, Anda akan mendalami inti Pemrograman Berorientasi Objek (OOP) dalam Scala. Kita akan mempelajari cara menyusun kode menggunakan kelas, membuat instans dari kelas tersebut (objek), dan menjaga semuanya tetap teratur dengan paket.
Mari mulai membangun aplikasi yang tangguh dan modular!
Kelas: Cetak Biru
Bayangkan kelas sebagai cetak biru untuk membuat objek. Kelas menentukan properti (data) dan perilaku (metode) yang akan dimiliki objeknya. Kelas tidak menyimpan data itu sendiri, tetapi menjelaskan data apa yang dapat disimpan oleh sebuah objek.
Berikut definisi kelas dasar:
class Car {
// Properties and methods go here
}Mendefinisikan Kelas Sederhana
Di Scala, Anda mendefinisikan kelas menggunakan kata kunci class diikuti namanya. Mari kita membuat kelas Dog sederhana. Kelas ini belum melakukan banyak hal, tetapi ini adalah awal yang baik!
Cobalah menjalankan definisi kelas kosong ini:
class Dog {
// This dog has no properties or behaviors yet
}
object Main {
def main(args: Array[String]): Unit = {
println("Dog class defined!")
}
}Membuat Objek (Instans)
Objek adalah instans dari sebuah kelas. Objek merupakan “sesuatu” nyata yang dibuat dari cetak biru tersebut. Untuk membuat objek, Anda menggunakan kata kunci new diikuti nama kelas.
Setiap objek mendapatkan kumpulan datanya sendiri, sebagaimana ditentukan oleh kelas.
class Dog {
// Still an empty dog blueprint
}
object Main {
def main(args: Array[String]): Unit = {
val myDog = new Dog()
val yourDog = new Dog()
println("Two dog objects created!")
}
}Menambahkan Properti ke Kelas
Kelas dapat memiliki properti (juga disebut bidang atau anggota) untuk menyimpan data. Anda dapat mendefinisikannya di konstruktor kelas, sehingga properti tersebut menjadi parameter saat Anda membuat objek.
Mari kita memberikan Dog sebuah name dan breed:
class Dog(val name: String, val breed: String) {
// 'val' makes name and breed immutable properties
}
object Main {
def main(args: Array[String]): Unit = {
val myDog = new Dog("Buddy", "Golden Retriever")
println(s"My dog's name is ${myDog.name} and breed is ${myDog.breed}.")
}
}Menambahkan Perilaku (Metode)
Kelas juga mendefinisikan metode, yaitu fungsi yang menjelaskan perilaku objek. Metode dapat mengakses dan mengubah properti objek.
Sekarang Dog kita dapat bark():
class Dog(val name: String, val breed: String) {
def bark(): String = {
s"${name} says Woof!"
}
}
object Main {
def main(args: Array[String]): Unit = {
val myDog = new Dog("Max", "Labrador")
println(myDog.bark())
}
}`object` di Scala (Singleton)
Di Scala, kata kunci object mendefinisikan sebuah singleton. Artinya, hanya satu instans yang dapat ada. Anda tidak menggunakan new untuk membuatnya; Anda cukup merujuk namanya.
Singleton sering digunakan untuk metode utilitas atau satu titik masuk.
object MathUtils {
def add(a: Int, b: Int): Int = a + b
def subtract(a: Int, b: Int): Int = a - b
}
object Main {
def main(args: Array[String]): Unit = {
val sum = MathUtils.add(5, 3)
println(s"5 + 3 = ${sum}")
}
}Objek Pendamping
Objek pendamping adalah object yang memiliki nama sama dengan sebuah class dan didefinisikan dalam berkas sumber yang sama. Keduanya memiliki akses khusus ke anggota privat satu sama lain.
- Kelas menyimpan data dan metode khusus untuk setiap instans.
- Objek pendamping menyimpan metode yang menyerupai metode statis atau metode pabrik.
class Circle(val radius: Double) {
def area: Double = Circle.PI * radius * radius
}
object Circle {
// This is the companion object for the Circle class
val PI: Double = 3.14159
def apply(r: Double): Circle = new Circle(r) // Factory method
}
object Main {
def main(args: Array[String]): Unit = {
val c = Circle(5.0) // Using the apply method from companion object
println(s"Circle area: ${c.area}")
}
}Mengatur Kode dengan Paket
Paket adalah cara untuk mengatur kelas dan objek ke dalam kelompok logis, mencegah benturan nama, serta meningkatkan kemudahan pemeliharaan kode.
Bayangkan paket sebagai folder untuk kode Anda. Kata kunci package mendeklarasikan paket di bagian atas berkas Scala.
package com.coddykit.animals
class Cat(val name: String) {
def meow(): String = s"${name} says Meow!"
}
// This class is now inside com.coddykit.animals packageMengimpor Anggota dari Paket
Untuk menggunakan kelas atau objek yang didefinisikan dalam paket lain, Anda perlu mengimpornya. Kata kunci import membuat anggota suatu paket tersedia dalam lingkup saat ini.
Mari kita mengimpor kelas Cat:
package com.coddykit.app
// Define a class in a package first for import example
package com.coddykit.animals {
class Cat(val name: String) {
def meow(): String = s"${name} says Meow!"
}
}
import com.coddykit.animals.Cat
object Main {
def main(args: Array[String]): Unit = {
val myCat = new Cat("Whiskers")
println(myCat.meow())
}
}Pemeriksaan Singkat: Kelas atau Objek?
Anda telah mempelajari kelas, objek, dan paket. Mari menguji pemahaman Anda!
Ringkasan: Kelas, Objek, Paket
Kerja yang luar biasa! Anda telah mempelajari dasar-dasar OOP di Scala:
- Kelas adalah cetak biru yang mendefinisikan properti dan perilaku.
- Objek adalah instans yang dibuat dari kelas menggunakan
new. - Kata kunci
objectdi Scala membuat singleton yang berguna untuk utilitas atau pabrik. - Objek pendamping dipasangkan dengan kelas untuk menyediakan anggota yang menyerupai anggota statis.
- Paket mengatur kode Anda, mencegah benturan nama, dan meningkatkan struktur kode.
Selanjutnya, kita akan membangun dasar ini dengan mempelajari pewarisan dan polimorfisme!
Pertanyaan yang Sering Diajukan
Apakah pelajaran “Kelas, Objek, dan Pengemasan” gratis?
Ya — teks lengkap “Kelas, Objek, dan Pengemasan” 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 “Kelas, Objek, dan Pengemasan”?
Pahami cara mendefinisikan kelas, membuat objek, dan menata kode menggunakan paket 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 1 dari 2.
Berapa lama pelajaran “Kelas, Objek, dan Pengemasan” 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