Inheritance
## Learning Objectives
- Understand inheritance relationships
- Use extends keyword
- Override methods
- Master super keyword
## What is Inheritance?
A way to create a new class based on an existing class:
```java
// Parent class
public class Animal {
String name;
int age;
public void eat() {
System.out.println("Eating...");
}
}
// Child class
public class Dog extends Animal {
String breed;
public void bark() {
System.out.println("Woof!");
}
}
```
## Why Inheritance?
### Code Reuse
```java
Dog dog = new Dog();
dog.name = "Buddy"; // Inherited from Animal
dog.age = 3; // Inherited from Animal
dog.eat(); // Inherited from Animal
dog.bark(); // Dog's own method
```
### Hierarchical Organization
```text
Animal (parent)
├── Dog (child)
├── Cat (child)
└── Bird (child)
```
## The extends Keyword
```java
public class Parent {
// fields and methods
}
public class Child extends Parent {
// inherits all Parent members
// adds its own fields and methods
}
```
## Method Overriding
### @Override Annotation
```java
public class Animal {
public void makeSound() {
System.out.println("Some sound");
}
}
public class Dog extends Animal {
@Override
public void makeSound() {
System.out.println("Woof!");
}
}
```
### Calling Parent Method
```java
public class Dog extends Animal {
@Override
public void makeSound() {
super.makeSound(); // Call parent's version first
System.out.println("Woof!");
}
}
```
## super Keyword
### Reference Parent Class
```java
public class Child extends Parent {
public Child(String name, int age) {
super(name); // Call Parent constructor
super.name = "Override"; // Access parent field
}
@Override
public void someMethod() {
super.someMethod(); // Call parent version
}
}
```
### super() Constructor
```java
public class Animal {
private String name;
public Animal(String name) {
this.name = name;
}
}
public class Dog extends Animal {
private String breed;
public Dog(String name, String breed) {
super(name); // Must be first statement
this.breed = breed;
}
}
```
## Inheritance and Constructors
### Constructor Chaining
```java
public class GrandParent {
public GrandParent() {
System.out.println("GrandParent constructor");
}
}
public class Parent extends GrandParent {
public Parent() {
super(); // Automatically called if not explicit
System.out.println("Parent constructor");
}
}
public class Child extends Parent {
public Child() {
super(); // Automatically called
System.out.println("Child constructor");
}
}
// Output:
// GrandParent constructor
// Parent constructor
// Child constructor
```
## Access Control with Inheritance
### What Child Inherits
| Member | private | (default) | protected | public |
|--------|---------|-----------|-----------|--------|
| Inherited | No | Yes | Yes | Yes |
| Accessible | No | Yes | Yes | Yes |
### Protected Access
```java
public class Animal {
protected int age; // Accessible in subclasses
}
public class Dog extends Animal {
public void setAge(int age) {
this.age = age; // OK - protected accessible
}
}
```
## Multi-level Inheritance
```java
public class A { }
public class B extends A { }
public class C extends B { }
// C inherits from B, which inherits from A
```
## Single Inheritance
Java only allows ONE direct parent:
```java
// This is NOT allowed in Java
public class A { }
public class B { }
public class C extends A, B { } // Error!
```
## Object Class
### Ultimate Parent
```java
public class Dog extends Object { // Implicit
// equals(), hashCode(), toString() inherited from Object
}
Dog dog = new Dog();
dog.toString(); // from Object class
```
## instanceof Operator
### Type Checking
```java
public class Animal { }
public class Dog extends Animal { }
public class Cat extends Animal { }
Animal animal = new Dog();
if (animal instanceof Dog) {
Dog dog = (Dog) animal; // Safe cast
dog.bark();
}
```
### Java 16+ Pattern Matching
```java
if (animal instanceof Dog dog) {
dog.bark(); // Direct access, no cast needed
}
```
## Method Hiding
### Static Methods
```java
public class Parent {
public static void staticMethod() {
System.out.println("Parent static");
}
}
public class Child extends Parent {
public static void staticMethod() {
System.out.println("Child static");
}
}
Parent.staticMethod(); // Parent static
Child.staticMethod(); // Child static
```
## Final Classes
### Cannot Extend
```java
public final class MathUtils {
public static int add(int a, int b) {
return a + b;
}
}
// public class ExtendedMath extends MathUtils { } // Error!
```
## Summary
- Inheritance: `class Child extends Parent`
- Child inherits all parent fields and methods (except private)
- Override methods with `@Override`
- Use `super` to access parent members
- Constructor calls chain: `super()` must be first
- `protected` accessible in subclasses
- Single inheritance only (one parent)
- `instanceof` checks object type
Comments
Comments powered by Giscus
To enable comments, add your Giscus embed code here.
Learn more about Giscus →