Inheritance

Imagine you have Dog , Cat , and Bird classes. Each needs a name , age , eat() , and sleep() . Without inheritance, you'd copy-paste the same code three times. Inheritance lets you define shared behavior once in a parent class ( Animal ), and every child class automatically gets it. Write once, reuse everywhere.

Learn Inheritance in our free Java course — a beginner-friendly interactive lesson with worked examples, a practice exercise and a quick reference.

Part of the free Java course at LearnCodingFast — hands-on lessons with examples you run in your browser, plus practice exercises and a quick quiz.

💡 Real-World Analogy: Family Tree

Think of a family tree. A child inherits traits (eye color, height) from their parents, but can also develop unique traits of their own. Similarly, a child class inherits fields and methods from a parent class, but can add new ones or override inherited ones with different behavior.

Without inheritance, you'd duplicate code across similar classes:

🔑 The extends keyword: class Dog extends Animal means "Dog is a type of Animal and inherits all its fields and methods." Dog automatically gets name , age , eat() , and sleep() without writing them again.

super refers to the parent class. You use it in two main places:

⚠️ Critical rule: If the parent class has no default (no-argument) constructor, you must call super(...) as the very first statement in the child's constructor. The compiler will refuse to compile otherwise.

A child class can override a parent's method to provide its own implementation. The method signature (name, parameters, return type) must match exactly. Always use the @Override annotation for safety.

💡 Why @Override ? Without it, a typo like speek() would create a new method instead of overriding speak() — a silent, hard-to-find bug. @Override tells the compiler to verify the parent actually has this method.

Polymorphism is the most powerful concept in OOP. It means a parent type variable can hold any child type object, and method calls automatically use the child's version. Think of it like a universal TV remote — the "power" button does something different on every TV brand.

🔑 Why this is powerful: You can write methods that accept Animal and they automatically work with Dog, Cat, Bird, and any future animal class you create. You don't need to change the method — it just works. This is the foundation of extensible software.

Sometimes you have a parent type variable but need to know the actual type at runtime. Use instanceof :

This is one of the most important design decisions you'll make. The test is simple:

❌ Bad inheritance: Stack extends ArrayList — a Stack is NOT a type of ArrayList. It just happens to use a list internally. Use composition instead.

💡 Pro rule: "Favor composition over inheritance." Deep inheritance hierarchies (5+ levels) become rigid and hard to change. Use 1-2 levels of inheritance + interfaces for flexibility.

Not all parent members are accessible to child classes. Here's what each access modifier allows:

Use protected for fields/methods that subclasses need but outsiders shouldn't access. It's the sweet spot for inheritance.

💡 Always use @Override: It's free compile-time error checking. There's no reason not to use it.

💡 Keep hierarchies shallow: 1-2 levels of inheritance is ideal. Beyond 3, consider interfaces + composition.

💡 Program to interfaces, not implementations: Use Animal pet = new Dog() instead of Dog pet = new Dog() when possible — this makes your code more flexible.

💡 Use protected wisely: It's better than public for fields that subclasses need, but consider if a getter method would be even better.

💡 The Liskov Substitution Principle: A child class should work anywhere the parent class is expected. If a method expects Animal , passing a Dog should work correctly.

You now understand inheritance, method overriding, polymorphism, the super keyword, and when to choose inheritance vs composition! These concepts are the backbone of extensible, maintainable Java applications.

Next up: Interfaces & Abstract Classes — define contracts and partial blueprints for maximum design flexibility.

Practice quiz

• Browse all free courses
• Cheat sheets & quizzes
• Coding dictionary