|
Si vous étiez invité à créer une classe pour
représenter ces boules, vous pouvez être tenté de mettre en
application une classe générale qui définit chaque boule. Ceci peut
être une mauvaise idée parce que, en dépit de leur ressemblance
ronde, il y a beaucoup de différences internes parmi ces boules. Les
langages de programmation comme C# fournissent une solution alternative
à ce type de situation.
La transmission consiste à créer une classe dont
la définition
ou le comportement principal est basé sur une autre classe. En d'autres
termes, la transmission commence en ayant une classe qui peut fournir un
comportement sur lequel d'autres classes peuvent s'améliorer.
- Commencez Microsoft Visual C# et créez une nouvelle application
de console appelée RealEstate4
- Pour créer une nouvelle classe, dans Affichage de classe,
droit-cliquez
le nom du projet, placez la souris sur Ajouter et cliquez classe…
- Place le nom propriété et lappuyez Enter
- Changez le fichier comme suit :
using System;
namespace RealEstate2
{
public enum PropertyCondition
{
Unknown,
Excellent,
Good,
NeedsRepair,
BadShape
}
public class Property
{
private string propNbr;
private PropertyCondition cond;
private int beds;
private float baths;
private int yr;
private decimal val;
public Property()
{
}
public string PropertyNumber
{
get { return propNbr; }
set
{
if (propNbr == "")
propNbr = "N/A";
else
propNbr = value;
}
}
public PropertyCondition Condition
{
get { return cond; }
set { cond = value; }
}
public int Bedrooms
{
get
{
if (beds <= 1)
return 1;
else
return beds;
}
set { beds = value; }
}
public float Bathrooms
{
get { return baths; }
set { baths = value; }
}
public int YearBuilt
{
get { return yr; }
set { yr = value; }
}
public decimal Value
{
get { return val; }
set { val = value; }
}
}
}
|
- Pour créer une nouvelle classe, dans Explorateur de solution,
droit-cliquez le nom du projet, placez la souris sur Ajouter
et cliquez classe…
- Placez le nom PropertyListing et appuyez Enter
- Changez le fichier comme suit :
using System;
namespace RealEstate2
{
public enum PropertyType
{
Unknown,
SingleFamily,
Townhouse,
Condominium
}
public class PropertyListing
{
private Property prop;
private PropertyType tp;
public Property ListProperty
{
get { return prop; }
set { prop = value; }
}
public PropertyType Type
{
get { return tp; }
set { tp = value; }
}
public PropertyListing()
{
prop = new Property();
}
public void CreateListing()
{
Console.WriteLine(" =//= Altair Realty =//=");
Console.WriteLine("-=- Property Creation -=-");
Console.WriteLine("\nTypes of Properties");
Console.WriteLine("1. Single Family");
Console.WriteLine("2. Townhouse");
Console.WriteLine("3. Condonium");
Console.WriteLine("4. Don't Know");
Console.Write("Enter Type of Property: ");
int propType = int.Parse(Console.ReadLine());
Console.Write("\nEnter Property #: ");
ListProperty.PropertyNumber = Console.ReadLine();
Console.WriteLine("\nProperties Conditions");
Console.WriteLine("1. Excellent");
Console.WriteLine("2. Good (may need minor repair)");
Console.WriteLine("3. Needs Repair");
Console.Write("4. In Bad Shape (property needs ");
Console.WriteLine("major repair or rebuild)");
Console.Write("Enter Property Condition: ");
int condition = int.Parse(Console.ReadLine());
if (condition == 1)
ListProperty.Condition = PropertyCondition.Excellent;
else if (condition == 2)
ListProperty.Condition = PropertyCondition.Good;
else if (condition == 3)
ListProperty.Condition = PropertyCondition.NeedsRepair;
else if (condition == 4)
ListProperty.Condition = PropertyCondition.BadShape;
else
ListProperty.Condition = PropertyCondition.Unknown;
switch ((PropertyType)propType)
{
case PropertyType.SingleFamily:
Type = PropertyType.SingleFamily;
break;
case PropertyType.Townhouse:
Type = PropertyType.Townhouse;
break;
case PropertyType.Condominium:
Type = PropertyType.Condominium;
break;
default:
Type = PropertyType.Unknown;
break;
}
Console.Write("\nHow many bedrooms? ");
ListProperty.Bedrooms = int.Parse(Console.ReadLine());
Console.Write("How many bathrooms? ");
ListProperty.Bathrooms = float.Parse(Console.ReadLine());
Console.Write("Year built: ");
ListProperty.YearBuilt = int.Parse(Console.ReadLine());
Console.Write("Property Value: ");
ListProperty.Value = decimal.Parse(Console.ReadLine());
}
public void ShowProperty()
{
Console.WriteLine("==================================");
Console.WriteLine(" =//=//= Altair Realty =//=//=");
Console.WriteLine("-=-=-=- Properties Listing -=-=-=-");
Console.WriteLine("----------------------------------");
Console.WriteLine("Property #: {0}",
ListProperty.PropertyNumber);
Console.WriteLine("Property Type: {0}", Type);
switch (Type)
{
case PropertyType.SingleFamily:
case PropertyType.Townhouse:
Type = PropertyType.SingleFamily;
break;
case PropertyType.Condominium:
break;
}
Console.WriteLine("Condition: {0}",
ListProperty.Condition);
Console.WriteLine("Bedrooms: {0}",
ListProperty.Bedrooms);
Console.WriteLine("Bathrooms: {0}",
ListProperty.Bathrooms);
Console.WriteLine("Year Built: {0}",
ListProperty.YearBuilt);
Console.WriteLine("Market Value: {0:C}",
ListProperty.Value);
Console.WriteLine("==================================");
}
}
}
|
- Accédez au fichier Program.cs et changez le comme suit :
using System;
namespace RealEstate2
{
class Program
{
static void Main()
{
PropertyListing listing = new PropertyListing();
listing.CreateListing();
Console.WriteLine("\n");
listing.ShowProperty();
Console.WriteLine();
}
}
}
|
- Exécutez l'application et l'examiner. Voici un exemple :
=//= Altair Realty =//=
-=- Property Creation -=-
Types of Properties
1. Single Family
2. Townhouse
3. Condominium
4. Don't Know
Enter Type of Property: 2
Enter Property #: 66DG8P
Properties Conditions
1. Excellent
2. Good (may need minor repair)
3. Needs Repair
4. In Bad Shape (property needs major repair or rebuild)
Enter Property Condition: 2
How many bedrooms? 2
How many bathrooms? 1.0
Year built: 1994
Property Value: 325880.75
==================================
=//=//= Altair Realty =//=//=
-=-=-=- Properties Listing -=-=-=-
----------------------------------
Property #: 66DG8P
Property Type: Townhouse
Condition: Good
Bedrooms: 2
Bathrooms: 1
Year Built: 1994
Market Value: $325,880.75
==================================
Press any key to continue . . .
|
- Fermez la fenêtre DOS
Comme vous avez pu deviné, afin de mettre en
application la transmission, vous devez d'abord avoir une classe qui
fournit la définition ou le comportement fondamentale dont vous avez
besoin. Il n'y a rien de magique au sujet d'une telle classe. Il pourrait
apparaître exactement comme n'importe laquelle des classes que nous avons
utilisées jusqu'ici. Voici un exemple :
using System;
class Circle
{
private double _radius;
public double Radius
{
get
{
return _radius;
}
set
{
if( _radius < 0 )
_radius = 0.00;
else
_radius = value;
}
}
public double Diameter
{
get
{
return Radius * 2;
}
}
public double Circumference
{
get
{
return Diameter * 3.14159;
}
}
public double Area
{
get
{
return Radius * Radius * 3.14159;
}
}
}
|
 |
