Programmation Orientée Objet C# El Akel Bouchra ISMONTIC Tanger 2013/2014

Plan 1. Classes 4. Accès aux attributs 5. Constructeur 6. Utilisation de « this » 7. Encapsulation 8. Propriétés 9. Accesseurs et mutateurs 10. Modificateur « static » 2. Champs et méthodes 3. Instanciation Objets 11. Notions de signature 12. ToString()

Classes Classe: une description d’une famille d’objets ayant une même structure et un même comportement. Elle est caractérisée par : Un nom Une composante statique : des champs (ou attributs) nommés ayant une valeur. Une composante dynamique : des méthodes représentant le comportement des objets de cette classe. Nom Méthodes Champs

Classes  Une classe peut contenir plusieurs éléments tels que : Données membres (« variables ») Propriétés (« méthodes spéciales ») Constructeurs (« méthodes spéciales ») Méthodes  Chaque fichier «.cs » contient exactement une classe. De plus, chaque fichier porte le nom de la classe qu’il contient (mais cela n’est pas obligatoire comme dans certains langages).

Classes La déclaration d'une classe se fait de la façon suivante : [Modificateurs] class NomClasse { //corps de la classe }

Champs  Les champs ou les données membres sont des variables propres à une classe permettant de stocker l’état d’un objet.  Généralement, elles sont utilisées par les propriétés et les méthodes, mais ne sont pas directement accessibles à l’extérieur de la classe.  Exemple: class Personne { // les champs string nom; string penom; int age; }

Méthodes  Une méthode est une action que peut effectuer un objet.  Exemple: class Personne { // les champs string nom; string prenom; int age; //les méthodes public void Afficher() { Console.Out.WriteLine("nom="+nom+",prénom="+prenom+ ",age ="+age); ); } public int CalculerAnneeN(int anneeA) { return anneeA-age;} }

Instanciation des objets Objets: sont des représentations dynamiques (instanciation), du modèle défini pour eux aux travers de la classe. - Une classe permet d’instancier (créer) plusieurs objets. - Chaque objet est instance d’une classe et une seule. Instanciation : concrétisation d’une classe en un objet « concret ».

Instanciation des objets class Personne { // deux variables d’instance public string nom; public string societe; // une méthode public void presenteToi() { Console.Out.WriteLine("Je m'appelle " + nom); Console.Out.WriteLine("Je travaille à " + societe); } public static void main(string[] args) { Personne p = new Personne();//création d'une instance de la classe Personne p.nom = "Mohamed"; p.societe= "Microsoft"; p.presenteToi(); //appel à méthode presenteToi() }

Accès aux attributs Chaque attribut et chaque méthode d'une classe peut être : public: accessible partout où la classe est accessible. privé: n'est accessible que par les seules méthodes internes de la classe. Protégé: n'est accessible que par les seules méthodes internes de la classe ou d'un objet dérivé (voir ultérieurement le concept d'héritage). Les mots réservés (Modificateurs) sont : Public Private Protected

Accès aux attributs

Seconde implémentation de la classe: class Personne { private string nom; private string societe; public void presenteToi() { Console.Out.WriteLine ("Je m'appelle " + nom); Console.Out.WriteLine("Je travaille à " + societe); } Maintenant, si on écrit : (dans une autre classe) Personne p = new Personne(); p.nom = "ahmed"; //Invalide car l'attribut est privé p.presenteToi(); //valide car la méthode est public

Accès aux attributs Le compilateur refuse la seconde instruction : p.nom, privée, est inaccessible pour l’utilisateur de la classe Personne. Ainsi il n'est plus possible de venir changer les données de la classe (ou propriétés) directement. On pourra changer la valeur de ces propriétés à travers des méthodes publiques.

Constructeur Contrôle d’instanciation: L’opérateur d’instanciation est new : MaClasse monObjet = new MaClasse(); En fait, new va appeler le constructeur de la classe MaClasse. Avec la définition de la classe Personne précédente, si nous exécutons : Personne p = new Personne(); p.presenteToi(); nous voyons s’afficher : Je m’appelle null Je travaille à null

Constructeur Quand le concepteur de la classe n’a pas spécifié de mécanisme d’instanciation, C# en fournit un par défaut, appelé constructeur par défaut. Le constructeur par défaut initialise chaque variable d’instance avec une valeur par défaut :null

Constructeur Définir un constructeur: class Personne { private string nom; private string societe; //Constructeur1 public Personne (string leNom) { nom = leNom; } /******ou bien******************** public Personne (string nom) { This.nom = nom; }***************/ //Constructeur2 public Personne (string leNom,string laSociete) { nom = leNom; societe=laSociete; } }

Constructeur Avec le constructeur Personne(String) on peut instancier un objet Personne dont le nom est conforme aux spécifications : Personne p = new Personne("mohamed"); On ne peut plus instancier d’objet de nom indéterminé : Personne p = new Personne(); // erreur de compilation : il n’y a plus de constructeur par défaut Le constructeur est une des composantes importantes de la programmation objet. Toute nouvelle instance est créée en utilisant un constructeur de classe

Constructeur Une nouvelle version de la classe class Personne { private String nom; private String societe; //l’absence de société sera signalée par "?" //Constructeur1 public Personne (String nom) { /*construit un objet Personne de nom qui sera traduit en majuscule et de société inconnue */ this.nom = nom.ToUpper(); // qualification avec this pour distinguer la variable d'instance du paramètre societe ="?”; } //Constructeur2 public Personne (String nom,String societe) { this.nom = nom.ToUpper(); this.societe =societe; }

Constructeur public void presenteToi() { Console.Out.WriteLine("Je m'appelle " + nom); if (societe.equals("?")) Console.Out.WriteLine("Je ne suis pas salarié"); else Console.Out.WriteLine("Je travaille à " + societe); } class Program() { static void main(String[] args) { Personne p1 = new Personne(" fatima" ); //Appel au constructeur1 p1.presenteToi(); /* Je m'appelle FATIMA Jene suis pas salarié */ Personne p2 = new Personne(" salma", " ISMONTIC"); //Appel au constructeur2 p2.presenteToi(); /* Je m'appelle SALMA Jetravaille à ISMONTIC*/ }

Constructeur Récapitulation: Le constructeur par défaut est encore appelé constructeur sans paramètres ou constructeur implicite. Un constructeur est une méthode particulière, en général publique l’identificateur est le même que celui de la classe. Dès qu’un constructeur explicite (Constructeur paramétré) est défini, le constructeur par défaut n’est plus disponible, sauf si le programmeur le rétablit en définissant explicitement un constructeur sans paramètres.

Utilisation de this Permet de désigner l’objet « courant » dans lequel on se trouve. Dans un constructeur, le mot-clef this désigne l'objet qui est construit. Dans une méthode, ce mot-clef désigne l’objet qui traite le message

Encapsulation L'encapsulation est un mécanisme consistant à empêcher l'accès aux données par un autre moyen que les services (les méthodes) proposés. L'encapsulation permet donc de garantir l'intégrité des données contenues dans l'objet. Les attributs ne devraient pouvoir être lus ou modifiés que par l'intermédiaire de méthodes.

Propriétés Comment changer de société ? Aucun moyen d’associer une société à une personne la variable d’instance societe est privée. créer des méthodes publiques permettant de manipuler ces variables d'instances tel que vous le souhaitez, appelées accesseurs (get) et mutateurs (set) public string societe { get; set; }

Accesseurs et mutateurs  Pour exécuter des opérations supplémentaires pour la lecture et l'écriture de la valeur de propriété: private string _societe; public string societe { //lecture (accesseur) get { return _societe.ToUpper(); } //écriture (mutateur) set { _societe = value; } }

Accesseurs et mutateurs Intérêt des accesseurs et mutateurs: Gérer l'accessibilité des variables privées (limiter l’accès en lecture) Gérer l'intégrité des données l'accesseur en modification comporte souvent des contrôles qui permettent de valider la nouvelle valeur de la variable. Classe plus sécurisée

Modificateur « static » Le modificateur «static» peut s'appliquer à une méthode ou un attribut d’une classe. Dans ce cas, l'élément statique est partagé par toutes les instances de la classe. On dit que l’élément est porté par la classe. Il est aussi accessible directement par la classe, sans disposer d’une instance. Exemple: compter le nombre d'objets personnes créées dans une application //attribut static de la classe Personne private static long _nbPersonnes;

Modificateur « static » Une méthode ou un attribut statique ne doit employer pour ses traitements que des méthodes ou attributs statiques. // propriété de classe public static long nbPersonnes{ get{ return _nbPersonnes;} } Cette propriété permet un accèes en lecture seule. En effet, il est préférable de ne pas laisser de possibilité au programmeur de modifier cette variable. La propriété à l'extérieur sera appelée avec la syntaxe: Personne.nbPersonnes

Modificateur « static »  Une nouvelle version de la classe Personne: class Personne { // attributs de classe private static long _nbPersonnes=0; // attributs d'instance private String _nom; private String _societe; // constructeur public personne(String nom, String societe){ _nbPersonnes++; // une personne de plus this._nom=nom; this._societe=societe; } // propriété de classe public static long nbPersonnes{ get{ return _nbPersonnes;} } // propriétés d’instance…… }

Notion de signature la signature d’un constructeur ou d’une méthode comprend son identificateur, la liste et les types de ses paramètres. Le compilateur détermine la méthode à exécuter en fonction de sa signature. Des méthodes différentes peuvent porter le même nom, à partir du moment où leurs signatures diffèrent.

Notion de signature Pour le compilateur, il n'y a pas d'ambiguïté entre deux constructeurs. Ainsi, l’exécution de : new Personne(" Ahmed", "Microsoft"); fait appel au constructeur Public personne(String nom,String société) { This.societe=societe; This.nom=nom; } car celui-ci utilise deux chaînes en paramètre. Et l’exécution de : new Personne("Meunier"); fait appel au constructeur: Public personne(String nom) { This.nom=nom; }

ToString() En C#, chaque classe hérite implicitement de la classe Object. Par conséquent, chaque objet en C# obtient la méthode ToString (définit dans la classe Object), qui retourne une représentation sous forme de chaîne de cet objet. Par exemple, toutes les variables de type int ont une méthode ToString qui leur permet de retourner leur contenu sous la forme d'une chaîne : int x = 42; string strx = x.ToString(); Console.WriteLine(strx); Déclaration de la méthode ToString(): public override string ToString(){}

ToString() Implémentation de la méthode ToString(): class Personne { public string Nom{ get; set; } public string Societe { get; set; } Public personne(String nom,String société) { This.societe=societe; This.nom=nom; } public override string ToString() { return "Personne: " + Nom+ " " + Société; } } Tester la méthode: Personne p = new Personne(“Ahmed”,”ISMONTIC”); Console.WriteLine(p); //l’appel de la méthode ToString() // Personne: Ahmed ISMONTIC

Thank you! Programmation Orientée Objet C#