Swift Academy · Pelajaran

Dasar-Dasar Upcasting dan Downcasting

Beralih antara tipe kelas induk dan kelas turunan.

Dasar-Dasar Upcasting dan Downcasting adalah pelajaran Swift Academy gratis di CoddyKit. Ini adalah pelajaran 1 dari 4. 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 Swift Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Swift Academy mencakup 4 pelajaran total.

Gambaran Umum Pengecoran Tipe

Pengecoran tipe memungkinkan Anda memperlakukan sebuah instans sebagai tipe berbeda dalam hierarki kelasnya. Ini memeriksa atau mengubah tipe statis, bukan mengonversi data.

class Animal {
    let name: String
    init(name: String) { self.name = name }
}
class Dog: Animal {
    func bark() -> String { return name + " says Woof" }
}
class Cat: Animal {
    func meow() -> String { return name + " says Meow" }
}
let d = Dog(name: "Rex")
print(d.bark())

Hierarki Kelas

Pengecoran memerlukan sebuah hierarki. Di sini, Dog dan Cat sama-sama mewarisi Animal. Dog adalah Animal.

class Animal {
    let name: String
    init(name: String) { self.name = name }
}
class Dog: Animal {
    func bark() -> String { return name + " says Woof" }
}
class Cat: Animal {
    func meow() -> String { return name + " says Meow" }
}
let pet: Animal = Dog(name: "Rex")
print(pet.name)

Penaikan Tipe dengan as

Penaikan tipe memperlakukan instans subkelas sebagai kelas induknya. Proses ini selalu berhasil, sehingga Anda menggunakan operator as biasa.

class Animal {
    let name: String
    init(name: String) { self.name = name }
}
class Dog: Animal {
    func bark() -> String { return name + " says Woof" }
}
class Cat: Animal {
    func meow() -> String { return name + " says Meow" }
}
let dog = Dog(name: "Rex")
let asAnimal = dog as Animal
print(asAnimal.name)

Mengapa Melakukan Penaikan Tipe

Penaikan tipe berguna untuk menyimpan berbagai subkelas secara bersamaan, misalnya dalam satu larik yang bertipe kelas induk bersama.

class Animal {
    let name: String
    init(name: String) { self.name = name }
}
class Dog: Animal {
    func bark() -> String { return name + " says Woof" }
}
class Cat: Animal {
    func meow() -> String { return name + " says Meow" }
}
let zoo: [Animal] = [Dog(name: "Rex"), Cat(name: "Mia")]
for a in zoo { print(a.name) }

Penaikan Tipe Selalu Aman

Karena setiap instans subkelas juga merupakan instans kelas induk yang valid, kompiler menerima as untuk penaikan tipe tanpa risiko kegagalan.

class Animal {
    let name: String
    init(name: String) { self.name = name }
}
class Dog: Animal {
    func bark() -> String { return name + " says Woof" }
}
class Cat: Animal {
    func meow() -> String { return name + " says Meow" }
}
let cat = Cat(name: "Mia")
let animal = cat as Animal
print("Treated as Animal:", animal.name)

Kehilangan Akses Setelah Penaikan Tipe

Setelah disimpan sebagai tipe kelas induk, Anda hanya dapat memanggil anggota kelas induk. bark() yang khusus untuk Dog tersembunyi sampai Anda melakukan penurunan tipe.

class Animal {
    let name: String
    init(name: String) { self.name = name }
}
class Dog: Animal {
    func bark() -> String { return name + " says Woof" }
}
class Cat: Animal {
    func meow() -> String { return name + " says Meow" }
}
let a: Animal = Dog(name: "Rex")
print(a.name)
// a.bark() would not compile here

Pengantar Penurunan Tipe

Penurunan tipe bekerja sebaliknya: memperlakukan referensi kelas induk sebagai subkelas tertentu untuk mendapatkan kembali anggotanya. Proses ini dapat gagal, sehingga memerlukan as? atau as!.

class Animal {
    let name: String
    init(name: String) { self.name = name }
}
class Dog: Animal {
    func bark() -> String { return name + " says Woof" }
}
class Cat: Animal {
    func meow() -> String { return name + " says Meow" }
}
let a: Animal = Dog(name: "Rex")
if let dog = a as? Dog {
    print(dog.bark())
}

