ESSai1

Dart est un langage orienté objet. Il prend en charge les

fonctionnalités de programmation orientée objet telles que les
classes, les interfaces, etc. Une classe en termes de POO est un
modèle pour créer des objets. Une classe encapsule les données
de l'objet. Dart offre un support intégré pour ce concept
appelé class .
Déclarer une classe
Utilisez le mot-clé class pour déclarer une classe dans Dart. Une
définition de classe commence par le mot-clé class suivi du nom de
la classe ; et le corps de la classe entouré d'une paire
d'accolades. La syntaxe correspondante est donnée ci-dessous -
A. Syntaxe
class class_name {
<fields>
<getters/setters>
<constructors>
<functions>
}
Le mot-clé class est suivi du nom de la classe. Les règles relatives
aux identifiants 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 n'importe quelle variable déclarée
dans une classe. Les champs représentent des données rela-
tives aux objets.
• Setters and Getters - Permet au programme d'initialiser et de
récupérer les valeurs des champs d'une classe. Un get-
ter/setter par défaut est associé à chaque classe. Cepen-
dant, ceux par défaut peuvent être remplacés en définissant
explicitement un setter/getter.
• Constructeurs - responsables de l'allocation de mémoire pour
les objets de la classe.
• Fonctions - Les fonctions représentent les actions qu'un objet
peut entreprendre. Ils sont aussi parfois appelés méthodes.
Ces composants réunis sont appelés données membres de la
classe.
B. 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é moteur . Le disp() est une fonction simple qui imprime la
valeur du moteur de terrain .
Création d'une instance de la classe
Pour créer une instance de la classe, utilisez le mot-clé new suivi
du nom de la classe. La syntaxe correspondante est donnée ci-
dessous -
C. Syntaxe
var object_name = new class_name([ arguments ])
• Le nouveau mot-clé est responsable de l'instanciation.
• Le côté droit de l’expression appelle le constructeur. Le cons-
tructeur doit recevoir des valeurs s'il est paramétré.
D. Exemple : instancier une classe
var obj = new Car("Engine 1")
Accès aux attributs et aux fonctions
Les attributs et fonctions d'une classe sont accessibles via
l'objet. Utilisez le '.' notation par points (appelée point ) pour
accéder aux données membres d'une classe.
//accessing an attribute
obj.field_name

//accessing a function
obj.function_name()
E. Exemple
Jetez un œil à l'exemple suivant pour comprendre comment
accéder aux attributs et aux fonctions dans Dart -
Démo en direct
void main() {
Car c= new Car();
c.disp();
}
class Car {
// field
String engine = "E1001";
 // function
void disp() {
print(engine);
}
}
La sortie du code ci-dessus est la suivante -
E1001
Constructeurs de fléchettes
Un constructeur est une fonction spéciale de la classe chargée
d’initialiser les 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,
un constructeur par défaut sans argument vous est fourni.
F. Syntaxe
Class_name(parameter_list) {
//constructor body
}
G. Exemple
L'exemple suivant montre comment utiliser les constructeurs dans
Dart -
Démo en direct
void main() {
Car c = new Car('E1001');
}
class Car {
Car(String engine) {
print(engine);
}
}
Il devrait produire le résultat suivant -
E1001
Constructeurs nommés
Dart fournit des constructeurs nommés pour permettre à une classe
de définir plusieurs constructeurs . La syntaxe des constructeurs
nommés est la suivante -
H. Syntaxe : Définition du constructeur
Class_name.constructor_name(param_list)
 I. Exemple
L'exemple suivant montre comment vous pouvez utiliser des
constructeurs nommés dans Dart -
Démo en direct
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 le résultat suivant -
The engine is : E1001
Non-parameterized constructor invoked
Le ce mot-clé
Le mot clé this 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éfixé par le mot-clé this . L'exemple suivant
explique la même chose -
J. Exemple
L'exemple suivant explique comment utiliser le mot-clé this dans
Dart -
Démo en direct
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 le résultat suivant -
The engine is : E1001
 Classe de fléchettes ─ Getters et Setters
Les getters et les setters , également
appelés accesseurs et mutateurs , permettent respectivement au
programme d'initialiser et de récupérer les valeurs des champs de
classe. Les getters ou accesseurs sont définis à l’aide du mot-
clé get . Les setters ou mutateurs sont définis à l’aide du mot-
clé set .
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.
K. Syntaxe : Définition d'un getter
Return_type get identifier
{
}
L. Syntaxe : Définir un setter
set identifier
{
}
M. Exemple
L'exemple suivant montre comment vous pouvez utiliser les
getters et les setters dans une classe Dart -
Démo en direct
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 devrait produire le résultat suivant -
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 étendue pour créer des classes plus récentes
est appelée classe parent/super classe. Les classes nouvellement
créées sont appelées classes enfants/sous-classes.
Une classe hérite d'une autre classe en utilisant le mot-clé
'extends'. Les classes enfants héritent de toutes les propriétés et
méthodes de la classe parent, à l'exception des constructeurs .
N. Syntaxe
class child_class_name extends parent_class_name
Remarque - Dart ne prend pas en charge l'héritage multiple.
O. Exemple : héritage de classe
Dans l'exemple suivant, nous déclarons une classe Shape . La
classe est étendue par la classe Circle . Puisqu'il existe une
relation d'héritage entre les classes, la classe enfant, c'est-à-dire
la classe Car, obtient un accès implicite aux données membres de
sa classe parent.
Démo en direct
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 le résultat suivant -
calling calc area defined in the Shape class
P. Types d'héritage
L'héritage peut être des trois types suivants -
• Single - Chaque classe peut au maximum 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 en-
fant.
Q. Exemple
L'exemple suivant montre comment fonctionne l'héritage à
plusieurs niveaux -
Démo en direct
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 Leaf dérive les attributs des classes Root et Child grâce à
un héritage multi-niveaux. Sa sortie est la suivante -
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 -
R. Exemple
Démo en direct
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 le résultat suivant -
value of b 12
Le nombre et le type des paramètres de la 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 -
Démo en direct
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 le résultat suivant -
value of b 12
Le mot-clé statique
Le mot-clé static peut être appliqué aux données membres d'une
classe, c'est-à-dire aux champs et aux méthodes . 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.
 S. Exemple
