Polymorphisme et abstraction

Namespaces et transmission

Imaginez que vous avez créé une classe appelée Person dans le namespace appelé People comme suit :

using System;

namespace People
{
    public class Person
    {
	private string _name;
	private string _gdr;

	public Person()
	{
	    this._name = "Not Available";
	    this._gdr  = "Unknown";
	}

	public Person(string name, string gender)
	{
	    this._name = name;
	    this._gdr  = gender;
	}

	private string FullName
	{
	    get { return _name; }
	    set { _name = value; }
	}

	private string Gender
	{
	    get { return _gdr; }
	    set { _gdr = value; }
	}
    }
}

Si vous décidez de dériver une classe à partir d'elle, rappelez vous que cette classe appartient à un namespace. Pour transmettre cette classe, le compilateur devra connaître le namespace dans lequel la classe a été créée. La transmission de classe qui implique des namespaces compte sur la qualification, de la même manière que appeler les membres d'un namespace. Pour dériver une classe d'une classe membre d'un namespace, dactylographiez le nom du namespace, suivi de l'opérateur point « .  », et suivi du nom du namespace de base. Voici un exemple :

using System;

namespace HighSchool
{
	public class Teacher : People.Person
	{
		private string _pos;

		public Teacher()
		{
			this._pos = "Staff Member";
		}

		public Teacher(string pos)
		{
			this._pos     = pos;
		}

		private string Position
		{
			get { return _pos; }
			set { _pos = value; }
		}
	}
}

Si vous devez appeler la classe qui a été définie dans un namespace différent, rappelez vous de qualifier son nom avec l'opérateur Point. Voici un exemple :

using System;

class Exercise
{
    static void Main()
    {
	People.Person man = new People.Person("Hermine Sandt", "Male");
	HighSchool.Teacher staff = new HighSchool.Teacher("Vice Principal");

	Console.WriteLine();
    }
}

Alternativement, pour utiliser le contenu d'un namespace, avant d'appeler un membre de ce namespace, vous pouvez dactylographier le mot-clé using suivi du nom du namespace. Voici un exemple :

using System;
using People;
using HighSchool;

class Exercise
{
	static void Main()
	{
		Person man = new Person("Hermine Sandt", "Male");
		Teacher staff = new Teacher("Vice Principal");

		Console.WriteLine();
	}
}

1. Commencez Microsoft Visual C# Express Edition et créer une application de console appelée Geometry1
2. Pour créer une nouvelle classe, sur le menu principal, cliquez projet  - > Ajouter la classe…
3. Placez le nom Square et appuyez Enter
4. Changez le fichier comme suit :
    

   using System; namespace Geometry2 { public class Square { private double _side; public Square() { _side = 0.00; } public Square(double s) { _side = s; } } }

5. Pour créer une nouvelle classe, sur le menu principal, cliquez projet - > Ajouter la classe…
6. Placez le nom Rectangle et appuyez Enter
7. Changez le fichier comme suit :
    

   using System; namespace Geometry2 { public class Rectangle { double _length; double _height; public Rectangle() { _length = 0.00; _height = 0.00; } public Rectangle(double L, double H) { _length = L; _height = H; } } }

8. Sauvegardez tout

Pour maintenir un rapport privilégié avec ses classes filles, une classe parent peut constituer une liste de l'ensemble des membres disponible seulement aux classes dérivées à partir d'elle. Avec ce rapport, quelques membres de la classe parent ont un niveau d'accès protégé. Naturellement, en tant que créateur de classe, c'est votre travail de spécifier ce rapport.

Pour créer un membre dont seules les classes dérivées peuvent accéder, dactylographiez le mot-clé protected à sa gauche. Voici les exemples :

using System;

namespace People
{
	public class Person
	{
		private string _name;
		private string _gdr;

		public Person()
		{
			this._name = "Not Available";
			this._gdr    = "Unknown";
		}
		public Person(string name, string gender)
		{
			this._name = name;
			this._gdr  = gender;
		}

		protected string FullName
		{
			get { return _name; }
			set { _name = value; }
		}

		protected string Gender
		{
			get { return _gdr; }
			set { _gdr = value; }
		}
		
		public void Show()
		{
			Console.WriteLine("Full Name: {0}", this.FullName);
			Console.WriteLine("Gender:    {0}", this.Gender);
		}
	}
}

Vous pouvez accéder aux membres protégés seulement dans les classes dérivées. Par conséquent, si vous instanciez une classe en dehors, vous pouvez appeler seulement les membres publics :

Fichier source : Exercise.cs

using System; class Exercise { static void Main() { People.Person man = new People.Person("Hermine Sandt", "Male"); Console.WriteLine("Staff Member"); man.Show(); Console.WriteLine(); } }

Ceci produirait :

Staff Member
Full Name: Hermine Sandt
Gender:     Male

