# Inheritance Review

A quick review of inheritance, using the Character and Archer classes, before we make a parent class abstract.

Apprentice · Java · OOP · Updated November 16, 2026

By Gregor Dzierzon

You recall that inheritance defines an is-a relationship, where one class inherits all properties of the parent class.

![Archer extends Character](https://fsdtrainingmedia.blob.core.windows.net/public/images/2026/09/49a277df1c934dcc86d66103b133f676.png "Archer extends Character")

The following code is the `Character` example from Inheritance and Constructors. The `Character` class defines the variables, getters and methods a character needs.

The Archer class extends the Character class, and adds a few more features of its own.

## Character

```java
public class Character
{
    protected static final int attackAmount = 10;

    private String name;
    private int health;
    private int level;
    private int experience;

    public Character(String name, int health, int level, int experience)
    {
        this.name = name;
        this.health = health;
        this.level = level;
        this.experience = experience;
    }

    public boolean isDefeated() { return health <= 0; }
    public String getName() { return name; }
    public int getHealth() { return health; }
    public int getLevel() { return level; }
    public int getExperience() { return experience; }

    public void attack(Character target)
    {
        if (isDefeated()){ return; }

        target.takeDamage(attackAmount);
    }

    public void takeDamage(int damage)
    {
        this.health -= damage;
        if (isDefeated()) { health = 0; }
    }

    public void levelUp()
    {
        if(isDefeated()) { return; }

        this.level++;
        this.health += 10;
    }

    public String specialAbility() { return "Standard"; }
}
```

## Archer

The Archer class extends Character. An archer has all the abilities of a character plus the additional attributes and methods defined here.

```java
public class Archer extends Character
{
    private int arrows;

    public Archer(String name, int health, int level, int experience, int arrows)
    {
        // the call to the super constructor must be first
        super(name, health, level, experience);

        this.arrows = arrows;
    }

    public int getArrows() { return this.arrows; }

    public void addArrow()
    {
        arrows++;
    }
}
```

## Do it: finish the wizard

The game needs another kind of character: a wizard. A wizard is a character, so it gets a name, health and a level from `Character`. It also has something only wizards have: **mana**, the magic it spends on spells.

`Character` is given at the bottom of the file, a shorter copy of the class above (a name, health and a level). The `Wizard` class is started: it extends `Character`, passes the name, health and level up with `super(...)`, and keeps its own `mana`.

For example, a new wizard named Merlin, at level 1 with 100 health and 50 mana, who levels up once:

```java
Wizard merlin = new Wizard("Merlin", 100, 1, 50);
merlin.levelUp();
```

| | Level | Health | Mana |
|---|---|---|---|
| New | 1 | 100 | 50 |
| After one `levelUp()` | 1 + 1 = 2 | 100 + 10 = 110 | 50 + 10 = 60 |

So after one level-up, Merlin is level `2`, with `110` health and `60` mana. His `specialAbility()` returns `"Fireball"`.

**Your job:** finish the `Wizard` class with two methods that override `Character`'s.

- `levelUp()`: run `Character`'s `levelUp()` first, so the level and health still go up, then add `10` to `mana`.
- A defeated wizard (health `0`) doesn't level up, so it gets no mana either: its level and mana stay as they were.
- `specialAbility()` returns `"Fireball"`.
- Leave `Character` as it is.

Practiced live on the lesson page: write the Java right there and check it.

## Cheat sheets

- [Abstraction in OOP and Inheritance Review](https://www.ask-codey.com/cheat-sheets/abstraction-in-oop-an-overview-cheat-sheet)

Source: https://www.ask-codey.com/lessons/abstraction-in-oop-inheritance-review
