Création d’un nouveau fichier Swift
| class Etudiant {
var nom: String var prenom: String erreur !! il faut définir des valeurs par défa var age: Int une classe, c’est obligatoire var adresse: String } |
| class Etudiant {
var nom: String = “Alami” var prenom: String = “Mohammed” var age: Int = 21 var adresse: String = “5 rue liberte Rabat” } |
class Etudiant {
var nom: String = “Alami”
var prenom: String = “Mohammed”
var age: Int = 21
var adresse: String = “5 rue liberte Rabat«
func sinscrire() {
}
func passerExamen() {
}
func demenager() {
}
}
class Etudiant {
var nom: String = “Alami”
var prenom: String = “Mohammed” var age: Int = 21
var adresse: String = “5 rue liberte Rabat “
var statut : String = ” N”
func sinscrire() {
if self.statut == “N” { statut = “O” }
}
func passerExamen() {
}
func demenager(nouvelleAdresse: String) {
self.adresse = nouvelleAdresse
}
}
- let etudiant = Etudiant()
- let etudiant = Etudiant()
- print(“Nom de l’étudiant au début : ” + nom)
- nom = “Farah”
- print(“Le nouveau nom est maintenant : ” + nom)
- // On peut réaliser des actions propres à l’ étudiant
- print(“Mon âge est \(age) “)
- print(“Actuellement j’habite à cette adresse : ” + adresse)
- demenager(“12 rue Casablanca“)
- print(“J’habite dorénavant à cette adresse : ” + adresse)
- La surcharge de méthode
La surcharge de méthode consiste à déclarer une nouvelle méthode portant le même nom mais avec :
- le même nombre de paramètres, mais au moins un type de ces paramètres est différent que celle de la méthode existante ;
- un nombre de paramètres différent ;
- les
func affiche() {
print(“Nom : ” + self.nom) print(“Prénom : ” + self.prenom) print(“Age : \(self.age)”) print(“Adresse : ” + self.adresse)
}
func affiche(valeurAAfficher: String) {
switch valeurAAfficher { case “Nom”:
print(“Nom : ” + self.nom)
case “Prénom”:
print(“Prénom : ” + self.prenom)
case “Age”:
print(“Age : \(self.age)”)
case “Adresse”:
print(“Adresse : ” + self.adresse)
default:
print(“Nous n’avons pas pu afficher ce que vous avez demandé.”)
}
}
}
Etudiant.affiche() Etudiant.affiche(” age “)
Le constructeur
class Etudiant {
// On peut maintenant supprimer les valeurs par défaut
|
|
var nom: String
var prenom: String
var sexe: String var age: Int
var adresse: String
// Constructeur init() {
init(nom: String, prenom: String, age: Int, adresse: init() {
String) {
self.nom = “Salhi” self.nom = nom self.prenom = “Ahmed” self.prenom = prenom self.age = 20
self.age = age
self.adresse = “94 rue Saada”
} }
}
// Autres méthodes de la cla
self.adresse = adresse
let
}etudiant = Etudiant(nom :”Salhi“, prenom = “Ahmed“, age : 20 , adresse = “94 rue Saada”)
Le concept des propriétés
Øles propriétés stockées sont associées à une valeur Øles propriétés calculées sont associées à un calcul
une propriété admet deux acfons :
- une acTon pour récupérer la valeur contenue, on va appeler ceYe acTon get (récupérer en anglais)
- ne acTon pour modifier la valeur contenue, on va appeler ceYe acTon set (modifier en anglais)
class Carré {
var longueur = 2
var périmètre: Int {
get {
return longueur*3
}
set {
}
}
}
Entre les accolades se trouvent deux sortes de sous-fonctions :
- get : c’est l’action qui permet de récupérer une valeur, on appelle ça le getter. Elle se comporte exactement comme une fonction avec une valeur de retour de type Int.
- set : c’est l’action qui permet de modifier notre valeur, on appelle ça le setter. Pour l’instant cette fonction est vide. Telle quelle, elle ne change rien à ce qu’il se passe lorsqu’on modifie la valeur de la variable périmètre.
var périmètre: Int {
get {
return longueur * 4
}
set {
longueur = newValue / 4
}
}
Le setter se comporte exactement comme une fonction qui a pour paramètre newValue. newValue contient la nouvelle valeur que l’on est en train de donner au périmètre.
Observafon des propriétés
deux méthodes pour écouter des propriétés stockées :
- willSet : ceYe méthode est appelée juste avant la modificaTon de la propriété.
- didSet : ceYe méthode est appelée juste après la modificaTon de la propriété.
var longueur = 1 {
willSet {
print(“Le carré va changer de taille”)
}
didSet {
if oldValue > longueur { print(“Le carré a rapetissé”)
} else {
print(“Le carré a grandi”)
}
}
}
set : pour les propriétés calculées
willSet et didSet : pour les propriétés stockées
Les structures
struct NomStructure {
// Attributs et méthodes
}
Les structures
etudiant = Etudiant(nom: “Alami”, prenom: “Ahmed”, age: 27, adresse: “94 rue rabat”)
var etudiant1 = etudiant etudiant.age = 12 etudiant.affiche(“Age”) etudiant1.affiche(“Age”)
Age : 12
Age : 12
struct Personne { var nom: String
var age : String
Les structures
func quiEstCe() {
print(“Nom : ” + self.nom + “, age : ” + self.age)
}
}
var personne = Personne(nom: “Alami”, age: 20) var personne2 = personne
personne2.nom = “Losi” personne.quiEstCe()
Personne1.quiEstCe()
Nom : Alami Age : 20 Nom : Losi Age : 20
L’HÉRITAGE
class Etudiant : Personne {
}
:
let personne = Personne(nom: “Alami”, prenom: “Ahmed”, age: 20,
adresse: “94 casa”)
let etudiant = etudiant(nom: “Alami”, prenom: “Ahmed”, age: 20,
adresse: “94 rue casa”)
personne.affiche()
Ecltaudsis aEnttu.daifafnitc h:e( )P ersonne {
var modules: [String] = [ ] // Par défaut, le
tableau est vide
func passerControle(nomModule: String) {
}
func participerStage (nomSociete: String) {
}
}
class Etudiant : Personne {
var modules: [Module] = [ ] // Par défaut, le
tableau est vide
func passerControle(nomModule: Module) {
}
func participerStage (nomSociete: Societe) {
}
}
Exercice
Dans la fonction Main :
ü Créer des étudiants
ü Affecter des modules à chaque étudiant
ü Lister les différents modules de chaque étudiant
LE POLYMORPHISME
class Etudiant : Personne {
func afficher() {
super.afficher()
Print(” les modules sont :\(modules) ” )
}
}
func participerStage (nomSociete: Societe) {
}
}
.
class Etudiant : Personne {
var modules:[String]
init(nom: String, prenom: String, sexe: String, age: Int, adresse:
String, modules: [String])
{
Self.modules = modules
super.init(nom: nom, prenom: prenom, sexe: sexe, age: age,
adresse: adresse)
}
Récapitulatif
§ On peut réaliser un héritage si l’on peut dire que « B est un
A », B et A étant deux classes différentes.
§ Une classe B qui hérite d’une autre classe A possédera tous les
attributs et méthodes de A.
§ Une classe héritée peut avoir des attributs et méthodes
supplémentaires que ceux de sa classe mère.
§ On peut faire hériter une classe qui est déjà héritée (et ainsi
de suite) mais on ne peut faire hériter deux classes à une
même classe.
§ Il est possible grâce au polymorphisme de redéfinir ou
modifier le comportement d’une méthode
Les Protocoles :
protocol NomDeMonProtocole {
}
:
protocol ProtocoleVéhicule {
func démarrer()
func accélerer()
}
Les Protocoles & Héritage
Class Voiture :Vehicule, ProtocoleVéhicule {
instructions….
}
}
UTlisaTon d’un protocole :
Protocole ProtocoleVéhicule1 : ProtocoleV2 {
//…..
}
Class voiture : ProtocoleVéhicule1 {
//…..
}
LES ÉNUMÉRATIONS
enum NomEnumeration {
// Liste des différents cas ici }
Déclaration d’une énumération:
:
enum Langage {
case Swift
case Java
case C++
case C
}
Ou
enum Langage {case Swift , Java , Php,
Utilisation d’une énumération:
var lanaggeuilise = Langage.Swift
langageutilise = .java
var langageUtilise = Langage.Swift
switch langageUtilise {
case .Swift:
print(“le langage Swift.”)
case .Java:
print(” le Java.”)
case .C++:
print(” le C++.”)
case .C:
print(” le langage C.”)
}
Valeurs associées à une énumération :
enum Langage {
case Swift ( String , String)
case Java (String)
case C++ (String)
case C (String)
}
var lanaggeuilise = Langage.Swift(“Le langage Swift”, “3
modialement”)
langageutilise = .java((“Le langage
java”)
Valeurs associées à une énumération :
var lanaggeuilise = Langage.Swift(“Le langage Swift” ,”N°3″)
langageutilise = .java((“Le langage
java”)
switch langageUtilise {
case let .Swift(description, niveau):
print(description +” “+ niveau)
case var .Java(description) :
print( description)
default :
print(” autre langage.”)
}
LES EXTENSIONS
Ajout d’une méthode:
.
extension Int {
func carre() -> Int {
return self * self
}
func cube() -> Int {
return self * self * self
}
func afficheCarreEtCube() {
print(“\(self.carre()), \(self.cube())”)
}
}
5.afficheCarreEtCube()
print(4.cube())
