Introduzione
Ereditarietà
L'ereditarietà è un concetto fondamentale nella programmazione orientata agli oggetti (OOP).
Rappresenta una relazione IS-A.
In programmazione significa esattamente quello che significa in inglese: ereditare caratteristiche dal genitore (in programmazione le caratteristiche sono normalmente funzioni e variabili).
Considera una classe, Animal, come mostrato qui:
//Creating an Animal class with bark() as a member function.
public class Animal {
public void bark() {
System.out.println("This is an animal");
}
}
Animal è una classe genitore, perché le proprietà di questa classe possono essere estese a tutti gli animali in generale.
Considera un animale di nome Lion, con una classe come questa:
//Lion class is a child class of Animal.
public class Lion extends Animal {
@Override
public void bark() {
System.out.println("Lion here!!");
}
}
L'annotazione Override serve a indicare che un metodo di una sottoclasse sta sovrascrivendo un metodo della sua superclasse.
Non è strettamente necessaria, ma usarla è una buona pratica.
Ora, ogni volta che scriviamo:
Animal animal = new Lion(); //creating instance of Animal, of type Lion
animal.bark();
Nota: stiamo inizializzando la classe Animal con Lion.
L'output sarà così:
Lion here!!
Secondo la programmazione orientata agli oggetti esistono molti tipi di ereditarietà, ma Java ne supporta solo alcuni (multi-livello e gerarchica).
Per saperne di più, leggi questo.
Istruzioni
In questo esercizio giochi a un gioco di ruolo in cui diversi tipi di combattenti possono scontrarsi tra loro.
Il gioco ha regole diverse per ogni tipo di combattente.
Ci concentreremo su due tipi specifici: Wizards e Warriors.
Per un Warrior, queste sono le regole:
- Un Warrior non è mai vulnerabile.
- Un Warrior infligge
6 punti di danno se il combattente che sta attaccando non è vulnerabile.
- Un Warrior infligge
10 punti di danno se il combattente che sta attaccando è vulnerabile.
Per un Wizard, queste sono le regole:
- Un Wizard può preparare un incantesimo in anticipo.
- Un Wizard è vulnerabile a meno che non abbia preparato un incantesimo in anticipo.
- Un Wizard infligge
12 punti di danno se ha preparato un incantesimo in anticipo.
- Un Wizard infligge
3 punti di danno se non ha preparato un incantesimo in anticipo.
1. Crea la classe Warrior
Crea una nuova classe chiamata Warrior.
Questa classe deve ereditare dalla classe Fighter esistente.
2. Descrivi un Warrior
Aggiorna la classe Warrior in modo che il suo metodo toString() descriva che tipo di combattente è.
Il metodo deve restituire la stringa "Fighter is a Warrior".
Warrior warrior = new Warrior();
warrior.toString();
// => "Fighter is a Warrior"
3. Rendi i Warrior invulnerabili
Aggiorna la classe Warrior in modo che il suo metodo isVulnerable() restituisca sempre false.
Warrior warrior = new Warrior();
warrior.isVulnerable();
// => false
4. Calcola i punti di danno per un Warrior
Aggiorna la classe Warrior in modo che il suo metodo getDamagePoints(Fighter) calcoli il danno inflitto da un Warrior secondo le regole qui sopra.
Warrior warrior = new Warrior();
Wizard wizard = new Wizard();
warrior.getDamagePoints(wizard);
// => 10
5. Crea la classe Wizard
Crea un'altra nuova classe chiamata Wizard.
Anche questa classe deve ereditare dalla classe Fighter esistente.
6. Descrivi un Wizard
Aggiorna la classe Wizard in modo che il suo metodo toString() descriva che tipo di combattente è.
Il metodo deve restituire la stringa "Fighter is a Wizard".
Wizard wizard = new Wizard();
wizard.toString();
// => "Fighter is a Wizard"
7. Permetti ai Wizard di preparare un incantesimo e rendili vulnerabili quando non ne hanno preparato uno
Aggiorna la classe Wizard per aggiungere un metodo chiamato prepareSpell().
La classe deve ricordare quando questo metodo viene chiamato e assicurarsi che il suo metodo isVulnerable() restituisca false solo quando un incantesimo è preparato.
Wizard wizard = new Wizard();
wizard.prepareSpell();
wizard.isVulnerable();
// => false
8. Calcola i punti di danno per un Wizard
Aggiorna la classe Wizard in modo che il suo metodo getDamagePoints(Fighter) calcoli il danno inflitto da un Wizard secondo le regole qui sopra.
Wizard wizard = new Wizard();
Warrior warrior = new Warrior();
wizard.prepareSpell();
wizard.getDamagePoints(warrior);
// => 12
Esercizio di apprendimento
