\(\quad\) a) Classes allow us to create as many data structure objects as we wish. b) Inheritance enables a subclass to reuse the functionality from a superclass. Public and protected superclass methods can be accessed through a subclass to eliminate duplicate logic. c) Composition enables a class to reuse code by storing a reference to an instance of another class in a field. Public methods of the instance can be called by methods in the class that contains the reference.

Classes in Java are fundamental building blocks of object-oriented programming. Think of a class as a blueprint from which you can create as many objects (known as instances) as needed. This blueprint defines attributes and behaviors that the objects created from the class will have. For example, if you have a class named 'Book', instances of this class may represent individual books, each with their own title, author, and number of pages.

Inside classes, data is encapsulated, meaning it is kept within the class and protected from outside interference and misuse. Classes achieve this by using access modifiers like 'private', which restrict access to the class's internal data. This way, developers can control how data in objects is accessed and modified. Furthermore, methods within the class can manipulate this data, providing a way to interact with the objects. If properly designed, classes can make code more modular, reusable, and maintainable.

Inheritance in Java allows you to create a new class that is based on an existing class. The new class, called a subclass, inherits the characteristics of the existing class, which is called the superclass. This is a powerful way to achieve code reuse and establish a hierarchical relationship between classes.

When a subclass inherits from a superclass, it can use the fields and methods of the superclass as if they were its own. It can also override some of the superclass's methods to provide specific behavior for the subclass. However, it still retains the ability to use methods from the superclass, which prevents the need to rewrite code that is common to both. This 'is-a' relationship simplifies the expansion and maintenance of your codebase.

Example of Inheritance:

Consider a class 'Animal' with a method 'eat()'. If 'Dog' is a subclass of 'Animal', it inherits 'eat()' and can also define additional behaviors like 'bark()'.

Composition is an alternative to inheritance for reusing code and establishing relationships between classes in Java. It involves adding an instance of one class as a field within another class. This represents a 'has-a' relationship and indicates that one class is a component of another class.

By using composition, classes gain access to the methods of the composed instances, thereby reusing functionality without inheritance's tight coupling. This encourages better design flexibility since classes can be composed of multiple other classes, granting a richer set of behaviors. The main advantage of composition is that it provides a means to follow the design principle of 'favor composition over inheritance', leading to a more maintainable and flexible codebase.

Example of Composition:

In a 'Car' class, instead of inheriting from a 'Wheel' class, you can have 'Wheel' instances as fields inside the 'Car' class, depicting that a car has wheels, rather than a car is a wheel.