Percursos
/
Java
Java
/
Exercícios
/
Feiticeiros e guerreiros
Feiticeiros e guerreiros

Feiticeiros e guerreiros

Exercício de aprendizagem

Introdução

Herança

A herança é um conceito central na POO (Programação Orientada a Objetos). Representa uma relação é-um. Significa literalmente, em programação, o mesmo que em inglês: herdar características do progenitor (em programação, essas características são normalmente funções e variáveis).

Considera uma classe, Animal, como mostrada,

//Creating an Animal class with bark() as a member function.
public class Animal {

    public void bark() {
        System.out.println("This is an animal");
    }

}

Animal é uma classe progenitora, porque as propriedades desta classe podem ser estendidas a todos os animais em geral.

Considera um animal chamado Lion, com uma classe como esta,

//Lion class is a child class of Animal.
public class Lion extends Animal {

    @Override
    public void bark() {
        System.out.println("Lion here!!");
    }

}
Note

A anotação Override serve para indicar que um método numa subclasse está a sobrepor um método da sua superclasse. Não é estritamente necessária, mas é uma boa prática utilizá-la.

Agora, sempre que fazemos,

Animal animal = new Lion(); //creating instance of Animal, of type Lion
animal.bark();

Nota: inicializamos a classe Animal com Lion. O resultado será algo como

Lion here!!

Segundo a POO, existem muitos tipos de herança, mas o Java só suporta alguns deles (multi-nível e hierárquica). Para saberes mais sobre isto, lê isto.

Instruções

Neste exercício estás a jogar um jogo de interpretação de papéis em que diferentes tipos de lutadores podem combater entre si. O jogo tem regras diferentes para cada tipo de lutador. Vamos concentrar-nos em dois tipos específicos: Wizards e Warriors.

Para um Warrior, as regras são estas:

  • Um Warrior nunca é vulnerável.
  • Um Warrior causa 6 pontos de dano se o lutador que está a atacar não for vulnerável.
  • Um Warrior causa 10 pontos de dano se o lutador que está a atacar for vulnerável.

Para um Wizard, as regras são estas:

  • Um Wizard pode preparar um feitiço com antecedência.
  • Um Wizard é vulnerável a menos que tenha preparado um feitiço com antecedência.
  • Um Wizard causa 12 pontos de dano se tiver preparado um feitiço com antecedência.
  • Um Wizard causa 3 pontos de dano se não tiver preparado um feitiço com antecedência.

1. Cria a classe Warrior

Cria uma nova classe chamada Warrior. Esta classe deve herdar da classe Fighter existente.

2. Descreve um Warrior

Atualiza a classe Warrior para que o seu método toString() descreva que tipo de lutador é. O método deve devolver a string "Fighter is a Warrior".

Warrior warrior = new Warrior();
warrior.toString();
// => "Fighter is a Warrior"

3. Torna os Warriors invulneráveis

Atualiza a classe Warrior para que o seu método isVulnerable() devolva sempre false.

Warrior warrior = new Warrior();
warrior.isVulnerable();
// => false

4. Calcula os pontos de dano de um Warrior

Atualiza a classe Warrior para que o seu método getDamagePoints(Fighter) calcule o dano causado por um Warrior de acordo com as regras acima.

Warrior warrior = new Warrior();
Wizard wizard = new Wizard();

warrior.getDamagePoints(wizard);
// => 10

5. Cria a classe Wizard

Cria outra nova classe chamada Wizard. Esta classe também deve herdar da classe Fighter existente.

6. Descreve um Wizard

Atualiza a classe Wizard para que o seu método toString() descreva que tipo de lutador é. O método deve devolver a string "Fighter is a Wizard".

Wizard wizard = new Wizard();
wizard.toString();
// => "Fighter is a Wizard"

7. Permite que os Wizards preparem um feitiço e torna-os vulneráveis quando não tiverem um feitiço preparado

Atualiza a classe Wizard para adicionar um método chamado prepareSpell(). A classe deve registar quando este método é chamado e garantir que o seu método isVulnerable() devolve false apenas quando um feitiço estiver preparado.

Wizard wizard = new Wizard();
wizard.prepareSpell();
wizard.isVulnerable();
// => false

8. Calcula os pontos de dano de um Wizard

Atualiza a classe Wizard para que o seu método getDamagePoints(Fighter) calcule o dano causado por um Wizard de acordo com as regras acima.

Wizard wizard = new Wizard();
Warrior warrior = new Warrior();

wizard.prepareSpell();
wizard.getDamagePoints(warrior);
// => 12
Editar via GitHub A ligação abre numa nova janela ou separador
Java Exercism

Estás pronto para começar Feiticeiros e guerreiros?

Inscreve-te no Exercism para aprenderes e dominares Java com 26 conceitos158 exercícios, e mentoria humana real, tudo grátis.