class Exercise
{
public static int Main()
{
Circle c = new Circle();
c.Radius = 25.55;
Console.WriteLine("Circle Characteristics");
Console.WriteLine("Side: {0}", c.Radius);
Console.WriteLine("Diameter: {0}", c.Diameter);
Console.WriteLine("Circumference: {0}", c.Circumference);
Console.WriteLine("Area: {0}", c.Area);
return 0;
}
}
Ceci produirait :
Circle Characteristics
Side: 25.55
Diameter: 51.1
Circumference: 160.535249
Area: 2050.837805975
Press any key to continue
La classe ci-dessus est utilisée pour traiter un
cercle. Elle peut demander ou fournir un rayon, alors elle calcule la
circonférence et l'aire. Maintenant, supposer que vous voulez créer
une classe pour une sphère. Vous pourriez commencer à partir du
sommaire comme nous avons fait jusqu'ici. D'une part, puisqu'une sphère est
principalement un cercle à trois dimensions, et si vous avez déjà une classe
pour un cercle, vous pouvez simplement créer votre classe sphère
qui utilise le comportement d'une classe cercle déjà mis en application.
Créant une classe qui est basée sur une autre
classe est désigné également sous le nom de dériver une classe des
autres. La première classe sert de parent ou de base. La classe qui est
basée sur une autre classe est également désigné sous le nom de child
ou est dérivée. Pour créer une classe basée sur d'autres, vous
utilisez la formule suivante :
class NewChild : BaseClass
{
// Body of the new class
}
Dans cette formule, vous commencez par le mot-clé class suivi d'un nom pour votre classe. Du côté
droit du nom
de votre classe, vous devez dactylographier des deux points : , suivi du
nom de la classe qui servira de parent. Naturellement, la classe BaseClass
doit avoir été définie ; c'est-à-dire, le compilateur doit pouvoir
trouver sa définition. Basé sur la formule ci-dessus, vous pouvez créer
une classe sphère basée sur la classe cercle mentionnée
précédement comme suit :
class Sphere : Circle
{
// The class is ready
}
Après dérivation d'une classe, elle devient
disponible et vous pouvez l'utiliser juste comme vous faites pour n'importe quelle
autre classe. Voici un exemple :
using System;
class Circle
{
private double _radius;
public double Radius
{
get
{
if( _radius < 0 )
return 0.00;
else
return _radius;
}
set
{
_radius = value;
}
}
public double Diameter
{
get
{
return Radius * 2;
}
}
public double Circumference
{
get
{
return Diameter * 3.14159;
}
}
public double Area
{
get
{
return Radius * Radius * 3.14159;
}
}
}
class Sphere : Circle
{
}
class Exercise
{
public static int Main()
{
Circle c = new Circle();
c.Radius = 25.55;
Console.WriteLine("Circle Characteristics");
Console.WriteLine("Side: {0}", c.Radius);
Console.WriteLine("Diameter: {0}", c.Diameter);
Console.WriteLine("Circumference: {0}", c.Circumference);
Console.WriteLine("Area: {0}", c.Area);
Sphere s = new Sphere();
s.Radius = 25.55;
Console.WriteLine("\nSphere Characteristics");
Console.WriteLine("Side: {0}", s.Radius);
Console.WriteLine("Diameter: {0}", s.Diameter);
Console.WriteLine("Circumference: {0}", s.Circumference);
Console.WriteLine("Area: {0}", s.Area);
return 0;
}
}
Ceci produirait :
Circle Characteristics
Side: 25.55
Diameter: 51.1
Circumference: 160.535249
Area: 2050.837805975
Sphere Characteristics
Side: 25.55
Diameter: 51.1
Circumference: 160.535249
Area: 2050.837805975
Press any key to continue
Quand une classe est basée sur une autre classe,
tous les (nous présenterons également un autre mot-clé transmission
orienté pour cette question) membres publics de la classe parent sont rendus disponibles à la classe dérivée qui peut les
utiliser aussi facilement. Tandis que d'autres méthodes et
classes peuvent également utiliser les membres publics d'une classe, la
différence est que, la classe dérivée peut appeler les membres publics
du parent comme si ils ont appartenu à la classe dérivée. C'est-à-dire,
la classe child ne doit pas « qualifier » les membres
publics de la classe parent quand ces membres publics sont utilisés dans le corps de la classe dérivée. Ceci est illustré dans le
programme suivant :
using System;
class Circle
{
private double _radius;
public double Radius
{
get
{
if( _radius < 0 )
return 0.00;
else
return _radius;
}
set
{
_radius = value;
}
}
public double Diameter
{
get
{
return Radius * 2;
}
}
public double Circumference
{
get
{
return Diameter * 3.14159;
}
}
public double Area
{
get
{
return Radius * Radius * 3.14159;
}
}
public void ShowCharacteristics()
{
Console.WriteLine("Circle Characteristics");
Console.WriteLine("Side: {0}", Radius);
Console.WriteLine("Diameter: {0}", Diameter);
Console.WriteLine("Circumference: {0}", Circumference);
Console.WriteLine("Area: {0}", Area);
}
}
class Sphere : Circle
{
public void ShowCharacteristics()
{
// Because Sphere is based on Circle, you can access
// any public member(s) of Circle without qualifying it(them)
Console.WriteLine("\nSphere Characteristics");
Console.WriteLine("Side: {0}", Radius);
Console.WriteLine("Diameter: {0}", Diameter);
Console.WriteLine("Circumference: {0}", Circumference);
Console.WriteLine("Area: {0}\n", Area);
}
}
class Exercise
{
public static int Main()
{
Circle c = new Circle();
c.Radius = 25.55;
c.ShowCharacteristics();
Sphere s = new Sphere();
s.Radius = 25.55;
s.ShowCharacteristics();
return 0;
}
}
Ceci produirait le même résultat.
- Sur le menu principal, cliquez projet - > Ajouter - >
classe…
- Placez le nom HouseType et appuyez Enter
- Pour dériver une classe, changez le fichier comme suit :
using System;
namespace RealEstate2
{
public class HouseType : Property
{
private int nbrOfStories;
private bool basement;
private bool garage;
public int Stories
{
get { return nbrOfStories; }
set { nbrOfStories = value; }
}
public bool FinishedBasement
{
get { return basement; }
set { basement = value; }
}
public bool IndoorGarage
{
get { return garage; }
set { garage = value; }
}
}
}
|
- Sur le menu principal, cliquez projet - > Ajouter - >
classe…
- Placer le nom condominium et appuyez Enter
- Pour créer une autre classe basée sur la classe propriété,
changez le fichier comme suit :
using System;
namespace RealEstate2
{
public class Condominium : Property
{
private bool handicap;
public bool HandicapAccessible
{
get { return handicap; }
set { handicap = value; }
}
}
}
|
- Accédez au fichier PropertyListing.cs et changez le comme suit :
using System;
namespace RealEstate2
{
public enum PropertyType
{
Unknown,
SingleFamily,
Townhouse,
Condominium
}
class PropertyListing
{
private Property prop;
private HouseType hse;
private Condominium cond;
private PropertyType tp;
public Property ListProperty
{
get { return prop; }
set { prop = value; }
}
public HouseType House
{
get { return hse; }
set { hse = value; }
}
public Condominium Condo
{
get { return cond; }
set { cond = value; }
}
public PropertyType Type
{
get { return tp; }
set { tp = value; }
}
public PropertyListing()
{
prop = new Property();
hse = new HouseType();
cond = new Condominium();
}
public void CreateListing()
{
char answer;
Console.WriteLine(" =//= Altair Realty =//=");
Console.WriteLine("-=- Property Creation -=-");
Console.WriteLine("\nTypes of Properties");
Console.WriteLine("1. Single Family");
Console.WriteLine("2. Townhouse");
Console.WriteLine("3. Condonium");
Console.WriteLine("4. Don't Know");
Console.Write("Enter Type of Property: ");
int propType = int.Parse(Console.ReadLine());
Console.Write("\nEnter Property #: ");
ListProperty.PropertyNumber = Console.ReadLine();
Console.WriteLine("\nProperties Conditions");
Console.WriteLine("1. Excellent");
Console.WriteLine("2. Good (may need minor repair)");
Console.WriteLine("3. Needs Repair");
Console.Write("4. In Bad Shape (property needs ");
Console.WriteLine("major repair or rebuild)");
Console.Write("Enter Property Condition: ");
int condition = int.Parse(Console.ReadLine());
if (condition == 1)
ListProperty.Condition = PropertyCondition.Excellent;
else if (condition == 2)
ListProperty.Condition = PropertyCondition.Good;
else if (condition == 3)
ListProperty.Condition = PropertyCondition.NeedsRepair;
else if (condition == 4)
ListProperty.Condition = PropertyCondition.BadShape;
else
ListProperty.Condition = PropertyCondition.Unknown;
switch ((PropertyType)propType)
{
case PropertyType.SingleFamily:
Type = PropertyType.SingleFamily;
Console.Write("\nHow many stories (levels)? ");
House.Stories = int.Parse(Console.ReadLine());
Console.Write("Does it have an indoor car garage (y/n): ");
answer = char.Parse(Console.ReadLine());
if ((answer == 'y') || (answer == 'Y'))
House.IndoorGarage = true;
else
House.IndoorGarage = false;
Console.Write("Is the basement finished(y/n): ");
answer = char.Parse(Console.ReadLine());
if ((answer == 'y') || (answer == 'Y'))
House.FinishedBasement = true;
else
House.FinishedBasement = false;
break;
case PropertyType.Townhouse:
Type = PropertyType.Townhouse;
Console.Write("\nHow many stories (levels)? ");
House.Stories = int.Parse(Console.ReadLine());
Console.Write("Does it have an indoor car garage (y/n): ");
answer = char.Parse(Console.ReadLine());
if ((answer == 'y') || (answer == 'Y'))
House.IndoorGarage = true;
else
House.IndoorGarage = false;
Console.Write("Is the basement finished(y/n): ");
answer = char.Parse(Console.ReadLine());
if ((answer == 'y') || (answer == 'Y'))
House.FinishedBasement = true;
else
House.FinishedBasement = false;
break;
case PropertyType.Condominium:
Type = PropertyType.Condominium;
Console.Write("\nIs the building accessible to handicapped (y/n): ");
answer = char.Parse(Console.ReadLine());
if ((answer == 'y') || (answer == 'Y'))
Condo.HandicapAccessible = true;
else
Condo.HandicapAccessible = false;
break;
default:
Type = PropertyType.Unknown;
break;
}
Console.Write("\nHow many bedrooms? ");
ListProperty.Bedrooms = int.Parse(Console.ReadLine());
Console.Write("How many bathrooms? ");
ListProperty.Bathrooms = float.Parse(Console.ReadLine());
Console.Write("Year built: ");
ListProperty.YearBuilt = int.Parse(Console.ReadLine());
Console.Write("Property Value: ");
ListProperty.Value = decimal.Parse(Console.ReadLine());
}
public void ShowProperty()
{
Console.WriteLine("==================================");
Console.WriteLine(" =//=//= Altair Realty =//=//=");
Console.WriteLine("-=-=-=- Properties Listing -=-=-=-");
Console.WriteLine("----------------------------------");
Console.WriteLine("Property #: {0}",
ListProperty.PropertyNumber);
Console.WriteLine("Property Type: {0}", Type);
switch(Type)
{
case PropertyType.SingleFamily:
case PropertyType.Townhouse:
Type = PropertyType.SingleFamily;
Console.WriteLine("Stories: {0}",
House.Stories);
Console.WriteLine("Has Indoor Car Garage: {0}",
House.IndoorGarage);
Console.WriteLine("Finished Basement: {0}",
House.FinishedBasement);
break;
case PropertyType.Condominium:
Console.WriteLine("Handicapped Accessible Building: {0}",
Condo.HandicapAccessible);
break;
}
Console.WriteLine("Condition: {0}", ListProperty.Condition);
Console.WriteLine("Bedrooms: {0}", ListProperty.Bedrooms);
Console.WriteLine("Bathrooms: {0}", ListProperty.Bathrooms);
Console.WriteLine("Year Built: {0}", ListProperty.YearBuilt);
Console.WriteLine("Market Value: {0:C}", ListProperty.Value);
}
}
}
|
- Exécutez l'application et l'examiner. Voici un exemple :
=//= Altair Realty =//=
-=- Property Creation -=-
Types of Properties
1. Single Family
2. Townhouse
3. Condonium
4. Don't Know
Enter Type of Property: 1
Enter Property #: 4LP804
Properties Conditions
1. Excellent
2. Good (may need minor repair)
3. Needs Repair
4. In Bad Shape (property needs major repair or rebuild)
Enter Property Condition: 3
How many stories (levels)? 3
Does it have an indoor car garage (y/n): y
Is the basement finished(y/n): n
How many bedrooms? 4
How many bathrooms? 2.5
Year built: 1996
Property Value: 640885.80
==================================
=//=//= Altair Realty =//=//=
-=-=-=- Properties Listing -=-=-=-
----------------------------------
Property #: 4LP804
Property Type: SingleFamily
Stories: 3
Has Indoor Car Garage: True
Finished Basement: False
Condition: NeedsRepair
Bedrooms: 4
Bathrooms: 2.5
Year Built: 1996
Market Value: $640,885.80
Press any key to continue . . .
|
- Revenez au bloc-notes
Vous pouvez noter dans l'exemple ci-dessus que la
classe dérivée produit les mêmes résultats que la classe de base. En réalité,
la transmission est utilisée pour résoudre les divers problèmes
de Programmation d'Objects Orientés (POO). L'un d'entre eux consiste à
personnaliser ou améliorer le comportement
d'un dispositif (propriété ou méthode, etc.) de la classe parent.
Par exemple, bien que le cercle et la sphère aient une aire, leurs
aires ne sont pas identiques. Un cercle est une surface plane mais
une sphère est un volume, qui rend son aire beaucoup plus grande.
Puisqu'elles utilisent des formules différentes pour leurs aires respectifs, vous devriez mettre en application une nouvelle version
de l'aire dans la sphère. Basé sur ceci, en dérivant votre classe d'une
autre classe, vous devriez vous rendre compte des propriétés et des méthodes
de la classe de base de sorte que, si vous savez que la classe parent a un
certain comportement ou une caractéristique qui n'est pas conforme à la nouvelle classe dérivée, vous pouvez faire quelque
chose à ce sujet. Une nouvelle version de l'aire dans la sphère peut
être calculée comme suit :
using System;
class Circle
{
private double _radius;
public double Radius
{
get
{
if( _radius < 0 )
return 0.00;
else
return _radius;
}
set
{
_radius = value;
}
}
public double Diameter
{
get
{
return Radius * 2;
}
}
public double Circumference
{
get
{
return Diameter * 3.14159;
}
}
public double Area
{
get
{
return Radius * Radius * 3.14159;
}
}
}
class Sphere : Circle
{
public double Area
{
get
{
return 4 * Radius * Radius * 3.14159;
}
}
}
class Exercise
{
public static int Main()
{
Circle c = new Circle();
c.Radius = 25.55;
Console.WriteLine("Circle Characteristics");
Console.WriteLine("Side: {0}", c.Radius);
Console.WriteLine("Diameter: {0}", c.Diameter);
Console.WriteLine("Circumference: {0}", c.Circumference);
Console.WriteLine("Area: {0}", c.Area);
Sphere s = new Sphere();
s.Radius = 25.55;
Console.WriteLine("\nSphere Characteristics");
Console.WriteLine("Side: {0}", s.Radius);
Console.WriteLine("Diameter: {0}", s.Diameter);
Console.WriteLine("Circumference: {0}", s.Circumference);
Console.WriteLine("Area: {0}", s.Area);
return 0;
}
}
Ceci produirait :
Circle Characteristics
Side: 25.55
Diameter: 51.1
Circumference: 160.535249
Area: 2050.837805975
Sphere Characteristics
Side: 25.55
Diameter: 51.1
Circumference: 160.535249
Area: 8203.3512239
Press any key to continue
Notez que, cette fois, les aires des deux figures
ne sont pas identiques quoique leurs rayons soient identiques.
En plus de personnaliser les variables membre et les méthodes
des classes parent, vous pouvez ajouter
de nouveaux membres comme vous souhaitez. C'est un autre dispositif
valable de la transmission. Dans notre exemple, alors que le cercle est
une forme plane, une sphère a un volume. Dans ce cas-ci, vous pouvez
vouloir calculer le volume d'une sphère comme une nouvelle méthode ou
une propriété de la classe dérivée. Voici un exemple :
using System;
class Circle
{
private double _radius;
public double Radius
{
get
{
if( _radius < 0 )
return 0.00;
else
return _radius;
}
set
{
_radius = value;
}
}
public double Diameter
{
get
{
return Radius * 2;
}
}
public double Circumference
{
get
{
return Diameter * 3.14159;
}
}
public double Area
{
get
{
return Radius * Radius * 3.14159;
}
}
}
class Sphere : Circle
{
public double Area
{
get
{
return 4 * Radius * Radius * 3.14159;
}
}
public double Volume
{
get
{
return 4 * 3.14159 * Radius * Radius * Radius / 3;
}
}
}
class Exercise
{
public static int Main()
{
Circle c = new Circle();
c.Radius = 25.55;
Console.WriteLine("Circle Characteristics");
Console.WriteLine("Side: {0}", c.Radius);
Console.WriteLine("Diameter: {0}", c.Diameter);
Console.WriteLine("Circumference: {0}", c.Circumference);
Console.WriteLine("Area: {0}", c.Area);
Sphere s = new Sphere();
s.Radius = 25.55;
Console.WriteLine("\nSphere Characteristics");
Console.WriteLine("Side: {0}", s.Radius);
Console.WriteLine("Diameter: {0}", s.Diameter);
Console.WriteLine("Circumference: {0}", s.Circumference);
Console.WriteLine("Area: {0}", s.Area);
Console.WriteLine("Volume: {0}\n", s.Volume);
return 0;
}
}
Ceci produirait :
Circle Characteristics
Side: 25.55
Diameter: 51.1
Circumference: 160.535249
Area: 2050.837805975
Sphere Characteristics
Side: 25.55
Diameter: 51.1
Circumference: 160.535249
Area: 8203.3512239
Volume: 209595.623770645
Press any key to continue
Si vous créez une propriété ou
une méthode dans une classe dérivée et cette propriété ou cette méthode
existe déjà dans la classe parent, quand vous accédez à la propriété
ou à la méthode dans la classe dérivée, vous devez vous assurer d'indiquer
quel membre vous accédez. Pour rendre ce possible, le langage C# fournit le mot-clé base. Pour accéder à une propriété
ou à une méthode de la classe parent dans la classe dérivée,
dactylographiez le mot-clé base, suivi de l'opérateur point (.),
suivi du nom de la propriété ou de la méthode de la classe de base.
Imaginez que vous créer une classe utilisée pour
traiter un cercle comme nous avons vu plus tôt. Vous pouvez utiliser ceci comme classe
de base pour une sphère. Le cercle et la sphère ont une aire mais leurs valeurs sont différentes. Ceci signifie cela, comme
mentionné dans notre introduction à la transmission, en dérivant la
classe sphère, vous devriez calculer une nouvelle aire pour la sphère.
Si vous créez ou déclarez un nouveau membre dans
une classe dérivée et ce membre a le même nom qu'un membre de la
classe de base, en créant le nouveau membre, vous pouvez vouloir indiquer
au compilateur que, au lieu de d'outrepasser cette même méthode qui a été
définie dans la classe de base, vous voulez créer une version nouvelle et
indépendante de cette méthode. En faisant ceci, vous demanderiez au
compilateur de cacher le membre de la classe de base qui a le même nom,
quand le membre de la classe dérivée est appelé. Pour ce faire,
dactylographiez le mot-clé new à sa gauche. Voici un
exemple :
using System;
class Circle
{
private double _radius;
public double Radius
{
get { return (_radius < 0) ? 0.00 : _radius; }
set { _radius = value; }
}
public double Diameter
{
get { return Radius * 2; }
}
public double Circumference
{
get { return Diameter * 3.14159; }
}
public double Area
{
get { return Radius * Radius * 3.14159; }
}
}
class Sphere : Circle
{
new public double Area
{
get { return 4 * Radius * Radius * 3.14159; }
}
public double Volume
{
get { return 4 * 3.14159 * Radius * Radius * Radius / 3; }
}
}
class Exercise
{
public static int Main()
{
Circle c = new Circle();
c.Radius = 25.55;
Console.WriteLine("Circle Characteristics");
Console.WriteLine("Side: {0}", c.Radius);
Console.WriteLine("Diameter: {0}", c.Diameter);
Console.WriteLine("Circumference: {0}", c.Circumference);
Console.WriteLine("Area: {0}", c.Area);
Sphere s = new Sphere();
s.Radius = 25.55;
Console.WriteLine("\nSphere Characteristics");
Console.WriteLine("Side: {0}", s.Radius);
Console.WriteLine("Diameter: {0}", s.Diameter);
Console.WriteLine("Circumference: {0}", s.Circumference);
Console.WriteLine("Area: {0}", s.Area);
Console.WriteLine("Volume: {0}\n", s.Volume);
return 0;
}
}
|
|
Étude pratique : Présentation de la transmission