What conditions must a subclass method satisfy to override a method inherited from its superclass?

## What overriding is **Inheritance** lets a class (the *subclass* or *child*) reuse and extend another class (the *superclass* or *parent*) via `extends`. The subclass receives the parent's non-private methods. **Overriding** means the subclass provides its *own* implementation of a method it inherited, replacing the parent's version *for instances of the subclass*. This is the engine of **polymorphism**: when you call the method through a parent-typed reference that actually points to a child object, the child's version runs. That decision is made at runtime (**dynamic dispatch** / **late binding**), not at compile time. ## The rules, term by term A **method signature** is the method's *name plus its ordered parameter types* (return type is NOT part of the signature in Java). To override, the subclass method must: 1. **Same name + same parameter list (same signature).** If parameters differ, you are *overloading* (a different, unrelated method), not overriding. `eat()` and `eat(String food)` are two distinct methods. 2. **Same or covariant return type.** *Covariant* means the override may return a *subtype* of the parent's return type. If `Animal reproduce()` is the parent, `Cat reproduce()` is a legal override because `Cat` is an `Animal`. A wider or unrelated return type is a compile error. 3. **Access may only widen, never narrow.** If the parent method is `protected`, the override can be `protected` or `public`, but not `private` or package-private. Narrowing would let a subtype refuse access the supertype promised - breaking substitutability. 4. **Checked exceptions may only narrow.** A *checked exception* is one the compiler forces you to declare with `throws` or handle. The override may throw the same checked exceptions, *subtypes* of them, *fewer* of them, or none - but it may NOT add a *new or broader* checked exception. (Unchecked exceptions - `RuntimeException` and its subtypes - are unrestricted.) Reason: code calling through the parent reference only prepared for the parent's declared exceptions. 5. **The method must be overridable.** `static`, `final`, and `private` methods cannot be overridden. A `static` method with the same signature is *hidden*, not overridden (resolved by reference type, not runtime type). A `private` method is invisible to the subclass, so a same-named subclass method is brand new. `final` explicitly forbids overriding. ## @Override `@Override` is an annotation you place on the subclass method. It does not change behavior; it asks the **compiler to verify** that this method really overrides (or implements) a supertype method. If you misspell the name or get a parameter type wrong, the compiler emits an error instead of silently creating a useless new method. It is a cheap, strongly-recommended safety net. ## Worked picture ```java class Animal { protected Animal reproduce() throws Exception { return new Animal(); } } class Cat extends Animal { @Override public Cat reproduce() { return new Cat(); } // widened access, covariant return, fewer exceptions } ``` All three relaxations above are legal: `public` widens `protected`; `Cat` is a covariant `Animal`; throwing nothing narrows the `throws Exception`. With `Animal a = new Cat(); a.reproduce();` the **Cat** version runs - that is dynamic dispatch driven by a valid override.