Mengapa Penurunan Tipe Dapat Gagal

Kompiler tidak dapat menjamin bahwa Animal tertentu benar-benar merupakan Dog. Bisa saja itu adalah Cat. Ketidakpastian inilah yang membuat penurunan tipe harus diperiksa.

class Animal {
    let name: String
    init(name: String) { self.name = name }
}
class Dog: Animal {
    func bark() -> String { return name + " says Woof" }
}
class Cat: Animal {
    func meow() -> String { return name + " says Meow" }
}
let a: Animal = Cat(name: "Mia")
let maybeDog = a as? Dog
print("Is it a Dog?", maybeDog != nil)

Penurunan Tipe dalam Perulangan

Pola yang umum adalah mengiterasi larik kelas induk dan menurunkan tipe setiap elemennya untuk menangani subkelas secara berbeda.

class Animal {
    let name: String
    init(name: String) { self.name = name }
}
class Dog: Animal {
    func bark() -> String { return name + " says Woof" }
}
class Cat: Animal {
    func meow() -> String { return name + " says Meow" }
}
let zoo: [Animal] = [Dog(name: "Rex"), Cat(name: "Mia")]
for a in zoo {
    if let dog = a as? Dog { print(dog.bark()) }
    if let cat = a as? Cat { print(cat.meow()) }
}

Ringkasan Penaikan dan Penurunan Tipe

Penaikan tipe (as) bergerak menuju tipe dasar dan selalu berhasil. Penurunan tipe (as? atau as!) bergerak menuju tipe tertentu dan dapat gagal.

class Animal {
    let name: String
    init(name: String) { self.name = name }
}
class Dog: Animal {
    func bark() -> String { return name + " says Woof" }
}
class Cat: Animal {
    func meow() -> String { return name + " says Meow" }
}
let d = Dog(name: "Rex")
let up = d as Animal
let down = up as? Dog
print(up.name, down?.bark() ?? "no")

Pengecoran Hanya dalam Satu Hierarki

Anda hanya dapat melakukan pengecoran antarjenis yang saling berhubungan dalam hierarki yang sama. Tipe yang tidak berhubungan tidak dapat dicor satu sama lain.

class Animal {
    let name: String
    init(name: String) { self.name = name }
}
class Dog: Animal {
    func bark() -> String { return name + " says Woof" }
}
class Cat: Animal {
    func meow() -> String { return name + " says Meow" }
}
let a: Animal = Dog(name: "Rex")
print(a is Animal)
print(a is Dog)

Pemeriksaan Singkat

Ingat kembali arah pengecoran yang selalu berhasil.

Ringkasan: Penaikan dan Penurunan Tipe

Anda telah mempelajari bahwa pengecoran bekerja dalam hierarki kelas, bahwa penaikan tipe dengan as menuju tipe dasar selalu berhasil, serta bahwa penurunan tipe menuju subkelas tertentu dapat gagal dan karena itu memerlukan operator pemeriksaan yang diperkenalkan berikutnya.

class Animal {
    let name: String
    init(name: String) { self.name = name }
}
class Dog: Animal {
    func bark() -> String { return name + " says Woof" }
}
class Cat: Animal {
    func meow() -> String { return name + " says Meow" }
}
let pets: [Animal] = [Dog(name: "Rex"), Cat(name: "Mia")]
for p in pets {
    if let d = p as? Dog { print(d.bark()) } else { print(p.name) }
}

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Dasar-Dasar Upcasting dan Downcasting” gratis?

Ya — teks lengkap “Dasar-Dasar Upcasting dan Downcasting” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Swift Academy, upgrade ke CoddyKit PRO. Kursus Swift Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Dasar-Dasar Upcasting dan Downcasting”?

Beralih antara tipe kelas induk dan kelas turunan. Kamu berlatih Swift Academy 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 Swift Academy?

Tidak diperlukan pengalaman sebelumnya. Swift Academy 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 4.

Berapa lama pelajaran “Dasar-Dasar Upcasting dan Downcasting” 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 Swift Academy ini?

Ya. Setiap pelajaran Swift Academy 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

← Kembali ke Swift Academy