BURKINA FASO
La patrie ou la mort, nous vaincrons
MASTER
DEVELOPPEMENT DES APPLICATIONS ANDROID
Le langage Dart
Enseignant: COMPAORE Moctar @ 2025
INTRODUCTION
• Dart est un langage qui alimente l'innovation et la création d'expériences
mobiles modernes et dynamiques. Conçu par Google, Dart a été développé
spécifiquement pour surmonter les défis auxquels sont confrontés les
développeurs lorsqu'ils créent des applications réactives et performantes.
• Dart est un langage de programmation orienté objet, open source et
évolutif. Il possède une syntaxe claire et concise, ce qui le rend relativement
facile à apprendre et à maîtriser.
• Dans ce module, nous explorerons les caractéristiques fondamentales de
Dart. Nous présentons sa syntaxe, ses principes de base et ses concepts clés.
Nous apprendrons comment manipuler les variables, les structures
conditionnelles, les boucles, les fonctions, etc.
VARIABLES ET TYPES EN DART
Les variables jouent un rôle fondamental dans la programmation en permettant aux
développeurs de stocker et gérer des données de manière flexible. Dart est un langage à
typage statique optionnel, ce qui signifie que bien qu'il soit possible de spécifier un type
pour les variables, cela n'est pas obligatoire. En d’autres termes, les types de variables ne
sont pas vérifiés à l'exécution. Leur principal objectif est d'aider à la documentation du
code et à la lisibilité, plutôt qu’à l'exécution proprement dite. Cette approche a été choisie
par Google pour rendre le langage accessible à un large public, permettant à la fois un
typage statique pour ceux qui préfèrent un code plus strict et un typage dynamique pour
ceux qui préfèrent plus de flexibilité. Voici un exemple qui montre la différence entre
typage statique et dynamique.
VARIABLES ET TYPES EN DART
VARIABLES ET TYPES EN DART
VARIABLES ET TYPES EN DART
Dart offre plusieurs types de données de base :
• Entiers (int) : Représentent les nombres entiers, sans partie décimale, qui
peuvent être positifs, négatifs ou nuls. Leur taille en mémoire est déterminée
par un nombre arbitraire de bits.
• Décimaux (double) : Représentent des nombres à virgule flottante, c'est-à-dire
des nombres avec une partie décimale. Ils sont codés sur 64 bits.
• En Dart, tant les entiers que les décimaux héritent de la classe num, ce qui
leur permet de partager certaines fonctionnalités communes.
• Chaînes de caractères (String) : Représentent des séquences de texte
encodées en UTF-16. Les chaînes peuvent être délimitées par des guillemets
simples (' ') ou doubles (" "). Pour comparer deux chaînes de caractères,
l’opérateur == est utilisé.
VARIABLES ET TYPES EN DART
Exemple :
Dans l'exemple suivant, les variables nom1 et nom2 contiennent
respectivement les chaînes "Alice" et "Bob". La condition if (nom1 == nom2)
compare les deux chaînes. Si elles sont identiques, le message "Les deux noms
sont identiques." sera affiché ; sinon, "Les deux noms sont différents." sera
affiché.
void main() {
String nom1 = "Alice";
String nom2 = "Bob ";
if (nom1 == nom2) {
print("Les deux noms sont identiques."); }
else { print("Les deux noms sont différents.");
}
VARIABLES ET TYPES EN DART
Déclaration et Utilisation des Variables en Dart
En Dart, pour créer une variable, il est nécessaire de spécifier son type et de
lui attribuer une valeur initiale. Par exemple, on peut déclarer et initialiser
une variable comme suit :
int age = 25;
Il est également possible d'utiliser le mot-clé var pour déclarer une variable
sans avoir à spécifier explicitement son type. Dans ce cas, le type de la
variable est automatiquement déterminé par Dart en fonction de la valeur qui
lui est assignée.
var age = 25;
print(age);
VARIABLES ET TYPES EN DART
La fonction main() est le point d'entrée du programme en Dart. Tous les
codes à exécuter doivent se trouver à l’intérieur de cette fonction.
void main() {
int age = 27;
String nom = "Marc";
double poids = 90.6;
double taille = 1.60;
bool estObese = true;
double imc = poids / (taille * taille);
if (estObese) {
print("$nom est obèse. IMC: $imc");
} else {
print("$nom n'est pas obèse. IMC: $imc"); }
}
VARIABLES ET TYPES EN DART
Déclaration de Constantes en Dart
En Dart, pour déclarer une constante, il faut utiliser le mot-clé const. Une constante est une valeur
immuable, c’est-à-dire qu’une fois qu’elle est définie, sa valeur ne peut plus être modifiée. Cela
permet d'améliorer la lisibilité et la sécurité du code en garantissant que certaines valeurs
restent constantes tout au long de l'exécution du programme.
Exemple de déclaration de constante en Dart :
const double pi = 3.14159;
const String nomPays = "Burkina Faso";
OPERATEURS
Les opérateurs facilitent la manipulation mathématique de
valeurs, généralement via les variables auxquelles elles sont
attribuées. Dans Dart les opérateurs les plus utilisés sont :
opérateurs arithmétiques, égalité et opérateurs de relation,
expressions conditionnelles, opérateurs logiques, opérateurs de
test de type et opérateurs d'assignation.
•Les opérateurs arithmétiques : sont utilisés pour réaliser des
opérations arithmétiques sur des valeurs. Le tableau suivant
récapitule les opérateurs arithmétiques et leurs interprétations.
OPERATEURS
1. Opérateurs Arithmétiques
Les opérateurs arithmétiques sont utilisés pour effectuer des opérations
mathématiques de base.
+ : Addition int a = 10;
int b = 3;
- : Soustraction print(a + b); // 13
* : Multiplication print(a - b); // 7
/ : Division print(a * b); // 30
print(a / b); // 3.333...
% : Modulo (reste de la division) print(a % b); // 1
~/ : Division entière (retourne la partie entière du quotient) print(a ~/ b); // 3
OPERATEURS
2. Opérateurs de Comparaison
Les opérateurs de comparaison sont utilisés pour comparer deux
valeurs.
== : Égal à
int x = 5;
!= : Différent de int y = 10;
> : Plus grand que print(x == y); // false
print(x != y); // true
< : Moins grand que print(x > y); // false
>= : Plus grand ou égal à print(x < y); // true
print(x >= y); // false
<= : Moins grand ou égal à print(x <= y); // true
OPERATEURS
3, Les opérateurs logiques sont utilisés pour combiner des
expressions booléennes.
&& : ET logique (AND)
|| : OU logique (OR)
! : NON logique (NOT)
bool a = true;
bool b = false;
print(a && b); // false
print(a || b); // true
print(!a); // false
OPERATEURS
4. Les opérateurs d'assignation sont utilisés pour affecter des valeurs à des
variables.
= : Affectation simple
+= : Addition et assignation
-= : Soustraction et assignation
*= : Multiplication et assignation
/= : Division et assignation
%= : Modulo et assignation int c = 10;
c += 5; // c = c + 5 -> 15
c -= 3; // c = c - 3 -> 12
c *= 2; // c = c * 2 -> 24
c /= 4; // c = c / 4 -> 6
c %= 5; // c = c % 5 -> 1
STRUCTURES DE CONTROLES
Les structures de contrôle en Dart sont utilisées pour définir le flux d'exécution d'un programme en
fonction de certaines conditions ou répétitions. Ces structures permettent de contrôler l'exécution du
code, en fonction de la logique que l'on souhaite appliquer.
La structure if permet d'exécuter un bloc de code L'instruction if-else permet d'exécuter un bloc de
uniquement si une condition est vraie. code si la condition est vraie, et un autre bloc si la
condition est fausse.
int a = 10; if (a > 5) { if (condition) {
print("a est plus grand que 5"); // Code à exécuter si la condition est vraie
} } else {
// Code à exécuter si la condition est fausse
}
int a = 3; if (a > 5) {
print("a est plus grand que 5");
} else {
print("a est inférieur ou égal à 5");
}
STRUCTURES DE CONTROLES
La structure switch permet de tester plusieurs valeurs
possibles pour une même variable, ce qui est souvent
plus pratique que de multiples if-else.
int jour = 3;
switch (jour) {
switch (variable) {
case 1:
case valeur1:
print("Lundi");
// Code à exécuter si la variable est égale à valeur1
break;
break;
case 2:
case valeur2:
print("Mardi");
// Code à exécuter si la variable est égale à valeur2
break;
break;
[…]
default:
default:
// Code à exécuter si aucune des valeurs
print("Week-end");
précédentes n'est correspondante
}
}
STRUCTURES DE CONTROLES
Les boucles permettent de répéter l'exécution d'un bloc de code plusieurs fois. Dart
propose différentes structures de boucle, dont les suivantes :
Boucle for
La boucle for répète un bloc de code un nombre déterminé de fois.
for (initialisation; condition; modification) {
// Code à répéter tant que la condition est vraie
}
Exemple :
for (int i = 0; i < 5; i++) {
print(i);
}
STRUCTURES DE CONTROLES
Boucle while while (condition) {
// Code à répéter tant que la condition est vraie
}
La boucle while répète un bloc de code tant
que la condition est vraie. La condition est Exemple :
vérifiée avant chaque itération.
int i = 0;
while (i < 5) {
print(i);
i++;
}
STRUCTURES DE CONTROLES
Boucle do-while
do {
La boucle do-while est similaire à la boucle // Code à exécuter
while, mais elle vérifie la condition après } while (condition);
chaque itération, garantissant que le bloc de
code soit exécuté au moins une fois. Exemple :
int i = 0;
do {
print(i);
i++;
} while (i < 5);
STRUCTURES DE CONTROLES
Instructions de Contrôle de Flux
Exemple :
Ces instructions permettent de manipuler le flux
d'exécution des boucles et des conditions.
for (int i = 0; i < 10; i++) {
break
if (i == 5) {
break; // Quitte la boucle quand i vaut 5
L'instruction break permet de sortir immédiatement
}
d'une boucle ou d'un switch.
print(i);
}
STRUCTURES DE CONTROLES
continue
Exemple :
L'instruction continue permet for (int i = 0; i < 10; i++) {
de sauter l'itération en cours if (i == 5) {
continue; // Passe à l'itération suivante quand i vaut 5
d'une boucle et de passer }
print(i);
directement à l'itération }
suivante.
EXERCICES
Avec [Link]
1. Déclarez une liste de nombres [3, 9, 12, 15, 18, 21, 24, 27, 30].
2. Utilisez une boucle for pour parcourir la liste.
3. À l'intérieur de la boucle, utilisez une structure conditionnelle pour
afficher Multiple de 3 si le nombre est un multiple de 3, et Non multiple
de 3 sinon.
4. switch pour afficher Faible si le nombre est inférieur à 15, Moyen s'il est
entre 15 et 25 inclus, et Élevé s'il est supérieur à 25.
5. Calculez la somme des nombres qui sont multiples de 3 et supérieurs à
15, et affichez-la à la fin.
EXERCICES
void main() {
List<int> listeDeNombres= [3, 5, 9, 12, 15, 10, 11, 18, 21, 24, 13, 27, 30]; // if(element <15) { // faible
int sommeMultiple3sup15 =0; // print("Element $element est faible ");
//print([Link]);
// } else if(element >=15 && element <=25){ //
for(int i =0; i<[Link];i++){
Moyen
int element = [Link](i);
// print("Element $element est moyen ");
// print("Element à index : $i est $element");
if(element%3==0) { // le reste de la division // de l'element par 3 // } else if(element >25) { //Elévé
est zero
// print("Element $element est Elévé ");
///print("Element $element est multiple de 3");
// }
if(element >=15) {
sommeMultiple3sup15 +=element;
}
EXERCICES
switch (element){
case < 15 :
print("Element $element est faible ");
break;
case >=15 && <=25 :
print("Element $element est Moyen ");
break;
case >25 :
print("Element $element est élévé ");
break;
}
print("La somme des multiples de 3 et supérieur à 15
est $sommeMultiple3sup15");
}
LES FONCTIONS
Les fonctions en Dart sont des blocs de code qui peuvent être appelés
à plusieurs endroits dans un programme pour exécuter une tâche
spécifique. Les fonctions permettent de structurer le code, d'éviter la
répétition et d'améliorer la lisibilité. Dart permet de déclarer des
fonctions de manière simple, avec des paramètres optionnels et des
valeurs de retour.
LES FONCTIONS
1. Déclaration d'une fonction
En Dart, une fonction est déclarée en Exemple de fonction simple qui
spécifiant son type de retour (ou void n'a pas de paramètres et ne
si elle ne retourne rien), suivie de retourne rien (fonction void) :
son nom, des parenthèses et du bloc
de code entre accolades {}. void saluer() {
print("Bonjour !");
type_de_retour }
nom_de_fonction(paramètres) {
// corps de la fonction
}
LES FONCTIONS
2. Fonction avec des paramètres
Les fonctions peuvent accepter des paramètres, ce qui permet de rendre le code plus flexible.
Les paramètres sont définis dans les parenthèses lors de la déclaration de la fonction.
Exemple de fonction avec des paramètres :
void saluer(String nom) {
print("Bonjour, $nom !");
}
Dans cet exemple, la fonction saluer() prend un paramètre de type String nommé nom, et elle
affiche un message personnalisé avec le nom fourni.
Appel de la fonction avec un argument :
saluer("Marc"); // Affiche "Bonjour, Marc !
LES FONCTIONS
3. Fonction avec une valeur de retour
Une fonction peut retourner une valeur. Dans ce cas, le type de retour doit être
spécifié au moment de la déclaration de la fonction.
Exemple de fonction avec un type de retour :
int additionner(int a, int b) {
return a + b;
}
Dans cet exemple, la fonction additionner() prend deux entiers comme
paramètres et retourne leur somme.
Appel de la fonction et utilisation de la valeur retournée :
int resultat = additionner(3, 4); // resultat vaudra 7
print(resultat); // Affiche 7
LES FONCTIONS
4. Fonctions anonymes (Lambda)
En Dart, il est possible de créer des fonctions anonymes, souvent appelées
fonctions lambda ou fonctions de première classe. Elles n'ont pas de nom et
peuvent être utilisées directement comme des expressions.
Exemple de fonction anonyme :
var addition = (int a, int b) => a + b;
print(addition(2, 3)); // Affiche 5
Ici, la fonction anonyme utilise l'opérateur =>, qui est une syntaxe concise
pour une fonction qui retourne une seule valeur.
LES FONCTIONS
5. Paramètres optionnels
Dart permet de définir des paramètres optionnels, ce qui signifie que l'appel de la fonction peut se faire avec ou
sans ces paramètres. Il existe deux types de paramètres optionnels : paramètres nommés et paramètres
positionnels.
Paramètres nommés
Les paramètres nommés sont entourés de crochets [] et doivent être appelés par leur nom.
void afficherInfo({String? nom, int? age}) {
print("Nom: $nom, Âge: $age");
}
Lorsque vous appelez la fonction, vous devez spécifier les paramètres par leur nom :
afficherInfo(nom: "Alice", age: 30); // Affiche "Nom: Alice, Âge: 30"
Les paramètres nommés peuvent être rendus optionnels en leur assignant une valeur par défaut :
void afficherInfo({String nom = "Inconnu", int age = 0}) {
print("Nom: $nom, Âge: $age");
}
LES FONCTIONS
5. Paramètres optionnels
Paramètres positionnels
Les paramètres positionnels sont des paramètres qui n'ont pas de noms spécifiques et doivent
être passés dans l'ordre dans lequel ils sont définis.
void afficherInfo(String nom, int age) {
print("Nom: $nom, Âge: $age");
}
Les paramètres positionnels peuvent également être rendus optionnels en utilisant des crochets
[] :
void afficherInfo([String? nom = "Inconnu", int? age = 0]) {
print("Nom: $nom, Âge: $age");
}
LES FONCTIONS
7. Fonctions en tant qu'arguments (Fonctions de première classe)
En Dart, les fonctions sont des objets de première classe, ce qui signifie qu'elles peuvent être
passées en argument d'autres fonctions, retournées par des fonctions ou affectées à des
variables.
Exemple de fonction prenant une fonction comme argument :
void appliquerFonction(int a, int b, Function(int, int) f) {
print(f(a, b));
}
void addition(int a, int b) {
print(a + b);
}
void main() {
appliquerFonction(3, 4, addition); // Affiche 7
LES COLLECTIONS DE DONNÉES
Les collections de données en Dart sont des structures qui
permettent de stocker plusieurs valeurs dans une seule
variable. Ces structures incluent des Listes, des
Ensembles (Sets) et des Maps (dictionnaires), qui
permettent de gérer et de manipuler efficacement des
ensembles de données.
LES COLLECTIONS DE DONNÉES
1. Listes (List)
Les Listes en Dart sont des collections ordonnées qui peuvent contenir des éléments de n'importe quel
type. Chaque élément a un index, qui commence à 0. Dart permet de créer des listes avec des éléments
hétérogènes ou homogènes.
Déclaration d'une liste :
// Liste avec des éléments de types homogènes
List<int> nombres = [1, 2, 3, 4, 5];
// Liste avec des éléments de types hétérogènes
List<dynamic> diverse = [1, "Alice", 3.14, true];
LES COLLECTIONS DE DONNÉES
1. Listes (List)
Accès aux éléments :
Les éléments d'une liste peuvent être accédés en utilisant leur index :
print(nombres[0]); // Affiche 1
print(diverse[1]); // Affiche Alice
Ajout d'éléments :
[Link](6); // Ajoute 6 à la fin de la liste
[Link]("New element"); // Ajoute un nouvel élément à la fin
LES COLLECTIONS DE DONNÉES
1. Listes (List)
Exemple :
Autres opérations sur les listes : void main() {
List<int> nombres = [1, 2, 3];
[Link](4);
Modifier un élément : nombres[0] = 10; print(nombres); // [1, 2, 3, 4]
Supprimer un élément : [Link](3);
print(nombres[2]); // 3
Taille de la liste : print([Link]);
Vérifier si un élément existe : nombres[0] = 10;
print([Link](3)); print(nombres); // [10, 2, 3, 4]
[Link](3);
print(nombres); // [10, 2, 4]
}
LES COLLECTIONS DE DONNÉES
2. Ensembles (Set)
Un Set est une collection non ordonnée d'éléments uniques. Contrairement à une Liste,
un Set ne permet pas de dupliquer des valeurs.
Déclaration d'un ensemble :
Set<int> nombres = {1, 2, 3, 4};
Set<String> fruits = {"Pomme", "Banane", "Orange"};
Ajout d'éléments :
[Link](5); // Ajoute l'élément 5
[Link](1); // Aucun effet, car l'élément 1 existe déjà
LES COLLECTIONS DE DONNÉES
2. Ensembles (Set)
Exemple :
void main() {
Set<String> fruits = {"Pomme", "Banane", "Orange"}
Autres opérations sur les ensembles :
[Link]("Mangue");
[Link]("Pomme"); // Aucun effet car "Pomme"
Supprimer un élément : [Link](2);
existe déjà
Vérifier si un élément existe : print([Link](3));
Taille du Set : print([Link]);
print(fruits); // {Pomme, Banane, Orange, Mangue}
[Link]("Banane");
print(fruits); // {Pomme, Orange, Mangue}
}
LES COLLECTIONS DE DONNÉES
3. Maps (Dictionnaires)
Un Map est une collection de paires clé-valeur. Chaque clé est unique, et
chaque clé est associée à une valeur. Le Map peut contenir n'importe quel type
de données comme clé et valeur.
Déclaration d'un Map :
Map<String, int> ages = {"Alice": 25, "Bob": 30, "Charlie": 22};
Accès à une valeur :
print(ages["Alice"]); // Affiche 25
Ajout ou modification d'une paire clé-valeur :
ages["David"] = 28; // Ajoute une nouvelle clé "David" avec la valeur 28
ages["Alice"] = 26; // Modifie la valeur associée à la clé "Alice"
LES COLLECTIONS DE DONNÉES
3. Maps (Dictionnaires)
Exemple :
Autres opérations sur les Maps : void main() {
Map<String, int> ages = {"Alice": 25, "Bob": 30};
Supprimer une paire clé-valeur : [Link]("Bob");
Vérifier si une clé existe : ages["Charlie"] = 22;
print([Link]("Charlie")); print(ages); // {Alice: 25, Bob: 30, Charlie: 22}
Taille du Map : print([Link]);
ages["Bob"] = 31; // Mise à jour de la valeur associée à la clé
"Bob"
print(ages); // {Alice: 25, Bob: 31, Charlie: 22}
[Link]("Alice");
print(ages); // {Bob: 31, Charlie: 22}
}
LES COLLECTIONS DE DONNÉES
4. Collections de données spéciales
Queue (File)
Dart fournit également une classe Queue qui représente une collection ordonnée avec
des opérations de type FIFO (First-In-First-Out). Elle permet d'ajouter des éléments à la
fin et de les retirer du début.
import 'dart:collection';
Queue<int> file = Queue<int>();
[Link](1); // Ajoute 1 à la fin
[Link](0); // Ajoute 0 au début
[Link](); // Supprime 0 du début
print(file); // Affiche: [1]
LES CLASSES ET LES OBJETS
Les classes et les objets sont des concepts fondamentaux de la
programmation orientée objet (POO). En Dart, comme dans
d'autres langages orientés objet, les classes permettent de
définir des types d'objets, et les objets sont des instances de ces
classes.
LES CLASSES ET LES OBJETS
class NomDeClasse {
1. Qu'est-ce qu'une classe ? // Propriétés
type nomPropriete;
Une classe en Dart est une sorte de
modèle ou de plan pour créer des // Constructeur
objets. Elle définit les propriétés NomDeClasse(type valeur) {
(également appelées attributs ou [Link] = valeur;
champs) et les méthodes (également }
appelées comportements) que les
objets de cette classe auront. // Méthode
Syntaxe de déclaration d'une classe : void maMethode() {
// code ici
}
LES CLASSES ET LES OBJETS
Exemple : Déclaration d'une classe Personne :
2. Déclaration d'une classe en Dart
class Personne {
Un exemple de déclaration d'une
// Propriétés
classe représentant une Personne.
String nom;
int age;
// Constructeur
Personne([Link], [Link]); // Le constructeur
initialise les propriétés avec des valeurs
// Méthode
void sePresenter() {
print("Bonjour, je m'appelle $nom et j'ai $age ans.");
}
}
LES CLASSES ET LES OBJETS
3. Propriétés et Constructeurs
Propriétés : Les propriétés d'une classe définissent les attributs
de l'objet. Dans l'exemple précédent, nom et age sont des
propriétés de la classe Personne.
Constructeur : Le constructeur est une méthode spéciale qui est
appelée lors de la création d'un nouvel objet de cette classe. Il
permet d'initialiser les propriétés de l'objet. Dans l'exemple, le
constructeur Personne([Link], [Link]) initialise les propriétés
avec les valeurs passées lors de la création de l'objet.
LES CLASSES ET LES OBJETS
4. Créer un objet (Instance d'une classe) Exemple de création d'objets :
Une fois que la classe est définie, vous pouvez void main() {
créer des objets en utilisant le nom de la // Création de deux objets de type Personne
classe et en appelant son constructeur. Personne personne1 = Personne("Alice", 30);
Personne personne2 = Personne("Bob", 25);
// Appel d'une méthode sur ces objets
[Link](); // Affiche: Bonjour, je
m'appelle Alice et j'ai 30 ans.
[Link](); // Affiche: Bonjour, je
m'appelle Bob et j'ai 25 ans.
}
LES CLASSES ET LES OBJETS
Exemple avec une propriété privée :
class Personne {
5. Encapsulation String _nom; // Propriété privée
int _age; // Propriété privée
L'encapsulation fait référence à l'idée de
cacher les détails internes d'une classe et Personne(this._nom, this._age);
de n'exposer que des interfaces publiques.
En Dart, cela se fait en définissant les // Méthodes pour accéder et modifier les propriétés
propriétés comme private ou public. Pour String get nom => _nom;
rendre une propriété ou méthode privée, void set nom(String nom) => _nom = nom;
vous utilisez un underscore (_) avant son
nom. int get age => _age;
void set age(int age) => _age = age;
void sePresenter() {
print("Bonjour, je m'appelle $_nom et j'ai $_age ans.");
}
}
LES CLASSES ET LES OBJETS
6. Héritage Exemple d'héritage :
L'héritage est un mécanisme qui permet à une classe
d'hériter des propriétés et des méthodes d'une autre class Animal {
String nom;
classe. Dart supporte l'héritage simple, c'est-à-dire
Animal([Link]);
qu'une classe peut hériter d'une seule autre classe.
void parler() {
print("$nom fait un bruit.");
class Chien extends Animal {
}
Chien(String nom) : super(nom); // Appel du constructeur de la classe parente
}
@override
void parler() { void main() {
print("$nom aboie."); Animal animal = Animal("Un animal");
} [Link](); // Affiche: Un animal fait un bruit.
}
Chien chien = Chien("Rex");
[Link](); // Affiche: Rex aboie.
}
LES CLASSES ET LES OBJETS
7. Polymorphisme
void faireParler(Animal animal) {
Le polymorphisme permet à [Link](); // Appelle la méthode 'parler'
spécifique à l'objet
des objets de classes dérivées }
de se comporter comme des
objets de la classe parente tout void main() {
Animal animal = Animal("Un animal");
en ayant un comportement Chien chien = Chien("Rex");
spécifique.
faireParler(animal); // Affiche: Un animal fait un
Exemple de polymorphisme : bruit.
faireParler(chien); // Affiche: Rex aboie.
}
LES CLASSES ET LES OBJETS
Exemple de classe abstraite :
abstract class Vehicule {
8. Classes abstraites void demarrer(); // Méthode abstraite sans corps
}
Une classe abstraite est une classe
qui ne peut pas être instanciée class Voiture extends Vehicule {
@override
directement. Elle sert de modèle
void demarrer() {
pour d'autres classes. Les méthodes print("La voiture démarre.");
abstraites, qui n'ont pas de corps, }
doivent être définies dans les }
classes dérivées.
void main() {
Voiture voiture = Voiture();
[Link](); // Affiche: La voiture démarre.
}
EXERCICE
Écrire un programme Dart(en utilisant des fonctions !) qui
demande à l’utilisateur une longue chaîne contenant plusieurs
mots.
1- Afficher la chaîne (fonction print)
2- Renvoyez à l’utilisateur la même chaîne, avec les mots dans
l’ordre inverse.
3- Compter le nombre de mots dans la chaîne donnée.
4- Trouver le nombre de voyelles qui se sont produites dans la
chaîne donnée.
Merci pour votre attention !
