void Start()
{
Fruit_polymorphism myApple = new Apple();
_fruits.Add(myApple);
Fruit_polymorphism myRipeApple = new RipeApple();
_fruits.Add(myRipeApple);
// Notice that the Apple version of the methods
// override the fruit versions. Also notice that
// since the Apple versions call the Fruit version with
//t he "base" keyword, both are called.
// Overriding is also useful in a polymorphic situation.
// Since the methods of the Fruit class are "virtual" and
// the methods of the RipeApple class are "override", when we
// upcast an RipeApple into a Fruit, the RipeApple version of the
// Methods are used
foreach (var apple in _fruits)
{
apple.Taste();
}
}
void Start()
{
/*
* Notice here how the variable "myFruit" is of type
* Fruit but is being assigned a reference to an Apple. This
* works because of Polymorphism. Since an Apple is a Fruit,
* this works just fine. While the Apple reference is stored
* in a Fruit variable, it can only be used like a Fruit
*/
Fruit_polymorphism myFruit = new Apple();
myFruit.SayHello();
myFruit.Chop();
/*
* This is called downcasting. The variable "myFruit" which is
* of type Fruit, actually contains a reference to an Apple. Therefore,
* it can safely be turned back into an Apple variable. This allows
* it to be used like an Apple, where before it could only be used
* like a Fruit.
*/
Apple myApple = (Apple)myFruit;
myApple.SayHello();
myApple.Chop();
// Notice how each Humanoid variable contains
// a reference to a different class in the
// inheritance hierarchy, yet each of them
// calls SayHello() method.
// Apple myRipApple = new RipeApple();
Fruit_polymorphism myRipApple = new RipeApple();
myRipApple.SayHello();
}