Démo en direct
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 le résultat suivant -
The value of num is 12
Le super mot-clé
Le super 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 superclasse d'une variable, d'une
propriété ou d'une méthode . L'exemple suivant illustre la même
chose -
T. Exemple
Démo en direct
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 le résultat suivant -
 value of b 12
value of a 13
message variable from the parent class
Essaie2:
Dart – Classes et objets

• Lire
• Discuter
• Cours
• Pratique

•
Dart est un langage de programmation orienté objet, il prend donc en charge le
concept de classe, d'objet… etc. Dans Dart, nous pouvons définir nos propres
classes et objets. Nous utilisons le mot-clé class pour ce faire. Dart prend en
charge les fonctionnalités de programmation orientée objet telles que les classes
et les interfaces.
Classe : la classe est le modèle d'objets et la classe est la collection de données
membres et de moyens de fonctions de données qui incluent ces champs, getter et
setter, constructeur et fonctions.
U. Dé clarer une classe dans Dart
Syntaxe:
classe nom_classe {
// Corps de la classe
}
Dans la syntaxe ci-dessus :
• Class est le mot-clé utilisé pour initialiser la classe.
• class_name est le nom de la classe.
• Le corps de la classe se compose de champs, de constructeurs, de mé thodes
getter et setter, etc.
V. Dé clarer des objets dans Dart
Les objets sont l'instance de la classe et ils sont déclarés à l'aide du nouveau mot-
clé suivi du nom de la classe.
Syntaxe:
var nom_objet = nouveau nom_classe ([ arguments ]);
Dans la syntaxe ci-dessus :
• new est le mot-clé utilisé pour dé clarer l'instance de la classe
• object_name est le nom de l'objet et son nom est similaire au nom de la va-
riable dans Dart.
• class_name est le nom de la classe dont la variable d'instance a é té cré ée.
• les arguments sont les entré es qui doivent ê tre transmises si nous sommes
prê ts à appeler un constructeur.
Une fois l'objet créé, il sera nécessaire d'accéder aux champs que nous allons
créer. Nous utilisons l' opérateur point(.) à cette fin.
Syntaxe:
// Pour accéder à la propriété
nom_objet.nom_propriété ;
// Pour accéder à la méthode
nom_objet.nom_méthode();
W. Cré er une classe et accé der à ses champs
1. Exemple 1 : exemple simple
Dard

// Creating Class named Gfg

class Gfg {

// Creating Field inside the class

String geek1 = '';

// Creating Function inside class

void geek()

print("Welcome to $geek1");

}
 void main()

// Creating Instance of class

Gfg geek = new Gfg();

// Calling field name geek1 and assigning value

// to it using object of the class Gfg

geek.geek1 = 'GeeksforGeeks';

// Calling function name geek using object of the class Gfg

geek.geek();

Sortir:
Bienvenue sur GeeksforGeeks
Explication:
Ici nous avons d'abord créé la classe nommée Gfg avec un champ geek1 et une
fonction geek. Maintenant dans la fonction principale, nous avons créé un objet de
la classe Gfg de nom geek. En utilisant cet objet, nous avons attribué la valeur
' GeeksforGeeks ' à la variable chaîne de la classe puis nous avons appelé la
fonction geek qui a imprimé la sortie.
2. Exemple 2 :
Dard

