1 mark MULTIPLE CHOICE QUESTIONS

WEEK 1:

1. Java Was Developed:

a. To replace C++
b. To Solve issues of C++
c. As a gaming Language
d. As a replacement to other programming language

Ans : b. To Solve issues of C++

2. Java is

a. Purely Object Oriented Programming Language

b. Procedural Programming Language
c. Partial Object Oriented Programming Language
d. Structural Programming Language

Ans : Purely Object Oriented Programming Language.

3. Which of the following is not a java Feature?

a. Dynamic
b. Architectural Neutral
c. Use Of Pointers
d. Object Oriented

Ans: c. Use of Pointers

4.

5 marks question

Q1.
a. What is Object Oriented Programing? Discuss various OOPS principles in java

Ans:

Object-Oriented Programming (OOP) is a programming paradigm that focuses on organizing

software design around objects, which are instances of classes. In OOP, objects encapsulate data
and behavior together, allowing for modular and reusable code.
Various OOP principles in Java include:

1. Encapsulation:

- Encapsulation is the principle of hiding internal implementation details of an object and

providing a public interface to interact with it.

- In Java, this is achieved using classes and access modifiers (public, private, protected) to
control access to the object's variables and methods.

- Encapsulation promotes information hiding, abstraction, and modularity, enhancing code

maintainability and reusability.

2. Inheritance:

- Inheritance is the principle of creating new classes (derived or child classes) based on existing
classes (base or parent classes).

- In Java, inheritance is achieved using the "extends" keyword, allowing derived classes to
inherit the properties and methods of the base class.

- Inheritance promotes code reuse, extensibility, and the creation of hierarchical class
structures.

3. Polymorphism:

- Polymorphism is the principle that allows objects of different types to be treated as instances
of a common superclass or interface.

- In Java, polymorphism is achieved through method overriding and method overloading.

- Method overriding allows a subclass to provide its own implementation of a method defined
in the superclass.

- Method overloading allows multiple methods with the same name but different parameter
lists to coexist within a class.

- Polymorphism enables flexibility, modularity, and code extensibility.

4. Abstraction:

- Abstraction is the principle of simplifying complex systems by breaking them down into
manageable and understandable components.

- In Java, abstraction is achieved using abstract classes and interfaces.

- Abstract classes provide a blueprint for derived classes but cannot be instantiated themselves.

- Interfaces define a contract for implementing classes to follow, specifying method signatures
without providing an implementation.

- Abstraction promotes modularity, loose coupling, and the ability to focus on essential aspects
of an object or system.

5. Composition:

- Composition is the principle of building complex objects by combining simpler objects or

components.

- In Java, composition is achieved by creating objects of one class within another class.

- Composition allows for the creation of flexible and modular code by assembling objects with
different behaviors and responsibilities.

- It promotes code reuse, maintainability, and the creation of complex systems from smaller,
well-defined components.

These principles form the foundation of OOP in Java and help in creating well-structured,
maintainable, and scalable software systems. They provide a set of guidelines and practices to
design and implement object-oriented programs effectively.

b. Differentiate between method Overloading and Overriding in java?

Ans :

Method Overloading and Method Overriding are two fundamental concepts in Java that involve
the usage of methods within classes. Here's a differentiation between the two:

Method Overloading:
- Method overloading refers to defining multiple methods with the same name but different
parameters within the same class.

- Overloaded methods must have different parameter lists, which can vary in the number of
parameters, order, or data types.

- The compiler determines which overloaded method to invoke based on the arguments passed
during the method call.

- Method overloading allows a class to provide multiple methods with the same name, but each
method performs a different operation or handles different types of inputs.

- Overloading helps improve code readability and provides flexibility when working with
different input scenarios.

Method Overriding:

- Method overriding occurs when a subclass provides its own implementation of a method that is
already defined in its superclass.

- The overriding method must have the same method signature (name, return type, and parameter
list) as the method in the superclass.

