Farih.co.id
Home Programming Cara Menerapkan Konsep Pemrograman Berorientasi Objek di Rust

Cara Menerapkan Konsep Pemrograman Berorientasi Objek di Rust

rust foundation 2

Pemrograman Berorientasi Objek (OOP) menyederhanakan desain perangkat lunak dengan menekankan penggunaan objek untuk mewakili entitas dan konsep dunia nyata. OOP mendorong pemeliharaan dengan mengenkapsulasi fungsionalitas dalam objek.


Rust adalah bahasa fleksibel yang mendukung pemrograman fungsional dan prosedural. Meskipun tidak mendukung pemrograman berorientasi objek secara asli, Anda dapat mengimplementasikan konsep OOP menggunakan tipe data bawaan Rust.


Enkapsulasi dalam Karat

Enkapsulasi memerlukan pengorganisasian kode ke dalam unit mandiri yang menyembunyikan detail internal sambil memaparkan antarmuka publik untuk interaksi eksternal guna meminimalkan kerumitan dan meningkatkan pemeliharaan kode.

Anda dapat mengenkapsulasi kode Rust dengan modul. Modul adalah kumpulan item termasuk fungsi, struct, enum, dan konstanta. Modul Rust menyediakan fungsionalitas untuk mengelompokkan dan menentukan batasan antara bagian-bagian dari suatu program.

Menggunakan Modul untuk Mengenkapsulasi Data dan Fungsi

Anda dapat menentukan modul menggunakan mod kata kunci diikuti dengan nama:

 mod my_module {
    
}

Anda dapat mengatur modul secara hierarki dengan menyarangkan deklarasinya:

 mod parent_module {
    mod my_module {
        
    }
}

Anda kemudian dapat merujuk ke modul bersarang dengan hierarki penuh, memisahkan setiap modul dengan titik dua ganda, misalnya, parent_module::my_module.

Secara default, item dalam modul bersifat pribadi dan hanya dapat diakses oleh kode dalam modul yang sama. Tapi Anda bisa membuat modul menjadi publik menggunakan pub kata kunci:

 mod my_module {
    pub fn my_function() {
        
    }
}

Anda kemudian dapat mengakses my_function dari bagian lain dari program Anda.

Menggunakan Sifat untuk Mendefinisikan Perilaku

Cara lain Rust mengaktifkan enkapsulasi adalah melalui penggunaan sifat. Ciri menentukan perilaku yang dapat diimplementasikan oleh tipe dan memastikan bahwa tipe yang berbeda sesuai dengan antarmuka yang sama.

 pub trait Printable {
    fn print(&self);
}

pub struct MyType {
    
}

impl Printable for MyType {
    fn print(&self) {
        
    }
}

Itu Dapat dicetak sifat memiliki a mencetak metode, dan Tipe ku struct mengimplementasikan Dapat dicetak sifat dengan menerapkan mencetak metode.

Dengan menggunakan ciri-ciri, Anda dapat memastikan bahwa jenis apa pun yang mengimplementasikan Dapat dicetak sifat memiliki a mencetak metode. Ini berguna saat bekerja dengan kode generik yang perlu beroperasi dengan tipe berbeda yang berbagi perilaku umum.

Warisan dalam Karat

Warisan memungkinkan Anda menentukan satu kelas berdasarkan kelas yang berbeda. Sub-kelas akan mewarisi properti dan metode dari induknya.

Di Rust, Anda didorong untuk menggunakan komposisi alih-alih pewarisan. Komposisi adalah proses menciptakan objek baru dengan menggabungkan yang sudah ada. Alih-alih membuat kelas baru yang mewarisi fungsionalitas dari kelas dasar, Anda dapat membuat struct baru yang berisi turunan dari struct dasar dan bidangnya.

Membuat Tipe Baru dengan Menggabungkan Tipe yang Sudah Ada

Anda akan menggunakan enum dan struct untuk membuat tipe baru. Enum berguna untuk tipe dengan nilai terbatas, dan struct dapat menampung banyak bidang.

Anda dapat membuat tipe enum untuk berbagai jenis hewan.

 enum Animal {
    Cat,
    Dog,
    Bird,
    
}

Alternatifnya, Anda dapat membuat struct yang berisi bidang untuk setiap jenis hewan. Struct dapat menampung enum dan jenis lainnya.

 struct Animal {
    name: String,
    age: u8,
    animal_type: AnimalType,
}

enum AnimalType {
    Cat,
    Dog,
    Bird,
    
}

Itu Satwa struct memegang nilai-nilai dari Jenis Hewan jenis enumerasi.

Anda dapat menggunakan sifat untuk menerapkan pewarisan dan menambahkan perilaku ke suatu tipe tanpa membuat yang baru.

 trait Fly {
    fn fly(&self);
}

Inilah cara Anda dapat mengimplementasikan Terbang sifat untuk beberapa jenis.

 struct Bird {
    name: String,
    wingspan: f32,
}

impl Fly for Bird {
    fn fly(&self) {
        println!("{} is flying!", self.name);
    }
}

