Rust 面向对象

Les langages de programmation orientés objet généralement implémentent l'encapsulation des données et l'héritage, et peuvent appeler des méthodes basées sur les données.

Rust n'est pas un langage de programmation orienté objet, mais ces fonctionnalités peuvent tout de même être réalisées.

Encapsulation

L'encapsulation est une stratégie de présentation externe, en Rust, elle peut être réalisée par le mécanisme des modules, et chaque fichier Rust peut être considéré comme un module. Les éléments du module peuvent être explicitement indiqués à l'extérieur par le mot-clé pub. Cela est détaillé dans le chapitre "Organisation et gestion".

"Classe" est un concept couramment utilisé dans les langages de programmation orientés objet. "Classe" encapsule des données, c'est une abstraction des entités de données du même type ainsi que de leurs méthodes de traitement. En Rust, nous pouvons utiliser des structures ou des ensembles pour réaliser les fonctionnalités des classes :

pub　struct　ClassName　{}}
　　　　pub champ: Type,
}
pub impl ClassName {
　　　　fn some_method(&self) {
　　　　　　　　//　Corps de la fonction
　　　　}
}
pub enum EnumName {
　　　　A,
　　　　B,
}
pub impl EnumName {
　　　　fn some_method(&self) {
　　　　}　
}

Construons une classe complète ci-dessous :

second.rs
pub　struct　ClassName　{}}
　　　　field:　i32,
}
impl　ClassName　{
　　　　pub　fn　new(value:　i32)　->　ClassName　{
　　　　　　　　ClassName　{
　　　　　　　　　　　　field:　value
　　　　　　　　}
　　　　}
　　　　pub　fn　public_method(&self)　{
　　　　　　　　println!("from　public　method");
　　　　　　　　self.private_method();
　　　　}
　　　　fn　private_method(&self)　{
　　　　　　　　println!("from　private　method");
　　　　}
}
main.rs
mod　second;
use　second::ClassName;
fn　main()　{
　　　　let　object　=　ClassName::new(1024);
　　　　object.public_method();
}

Résultat de la sortie :

from　public　method
from　private　method

继承

Presque tous les langages de programmation orientés objet peuvent réaliser l'héritage et utiliser le mot "extend" pour décrire cette action.

L'héritage est une mise en œuvre de l'idée de polymorphisme, où le polymorphisme signifie que le langage de programmation peut gérer du code pour plusieurs types de données. En Rust, le polymorphisme est mis en œuvre par les traits. Les détails des traits sont expliqués dans la section "Traits" mais les traits ne peuvent pas réaliser l'héritage des attributs, ils ne peuvent que réaliser une fonctionnalité similaire à celle d'une "interface". Par conséquent, pour hériter des méthodes d'une classe, il est préférable de définir un exemple de "classe parente" dans la "classe enfant".

En résumé, Rust ne fournit pas de syntaxe sucrée pour l'héritage, ni de moyen officiel d'héritage (comme l'héritage des classes en Java), mais une syntaxe flexible permet néanmoins d'implémenter des fonctionnalités similaires.