Académique Documents
Professionnel Documents
Culture Documents
Dart Class
Dart Class
//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;
• 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
class Gfg {
void geek()
print("Welcome to $geek1");
}
void main()
geek.geek1 = 'GeeksforGeeks';
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 = " ";
return name;
this.name = name;
void result(){
print(name);
void main() {
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 :
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 )
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 )
void main() {
var p1 = Point();
}Langage du code : Dart ( fléchette )
Ajout de propriétés à la classe
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 )
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;
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 )
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 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) :
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.
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.
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é
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.
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.
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.
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
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: