OOP Capstone — Animal Hierarchy in Scala in Scala

abstract class Animal {
    public var name: String = ""
    public Animal(String name) { this.name = name; }
    public abstract String sound()      // each subclass picks
    def speak() {                 // shared by all
        println(name + ": " + sound())
    }
}
// Dog, Cat, Bird each override sound()
// Animal[] zoo = { new Dog("Rex"), ... }
// for (Animal a : zoo) a.speak()

Full lesson:

This problem stitches together everything you've learned in this chapter:

1. Inheritance — three concrete classes share a common parent.
2. Constructors — each subclass forwards a name to the parent.
3. Abstract methods — the parent declares sound() with no body; each child must provide one.
4. Shared behavior — the parent has a concrete speak() that calls sound(); every subclass inherits it for free.
5. Polymorphism — a collection typed as Animal holds a Dog, a Cat, and a Bird; speak() dispatches to the right sound() at runtime.

The shape of this code is the shape of nearly every real OOP design you'll see — a small contract at the top (the abstract parent), concrete variants below, and the rest of the program written against the abstract type. New variants get added without touching the consumer code.

Your task

The abstract Animal class is already defined, with a concrete speak() that calls the abstract sound(). Add three subclasses — Dog (returns "Woof"), Cat (returns "Meow"), and Bird (returns "Tweet"). Then in MainFunction / main, build a polymorphic collection holding one of each (Rex, Whiskers, Tweety in that order) and loop through it calling speak().

Expected output:

Rex: Woof
Whiskers: Meow
Tweety: Tweet