Java Notes
HubWhat Is Java?History of JavaFeatures of JavaJava EditionsJDK, JRE, and JVMYour First Java ProgramJava Program StructureJava Compilation ProcessIdentifiers in JavaKeywords in JavaVariables in JavaData Types in JavaType Casting in JavaOperators in JavaInput and Output in JavaComments in JavaIf-Else Statements in JavaSwitch-Case in JavaFor Loop in JavaWhile Loop in JavaDo-While Loop in JavaNested Loops in Javabreak and continue in JavaArray IntroductionOne Dimensional ArrayMulti Dimensional ArrayJagged Array in JavaArray OperationsArray Programs — FundamentalsArray Interview QuestionsString Class in JavaImmutable Strings in JavaString MethodsStringBuilder in JavaStringBuffer in JavaString Programs — FundamentalsString Interview QuestionsOOPs IntroductionClass and Object in JavaConstructor in Javathis Keyword in Javastatic Keyword in JavaEncapsulation in JavaInheritance in Javasuper Keyword in JavaPolymorphism in JavaMethod Overloading in JavaMethod Overriding in JavaAbstraction in JavaAbstract Class in JavaInterface in JavaObject Class in JavaWrapper Class in JavaInner Class in JavaAnonymous Class in JavaObject Cloning in JavaJava Collections Framework OverviewGenerics in JavaArrayList in JavaLinkedList in JavaVector in JavaStack in JavaHashSet in JavaLinkedHashSet in JavaTreeSet in JavaPriorityQueue in JavaArrayDeque in JavaDeque Interface in JavaHashMap in JavaLinkedHashMap in JavaTreeMap in JavaHashtable in JavaIterator in JavaComparable vs Comparator in JavaJava Collections Practice ProgramsException Handling IntroductionException Hierarchy in JavaTry-Catch Block in JavaFinally Block in Javathrow and throws Keywords in JavaCustom Exceptions in JavaException Handling Best PracticesFile Class in JavaByte Streams in JavaCharacter Streams in JavaBuffered Streams in JavaSerialization in JavaDeserialization in JavaJava NIO PackageLambda Expression in Java 8Functional Interface in Java 8Method Reference in Java 8Default and Static Methods in InterfacesStream API in Java 8Optional Class in Java 8Date and Time API in Java 8Thread IntroductionThread Life Cycle in JavaThread Class in JavaRunnable Interface in JavaCreating Threads in JavaThread Priority in JavaDaemon Threads in JavaSynchronization in JavaInter-Thread Communication in JavaExecutor Framework in JavaMultithreading Programs in JavaJDBC IntroductionJDBC ArchitectureMySQL Connection with JDBCStatement Interface in JDBCPreparedStatement in JDBCResultSet in JDBCCallableStatement in JDBCTransaction Management in JDBCBatch Processing in JDBCJDBC ProjectsServlet IntroductionGenericServletHttpServletServlet Life CycleRequest and Response ObjectsCookies in ServletsSession TrackingJSP IntroductionJSP Tags and JSTLExpression Language (EL)MVC ArchitectureSpring Framework IntroductionSpring Core ContainerSpring BeansDependency InjectionSpring Boot IntroductionREST API with Spring BootValidation in Spring BootCRUD ApplicationSpring Data JPAException Handling in Spring BootSpring SecurityJWT Authentication — Java ProgrammingConfig ServerEureka Server - Service DiscoveryAPI GatewayDocker DeploymentTime ComplexityRecursion in JavaLinked List in JavaStack in Java — DSA in JavaQueue in JavaHashing in JavaSorting Algorithms in JavaSearching Algorithms in JavaTree Data Structure in JavaHeap (DSA)Graph Data Structure in JavaDynamic Programming in JavaSingleton Design PatternFactory Design PatternBuilder Design PatternAdapter Design PatternObserver Design PatternMVC Pattern — Java ProgrammingBasic Java ProgramsArray Programs — PracticeString Programs — PracticeOOP ProgramsCollection ProgramsMultithreading ProgramsJDBC ProgramsPlacement Coding QuestionsStudent Management System — Java ProgrammingEmployee Management SystemLibrary Management System — Java ProgrammingBanking System — Java ProgrammingChat ApplicationE-Commerce BackendSpring Boot Fullstack ProjectCore Java Interview QuestionsOOPs Interview QuestionsCollections Interview QuestionsMultithreading Interview QuestionsJDBC Interview QuestionsSpring Framework Interview QuestionsCoding Interview QuestionsJava Cheat SheetQuick Revision Notes — Java ProgrammingImportant Java ProgramsImportant Formulas & ConceptsJava Master Course - Learning Roadmap
Learn method overriding in Java — how a child class replaces a parent method, the @Override annotation, rules for overriding, what cannot be overridden, and runtime dispatch.
Method overriding happens when a child class redefines a method that already exists in the parent class — same name, same parameters, same return type. The child's version replaces the parent's for child objects.
This is runtime polymorphism. Java decides at runtime which version to call, based on the actual object, not the reference type.
Basic Override Example
Try it in WoHoCode
Edit the program, then run it here.
Loading editor...
Ln 1, Col 1java | Ctrl+Enter: run | Ctrl+S: save
Output
Run this example to see its output.
Line by line:
Animal a1 = new Dog();— reference isAnimalbut object isDog.a1.makeSound()— Java looks at the actual object (Dog), not the reference type (Animal). Runs Dog's version.@Override— annotation that tells the compiler: this is intentionally overriding a parent method. If the parent does not have a matching method, the compiler throws an error. Always use it.
The @Override Annotation
@Override is not required but you should always use it.
java example
public class Vehicle {
void start() {
System.out.println("Vehicle starting");
}
}
public class Car extends Vehicle {
// Without @Override — compiles, but no protection
void strat() { // typo — creates a new method instead of overriding
System.out.println("Car starting");
}
}
public class Car extends Vehicle {
@Override
void strat() { // COMPILE ERROR — no strat() in Vehicle to override
System.out.println("Car starting");
}
}Without @Override, a typo silently creates a new method instead of overriding. With @Override, the compiler catches the mistake immediately.
Rules for Overriding
- Same method signature — same name, same parameter list.
- Same or covariant return type — you can return a subtype (e.g., return
Dogwhere parent returnsAnimal). - Access modifier must be same or wider — a
protectedparent method can be overridden aspublic, but not asprivate. - Cannot throw broader checked exceptions — if parent throws
IOException, child cannot throwException.
java example
public class Parent {
protected Animal getAnimal() {
return new Animal();
}
}
public class Child extends Parent {
@Override
public Dog getAnimal() { // public is wider than protected — OK
return new Dog(); // Dog is a subtype of Animal — OK (covariant)
}
}Calling the Parent Version — super.method()
Sometimes the child wants to extend the parent's behaviour rather than fully replace it.
Try it in WoHoCode
Edit the program, then run it here.
Loading editor...
Ln 1, Col 1java | Ctrl+Enter: run | Ctrl+S: save
Output
Run this example to see its output.
super.log(message) runs the parent's version. Then the child adds the timestamp. Without super.log(), the parent's line would never print.
What Cannot Be Overridden
Some methods are blocked from overriding:
java example
public class Base {
final void cannotOverride() { // final — locked
System.out.println("Base final method");
}
static void staticMethod() { // static — not overriding, only hiding
System.out.println("Base static");
}
private void privateMethod() { // private — not visible to child
System.out.println("Base private");
}
}
public class Derived extends Base {
// @Override
// void cannotOverride() { } // COMPILE ERROR — cannot override final
// This is METHOD HIDING, not overriding
static void staticMethod() {
System.out.println("Derived static");
}
// This creates a new method, does NOT override parent's private
private void privateMethod() {
System.out.println("Derived private");
}
}| Can it be overridden? | Reason |
|---|---|
final method | No — intentionally locked by parent |
static method | No — static methods are hidden, not overridden; runtime polymorphism does not apply |
private method | No — not visible to child at all |
public or protected method | Yes |
Overriding vs Overloading — Side by Side
| Feature | Overriding | Overloading |
|---|---|---|
| Class | Parent + child | Same class (or parent/child) |
| Method name | Same | Same |
| Parameters | Same | Different |
| Return type | Same or covariant | Can be different |
| Resolved | Runtime | Compile time |
| Polymorphism type | Runtime (dynamic) | Compile time (static) |
@Override | Should use | Cannot use |
Common Mistake 1: Narrowing Access Modifier
java example
public class Parent {
public void show() { System.out.println("Parent"); }
}
public class Child extends Parent {
// COMPILE ERROR — cannot reduce from public to protected
@Override
protected void show() { System.out.println("Child"); }
}Overriding can only make access wider (protected → public) or keep it the same. Never narrower.
Common Mistake 2: Trying to Override static or final
java example
public class Parent {
static void greet() { System.out.println("Hello"); }
}
public class Child extends Parent {
@Override
static void greet() { System.out.println("Hi"); } // COMPILE ERROR
}Static methods belong to the class, not objects. Runtime dispatch does not apply to them. Calling Parent.greet() always calls Parent's version; calling Child.greet() always calls Child's version — this is hiding, not overriding.
Common Mistake 3: Missing @Override and Creating an Overload Instead
java example
public class Animal {
void eat(String food) { System.out.println("Eating " + food); }
}
public class Cat extends Animal {
// Intended override, but wrong parameter type — actually an overload
void eat(int amount) { System.out.println("Eating " + amount + " grams"); }
}Cat.eat(int) does not override Animal.eat(String) — they have different parameters. Without @Override, the compiler will not warn you. Add @Override and the compile error will immediately show the mistake.
Practice Task
Task: Create a class Shape with a method area() that returns 0.0. Create two subclasses:
Circlewith a fieldradius, overridesarea()to return3.14159 * radius * radiusRectanglewith fieldslengthandwidth, overridesarea()to returnlength * width
In main, create a Shape[] with one Circle (radius 5) and one Rectangle (4 × 6). Loop through and print each area.
Hint: Use @Override on both. Store both in a Shape[] — this is upcasting. The loop calls each object's own area() at runtime.
Solution:
Try it in WoHoCode
Edit the program, then run it here.
Loading editor...
Ln 1, Col 1java | Ctrl+Enter: run | Ctrl+S: save
Output
Run this example to see its output.
What to observe: The loop uses Shape reference. s.area() calls each object's own overridden version. Add a Triangle class with its own area() — the loop handles it with zero changes to the loop itself.
Continue the lesson path
Study next in this module
01OOPsAbstraction in JavaUnderstand abstraction in Java — hiding internal complexity, showing only what is needed, and achieving abstraction through abstract classes and interfaces.02OOPsMethod Overloading in JavaLearn method overloading in Java — same method name with different parameters, how Java picks the right version, what you can and cannot overload, and common mistakes.03OOPsAbstract Class in JavaLearn abstract classes in Java — abstract keyword, abstract vs concrete methods, when a child must override, why you cannot create abstract class objects, and when to choose abstract class over interface.04OOPsPolymorphism in JavaUnderstand polymorphism in Java — compile-time polymorphism through method overloading and runtime polymorphism through method overriding, with upcasting and real-world examples.