Mengimplementasikan Trait

Termasuk bagian Pemrograman Berorientasi Objek dalam perjalanan Rust di Coddy. Pelajaran 30 dari 61.

Sekarang setelah kamu tahu cara mendefinisikan trait, mari kita lihat cara membuat struct memenuhi kontrak tersebut. Mengimplementasikan trait menghubungkan persyaratan abstrak dengan perilaku konkret.

Sintaksnya menggunakan impl TraitName for StructName:

trait Speak {
    fn speak(&self) -> String;
}

struct Dog {
    name: String,
}

impl Speak for Dog {
    fn speak(&self) -> String {
        format!("{} says: Woof!", self.name)
    }
}

Blok impl Speak for Dog memberi tahu Rust bahwa Dog mengimplementasikan trait Speak. Di dalamnya, kamu menyediakan isi method yang sebenarnya. Di sinilah kamu menentukan bagaimana anjing berbicara.

Kegunaan trait menjadi jelas saat beberapa tipe mengimplementasikan trait yang sama:

struct Cat {
    name: String,
}

impl Speak for Cat {
    fn speak(&self) -> String {
        format!("{} says: Meow!", self.name)
    }
}

Dog dan Cat kini sama-sama memiliki kemampuan Speak, tetapi masing-masing menyediakan implementasi uniknya sendiri. Kamu dapat memanggil .speak() pada kedua tipe:

let dog = Dog { name: String::from("Rex") };
let cat = Cat { name: String::from("Whiskers") };

println!("{}", dog.speak());  // Rex berkata: Woof!
println!("{}", cat.speak());  // Whiskers berkata: Meow!

Inilah dasar polimorfisme di Rust: tipe yang berbeda, antarmuka yang sama, perilaku yang unik.

Tantangan

Mudah

Mari wujudkan trait dengan mengimplementasikannya untuk berbagai tipe! Kamu akan membuat trait Describable dan mengimplementasikannya untuk dua struct yang berbeda, masing-masing memberikan deskripsi uniknya sendiri.

Kamu akan mengatur kodemu dalam tiga file:

describable.rs: Definisikan trait publik Describable dengan method describe(&self) -> String.
items.rs: Buat dua struct publik yang mengimplementasikan trait-mu:
- Book dengan field title publik (String)
- Movie dengan field name publik (String)
Setiap struct harus mengimplementasikan Describable dengan format deskripsinya sendiri yang unik.
main.rs: Satukan module-modulemu, buat instance dari kedua struct, lalu panggil method describe keduanya untuk menunjukkan bagaimana trait yang sama menghasilkan output berbeda untuk tipe yang berbeda.

Book-mu harus mendeskripsikan dirinya sebagai Book: {title} dan Movie-mu harus mendeskripsikan dirinya sebagai Film: {name}. Perhatikan bagaimana setiap tipe memenuhi kontrak yang sama, tetapi dengan perilakunya sendiri!

Di file utamamu, buat book dan movie menggunakan dua input yang diberikan, lalu cetak deskripsinya pada baris terpisah.

Output-mu harus mengikuti format ini:

Book: {title}
Film: {name}

Contohnya, dengan input 1984 dan Inception:

Book: 1984
Film: Inception

Kamu akan menerima dua input: judul book dan nama movie.

Coba sendiri

mod describable;
mod items;

use describable::Describable;
use items::{Book, Movie};

fn main() {
    // Baca input
    let mut title = String::new();
    std::io::stdin().read_line(&mut title).expect("Failed to read line");
    let title = title.trim().to_string();
    
    let mut name = String::new();
    std::io::stdin().read_line(&mut name).expect("Failed to read line");
    let name = name.trim().to_string();
    
    // TODO: Buat instance Book dengan judulnya
    
    // TODO: Buat instance Movie dengan namanya
    
    // TODO: Cetak deskripsi buku
    
    // TODO: Cetak deskripsi film
}