Overriding and polymorphism

Overriding

Inheriting a method as-is is only half the story — a SavingsAccount needs withdraw to behave differently from its parent, not identically. A subclass can replace an inherited method by redefining it with the same signature. That is overriding (different from overloading in lesson 4-2, which was same name, different parameters).

class Animal {
  void speak() { System.out.println("..."); }
}

class Dog extends Animal {
  @Override
  void speak() { System.out.println("woof"); }
}

Now the payoff, polymorphism: a variable of type Animal may hold any animal, and Java picks the method of the object's actual class at runtime:

Animal pet = new Dog();
pet.speak();   // woof, not ...

One loop over Animal[] can make every species speak correctly without a single if-statement.

instanceof: asking what an object really is

A variable typed Animal only exposes Animal's methods — even when the object inside is a Dog, pet.fetch() will not compile, because the compiler can only trust the declared type. When you genuinely need the specific type back, instanceof tests what the object actually is, and its pattern form gives you a correctly-typed variable in one step:

Animal pet = new Dog();
pet instanceof Dog          // true — asks about the object, not the variable

if (pet instanceof Dog d) { // test + cast in one move
  d.fetch();                // d is a Dog here
}

Use it sparingly: a chain of instanceof checks choosing behavior per type is usually a sign the behavior should be an overridden method instead — that is what polymorphism is for.