La programmation orientée objet (POO) simplifie la conception des logiciels en mettant l’accent sur l’utilisation d’objets pour représenter les entités et les concepts du monde réel. La POO favorise la maintenabilité en encapsulant les fonctionnalités dans des objets.
Rust est un langage flexible qui prend en charge la programmation fonctionnelle et procédurale. Bien qu’il ne supporte pas nativement la programmation orientée objet, vous pouvez implémenter des concepts OOP en utilisant les types de données intégrés de Rust.
L’encapsulation en Rust
L’encapsulation consiste à organiser le code en unités autonomes qui cachent les détails internes tout en exposant une interface publique pour l’interaction externe afin de minimiser la complexité et d’améliorer la maintenabilité du code.
Vous pouvez encapsuler du code Rust avec des modules. Un module est une collection d’éléments comprenant des fonctions, des structures, des enums et des constantes. Les modules Rust permettent de regrouper et de définir les limites entre les différentes parties d’un programme.
Utiliser des modules pour encapsuler des données et des fonctions
Vous pouvez définir un module à l’aide de la fonction mod suivi d’un nom :
mod my_module {
// module items go here
}
Vous pouvez organiser les modules de manière hiérarchique en imbriquant leurs déclarations :
mod parent_module {
mod my_module {
// module items go here
}
}
Vous pouvez ensuite faire référence aux modules imbriqués avec la hiérarchie complète, en séparant chaque module par un double deux-points, par exemple, module_parent::mon_module.
Par défaut, les éléments des modules sont privés et ne sont accessibles qu’au code du même module. Mais vous pouvez rendre les modules publics à l’aide de la fonction pub mot-clé :
mod my_module {
pub fn my_function() {
// function body goes here
}
}
Vous pouvez ensuite accéder à ma_fonction à partir d’autres parties de votre programme.
Utiliser les caractéristiques pour définir les comportements
Rust permet également l’encapsulation grâce à l’utilisation de traits. Les traits définissent les comportements que les types peuvent implémenter et garantissent que différents types se conforment à la même interface.
pub trait Printable {
fn print(&self);
}
pub struct MyType {
// struct fields here
}
impl Printable for MyType {
fn print(&self) {
// implementation here
}
}
L’élément Imprimable Le trait a un impression et la méthode MyType La structure MyType met en œuvre la fonction Imprimable en mettant en œuvre le trait print méthode.
En utilisant les traits, vous pouvez vous assurer que tout type qui implémente la méthode Imprimable Le trait a un impression . Ceci est pratique lorsque l’on travaille avec du code générique qui doit interopérer avec différents types partageant un comportement commun.
L’héritage en Rust
L’héritage permet de définir une classe à partir d’une autre. La sous-classe hérite des propriétés et des méthodes de sa mère.
En Rust, vous êtes encouragé à utiliser la composition plutôt que l’héritage. La composition est un processus qui consiste à créer de nouveaux objets en combinant des objets existants. Au lieu de créer une nouvelle classe qui hérite des fonctionnalités de la classe de base, vous pouvez créer une nouvelle structure qui contient une instance de la structure de base et ses champs.
Créer de nouveaux types en combinant des types existants
Vous utiliserez les enums et les structs pour créer de nouveaux types. Les enums sont pratiques pour les types à valeurs finies, et les structs peuvent contenir plusieurs champs.
Vous pouvez créer un type enum pour différents types d’animaux.
enum Animal {
Cat,
Dog,
Bird,
// ...
}
Vous pouvez également créer une structure contenant des champs pour chaque type d’animal. Les structures peuvent contenir des enums et d’autres types.
struct Animal {
name: String,
age: u8,
animal_type: AnimalType,
}
enum AnimalType {
Cat,
Dog,
Bird,
// ...
}
L’élément Animal La structure contient les valeurs de l’élément AnimalType type d’énumération.
Vous pouvez utiliser les traits pour mettre en œuvre l’héritage et ajouter un comportement à un type sans en créer un nouveau.
trait Fly {
fn fly(&self);
}
Voici comment vous pouvez implémenter le trait Mouche pour plusieurs types.
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);
}
}
Le Oiseau et Avion Les structs mettent en œuvre la fonction Mouche trait et imprimer des chaînes de caractères avec le Println ! macro.
Vous pouvez appeler la macro mouche sur les deux structures sans connaître leurs types spécifiques.
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();
}
}
La méthode principal instancie la fonction Plan et Oiseau types. Les objets_volants est un vecteur d’instances d’objets, et le vecteur pour parcourt le vecteur et appelle la fonction mouche sur les instances.
Implémentation du polymorphisme en Rust
Une classe ou un type est polymorphe si plusieurs types représentent une interface. Puisque les traits fournissent la fonctionnalité pour définir des comportements en Rust, tout en fournissant une interface commune pour écrire du code générique, vous pouvez utiliser les traits pour implémenter le polymorphisme.
Voici un trait nommé Dessinable qui définit le comportement de rendu des objets à l’écran :
trait Drawable {
fn draw(&self);
}
Les types qui implémentent le trait Drawable peuvent accéder à la fonction dessiner fonction.
struct Rectangle {
width: u32,
height: u32,
}
impl Drawable for Rectangle {
fn draw(&self) {
// Render the rectangle on the screen
}
}
Vous pouvez écrire du code générique qui dessine des objets qui implémentent la fonction Dessinable trait.
fn draw_object<T: Drawable>(object: &T) {
object.draw();
}
Le dessiner_objet la fonction prend un type générique T en entrée qui implémente la fonction Dessinable et appelle le trait tirage sur le trait. Différents objets peuvent implémenter la méthode Dessinable et accéder à la fonctionnalité.
Implémentation de l’abstraction en Rust
L’abstraction est un concept OOP dans lequel les classes et les interfaces sont accessibles à des objets et des types spécifiques. Vous pouvez implémenter l’abstraction en Rust avec les traits.
Voici un exemple de trait pour un lecteur multimédia :
trait Media {
fn play(&self);
}
Les structures et les enums qui implémentent le trait Médias Le trait doit fournir une implémentation pour le trait jouer méthode.
struct Song {
title: String,
artist: String,
}
impl Media for Song {
fn play(&self) {
println!("Playing song: {} by {}", self.title, self.artist);
}
}
La Chanson struct met en œuvre le Médias en fournissant une implémentation pour le caractère jouer qui imprime un message avec les champs de la méthode Chanson à la console.
fn main() {
// Create an instance of the Song struct
let song = Song {
title: String::from("Bohemian Rhapsody"),
artist: String::from("Queen"),
};
// Call the play method on the song instance
song.play();
}
La fonction chanson est une instance de la variable Chanson et la variable peut accéder et appeler la structure jouer méthode.
Organiser le code Rust est facile
La programmation orientée objet facilite l’organisation du code. Grâce au système de modules de Rust, vous pouvez facilement organiser votre code Rust tout en mettant en œuvre les concepts de la POO pour votre application afin de garder votre code organisé, gérable et intuitif.