class GFG {
 String name = " ";

String get gfg1 {

return name;

void set gfg1(String name) {

this.name = name;

void result(){

print(name);

void main() {

GFG gfg2 = new GFG();

gfg2.name="Geeks for geeks employee no 1 : avinash ,aakanksha";

gfg2.result();
 }

Sortir:
Geeks pour geeks employé n°1 : avinash, aakanksha
Essaie3:

Résumé : dans ce tutoriel, vous apprendrez à définir une classe Dart et à créer des
objets à partir de la classe.
Introduction aux cours de Dart

Dart est un langage de programmation orienté objet. Dans Dart, tout est objet. Un
objet est constitué d’états et de comportements :

• L'état décrit les valeurs qu'un objet possède à un moment spécifié.

• Les comportements sont des actions qu'un objet peut effectuer pour manipuler
son état.

Pour créer un objet, vous devez d'abord définir une classe . Une classe est un modèle
pour créer des objets.
Les variables sont utilisées pour modéliser l'état des objets. Lorsque des variables
sont définies à l’intérieur d’une classe, elles sont appelées propriétés de la classe.
Les fonctions sont utilisées pour modéliser les comportements des objets. Lorsque
des fonctions sont définies à l'intérieur d'une classe, elles sont appelées méthodes .
Définir une classe

Pour définir une classe, vous utilisez le classmot-clé suivi d'un nom de classe et
d'accolades :
class MyClass {
}Langage du code : Dart ( fléchette )

Par convention, les noms de classe suivent la PascalCaseconvention de

dénomination. Par exemple, ce qui suit définit la Pointclasse :
class Point {
}Langage du code : Dart ( fléchette )
Créer des objets à partir d'une classe

Pour créer un objet à partir d'une classe, vous utilisez le nom de la classe suivi des
parenthèses. C'est comme appeler une fonction.
Par exemple, ce qui suit crée un nouvel objet appelé p1depuis la Pointclasse :
Point p1 = Point();Langage du code : Dart ( fléchette )

Étant donné que le compilateur Dart peut déduire le type de p1as Point, vous pouvez
utiliser le varmot-clé pour rendre l'instruction plus concise :
var p1 = Point();Langage du code : Dart ( fléchette )

Dans cet exemple, p1est un objet de la Pointclasse. En d’autres termes, p1est

une instance de la Pointclasse :
class Point {
}

void main() {
var p1 = Point();
}Langage du code : Dart ( fléchette )
Ajout de propriétés à la classe

Ce qui suit ajoute la coordonnée x et la coordonnée y à la Pointclasse et initialise leurs

valeurs à zéro :
class Point {
int x = 0;
int y = 0;
}Langage du code : Dart ( fléchette )

En faisant cela, tous les objets de la Pointclasse auront les propriétés xet y. Pour
accéder à une propriété à partir d'un objet, vous utilisez la notation par points
comme suit :
objectName.propertyLangage du code : Dart ( fléchette )

Par exemple, ce qui suit crée un nouvel Pointobjet et attribue les valeurs aux
propriétés x et y :
class Point {
int x = 0;
int y = 0;
}

void main() {
var p1 = Point();
p1.x = 10;
p1.y = 20;
}Langage du code : Dart ( fléchette )

Il est important de noter que vous pouvez créer de nombreux objets à partir de
la Pointclasse. Par exemple, ce qui suit crée deux Pointobjets p1etp2 :
class Point {
int x = 0;
int y = 0;
}

void main() {
var p1 = Point();
p1.x = 10;
p1.y = 20;

var p2 = Point();
p2.x = 100;
p2.x = 200;
}Langage du code : Dart ( fléchette )

Dans cet exemple, p1and p2aura un ensemble distinct de propriétés xet y.

 Notation en cascade

Ce qui suit crée l' p1objet et attribue ses propriétés à des valeurs :
var p1 = Point();
p1.x = 10;
p1.y = 20;Langage du code : Dart ( fléchette )

Dans cet exemple, l'objet p1 est répété plusieurs fois, chacune pour une
affectation. Pour le rendre plus concis, Dart fournit un opérateur en cascade ( ..) qui
vous permet d'enchaîner plusieurs affectations sur le même objet sans répéter le nom
de l'objet. Par exemple:
class Point {
int x = 0;
int y = 0;
}

void main() {
var p1 = Point()
..x = 10
..y = 20;
}Langage du code : Dart ( fléchette )

Il est important de noter que le point-virgule ( ;) n'apparaît que sur la dernière ligne.
Ajouter une méthode à une classe

Une méthode est comme une fonction. Lorsque vous définissez une fonction dans
une classe, elle devient une méthode. Par exemple, ce qui suit ajoute une méthode
appelée move()à la Pointclasse qui déplace le point vers une nouvelle coordonnée :
class Point {
int x = 0;
int y = 0;

void move(int x1, int y1) {

x = x1;
y = y1;
}
}Langage du code : Dart ( fléchette )

Contrairement à une fonction, la move()méthode peut accéder aux propriétés xet y.

Pour appeler une méthode, vous utilisez également une syntaxe de notation par
points :
objectName.methodName(arguments);Langage de code : JavaScript ( javascript )

Par exemple, ce qui suit montre comment appeler la méthode move() :

p1.move(100, 200);Langage de code : CSS ( css )

Ce qui suit montre un programme complet qui définit la classe Point et affiche son
objet sur la console :
class Point {
int x = 0;
int y = 0;
 void move(int x1, int y1) {
x = x1;
y = y1;
}
}

void main() {
var p1 = Point()
..x = 10
..y = 20;

p1.move(100, 200);

print(p1);
}
Langage du code : Dart ( fléchette )

Sortir:
Instance of 'Point'Langage du code : Dart ( fléchette )

Lorsque vous transmettez l' p1objet à la print()fonction, celle print()-ci convertit

l' p1objet en chaîne avant de l'afficher. Par défaut, un objet a la représentation sous
forme de chaîne suivante :
Instance of 'ClassName'Langage du code : Dart ( fléchette )

Pour créer une représentation sous forme de chaîne personnalisée d'un objet, vous
devez remplacer une méthode appelée toString()méthode qui sera abordée dans un
didacticiel ultérieur.
Pour l'instant, vous pouvez définir une show()méthode qui affiche l' Pointobjet sur la
console comme ceci :
class Point {
int x = 0;
int y = 0;

void move(int x1, int y1) {

x = x1;
y = y1;
}

void show() {
print('Point($x,$y)');
}
}

void main() {
var p1 = Point()
..x = 10
..y = 20;
p1.move(100, 200);
p1.show();
}
Langage du code : Dart ( fléchette )

Sortir:
Point(100,200)Langage du code : Dart ( fléchette )
 L'opérateur est

L' isopérateur renvoie truesi un objet est une instance d'une classe. Si un objet n'est
pas une instance de la classe, l' isopérateur renvoie false:
myObject is MyClass

Par exemple, l'expression suivante est renvoyée truecar p1il s'agit d'une instance de
la Pointclasse :
var p1 = Point();
print(p1 is Point);
ESSAIE4(Fran) :

Classes et objets de fléchettes

Les classes Dart sont le modèle de l'objet, ou elles peuvent être appelées constructeurs
d'objets. Une classe peut contenir des champs, des fonctions, des constructeurs, etc. Il
s'agit d'un wrapper qui lie/encapsule les données et les fonctions ensemble ; accessible
en créant un objet. Une classe peut faire référence à un type de données défini par
l'utilisateur qui définit les caractéristiques de tous ses objets.
Nous pouvons considérer une classe comme un croquis (prototype) ou une voiture. Il
contient tous les détails sur le nom du modèle, l’année, les caractéristiques, le prix, etc.
Sur la base de ces propriétés de la voiture, nous pouvons construire la voiture. Ici, la
voiture est un objet. Il peut y avoir plusieurs voitures, nous pouvons donc créer de
nombreux objets de voitures pour accéder à toutes les propriétés.

Définir une classe dans Dart

Dart fournit un mot-clé de classe suivi d'un nom de classe qui est utilisé pour définir
une classe ; tous les champs et fonctions sont entourés par la paire d'accolades ({}). La
syntaxe est donnée ci-dessous.
Syntaxe:
1. classe Nom de classe {
2. <champs>
3. <getters/setters>
4. <constructeur>
5. <fonctions>
6. }
Ici, ClassName représente le nom réel de la classe, défini par l'utilisateur. Entre
accolades, nous fournissons une définition de classe. Une classe peut être composée
de champs, de constructeurs, de setters getters et de méthodes.
 3. Remarque - Selon la règle de la convention de dénomination des identifiants, la
première lettre du nom de classe doit être majuscule et ne pas utiliser de
séparateurs.

Comprenons l'exemple suivant.

Exemple -
1. vide main() {
2. // Définition de la classe
3. Étudiant de classe {
4. var NomStd ;
5. varAgeStd;
6. varstdRoll_nu;
7.
8. // Fonction de classe
9. showStdInfo() {
10. print( "Le nom de l'étudiant est : ${stdName}" );
11. print( "L'âge de l'étudiant est : ${stdAge}" );
12. print( "Le numéro de liste d'étudiant est : ${stdRoll_nu}" )
13. }
Dans l’exemple de classe ci-dessus, nous avons déclaré une classe
appelée Student . Cette classe comporte trois champs stdName,
stdAge et stdRoll_nu . showStdInfo () est une fonction de classe qui imprime les
champs de la classe. Pour accéder aux propriétés de la classe, nous devons créer son
objet.

Objet de fléchette
Dart est une programmation orientée objet et tout est traité comme un objet dans
Dart. Un objet est une variable ou une instance de la classe utilisée pour accéder aux
propriétés de la classe. Les objets ont deux caractéristiques : l'état et le
comportement. Supposons qu'un homme soit un objet avec un état (nom, âge, santé)
et un comportement (marcher, courir et dormir). Les objets de programmation sont
théoriquement similaires aux objets réels ; ils ont aussi un état et un comportement. Un
objet est créé à partir d'un modèle appelé classe.
Les champs des classes sont stockés sous forme d'états d'objet, tandis que la méthode
représente le comportement d'un objet.

Création d'objets de classe dans Dart

Après avoir créé la classe, nous pouvons créer une instance ou un objet de cette classe
auquel nous souhaitons accéder à ses champs et fonctions. Le mot-clé new est utilisé
 pour déclarer la classe suivi du nom de la classe. La syntaxe générale de création d'un
objet d'une classe est donnée ci-dessous.
Syntaxe:
1. var nom_objet = nouveau nom_classe(<constructor_arguments>);
Ici, object_name et class_name signifient respectivement le nom réel de l'objet et le
nom de la classe. Si le constructeur de classe est paramétré, les arguments du
constructeur doivent recevoir une valeur.
Comprenons l'exemple suivant.
Exemple -
1. // Définition de la classe
2. Étudiant de classe {
3. var NomStd ;
4. varAgeStd;
5. varstdRoll_nu;
6.
7. // Fonction de classe
8. showStdInfo() {
9. print( "Le nom de l'étudiant est : ${stdName}" );
10. print( "L'âge de l'étudiant est : ${stdAge}" );
11. print( "Le numéro de liste d'étudiant est : ${stdRoll_nu}" )
12.
13. }
14. }
15. vide principal () {
16. // Création d'un objet appelé std
17. var std = nouvel étudiant ();
18. }
Nous avons créé l'objet appelé std de la classe Student mais créer seulement un objet
ne suffit pas. Nous devons accéder aux propriétés en utilisant l'objet nouvellement
créé.

Évaluation de la variable d'instance et de la fonction

Après avoir créé un objet, nous pouvons accéder aux champs et méthodes de la
classe. Le nom de la propriété de classe est séparé par l'opérateur (.) du nom de
l'instance. La syntaxe est donnée ci-dessous.
Syntaxe:
1. objectName.propName ou objectName.methoName()
 Comprenons l'exemple suivant.
Exemple -
1. // Définition de la classe
2. Étudiant de classe {
3. var NomStd ;
4. varAgeStd;
5. varstdRoll_nu;
6.
7. // définition de la fonction de classe
8. showStdInfo() {
9. print( "Le nom de l'étudiant est : ${stdName}" );
10. print( "L'âge de l'étudiant est : ${stdAge}" );
11. print( "Le numéro de liste d'étudiant est : ${stdRoll_nu}" );
12.
13. }
14. }
15. vide principal () {
16.
17. // Création d'un objet appelé std
18. var std = nouvel étudiant ();
19. std.stdName = "Pierre" ;
20. std.stdAge = 24 ;
21. std.stdRoll_nu = 90001 ;
22. // Accès à la fonction de classe
23. std.showStdInfo();
24. }
Sortir
Le nom de l’étudiant est : Peter
L'âge de l'étudiant est : 24 ans
Le numéro de liste d’étudiant est : 90001

Explication:
Dans l'exemple ci-dessus, nous avons créé une classe appelée Student , qui
comprenait le nom de l'étudiant, son âge, son numéro de matricule et la
fonction showStdInfo() pour afficher les détails de l'étudiant.
Ensuite, nous avons créé un objet de classe Student et attribué les valeurs à chaque
champ à l'aide de l'opérateur (.). Nous avons appelé la fonction showStdInfo() qui
affichait les détails sous forme de sortie à l'écran.
 X. Bénéfice des objets
L’utilisation de la programmation orientée objet présente de nombreux
avantages. Voici les quelques avantages.
1. Modularité : le code source d'un objet peut être conservé individuellement et
peut être caché du code source de l'autre objet.
2. Masquage des données : grâce à la programmation oops, les détails de la fonc-
tionnalité interne du code sont cachés aux autres. Par exemple : Les utilisateurs
interagissent uniquement avec l’application, mais ne connaissent pas l’implé-
mentation interne.
3. Réutilisabilité - Nous n'avons pas besoin d'écrire le même code encore et en-
core. Nous pouvons utiliser l'objet de classe plusieurs fois dans notre pro-
gramme.
4. Pluggabilité et débogage faciles - Si un objet crée un problème dans notre
programme, nous pouvons alors le remplacer dans notre programme et bran-
cher le nouvel objet en remplacement. Le code oups peut être facile à déboguer.

Qu'est-ce que le constructeur ?

Un constructeur est un type différent de fonction créée avec le même nom que son
nom de classe. Le constructeur est utilisé pour initialiser un objet lors de sa
création. Lorsque nous créons l’objet de classe, le constructeur est automatiquement
appelé. C'est assez similaire à la fonction de classe mais elle n'a pas de type de retour
explicite. Le constructeur génératif est la forme la plus générale du constructeur, utilisé
pour créer une nouvelle instance d'une classe.
C'est une option à déclarer au sein de la classe. Toutes les classes ont leur propre
constructeur, mais si nous ne déclarons pas ou n'oublions pas, le
compilateur Dart créera automatiquement le constructeur par défaut en transmettant
la valeur par défaut à la variable membre. Si nous déclarons notre propre constructeur,
alors le constructeur par défaut sera ignoré.
Exemple -
Supposons que nous ayons un nom de classe Student et que nous en créons un objet
comme suit.
Backward Skip 10sPlay VideoForward Skip 10s

1. Étudiant std = nouvel étudiant()

Il a invoqué le constructeur par défaut de la classe Student .
 Création d'un constructeur dans Dart
Comme nous l'avons mentionné, un constructeur a le même nom que son nom de
classe et il ne renvoie aucune valeur. Supposons que si nous avons la classe Student, le
nom du constructeur devrait également être Student .
Syntaxe:
1. classe Nom de classe {
2. Nom du cours() {
3. }
4. }
Nous devons nous rappeler les deux règles suivantes lors de la création d'un
constructeur.
o Le nom du constructeur doit être le même que le nom de la classe.
o Le constructeur n'a pas de type de retour explicite.

Comprenons l'exemple suivant.

Exemple -
1. vide main() {
2. // Création d'un objet
3. Étudiant std = new Student( "Jones" , 26 );
4. }
5. Étudiant de classe {
6. // Déclaration d'un constructeur
7. Étudiant (String str, int age) {
8. print( "Le nom est : ${str}" );
9. print( "L'âge est : ${age}" );
10.
11. }
12. }
Sortir
Le nom est : Jones
L'âge est : 26 ans

Explication:
Dans l'exemple ci-dessus, nous avons créé une fonction constructeur Student() qui est
identique au nom de la classe. Nous avons transmis deux paramètres transmis dans le
constructeur et lorsque nous avons instancié un objet de la classe Student et transmis
la valeur, il a automatiquement appelé le constructeur puis imprimé le résultat.
 Types de constructeurs
Il existe trois types de constructeurs dans Dart, comme indiqué ci-dessous.
o Constructeur par défaut ou constructeur sans argument
o Constructeur de paramètres
o Constructeur nommé

Constructeur par défaut ou constructeur sans

argument
Un constructeur qui n'a aucun paramètre est appelé constructeur par défaut ou
constructeur sans argument. Il est automatiquement créé (sans argument) par le
compilateur Dart si nous ne le déclarons pas dans la classe. Le compilateur Dart ignore
le constructeur par défaut si nous créons un constructeur avec ou sans argument. La
syntaxe est donnée ci-dessous.
Syntaxe:
1. classe Nom de classe {
2. Nom du cours() {
3. // corps du constructeur
4. }
5. }
Comprenons l'exemple suivant.
Exemple -
1. vide main() {
2. // Appel automatique du constructeur lorsque l'on crée un objet
3. Étudiant std = nouvel étudiant ();
4. }
5.
6. Étudiant de classe {
7. // Déclaration d'un constructeur
8. Étudiant(){
9. print( "L'exemple du constructeur par défaut" );
10. }
11. }
Sortir
L'exemple du constructeur par défaut
 Constructeur paramétré
Nous pouvons également transmettre les paramètres à un constructeur dont le type
est appelé constructeur paramétré. Il est utilisé pour initialiser les variables
d'instance. Parfois, nous avons besoin d'un constructeur qui accepte un ou plusieurs
paramètres. Les constructeurs paramétrés sont principalement utilisés pour initialiser
une variable d'instance avec ses propres valeurs. La syntaxe est donnée ci-dessous.
Syntaxe:
1. classe Nom de classe {
2. Nom de classe (liste_paramètres)
3. // corps du constructeur
4. }
Comprenons l'exemple suivant.
Exemple -
1. vide main() {
2. // Création d'un objet
3. Étudiant std = new Student( "Jones" , 26 );
4. }
5. Étudiant de classe {
6. // Déclaration d'un constructeur paramétré
7. Étudiant (String str, int age) {
8. print( "Le nom est : ${str}" );
9. print( "L'âge est : ${age}" );
10.
11. }
12. }
Sortir
Le nom est : Jones
L'âge est : 26 ans

Explication -
Dans l'exemple ci-dessus, nous avons déclaré un constructeur paramétré qui a deux
paramètres name et age. Nous avons créé un objet de la classe Student et transmis la
valeur appropriée au constructeur. Il imprimait le nom et l’âge en sortie à l’écran.

Constructeurs nommés
Les constructeurs nommés sont utilisés pour déclarer plusieurs constructeurs dans une
seule classe. La syntaxe est donnée ci-dessous.
Syntaxe:
1. nom de classe.nom_constructeur (liste_param)
Comprenons l'exemple suivant.
Exemple -
1. vide main() {
2. // Création d'un objet
3. Étudiant std1 = nouvel étudiant (); // objet pour le constructeur par défaut
4. Étudiant std2 = new Student.namedConst( "Informatique" ); // objet pour cons-
tructeur paramétré
5. }
6.
7. Étudiant de classe {
8. // Déclaration d'un constructeur
9. Étudiant(){
10. print( "L'exemple du constructeur nommé" );
11. }
12. // Deuxième constructeur
13. Student.namedConst (branche String){
14. print( "La branche est : ${branch}" );
15.
16. }
17. }
Sortir
L'exemple du constructeur nommé
La branche est : Informatique

Dart ce mot-clé
Le mot-clé this est utilisé pour faire référence à l'objet de classe actuel. Il indique
l'instance actuelle de la classe, des méthodes ou du constructeur. Il peut également
être utilisé pour appeler les méthodes ou constructeurs de la classe actuelle. Cela
élimine l'incertitude entre les attributs de classe et les noms de paramètres sont les
mêmes. Si nous déclarons les attributs de classe identiques au nom du paramètre, cette
situation créera une ambiguïté dans le programme, alors le mot-clé this peut supprimer
l'ambiguïté en préfixant les attributs de classe. Il peut être passé en argument dans la
méthode de classe ou dans les constructeurs.
Comprenons l'exemple suivant du fonctionnement de ce mot-clé.
Y. Exemple - Sans utiliser ce mot-clé
1. classe Mobile {
2. Nom du modèle de chaîne ;
3. int homme_année;
4.
5. // Création du constructeur
6. Mobile (nom du modèle, année_homme) {
7. nom du modèle = nom du modèle ;
8. homme_année = 2020 ;
9. print( "Le nom du modèle du mobile est : ${modelname} et l'année de fabrica-
tion est : ${man_year}" );
10.
11. }
12. }
13. vide principal(){
14. Mobile mob = nouveau Mobile( "iPhone 11 " , 2020 );
15. }
Sortir
Le nom du modèle du mobile est : iPhone 11 et l'année de fabrication est :
2020.
Z. Explication:
Dans le programme ci-dessus, nous avons créé une classe appelée Mobile, qui possède
deux attributs modelname et man_year. Ensuite, nous avons créé un constructeur et
transmis les mêmes paramètres que le nom des attributs de classe.
Backward Skip 10sPlay VideoForward Skip 10s

Dans le corps du constructeur, les variables de classe (attributs) sur le côté gauche sont
affectées par les paramètres du constructeur portant le même nom. Lorsque nous
créons l'instance d'une classe, le constructeur appelle automatiquement le
constructeur et imprime le résultat.
Le compilateur Dart peut être confus s'il existe un certain nombre de paramètres
portant le même nom. Le résultat est que le compilateur créera une ambiguïté. C'est
pourquoi nous utilisons le mot-clé this pour faire référence à l'objet de classe actuel.
AA. Exemple - 2 : Utilisation de ce mot-clé
1. classe Mobile {
2. Nom du modèle de chaîne ;
3. int homme_année;
4.
5. // Création du constructeur
6. Mobile (nom du modèle, année_homme) {
7. this .modelname = nom du modèle ;
8. ce .man_year = 2020 ;
9. print( "Le nom du modèle du mobile est : ${modelname} et l'année de fabrica-
tion est : ${man_year}" );
10.
11. }
12. }
13. vide principal(){
14. Mobile mob = nouveau Mobile( "IPhone 11" , 2020 );
15. }
Sortir
Le nom du modèle du mobile est : IPhone 11 et l'année de fabrication est :
2020.
BB. Explication:
L'exemple ci-dessus est le même que le programme précédent, mais la seule différence
est ce mot-clé.
1. this .modelname = nom du modèle ;
2. ce .man_year = 2020 ;
Nous avons utilisé le mot-clé this pour la variable d'instance ou de classe différente de
la variable locale.
CC. Points à retenir
o Le mot-clé this est utilisé pour pointer vers l'objet de classe actuel.
o Il peut être utilisé pour faire référence aux variables de classe actuelles.
o Nous pouvons instancier ou invoquer le constructeur de classe actuel en utilisant
ce mot-clé.
o Nous pouvons passer ce mot-clé en paramètre dans l’appel du constructeur.
o Nous pouvons passer ce mot-clé en paramètre dans l’appel de méthode.
o Il supprime l'ambiguïté ou le conflit de nom dans le constructeur ou la méthode
de notre instance/objet.
o Il peut être utilisé pour renvoyer l’instance de classe actuelle.

Variable locale
Les variables locales sont définies dans les méthodes, les constructeurs ou les blocs. Il
est créé lorsque nous créons une méthode ou un constructeur, et sa portée n'est qu'à
l'intérieur de ceux-ci. Nous ne pouvons pas utiliser de variable locale en dehors de la
méthode, du constructeur ou du bloc.
Variable de classe
La variable de classe est également connue sous le nom de variable membre statique ,
qui est utilisée pour déclarer à l'aide du mot clé static. Il est déclaré dans la classe, mais
en dehors d'un constructeur, d'une méthode ou d'un bloc. Toutes les instances
partagent une copie de la variable de classe ou nous pouvons dire que les variables de
classe sont communes à toutes les instances de cette classe.

Variable d'instance
La variable d'instance est également connue sous le nom de variable non statique qui
est utilisée pour déclarer sans le mot clé static. Les variables d'instance sont spécifiques
à un objet. Ces variables sont accessibles à l'aide de l'instance de cette classe.

Différence entre la variable de classe et la variable

d'instance
Voici la différence entre la variable de classe et la variable d'instance

Sr. Variable de classe Variable d'instance

1. La variable de classe est déclarée à l'aide La variable d'instance est déclarée dans
du mot-clé static dans une classe, mais pas classe sans utiliser le mot clé static.
dans la méthode et le constructeur.

2. La variable de classe est accessible en La variable d'instance est accessible à l'aid

utilisant le nom de la classe. l'instance de cette cl
Syntaxe: Syntaxe:
NomClasse.nomvariable ObjectRefernce.variableName

3 Les variables de classe sont communes à Les variables d'instance ne sont pas commun
toutes les instances de cette classe. Toutes toutes les instances de classe. Chaque o
les instances de la classe partagent une particulier conservera sa propre copie
copie de la variable statique. variables d'instance.

4 Ceux-ci sont créés au démarrage du Les variables d'instance sont créées lorsq
programme et détruits à la fin du objet d'une classe particulière est créé à l'aid
programme. mot-clé new() et détruit lorsque l'objet est dé
 Mot-clé statique Dart
Le mot-clé static est utilisé pour déclarer la variable et la méthode de classe. Il gère
généralement la mémoire de la variable de données globale. Les variables et méthodes
statiques sont le membre de la classe au lieu d’une instance individuelle. La variable ou
les méthodes statiques sont les mêmes pour chaque instance de la classe, donc si nous
déclarons le membre de données comme statique, nous pouvons y accéder sans créer
d'objet. L'objet de classe n'est pas requis pour accéder à la méthode ou à la variable
statique, nous pouvons y accéder en plaçant le nom de la classe avant la variable ou la
méthode statique. En utilisant le nom de la classe, nous pouvons appeler la méthode
de classe depuis les autres classes.

Variable statique de fléchette

Une variable déclarée à l’aide du mot-clé static à l’intérieur de la classe est
appelée mot-clé statique Dart . Il s'agit du membre de la classe au lieu d'une instance
spécifique. Les variables statiques sont traitées de la même manière pour toutes les
instances de la classe ; cela signifie qu'une seule copie de la variable statique est
partagée entre toutes les instances de classes. Il alloue de la mémoire une fois et lors
du chargement de la classe et l'utilise tout au long du programme.
Point à retenir -
o La variable statique est également identifiée comme variable de classe.
o Une copie unique de la variable statique est partagée entre les instances d'une
classe.
o Il est accessible en utilisant le nom de la classe. Nous n'avons pas besoin de créer
un objet de la classe à laquelle ils appartiennent.
o Les variables statiques sont accessibles directement dans les méthodes statiques.

Déclaration d'une variable statique

Dart fournit le mot-clé static pour déclarer la variable statique. Il est déclaré en utilisant
le mot-clé static suivi du nom de la variable. La syntaxe est donnée ci-dessous.
Syntaxe:
1. statique [type_données] [nom_variable] ;
Accéder à la variable statique
Nous pouvons accéder à la variable statique en utilisant le nom de la classe lui-même
au lieu d'en créer un objet. La syntaxe est donnée ci-dessous.
Syntaxe:
1. ClassName.staticVariableName;
 Méthode statique Dart
Le concept de la méthode statique est également similaire à celui de la variable
statique. Les méthodes statiques sont le membre de la classe au lieu de l'instance de
classe. Les méthodes statiques ne peuvent utiliser que des variables statiques et
peuvent invoquer la méthode statique de la classe. Nous n'avons pas besoin de créer
une instance de classe pour y accéder. La méthode statique est utile lorsque l’on
souhaite l’utiliser dans d’autres classes.
Points à retenir
o Les méthodes statiques sont la classe membre au lieu de son objet.
o Les méthodes statiques sont également identifiées comme méthodes de classe.
o Nous pouvons accéder aux méthodes statiques en utilisant le nom de la classe.
o Une copie particulière de la méthode statique est distribuée entre toutes les ins-
tances d'une classe.

Déclaration de méthodes statiques

Nous pouvons déclarer la méthode statique en utilisant le mot-clé static suivi du nom
de la méthode avec le type de retour. La syntaxe est donnée ci-dessous.
Syntaxe:
1. type de retour statique nom_méthode() {
2. //instruction(s)
3. }
Appel d'une méthode statique
Les méthodes statiques peuvent être appelées en utilisant le nom de la classe à laquelle
elles appartiennent au lieu de créer un objet.
Syntaxe:
1. className.staticMethod();
Comprenons l'exemple suivant.
Exemple -
1. Étudiant de classe {
2. Chaîne statique stdBranch ; // Déclaration d'une variable statique
3. Chaîne stdName ;
4. int numéro_rouleau ;
5.
6. showStdInfo() {
7. print( "Le nom de l'étudiant est : ${empName}" );
8. print( "Le salaire de l'étudiant est de : ${roll_num}" );
9. print( "Le nom de la branche de l'étudiant est : ${stdBranch}" );
10.
11. }
12. }
13.
14. vide main() {
15.
16. Étudiant std1 = nouvel étudiant (); // Création d'instances de classe d'étudiant
17. Étudiant std2 = nouvel étudiant ();
18. // Attribution de la valeur d'une variable statique à l'aide du nom de classe
19. Student.stdBranch = "Informatique" ;
20.
21. std1.stdName = "Ben Coupe" ;
22. std1.roll_num = 90013
23. std1.showStdInfo();
24.
25. std2.stdName = "Peter Handscomb" ;
26. std2.roll_num = 90014
27. std2.showStdInfo();
28. }
Sortir
Le nom de l'étudiant est : Ben Cutting
Le salaire de l'étudiant est : 90013
Le nom de la branche de l'étudiant est : Informatique Le
nom de l'étudiant est : Peter Handscomb
Le salaire de l'étudiant est : 90014
Le nom de la branche de l'étudiant est : Informatique

Explication:
Dans le code ci-dessus, nous avons déclaré la classe appelée Student , qui comporte
trois champs, dont la variable statique stdBranch et une
méthode showStdInfo() . Nous avons créé deux instances de la classe Student et
attribué des valeurs aux variables de classe.
La variable statique stdBranch accessible à l'aide du nom de classe et de la valeur
attribuée. Ensuite, nous avons appelé la fonction showStdInfo() par les objets std1 et
stu2. Il imprimait les détails de l’étudiant en sortie.

ESSAIE4(ANG) :
Partie1 :
 Dart Object-Oriented Concepts
Dart is an object-oriented programming language, and it supports all the concepts of
object-oriented programming such as classes, object, inheritance, mixin, and abstract
classes. As the name suggests, it focuses on the object and objects are the real-life
entities. The Object-oriented programming approach is used to implement the concept
like polymorphism, data-hiding, etc. The main goal of oops is to reduce programming
complexity and do several tasks simultaneously. The oops concepts are given below.
o Class
o Object
o Inheritance
o Polymorphism
o Interfaces
o Abstract class

Below is the brief introduction of these oops concepts.

Class
Dart classes are defined as the blueprint of the associated objects. A Class is a user-
defined data type that describes the characteristics and behavior of it. To get all
properties of the class, we must create an object of that class. The syntax of the class is
given below.
Syntax:
1. class ClassName {
2. <fields>
3. <getter/setter>
4. <constructor>
5. <functions>
6. }
Object
An object is a real-life entity such as a table, human, car, etc. The object has two
characteristics - state and behavior. Let's take an example of a car which has a name,
model name, price and behavior moving, stopping, etc. The object-oriented
programming offers to identify the state and behavior of the object.
We can access the class properties by creating an object of that class. In Dart, The
object can be created by using a new keyword followed by class name. The syntax is
given below.
Syntax:
1. var objectName = new ClassName(<constructor_arguments>)
Inheritance
Dart supports inheritance, which is used to create new classes from an existing class.
The class that to be extended is called parent /superclass, and the newly created class
is called child/subclass. Dart provides extends keyword to inherit the properties of
parent class in child class. The syntax is given below.
Syntax:
1. class child_class_name extends parent_class_name
Polymorphism
Polymorphism is an object-oriented programming concept where one thing has many
forms. It can be two types - Runtime polymorphism and Compile time polymorphism.
For example - A function has the same name but with a different behavior or class.
Another example is the shape() class, and all the class inherited from the Rectangle,
Triangle, and circle.

Interfaces
The interface is defined as a blueprint of the class. We can declare methods and
variables inside the interface just like the class but in interface only abstract declaration
of methods is provided. We can only define the function signature but not its body.
Another class can implement the interface. It is basically used for data-hiding.

Abstract Class
A class that contains one or more abstract method is called an abstract class. We can
declare the abstract class using the abstract keyword followed by class declaration.
The syntax is given below.
Syntax:
1. abstract class ClassName {
2. //Body of abstract class
3. }
The above introductions give the basic idea of oops concepts. We will have a detailed
discussion in upcoming tutorials.
Partie2: