Inheritance is the concept in object-oriented programming (OOP) that allows a class to inherit properties and behaviors from another class. It is one of the fundamental principles of OOP and plays a crucial role in code reuse and creating relationships between classes.

Inheritance is represented by an "is-a" relationship, where one class is considered to be a specialized version of another class. The class that inherits properties and behaviors is called the subclass or derived class, and the class from which it inherits is called the superclass or base class.

Key Points:
- Inheritance allows the subclass to inherit all the non-private members (properties and methods) of the superclass.
- The subclass can then extend or override these inherited members, as well as add new members specific to itself.
- Inheritance promotes code reuse and modularity by allowing common functionality to be defined in a base class and shared among multiple subclasses.
- It also helps in creating a hierarchy of classes, where subclasses can inherit from other subclasses, forming a tree-like structure.

Benefits of Inheritance:
1. Code Reusability: Inheritance allows subclasses to reuse the code defined in the superclass, reducing code duplication and promoting modular design.
2. Modularity and Maintainability: Inheritance helps in creating a hierarchical structure of classes, making the code more organized and easier to maintain.
3. Polymorphism: Inheritance is closely related to polymorphism, another important concept in OOP. Polymorphism allows objects of different classes to be treated as objects of a common superclass, enabling more flexible and extensible code.

Example:
Let's consider an example where we have a superclass called "Animal" and two subclasses called "Cat" and "Dog". The superclass "Animal" may have properties such as "name" and "age", as well as methods like "eat()" and "sleep()". The subclasses "Cat" and "Dog" can inherit these properties and methods from the superclass, along with any additional properties or methods specific to each subclass.

In this example, the inheritance relationship can be represented as follows:

Animal
- Properties: name, age
- Methods: eat(), sleep()

Cat (subclass of Animal)
- Inherits: name, age, eat(), sleep()
- Additional properties: breed
- Additional methods: meow()

Dog (subclass of Animal)
- Inherits: name, age, eat(), sleep()
- Additional properties: breed
- Additional methods: bark()

By using inheritance, we can create specialized classes like "Cat" and "Dog" that inherit common properties and behaviors from the superclass "Animal", while also adding their own unique characteristics. This promotes code reuse, modularity, and flexibility in our codebase.