struct Plane {
    model: String,
    max_speed: u32,
}

impl Fly for Plane {
    fn fly(&self) {
        println!("{} is flying!", self.model);
    }
}

Itu Burung Dan Pesawat struct mengimplementasikan Terbang sifat dan cetak string dengan Cetak! makro.

Anda dapat menghubungi terbang metode pada kedua struct tanpa mengetahui tipe spesifiknya.

 fn main() {
    let bird = Bird {
        name: String::from("Eagle"),
        wingspan: 2.0,
    };

    let plane = Plane {
        model: String::from("Boeing 747"),
        max_speed: 900,
    };

    let flying_objects: Vec<&dyn Fly> = vec![&bird, &plane];

    for object in flying_objects {
        object.fly();
    }
}

Itu utama fungsi instantiate Pesawat Dan Burung jenis. Itu benda_terbang vektor adalah vektor dari contoh objek, dan untuk loop melintasi vektor dan memanggil terbang metode pada contoh.

hasil dari implementasi pewarisan di Rust

Menerapkan Polimorfisme di Rust

Kelas atau tipe adalah polimorfik jika beberapa tipe mewakili antarmuka. Karena sifat menyediakan fungsionalitas untuk menentukan perilaku di Rust, sambil menyediakan antarmuka umum untuk menulis kode generik, Anda dapat menggunakan Sifat untuk mengimplementasikan polimorfisme.

Inilah sifat bernama Dapat digambar yang mendefinisikan perilaku untuk merender objek di layar:

 trait Drawable {
    fn draw(&self);
}

Tipe yang mengimplementasikan sifat Drawable dapat mengakses menggambar fungsi.

 struct Rectangle {
    width: u32,
    height: u32,
}

impl Drawable for Rectangle {
    fn draw(&self) {
        
    }
}

Anda dapat menulis kode generik yang menggambar objek yang mengimplementasikan Dapat digambar sifat.

 fn draw_object<T: Drawable>(object: &T) {
    object.draw();
}

Itu draw_object fungsi mengambil tipe generik T sebagai input yang mengimplementasikan Dapat digambar sifat dan memanggil menggambar metode pada sifat. Objek yang berbeda dapat mengimplementasikan Dapat digambar sifat dan mengakses fungsionalitas.

Menerapkan Abstraksi di Rust

Abstraksi adalah konsep OOP di mana kelas dan antarmuka dapat diakses oleh objek dan tipe tertentu. Anda dapat mengimplementasikan abstraksi di Rust dengan ciri-ciri.

Berikut adalah contoh sifat untuk pemutar media:

 trait Media {
    fn play(&self);
}

Struktur dan enum yang mengimplementasikan Media sifat harus menyediakan implementasi untuk bermain metode.

 struct Song {
    title: String,
    artist: String,
}

impl Media for Song {
    fn play(&self) {
        println!("Playing song: {} by {}", self.title, self.artist);
    }
}

Itu Lagu struct mengimplementasikan Media sifat dengan menyediakan implementasi untuk bermain metode yang mencetak pesan dengan bidang Lagu struct ke konsol.

 fn main() {
    
    let song = Song {
        title: String::from("Bohemian Rhapsody"),
        artist: String::from("Queen"),
    };

    
    song.play();
}

Itu lagu variabel adalah turunan dari Lagu struct, dan variabel dapat mengakses dan memanggil bermain metode.

hasil dari penerapan abstraksi di Rust

Mengatur Kode Karat Itu Mudah

Pemrograman berorientasi objek membantu dengan organisasi kode. Berkat sistem modul Rust, Anda dapat dengan mudah mengatur kode Rust Anda sambil menerapkan konsep OOP untuk aplikasi Anda agar kode Anda tetap teratur, mudah dikelola, dan intuitif.

Comment
Share:

Leave a Reply

Your email address will not be published. Required fields are marked *

beli jitu https://167.71.217.241/ https://188.166.210.27/ https://103.253.147.8/ https://139.59.194.132/ https://152.42.192.54/ https://152.42.187.123/ https://188.166.196.248/ https://163.47.9.78/ https://157.230.245.144/ http://68.183.96.87/ http://147.182.210.122/ http://147.182.128.234/ http://167.172.1.184/ http://157.245.5.74/ http://139.59.217.59/ http://163.47.9.16/ http://144.126.251.215/ http://139.59.217.128/ http://103.186.0.254/ http://161.35.251.176/ http://157.245.29.71/ https://170.64.254.102/ https://www.markas303.ac.id/ https://www.markas303.or.id/ https://www.markas303.sch.id/ http://103.172.205.75/ http://103.245.38.119/ http://138.197.224.231/ http://138.197.224.231/

Ad

BIJI18 BIJI18 https://goremekoop.com/ AGEN77 3DBET OBOR138 GACOR168JP YING77 RUMAH258 POHONHOKI99 ASALBET88 PARIS128 66KBET LONG111 DESA333 DEWAGACOR89 YING77
https://146.190.200.68/ https://188.166.204.36/