Introducción
Herencia
En C#, se puede definir una jerarquía de clases mediante la herencia, que permite que una clase derivada (Car) herede el comportamiento y los datos de su clase padre (Vehicle). Si no se especifica ninguna clase padre, la clase hereda de la clase object.
Las clases padre pueden proporcionar funcionalidad a las clases derivadas de tres formas:
- Definir un método normal.
- Definir un método
virtual, que es como un método normal pero que las clases derivadas pueden cambiar.
- Definir un método
abstract, que es un método sin implementación que las clases derivadas deben implementar. Una clase con métodos abstract también debe marcarse como abstract. Las clases abstractas no se pueden instanciar.
El modificador de acceso protected permite acceder a un miembro de la clase padre desde una clase derivada, pero bloquea el acceso desde otras clases.
Las clases derivadas pueden acceder a los miembros de la clase padre mediante la palabra clave base.
// Inherits from the 'object' class
abstract class Vehicle
{
// Can be overridden
public virtual void Drive()
{
}
// Must be overridden
protected abstract int Speed();
}
class Car : Vehicle
{
public override void Drive()
{
// Override virtual method
// Call parent implementation
base.Drive();
}
protected override int Speed()
{
// Implement abstract method
}
}
El constructor de una clase derivada llamará automáticamente al constructor de su clase padre antes de ejecutar la lógica de su propio constructor. Se pueden pasar argumentos al constructor de una clase padre mediante la palabra clave base:
abstract class Vehicle
{
protected Vehicle(int wheels)
{
Console.WriteLine("Called first");
}
}
class Car : Vehicle
{
public Car() : base(4)
{
Console.WriteLine("Called second");
}
}
Cuando se deriva más de una clase de una clase base, esas dos (o más) clases suelen implementar versiones distintas de un método de la clase base. Este es un principio muy importante llamado polimorfismo. Por ejemplo, en una variación del ejemplo anterior mostramos cómo el código que usa Vehicle puede cambiar su comportamiento según el tipo de vehículo que se haya instanciado.
abstract class Vehicle
{
public abstract string GetDescription();
}
class Car : Vehicle
{
public Car()
{
}
public override string GetDescription()
{
return "Runabout";
}
}
class Rig : Vehicle
{
public Rig()
{
}
public override string GetDescription()
{
return "Big Rig";
}
}
Vehicle v1 = new Car();
Vehicle v2 = new Rig();
v1.GetDescription();
// => Runabout
v2.GetDescription();
// => Big Rig
Instrucciones
En este ejercicio juegas a un juego de rol llamado «Wizard and Warriors», que te permite jugar como un mago o como un guerrero.
Hay reglas distintas para los guerreros y los magos a la hora de determinar cuántos puntos de daño infligen.
Para un guerrero, estas son las reglas:
- Inflige 6 puntos de daño si el personaje al que ataca no es vulnerable.
- Inflige 10 puntos de daño si el personaje al que ataca es vulnerable.
Para un mago, estas son las reglas:
- Inflige 12 puntos de daño si el mago ha preparado un hechizo con antelación.
- Inflige 3 puntos de daño si el mago no ha preparado un hechizo con antelación.
Por lo general, los personajes nunca son vulnerables. Sin embargo, los magos sí son vulnerables si no han preparado un hechizo.
Tienes seis tareas que trabajan con personajes guerreros y magos.
1. Describe un personaje
Sobrescribe el método ToString() de la clase Character para que devuelva una descripción del personaje, con el formato "Character is a <CHARACTER_TYPE>".
var warrior = new Warrior();
warrior.ToString();
// => "Character is a Warrior"
Asegúrate de que el método Character.Vulnerable() siempre devuelva false.
var warrior = new Warrior();
warrior.Vulnerable();
// => false
3. Permite que los magos preparen un hechizo
Implementa el método Wizard.PrepareSpell() para permitir que un mago prepare un hechizo con antelación.
var wizard = new Wizard();
wizard.PrepareSpell();
4. Haz que los magos sean vulnerables si no han preparado un hechizo
Asegúrate de que el método Vulnerable() devuelva true si el mago no ha preparado un hechizo; en caso contrario, que devuelva false.
var wizard = new Wizard();
wizard.Vulnerable();
// => true
5. Calcula los puntos de daño de un mago
Implementa el método Wizard.DamagePoints() para que devuelva los puntos de daño infligidos: 12 puntos de daño cuando se ha preparado un hechizo y 3 puntos de daño cuando no.
var wizard = new Wizard();
var warrior = new Warrior();
wizard.PrepareSpell();
wizard.DamagePoints(warrior);
// => 12
6. Calcula los puntos de daño de un guerrero
Implementa el método Warrior.DamagePoints() para que devuelva los puntos de daño infligidos: 10 puntos de daño cuando el objetivo es vulnerable y 6 puntos de daño cuando no.
var warrior = new Warrior();
var wizard = new Wizard();
warrior.DamagePoints(wizard);
// => 10
Ejercicio de aprendizaje