Nous venons juste de mentionner que vous pouvez créer une nouvelle version d'un membre dans une classe dérivée pour un membre qui existe déjà dans la classe parent. Après avoir fait ceci, quand vous appelez ce membre dans votre programme, vous devez vous assurer que c'est le bon membre qui est appelé, le membre dans la classe de basse ou le membre équivalent dans la classe dérivée. Quand vous créez une classe de basse, si vous prévoyez qu'une certaine propriété ou méthode devrait être redéfinie dans la classe dérivée, vous pouvez indiquer ceci au compilateur. D'une part, tout en créant vos classes, si vous découvrez que vous avez personnaliser une propriété de la méthode qui a déjà existé dans la classe de basse, vous devriez faire savoir au compilateur que vous avez fourni une nouvelle version. Dans les deux cas, le membre commun devrait être créé comme virtuel. Pour créer un membre virtuel, dans la classe de basse, dactylographiez le mot-clé virtual à gauche de la propriété ou de la méthode. Basé sur ceci, la propriété Area (Aire) de notre classe Circle (Cercle) peut être créée comme suit :

class Circle
{
    public virtual double Area
    {
	get
	{
	    return Radius * Radius * 3.14159;
	}
    }
}

En fait, dans C#, à la différence de C++, si vous omettez le mot-clé virtual, le compilateur afficherait un avertissement.

Quand vous dérivez une classe d'une classe abstraite, tant que les méthodes (s'il y en a) de la classe abstraite n'ont pas été mises en application, vous devez mettre chacune d'elles en application dans la classe dérivée. En personnalisant les membres virtuels dans une classe dérivée, pour indiquer qu'un membre est déjà virtuel dans la classe de basse et que vous avez défini une nouvelle version, dactylographiez le mot-clé override à la gauche de sa déclaration. Par exemple, la propriété Area dans notre classe Circle peut être créée comme suit :

class Sphere : Circle
{
    public override double  Area
    {
	get
	{
	    return 4 * Radius * Radius * 3.14159;
	}
    }

    public double Volume
    {
	get
	{
	    return 4 * 3.14159 * Radius * Radius * Radius;
	}
    }
}

De la même manière, quand vous appliquez une méthode abstraite d'une classe, dactylographiez le mot-clé de override à sa gauche.

1. Pour créer une nouvelle classe, sur le menu principal, cliquez projet - > Ajouter la classe…
2. Placez le nom ShapeDescription et appuyez sur Enter
3. Changez le fichier comme suit :
    

   using System; namespace Geometry2 { public class ShapeDescription { public virtual string Description() { string Msg = "A quadrilateral is a geometric figure " + "that has four sides and four angles."; return Msg; } } }

