Programmation Dart - Classes
Dart est un langage orienté objet. Il prend en charge les fonctionnalités de programmation orientées objet telles que les classes, les interfaces, etc.classen termes de POO est un modèle pour créer des objets. UNEclassencapsule les données de l'objet. Dart offre un support intégré pour ce concept appeléclass.
Déclarer une classe
Utilisez le class mot-clé pour déclarer un classdans Dart. Une définition de classe commence par la classe de mot-clé suivie declass name; et le corps de la classe entouré par une paire d'accolades. La syntaxe pour le même est donnée ci-dessous -
Syntaxe
class class_name {
<fields>
<getters/setters>
<constructors>
<functions>
}le classLe mot-clé est suivi du nom de la classe. Les règles relatives aux identificateurs doivent être prises en compte lors de la dénomination d'une classe.
Une définition de classe peut inclure les éléments suivants -
Fields- Un champ est une variable déclarée dans une classe. Les champs représentent les données relatives aux objets.
Setters and Getters- Permet au programme d'initialiser et de récupérer les valeurs des champs d'une classe. Un getter / setter par défaut est associé à chaque classe. Cependant, ceux par défaut peuvent être remplacés en définissant explicitement un setter / getter.
Constructors - responsable de l'allocation de mémoire pour les objets de la classe.
Functions- Les fonctions représentent les actions qu'un objet peut entreprendre. Ils sont également parfois appelés méthodes.
Ces composants réunis sont appelés data members de la classe.
Exemple: déclarer une classe
class Car {
// field
String engine = "E1001";
// function
void disp() {
print(engine);
}
}L'exemple déclare une classe Car. La classe a un champ nomméengine. ledisp() est une fonction simple qui imprime la valeur du champ engine.
Créer une instance de la classe
Pour créer une instance de la classe, utilisez le newmot-clé suivi du nom de la classe. La syntaxe pour le même est donnée ci-dessous -
Syntaxe
var object_name = new class_name([ arguments ])le new Le mot clé est responsable de l'instanciation.
Le côté droit de l'expression appelle le constructeur. Le constructeur doit recevoir des valeurs s'il est paramétré.
Exemple: instancier une classe
var obj = new Car("Engine 1")Accès aux attributs et fonctions
Les attributs et fonctions d'une classe sont accessibles via l'objet. Utilisez le '.' notation par points (appeléeperiod) pour accéder aux données membres d'une classe.
//accessing an attribute
obj.field_name
//accessing a function
obj.function_name()Exemple
Jetez un œil à l'exemple suivant pour comprendre comment accéder aux attributs et fonctions dans Dart -
void main() {
Car c= new Car();
c.disp();
}
class Car {
// field
String engine = "E1001";
// function
void disp() {
print(engine);
}
}le output du code ci-dessus est comme suit -
E1001Constructeurs de fléchettes
Un constructeur est une fonction spéciale de la classe qui est responsable de l'initialisation des variables de la classe. Dart définit un constructeur portant le même nom que celui de la classe. Un constructeur est une fonction et peut donc être paramétré. Cependant, contrairement à une fonction, les constructeurs ne peuvent pas avoir de type de retour. Si vous ne déclarez pas de constructeur, une valeur par défautno-argument constructor est fourni pour vous.
Syntaxe
Class_name(parameter_list) {
//constructor body
}Exemple
L'exemple suivant montre comment utiliser des constructeurs dans Dart -
void main() {
Car c = new Car('E1001');
}
class Car {
Car(String engine) {
print(engine);
}
}Il devrait produire les éléments suivants output -
E1001Constructeurs nommés
Dart fournit named constructors pour activer une classe définir multiple constructors. La syntaxe des constructeurs nommés est donnée ci-dessous -
Syntaxe: définition du constructeur
Class_name.constructor_name(param_list)Exemple
L'exemple suivant montre comment utiliser des constructeurs nommés dans Dart -
void main() {
Car c1 = new Car.namedConst('E1001');
Car c2 = new Car();
}
class Car {
Car() {
print("Non-parameterized constructor invoked");
}
Car.namedConst(String engine) {
print("The engine is : ${engine}");
}
}Il devrait produire les éléments suivants output -
The engine is : E1001
Non-parameterized constructor invokedLe mot-clé this
le thismot-clé fait référence à l'instance actuelle de la classe. Ici, le nom du paramètre et le nom du champ de la classe sont identiques. Par conséquent, pour éviter toute ambiguïté, le champ de la classe est précédé du préfixethismot-clé. L'exemple suivant explique la même chose -
Exemple
L'exemple suivant explique comment utiliser le this mot-clé dans Dart -
void main() {
Car c1 = new Car('E1001');
}
class Car {
String engine;
Car(String engine) {
this.engine = engine;
print("The engine is : ${engine}");
}
}Il devrait produire les éléments suivants output -
The engine is : E1001Classe de fléchettes ─ Getters et Setters
Getters et Setters, également appelé accessors et mutators, permettent au programme d'initialiser et de récupérer respectivement les valeurs des champs de classe. Les getters ou accesseurs sont définis à l'aide dugetmot-clé. Les setters ou mutators sont définis à l'aide duset mot-clé.
Un getter / setter par défaut est associé à chaque classe. Cependant, ceux par défaut peuvent être remplacés en définissant explicitement un setter / getter. Un getter n'a pas de paramètres et renvoie une valeur, et le setter a un paramètre et ne renvoie pas de valeur.
Syntaxe: Définition d'un getter
Return_type get identifier
{
}Syntaxe: définir un setter
set identifier
{
}Exemple
L'exemple suivant montre comment utiliser getters et setters dans une classe Dart -
class Student {
String name;
int age;
String get stud_name {
return name;
}
void set stud_name(String name) {
this.name = name;
}
void set stud_age(int age) {
if(age<= 0) {
print("Age should be greater than 5");
} else {
this.age = age;
}
}
int get stud_age {
return age;
}
}
void main() {
Student s1 = new Student();
s1.stud_name = 'MARK';
s1.stud_age = 0;
print(s1.stud_name);
print(s1.stud_age);
}Ce code de programme doit produire les éléments suivants output -
Age should be greater than 5
MARK
NullHéritage de classe
Dart prend en charge le concept d'héritage qui est la capacité d'un programme à créer de nouvelles classes à partir d'une classe existante. La classe qui est étendue pour créer des classes plus récentes est appelée la classe parent / super classe. Les classes nouvellement créées sont appelées les classes enfants / sous.
Une classe hérite d'une autre classe à l'aide du mot-clé 'extend'. Child classes inherit all properties and methods except constructors from the parent class.
Syntaxe
class child_class_name extends parent_class_nameNote - Dart ne prend pas en charge l'héritage multiple.
Exemple: héritage de classe
Dans l'exemple suivant, nous déclarons une classe Shape. La classe est étendue par leCircleclasse. Puisqu'il existe une relation d'héritage entre les classes, la classe enfant, c'est-à-dire la classeCar obtient un accès implicite à son membre de données de classe parent.
void main() {
var obj = new Circle();
obj.cal_area();
}
class Shape {
void cal_area() {
print("calling calc area defined in the Shape class");
}
}
class Circle extends Shape {}Il devrait produire les éléments suivants output -
calling calc area defined in the Shape classTypes d'héritage
L'héritage peut être des trois types suivants -
Single - Chaque classe peut au plus s'étendre à partir d'une classe parent.
Multiple- Une classe peut hériter de plusieurs classes. Dart ne prend pas en charge l'héritage multiple.
Multi-level - Une classe peut hériter d'une autre classe enfant.
Exemple
L'exemple suivant montre comment fonctionne l'héritage à plusieurs niveaux -
void main() {
var obj = new Leaf();
obj.str = "hello";
print(obj.str);
}
class Root {
String str;
}
class Child extends Root {}
class Leaf extends Child {}
//indirectly inherits from Root by virtue of inheritanceLa classe Leafdérive les attributs des classes Root et Child en vertu de l'héritage à plusieurs niveaux. Sesoutput est comme suit -
helloDart - Héritage de classe et remplacement de méthode
Le remplacement de méthode est un mécanisme par lequel la classe enfant redéfinit une méthode dans sa classe parent. L'exemple suivant illustre la même chose -
Exemple
void main() {
Child c = new Child();
c.m1(12);
}
class Parent {
void m1(int a){ print("value of a ${a}");}
}
class Child extends Parent {
@override
void m1(int b) {
print("value of b ${b}");
}
}Il devrait produire les éléments suivants output -
value of b 12Le nombre et le type des paramètres de fonction doivent correspondre lors de la substitution de la méthode. En cas de non-concordance dans le nombre de paramètres ou leur type de données, le compilateur Dart renvoie une erreur. L'illustration suivante explique la même chose -
import 'dart:io';
void main() {
Child c = new Child();
c.m1(12);
}
class Parent {
void m1(int a){ print("value of a ${a}");}
}
class Child extends Parent {
@override
void m1(String b) {
print("value of b ${b}");
}
}Il devrait produire les éléments suivants output -
value of b 12Le mot-clé statique
le static Le mot-clé peut être appliqué aux données membres d'une classe, c'est-à-dire fields et methods. Une variable statique conserve ses valeurs jusqu'à la fin de l'exécution du programme. Les membres statiques sont référencés par le nom de la classe.
Exemple
class StaticMem {
static int num;
static disp() {
print("The value of num is ${StaticMem.num}") ;
}
}
void main() {
StaticMem.num = 12;
// initialize the static variable }
StaticMem.disp();
// invoke the static method
}Il devrait produire les éléments suivants output -
The value of num is 12Le super mot-clé
le superLe mot clé est utilisé pour faire référence au parent immédiat d'une classe. Le mot-clé peut être utilisé pour faire référence à la version super classe d'unvariable, property, ou method. L'exemple suivant illustre la même chose -
Exemple
void main() {
Child c = new Child();
c.m1(12);
}
class Parent {
String msg = "message variable from the parent class";
void m1(int a){ print("value of a ${a}");}
}
class Child extends Parent {
@override
void m1(int b) {
print("value of b ${b}");
super.m1(13);
print("${super.msg}") ;
}
}Il devrait produire les éléments suivants output -
value of b 12
value of a 13
message variable from the parent class