- Method overriding is used to achieve runtime polymorphism, where the specific

implementation of the method is determined dynamically based on the actual object type.

- When a subclass overrides a method, it can provide additional functionality or modify the
behavior of the method defined in the superclass.

- Method overriding is typically used to customize the behavior of inherited methods and support
the "is-a" relationship between classes in an inheritance hierarchy.

In summary, method overloading involves defining multiple methods with the same name but
different parameters within the same class, while method overriding occurs when a subclass
provides its own implementation of a method already defined in its superclass. Method
overloading is resolved at compile-time based on the method's signature, whereas method
overriding is resolved at runtime based on the actual object type.

Q2:

a. Write a program in java to display student id and Name using default and
parameterized constructors?
Ans:

Algorithm:

1. Define a class called "Student" with private instance variables `studentId` (int) and
`studentName` (String).

2. Implement the default constructor of the "Student" class:

a. Set the `studentId` to 0 and `studentName` to an empty string.

3. Implement the parameterized constructor of the "Student" class:

a. Accept the student ID (id) and student name (name) as parameters.

b. Set the `studentId` to the value of id and `studentName` to the value of name.

4. Implement a method called `displayInfo` within the "Student" class:

a. Print "Student ID: " concatenated with the value of `studentId`.

b. Print "Student Name: " concatenated with the value of `studentName`.

5. In the `main` method:

a. Create an instance of the "Student" class using the default constructor.

b. Call the `displayInfo` method on the instance to display the student information.

c. Create another instance of the "Student" class using the parameterized constructor, providing
a student ID and name.

d. Call the `displayInfo` method on the second instance to display the student information.

6. Run the program and observe the output.

