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 -

E1001

Constructeurs 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 -

E1001

Constructeurs 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 invoked

Le 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 : E1001

Classe 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 
Null

Hé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_name

Note - 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 class

Types 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 inheritance

La classe Leafdérive les attributs des classes Root et Child en vertu de l'héritage à plusieurs niveaux. Sesoutput est comme suit -

hello

Dart - 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 12

Le 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 12

Le 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 12

Le 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