4. Sauvegardez le fichier comme Quadrilaterals.cs dans le dossier Shapes1
5. Accédez au fichier Square.cs et changez la méthode Description comme suit :
    

   using System; namespace Geometry2 { public class Square : ShapeDescription { private double _side; public Square() { _side = 0.00; } public Square(double s) { _side = s; } public override string Description() { // Get the introduction from the parent string Introduction = base.Description() + "\nA square is a quadrilateral that has four " + "equal sides and four right angles"; return Introduction; } } }

6. Accédez au fichier Rectangle.cs et changez le comme suit :
    

   using System; namespace Geometry2 { public class Rectangle : ShapeDescription { double _length; double _height; public Rectangle() { _length = 0.00; _height = 0.00; } public Rectangle(double L, double H) { _length = L; _height = H; } public override string Description() { // Get the introduction from the parent string Introduction = base.Description(); string Msg = Introduction + "\nA rectangle is a quadrilateral that has adjacent " + "perpendicular sides. This implies that its four " + "angles are right."; return Msg; } } }

7. Access au fichier Program.cs et changez le comme suit :
    

   using System; class Exercise { static void DisplaySquare(Square S) { Console.WriteLine("Square Characteristics"); Console.WriteLine("Description: {0}", S.Description()); } static void DisplayRectangle(Rectangle R) { Console.WriteLine("Rectangle Characteristics"); Console.WriteLine("Description: {0}", R.Description()); } static void Main() { Square Sq = new Square(); Rectangle Rect = new Rectangle(); Console.WriteLine("========================================"); DisplaySquare(Sq); Console.WriteLine("========================================"); DisplayRectangle(Rect); Console.WriteLine("========================================"); Console.WriteLine(); } }

8. Exécuterzle projet. Ceci produirait :
    

   ======================================== Square Characteristics Description: A quadrilateral is a geometric figure that has four sides and four angles.A square is a quadrilateral that has four equal sides and four right angles ======================================== Rectangle Characteristics Description: A quadrilateral is a geometric figure that has four sides and four angles. A rectangle is a quadrilateral that has adjacent perpendicular sides. This implies that its four angles are right. ========================================

9. Fermez la fenêtre DOS

Dans un programme, vous pouvez créer une classe censée avoir pour unique rôle de fournir des caractéristiques fondamentales pour d'autres classes. Ce type de classe ne peut pas être utilisé pour déclarer une variable. Une telle classe est désignée sous le nom de classe abstraite. Par conséquent, une classe abstraite peut être créée pour servir seulement de classe parent à d'autres classes.

Pour créer une classe abstraite, dactylographiez le mot-clé abstract à gauche de son nom. Voici un exemple :

abstract class Ball
{
	protected int TypeOfSport;
	protected string Dimensions;
}

1. Pour créer une classe abstraite, accédez au fichier ShapeDescription.cs et le changer comme suit :
    

   using System; namespace Geometry2 { public abstract class ShapeDescription { public virtual string Description() { string Msg = "A quadrilateral is a geometric figure " + "that has four sides and four angles."; return Msg; } } }

2. sauvegardez le fichier

En créant une classe qui serait principalement utilisée comme base pour une future transmission, vous pouvez créer une ou plusieurs propriétés et les rendre abstraites. Pour ce faire, en créant la propriété, dactylographiez le mot-clé abstract à sa gauche. Puisque vous ne définirez pas la propriété, vous pouvez simplement dactylographier le mot-clé get et son point-virgule dans le corps de la propriété.

Une méthode de classe peut également être rendue abstraite. Une méthode abstraite peut être seulement un membre d'une classe abstraite. Si vous créez une méthode abstraite dans une classe, vous ne devez pas appliquer la méthode. Pour créer une méthode abstraite, en créant sa classe, dactylographiez le mot-clé abstract à gauche du nom de la méthode. finissez la déclaration avec un point-virgule et aucun corps pour méthode puisque vous ne pouvez pas la mettre en application. Voici un exemple :

public abstract class Ball
{
    protected int TypeOfSport;
    protected string Dimensions;

    public abstract CalculateArea();
}

De la même manière, vous pouvez créer autant de propriétés et méthodes tant que vous voulez. Vous pouvez choisir quelles propriétés et méthodes rendre abstraites. C'est important pour la transmission.

1. Pour créer une propriété abstraite, accédez au fichier ShapeDescription.cs et changez sa classe comme suit :
    

   using System; namespace Geometry2 { public abstract class ShapeDescription { public abstract string Name { get; } public virtual string Description() { string Msg = "A quadrilateral is a geometric figure " + "that has four sides and four angles."; return Msg; } } }

2. Accédez au fichier Square.cs et le changer comme suit :
    

   using System; namespace Geometry2 { public class Square : ShapeDescription { private double _side; public Square() { _side = 0.00; } public Square(double s) { _side = s; } public override string Name { get { return "Square"; } } public override string Description() { // Get the introduction from the parent string Introduction = base.Description() + "\nA square is a quadrilateral that has four " + "equal sides and four right angles"; return Introduction; } } }

    

   Accédez au fichier Rectangle.cs et le changer comme suit :
    

   using System; namespace Geometry2 { public class Rectangle : ShapeDescription { double _length; double _height; public Rectangle() { _length = 0.00; _height = 0.00; } public Rectangle(double L, double H) { _length = L; _height = H; } public override string Name { get { return "Rectangle"; } } public override string Description() { // Get the introduction from the parent string Introduction = base.Description(); string Msg = Introduction + "\nA rectangle is a quadrilateral that has adjacent " + "perpendicular sides. This implies that its four " + "angles are right."; return Msg; } } }

3. Accédez au dossier Program.cs et le changer comme suit :
    

   using System; namespace Geometry2 { public class Program { static void DisplaySquare(Square S) { Console.WriteLine("Square Characteristics"); Console.WriteLine("Name: {0}", S.Name); Console.WriteLine("Description: {0}", S.Description()); } static void DisplayRectangle(Rectangle R) { Console.WriteLine("Rectangle Characteristics"); Console.WriteLine("Name: {0}", R.Name); Console.WriteLine("Description: {0}", R.Description()); } static void Main() { FlatShapes.Square Sq = new FlatShapes.Square(); FlatShapes.Rectangle Rect = new FlatShapes.Rectangle(); Console.WriteLine("========================================"); DisplaySquare(Sq); Console.WriteLine("========================================"); DisplayRectangle(Rect); Console.WriteLine("========================================"); Console.WriteLine(); } } }

4. Exécutez le projet. Ceci produirait :
    

   ======================================== Square Characteristics Name: Square Description: A quadrilateral is a geometric figure that has four sides and four angles. A square is a quadrilateral that has four equal sides and four right angles ======================================== Rectangle Characteristics Name: Rectangle Description: A quadrilateral is a geometric figure that has four sides and four angles. A rectangle is a quadrilateral that has adjacent perpendicular sides. This implies that its four angles are right. ========================================

5. Fermez la fenêtre DOS

Chacune des classes que nous avons utilisées jusqu'ici dans nos leçons peuvent être transmises. Si vous créez une certaine classe et ne voulez pas que quiconque dérive une autre classe d'elle, vous pouvez la marquer comme scellée. En d'autres termes, une classe scellée est une classe qui ne peut pas servir de base à une autre classe.

Pour marquer une classe comme scellée, dactylographiez le mot-clé sealed à gauche du mot-clé class. Voici un exemple :

public sealed class Ball
{
	public int TypeOfSport;
	public string Dimensions;
}

Il n'y a pas grand chose à dire au sujet d'une classe scellée. Rappelez vous simplement qu'aucune classe ne peut être dérivée d'elle.