Program
public class Student {

private int studentId;

private String studentName;

// Default constructor

public Student() {

this.studentId = 0;

this.studentName = "";

// Parameterized constructor

public Student(int id, String name) {

this.studentId = id;

this.studentName = name;

// Method to display student information

public void displayInfo() {

System.out.println("Student ID: " + studentId);

System.out.println("Student Name: " + studentName);

public static void main(String[] args) {

// Create an object using the default constructor

Student student1 = new Student();

 // Display student information

System.out.println("Student 1 (Default Constructor):");

student1.displayInfo();

// Create an object using the parameterized constructor

Student student2 = new Student(12345, "John Doe");

// Display student information

System.out.println("\nStudent 2 (Parameterized Constructor):");

student2.displayInfo();

Output

Student 1 (Default Constructor):

Student ID: 0

Student Name:

Student 2 (Parameterized Constructor):

Student ID: 12345

Student Name: John Doe

In this program, the Student class has a default constructor that initializes the studentId and
studentName with default values. It also has a parameterized constructor that accepts the student
ID and name as parameters and initializes the instance variables with the provided values.

In the displayInfo() method, the student ID and name are printed to the console.
In the main method, we create two instances of the Student class, one using the default
constructor and the other using the parameterized constructor. We then call the displayInfo()
method to display the student information for each instance.

b. What is inheritance and explain the terms parent class and child class? State the
advantages of inheritance in java?

Ans:

Inheritance is a fundamental concept in object-oriented programming (OOP) that allows classes

to inherit properties and behaviors from other classes. It establishes a parent-child relationship
between classes, where the child class inherits the attributes and methods of the parent class. The
parent class is also known as the superclass, while the child class is referred to as the subclass.

Parent Class:

- The parent class, also known as the superclass or base class, is the class from which other
classes inherit properties and behaviors.

- It serves as a blueprint for creating subclasses, providing a set of common attributes and
methods that can be reused by multiple subclasses.

- The parent class encapsulates general characteristics and behaviors shared by its subclasses.

Child Class:

- The child class, also known as the subclass or derived class, is a class that inherits properties
and behaviors from a parent class.

- It extends the parent class, inheriting its attributes and methods, and can add additional
attributes and methods specific to its own functionality.

- The child class can override inherited methods to provide its own implementation or extend the
behavior of the parent class.

Advantages of Inheritance in Java:

1. Code Reusability: Inheritance allows classes to reuse code from parent classes, reducing code
duplication. Common attributes and methods defined in the parent class can be inherited by
multiple subclasses, promoting code reuse and maintaining a modular code structure.

2. Modularity and Extensibility: Inheritance supports modularity by organizing classes into a

hierarchy based on their relationships. New classes can be created by extending existing classes,
allowing for the extension and modification of functionality while preserving the existing
codebase.

3. Polymorphism: Inheritance enables polymorphism, which allows objects of different classes to

be treated as objects of a common superclass. This promotes flexibility in coding and facilitates
the creation of code that can work with objects of various related types.

4. Method Overriding: Inheritance allows subclasses to override methods inherited from the
parent class. This enables customization of behavior specific to the subclass and supports
dynamic method dispatch, where the appropriate method implementation is determined at
runtime based on the actual object type.

5. Code Organization and Maintenance: Inheritance helps in organizing code by establishing

relationships between classes. It provides a clear structure and improves code readability.
Additionally, modifications made to the parent class automatically propagate to all its subclasses,
reducing the need for redundant changes.

Overall, inheritance in Java enhances code reuse, modularity, and extensibility while promoting
a structured and maintainable codebase. It is a powerful mechanism for building complex class
hierarchies and achieving code efficiency.

Q3.

a. Discuss the differences between checked and unchecked exceptions in java?

Ans:

Differences between Checked and Unchecked Exceptions in Java:

Checked Exceptions:

- Checked exceptions are exceptions that the compiler requires the programmer to handle or
declare using the "throws" keyword in the method signature.

- They are checked at compile-time, and the compiler ensures that the programmer handles these
exceptions either by using try-catch blocks to catch the exception or by declaring the exception
to be thrown.

- Checked exceptions typically represent conditions that are outside the control of the program
and require special handling, such as file I/O errors, network errors, or database connectivity
issues.

- Examples of checked exceptions in Java include IOException, SQLException, and

ClassNotFoundException.

Unchecked Exceptions:

- Unchecked exceptions, also known as runtime exceptions, are exceptions that do not require the
programmer to handle or declare them explicitly.

- They are not checked at compile-time, and the compiler does not enforce any handling or
declaration requirements.

- Unchecked exceptions typically indicate programming errors or exceptional conditions that can
be avoided through proper coding practices, such as NullPointerException,
ArrayIndexOutOfBoundsException, and IllegalArgumentException.

- Unchecked exceptions are subclasses of RuntimeException or Error classes.

Key Differences:

1. Handling Requirement: Checked exceptions require the programmer to handle or declare

them, while unchecked exceptions do not have this requirement.

2. Compile-time Checking: Checked exceptions are checked at compile-time by the compiler,

ensuring that they are either caught or declared, whereas unchecked exceptions are not checked
at compile-time.

3. Checked vs. Unchecked Hierarchy: Checked exceptions are subclasses of the Exception class
(excluding RuntimeException and its subclasses), while unchecked exceptions are subclasses of
RuntimeException or Error classes.
4. Programmatic Errors: Unchecked exceptions are usually caused by programming errors, such
as null references or array index out of bounds, whereas checked exceptions typically indicate
external conditions or exceptional situations beyond the programmer's control.

5. Developer Responsibility: With checked exceptions, the developer is responsible for handling
or declaring the exception explicitly, ensuring proper error handling and robustness. In the case
of unchecked exceptions, it is the developer's responsibility to avoid such exceptions through
careful coding practices.

It's important to note that while handling checked exceptions is mandatory, it's considered best
practice to handle unchecked exceptions as well to ensure program stability and reliability. By
properly handling exceptions, developers can create more robust and error-tolerant Java
programs.

b. What is deadlock in java? What are the precautions to avoid dead lock in java?

Ans:

Deadlock in Java occurs when two or more threads are blocked forever, waiting for each other to
release resources. It is a situation where a thread holds a resource and waits for another resource
that is held by a different thread, resulting in a circular dependency and a state of deadlock.

Precautions to avoid deadlock in Java:

1. Avoid Circular Dependency: Design your code in a way that avoids circular dependencies
between resources. If two threads are dependent on each other's resources, deadlock can occur.
Analyze the resource dependencies and ensure they are structured to prevent circular
dependencies.

2. Use Resource Ordering: Define a strict ordering of resources to avoid circular wait conditions.
This means that threads will always acquire resources in the same order, preventing potential
deadlocks. By enforcing a consistent resource acquisition order, you eliminate the possibility of
circular dependencies.

3. Use Timeout Mechanisms: Implement timeout mechanisms when acquiring resources. If a

thread is unable to acquire a resource within a specified time, it releases the acquired resources
and retries later. This approach prevents threads from waiting indefinitely and can help resolve
potential deadlocks.

4. Resource Allocation Strategy: Use resource allocation strategies such as resource pooling or
object pooling. By limiting the number of resources available, you can prevent resource
exhaustion and reduce the chances of deadlock.

5. Avoid Nested Locks: Avoid acquiring multiple locks in a nested manner. If you have to
acquire multiple locks, ensure that they are acquired in a consistent order across all threads.
Nested locks can introduce complexities and increase the risk of deadlocks.

6. Use Deadlock Detection and Recovery: Implement deadlock detection mechanisms that
periodically check for deadlock conditions. If a deadlock is detected, take appropriate actions to
recover from the deadlock, such as releasing resources, terminating threads, or restarting the
affected process.

7. Test and Monitor: Thoroughly test your code and perform stress testing to identify potential
deadlock scenarios. Monitor your application for any signs of deadlock and proactively address
them before they cause issues in production.

By following these precautions and best practices, you can minimize the occurrence of deadlocks
in your Java applications and ensure the smooth execution of concurrent code.

Q4.

a. With regards to event handling, describe the layout managers in java.

Ans:

In Java, layout managers are used to determine the placement and arrangement of components
within a container, such as a JFrame or JPanel, during event handling and GUI design. Layout
managers provide flexibility and responsiveness to different window sizes and platform-specific
guidelines. Here are some commonly used layout managers in Java:
1. BorderLayout:

- BorderLayout is the default layout manager for many Java containers.

- It divides the container into five regions: North, South, East, West, and Center.

- Each region can hold only one component, and the center region takes up any remaining
space.

- BorderLayout is useful for creating simple layouts where components need to be placed in
specific regions, such as a toolbar at the top and a status bar at the bottom.

2. FlowLayout:

- FlowLayout arranges components in a row, left to right, until there is no more horizontal
space.

- If the components exceed the width of the container, they wrap to the next row.

- It is useful for creating horizontally aligned components that automatically adjust their
positions as the window is resized.

- FlowLayout is commonly used for toolbars, buttons, or small groups of components.

3. GridLayout:

- GridLayout organizes components in a grid of rows and columns.

- Each cell in the grid has the same size, and components are placed one after another in row-
major order.

- It is useful when you want to arrange components in a grid-like structure, such as a calculator
with a grid of buttons.

4. CardLayout:

- CardLayout allows you to stack components on top of each other, similar to a deck of cards.

- Only one component is visible at a time, and you can switch between components using
methods like `next()` or `previous()`.

- It is suitable for implementing multi-pane interfaces, such as wizards or tabbed views.

5. GridBagLayout:

- GridBagLayout is the most flexible and complex layout manager in Java.

- It allows you to specify constraints for each component, such as its position, size, and
alignment.

- It offers precise control over component placement and is useful for creating complex and
customized layouts.

- GridBagLayout is commonly used in professional GUI design.

These layout managers provide different approaches to component placement and alignment
within containers. Choosing the appropriate layout manager depends on the specific
requirements of your GUI design and the desired behavior during event handling. By selecting
the appropriate layout manager, you can achieve dynamic and responsive GUI layouts in your
Java applications.

b. With the help of suitable examples, explain the different kinds of operators in java?

Ans:

Operators in Java are symbols or keywords used to perform specific operations on operands
(variables, constants, or expressions). Here are the different kinds of operators in Java with
suitable examples:

1. Arithmetic Operators:

- Arithmetic operators perform basic mathematical operations.

- Examples: `+` (addition), `-` (subtraction), `*` (multiplication), `/` (division), `%` (modulus).

- Example: `int result = 10 + 5; // result = 15`

2. Assignment Operators:

- Assignment operators are used to assign values to variables.

 - Examples: `=` (simple assignment), `+=` (add and assign), `-=` (subtract and assign), `*=`
(multiply and assign), `/=` (divide and assign), `%=` (modulus and assign).

- Example: `int x = 10; x += 5; // x = 15`

3. Comparison Operators:

- Comparison operators compare two values and return a boolean result (true or false).

- Examples: `==` (equality), `!=` (not equal), `<` (less than), `>` (greater than), `<=` (less than
or equal to), `>=` (greater than or equal to).

- Example: `boolean result = 10 > 5; // result = true`

4. Logical Operators:

- Logical operators perform logical operations on boolean values and return a boolean result.

- Examples: `&&` (logical AND), `||` (logical OR), `!` (logical NOT).

- Example: `boolean result = (5 > 3) && (4 < 6); // result = true`

5. Bitwise Operators:

- Bitwise operators perform operations on individual bits of integer values.

- Examples: `&` (bitwise AND), `|` (bitwise OR), `^` (bitwise XOR), `~` (bitwise
complement), `<<` (left shift), `>>` (right shift).

- Example: `int result = 10 & 5; // result = 0`

6. Unary Operators:

- Unary operators perform operations on a single operand.

- Examples: `+` (unary plus), `-` (unary minus), `++` (increment), `--` (decrement), `!` (logical
NOT).

- Example: `int x = 5; x++; // x = 6`

7. Ternary Operator:

- The ternary operator is a conditional operator that takes three operands and returns a value
based on a condition.

- Syntax: `condition ? value1 : value2`

- Example: `int x = 10; int y = (x > 5) ? 10 : 20; // y = 10`

These examples demonstrate the usage and functionality of different types of operators in Java.
Operators play a vital role in performing various computations, comparisons, and logical
operations in Java programs.

Q5.

a. With the help of suitable examples, discuss in detail the java AWT buttons and
AWT labels?

Ans:

Java AWT Buttons:

AWT buttons are used to create clickable components in a graphical user interface. They allow
users to perform actions or trigger events when clicked. Here's an example of creating and using
AWT buttons:

```java

import java.awt.*;

import java.awt.event.*;

public class ButtonExample {

public static void main(String[] args) {

// Create a frame

Frame frame = new Frame("Button Example");

// Create a button

Button button = new Button("Click Me");

// Set button position and size

button.setBounds(100, 100, 80, 30);

// Create a label

Label label = new Label();

// Set label position and size

label.setBounds(100, 150, 200, 30);

// Add an ActionListener to the button

button.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

label.setText("Button Clicked!");

});

// Add the button and label to the frame

frame.add(button);

frame.add(label);

// Set frame layout and size

frame.setLayout(null);
 frame.setSize(400, 300);

// Make the frame visible

frame.setVisible(true);

```

In this example, we create a frame using the `Frame` class from the AWT package. Then, we
create a button using the `Button` class and set its position and size using the `setBounds`
method. We also create a label using the `Label` class and set its position and size. Next, we add
an `ActionListener` to the button using an anonymous inner class, which defines the action to be
performed when the button is clicked. In this case, it sets the text of the label to "Button
Clicked!". Finally, we add the button and label to the frame, set the frame's layout to null, set the
size of the frame, and make it visible.

Java AWT Labels:

AWT labels are used to display text or images on a user interface. They provide descriptive
information or act as placeholders for user input. Here's an example of creating and using AWT
labels:

```java

import java.awt.*;

public class LabelExample {

public static void main(String[] args) {

// Create a frame

Frame frame = new Frame("Label Example");

 // Create a label

Label label = new Label("Hello, World!");

// Set label position and size

label.setBounds(100, 100, 200, 30);

// Add the label to the frame

frame.add(label);

// Set frame layout and size

frame.setLayout(null);

frame.setSize(400, 300);

// Make the frame visible

frame.setVisible(true);

```

In this example, we create a frame using the `Frame` class. Then, we create a label using the
`Label` class and set its text to "Hello, World!" using the constructor. We also set the position
and size of the label using the `setBounds` method. Next, we add the label to the frame, set the
frame's layout to null, set the size of the frame, and make it visible.
Both AWT buttons and AWT labels are fundamental components of Java's Abstract Window
Toolkit (AWT). They provide essential functionality for building interactive graphical user
interfaces in Java applications.

b. Describe in detail the string constructor in java?

Ans:

In Java, the `String` class represents a sequence of characters. It provides various constructors to
create strings from different sources, such as character arrays, bytes, and other string objects.
Let's discuss the `String` constructor in detail along with an example:

String Constructor:

The `String` class has multiple constructors, but the most commonly used constructor is
`String(String original)`, which creates a new `String` object that contains a copy of the specified
string. Here's the syntax:

```java

String str = new String(String original);

```

- `original`: The string from which a new `String` object is created.

Example:

```java

String originalString = "Hello, World!";

String newString = new String(originalString);

System.out.println("Original String: " + originalString);

System.out.println("New String: " + newString);

```

Output:

```

Original String: Hello, World!

New String: Hello, World!

```

In the example above, we have an original string "Hello, World!". We use the `String`
constructor to create a new string object `newString` by passing the original string as an
argument. The new string object is an exact copy of the original string.

Explanation:

- The `new String(originalString)` constructor creates a new string object `newString` that
contains a copy of the characters from the `originalString`.

- Both the original string and the new string have the same sequence of characters.

- The `newString` object is a separate instance from the `originalString`. Modifying one string
does not affect the other.

- While the `String` class provides various constructors, including those for character arrays,
bytes, and more, the constructor that takes another `String` object as an argument is commonly
used for creating copies of existing strings.

- It's important to note that in most cases, you don't need to use the `new String()` constructor
explicitly to create strings. Instead, you can directly assign string literals or use string
concatenation and other string manipulation operations.
Overall, the `String` constructor in Java allows you to create a new `String` object by making a
copy of an existing string. It provides flexibility and convenience when working with string
objects in Java.

PART C-10 MARKS EACH

Q1:With the help of suitable examples, discuss the various access modifiers in java?

Ans:

Access modifiers in Java determine the accessibility or visibility of classes, methods, and
variables. There are four types of access modifiers in Java: public, private, protected, and default
(no explicit modifier). Let's discuss each of them with suitable examples:

1. Public Access Modifier:

- The `public` access modifier allows unrestricted access to the class, method, or variable from
anywhere in the program.

- Public members can be accessed by any other class or package.

Example:

```java

public class PublicExample {

public int publicVariable = 10;

public void publicMethod() {

System.out.println("This is a public method.");

```
In this example, the `publicVariable` and `publicMethod()` are accessible from any other class or
package.

2. Private Access Modifier:

- The `private` access modifier restricts access to only within the same class.

- Private members cannot be accessed from other classes or packages.

Example:

```java

public class PrivateExample {

private int privateVariable = 10;

private void privateMethod() {

System.out.println("This is a private method.");

```

In this example, the `privateVariable` and `privateMethod()` can only be accessed within the
same class. They are not visible to other classes or packages.

3. Protected Access Modifier:

- The `protected` access modifier allows access within the same class, subclasses, and the same
package.

- Protected members can be accessed by subclasses and classes within the same package.

Example:
```java

public class ProtectedExample {

protected int protectedVariable = 10;

protected void protectedMethod() {

System.out.println("This is a protected method.");

```

In this example, the `protectedVariable` and `protectedMethod()` can be accessed within the
same class, subclasses, and the same package.

4. Default (No Explicit Modifier) Access Modifier:

- When no access modifier is specified, it is considered as the default access modifier.

- The default access modifier allows access within the same package but not outside of it.

Example:

```java

class DefaultExample {

int defaultVariable = 10;

void defaultMethod() {

System.out.println("This is a default method.");

```
In this example, the `defaultVariable` and `defaultMethod()` are accessible within the same
package but not outside of it.

- Access modifiers can be applied to classes, methods, and variables.

- The access level is hierarchical: `public` is the highest, followed by `protected`, default, and
`private` being the most restrictive.

- Access modifiers ensure encapsulation, data hiding, and maintainability in object-oriented

programming.

By utilizing different access modifiers, you can control the accessibility of classes, methods, and
variables in your Java programs, ensuring proper encapsulation and defining appropriate access
levels for different components.

Q2: Difference between Multilevel inheritance and Hierarchical inheritance in java.

Support your answer with suitable code examples?

Ans:

Multilevel inheritance and hierarchical inheritance are two types of class inheritance in Java.
Let's discuss the differences between them and provide code examples for better understanding:

1. Multilevel Inheritance:

- Multilevel inheritance occurs when a derived class inherits from a base class, and another
class inherits from that derived class.

- It creates a chain of inheritance where each class extends the previous one.

- It allows for the reusability of code and the creation of a specialized hierarchy of classes.

Example:

```java

class Animal {
 void eat() {

System.out.println("Animal is eating...");

class Dog extends Animal {

void bark() {

System.out.println("Dog is barking...");

class Labrador extends Dog {

void color() {

System.out.println("Labrador is black...");

public class MultilevelInheritanceExample {

public static void main(String[] args) {

Labrador labrador = new Labrador();

labrador.eat(); // Inherited from Animal class

labrador.bark(); // Inherited from Dog class

labrador.color(); // Specific to Labrador class

}
```

In this example, the `Animal` class is the base class, the `Dog` class inherits from `Animal`, and
the `Labrador` class inherits from `Dog`. The `Labrador` class can access methods from both the
`Animal` and `Dog` classes, creating a chain of inheritance.

2. Hierarchical Inheritance:

- Hierarchical inheritance occurs when multiple classes inherit from a single base class.

- It allows for the creation of multiple specialized classes from a common base class.

- Each derived class inherits the properties and methods of the base class and can have its own
additional features.

Example:

```java

class Animal {

void eat() {

System.out.println("Animal is eating...");

class Dog extends Animal {

void bark() {

System.out.println("Dog is barking...");

}
class Cat extends Animal {

void meow() {

System.out.println("Cat is meowing...");

public class HierarchicalInheritanceExample {

public static void main(String[] args) {

Dog dog = new Dog();

dog.eat(); // Inherited from Animal class

dog.bark(); // Specific to Dog class

Cat cat = new Cat();

cat.eat(); // Inherited from Animal class

cat.meow(); // Specific to Cat class

```

In this example, both the `Dog` and `Cat` classes inherit from the `Animal` class. Each derived
class can access the `eat()` method from the `Animal` class and has its own specific method
(`bark()` for `Dog` and `meow()` for `Cat`).

Key Difference:

- Multilevel inheritance involves a chain of inheritance, where each derived class extends the
previous one, while hierarchical inheritance involves multiple classes inheriting from a common
base class.
- In multilevel inheritance, there is a specialized hierarchy of classes, whereas in hierarchical
inheritance, multiple specialized classes are derived from a common base class.

Both multilevel and hierarchical inheritance provide flexibility and code reusability in Java,
allowing for the creation of class hierarchies and specialization of classes based on specific
requirements.