Inheritance in Java is one of the core concepts of Object-Oriented Programming (OOP). It allows a new class (subclass or derived class) to inherit properties and methods from an existing class (superclass or base class). This facilitates code reusability, allows for hierarchical classification, and helps in method overriding, promoting better organization of code.
For example, if you have a class Animal
that has common properties and methods for all animals, you can create subclasses like Dog
and Cat
that inherit from the Animal
class and also have their own specific behaviors.
class Animal {
void eat() {
System.out.println("This animal eats food.");
}
}
class Dog extends Animal {
void bark() {
System.out.println("The dog barks.");
}
}
class Cat extends Animal {
void meow() {
System.out.println("The cat meows.");
}
}
public class Main {
public static void main(String[] args) {
Dog dog = new Dog();
dog.eat(); // Inherited method
dog.bark(); // Dog's own method
Cat cat = new Cat();
cat.eat(); // Inherited method
cat.meow(); // Cat's own method
}
}
How do I avoid rehashing overhead with std::set in multithreaded code?
How do I find elements with custom comparators with std::set for embedded targets?
How do I erase elements while iterating with std::set for embedded targets?
How do I provide stable iteration order with std::unordered_map for large datasets?
How do I reserve capacity ahead of time with std::unordered_map for large datasets?
How do I erase elements while iterating with std::unordered_map in multithreaded code?
How do I provide stable iteration order with std::map for embedded targets?
How do I provide stable iteration order with std::map in multithreaded code?
How do I avoid rehashing overhead with std::map in performance-sensitive code?
How do I merge two containers efficiently with std::map for embedded targets?