DEPARTMENT OF COMPUTER SCIENCE AND ENGINEERING

CS3391 OBJECT ORIENTED PROGRAMMING

QUESTION BANK WITH ANSWERS
UNIT II
PART A (10 X 2 =20)
1. Mention the use of constructor overloading.Apr/May 2024
Constructor overloading in Java occurs when a class has multiple constructors, each with a
separate and unique method signature. Overloading constructors in Java provides a variety of
benefits to both the component developer and the API user: The ability to set sensible
defaults when property values are unknown.to
2. Illustrate method over riding with example.Apr/May 2024
Declaring a method in sub class which is already present in parent class is known as method
overriding.
Example:
We have two classes: A child class Boy and a parent class Human. The Boy class
extends Human class. Both the classes have a common method void eat(). Boy class is giving
its own implementation to the eat() method or in other words it is overriding the eat() method.
3.What is the use of final keyword?Apr/May 2023
The final keyword in Java is used to make classes, methods, and variables non-changeable, or
"final". It's used to ensure that the value of a variable or element doesn't change or extend,
which can help with thread safety, security, error prevention, and code optimization.
4.How dynamic method resolution is achieved in Java? Apr/May 2023
Dynamic method dispatch is the mechanism through which the correct version of an
overridden method is called at runtime. It plays a pivotal role in runtime polymorphism by
determining the appropriate method to execute based on the actual object type.
5. Define method overloading and method overriding. Nov/Dec 2022
Method overloading
In this case, multiple methods in the same class have the same name but different
parameters
Method overriding
In this case, a child class creates a method with the same name, parameters, and return type
as a method in the parent class. The overriding method can then perform different actions
depending on which class it's called in.

6. Can we access parent class variables in child class using super keyword? Nov/Dec
2022
Yes, we can access parent class variables in a child class using the super keyword, but the
super keyword is generally used to access methods or constructors from the parent class
rather than directly accessing variables. However, the accessibility of parent class variables
depends on their visibility.

7. Define Inheritance Apr/May 2022

Inheritance is a fundamental concept in object-oriented programming (OOP) that allows a
class (known as a child or subclass) to inherit properties and behaviors (methods) from
another class (known as a parent or superclass). It enables the creation of a new class based
on an existing class, promoting code reuse and establishing a natural hierarchy between
classes.

8. How can a subclass can call a constructor defined by its super class? Apr/May 2022
In object-oriented programming, a subclass can call a constructor defined by its superclass
(also known as the parent class) using the super() function. This allows the subclass to
initialize the properties of the superclass before adding or modifying its own properties.

9. When a class must be declared as abstract? Nov/Dec 2021

A class should be declared as abstract when it is intended to be a base class that provides a
common interface and/or partial implementation for its subclasses, but it should not be
instantiated on its own. An abstract class typically serves as a blueprint for other classes and
often contains abstract methods—methods that are declared but not implemented in the
abstract class. Subclasses are required to provide implementations for these abstract methods.

10. Outline the use of extends keyword in Java with syntax. Nov/Dec 2021
The extends keyword is used to indicate that one class is inheriting from another class. This
establishes a parent-child relationship between classes, where the child class (subclass)
inherits properties and methods from the parent class (superclass). This mechanism facilitates
code reuse, method overriding, and the creation of a class hierarchy.

PART B(5 x 13 = 65)

1.With an example explain the use of abstract classes in Java.
In Java, abstract classes are used to create a base class that cannot be instantiated on its own
but can be subclassed. Abstract classes allow you to define a common interface and provide
some method implementations while leaving other methods to be implemented by subclasses.
This promotes a clear class hierarchy and enforces certain structures for derived classes.
Key Points about Abstract Classes:
1. Cannot Be Instantiated: You cannot create an instance of an abstract class directly.
2. Can Have Abstract Methods: Abstract methods are declared without an
implementation and must be implemented by any concrete subclass.
3. Can Have Concrete Methods: Abstract classes can also have fully implemented
methods that can be inherited by subclasses.
4. Can Have Fields and Constructors: Abstract classes can have fields and
constructors, which can be used by their subclasses.
Syntax
abstract class AbstractClass
{
// Abstract method (does not have a body)
abstract void abstractMethod();
// Regular method
void regularMethod()
{ System.out.println("This is a regular method.");
}
}
Example: Abstract Class in Java
Let’s go through an example where we define an abstract class and then extend it with
concrete subclasses.
1. Define the Abstract Class
Abstract class Animal
{
// Abstract method (does not have a body)
abstract void makeSound();
// Regular method void sleep()
{
System.out.println("This animal is sleeping.");
}
}
In this example:
Animal is an abstract class.

 makeSound() is an abstract method that must be implemented by any subclass.

 sleep() is a concrete method that provides a default implementation.

2. Create Concrete Subclasses

class Dog extends Animal
{
// Implementing the abstract method
@Override
void makeSound()
{
System.out.println("The dog barks.");
}
}
class Cat extends Animal
{
// Implementing the abstract method
@Override
void makeSound()
{
System.out.println("The cat meows.");
}
}
In these subclasses:
 Dog and Cat extend Animal.
 They provide their own implementations of the makeSound() method.
3. Using the Abstract Class and Subclasses
java
Copy code
public class Main
{
public static void main(String[] args)
{
// Creating instances of concrete subclasses
Animal myDog = new Dog();
Animal myCat = new Cat();
 // Calling implemented methods
myDog.makeSound(); // Outputs: The dog barks.
myDog.sleep(); // Outputs: This animal is sleeping.

myCat.makeSound(); // Outputs: The cat meows.

myCat.sleep(); // Outputs: This animal is sleeping.
}
}
In this example:

 We create instances of Dog and Cat, which are concrete implementations of the
abstract Animal class.
 We call both the abstract method (makeSound()) and the concrete method (sleep()) on
these instances.

2. What is user defined package? How to create and import a user defined package?
Explain with example.Apr/May 2024

In Java, a user-defined package is a way to organize related classes and interfaces into a
namespace to avoid naming conflicts and to manage the complexity of large applications.
Packages help in grouping related functionality and making code more modular and
maintainable.
Creating a User-Defined Package
To create a user-defined package, you need to follow these steps:
1. Create the Package Directory Structure: Create a directory structure that matches
the package name. For example, if your package name is com.example.myapp, you
should create the following directory structure.
Example:
com/
example/
myapp/
MyClass.java
2. Declare the Package in Java Source File: At the top of your Java source file,
declare the package name using the package keyword.
Example
// File: com/example/myapp/MyClass.java
package com.example.myapp;
public class MyClass
{
public void displayMessage()
{
System.out.println("Hello from MyClass in com.example.myapp package.");
}
}
3. compile the Java Source File: Navigate to the root directory where the com
directory is located and compile the Java file using the javac command.
javac com/example/myapp/MyClass.java
This will create a MyClass.class file in the com/example/myapp/ directory.
Importing a User-Defined Package
To use classes from a user-defined package, you need to import them into your Java program.
You can use the import keyword to include the package in your code.
1. Import the Package in Your Java File:
Example:
// File: Main.java
import com.example.myapp.MyClass;

public class Main {

public static void main(String[] args) {
MyClass obj = new MyClass();
obj.displayMessage();
}
}
2. Compile and Run the Program: Compile the Main.java file from the root directory
(where the com directory is located).
javac Main.java
Then, run the compiled Main class.
java Main
Output:
Hello from MyClass in com.example.myapp package.
Detailed Example
Let’s walk through a complete example of creating and using a user-defined package.
1. Create the Package and Class
 Directory Structure:
project/ com/ example/ myapp/MyClass.java/Main.java
 MyClass.java:
// File: com/example/myapp/MyClass.java
package com.example.myapp;

public class MyClass {

public void show() {
System.out.println("This is a method from MyClass.");
}
}
2. Create the Main Class to Use the Package
 Main.java:
// File: Main.java
import com.example.myapp.MyClass;

public class Main {

public static void main(String[] args) {
MyClass myClass = new MyClass();
myClass.show();
}
}
3. Compile and Run the Program
 Compile the Package Classes:
javac com/example/myapp/MyClass.java
 Compile the Main Class:
javac Main.java
  Run the Main Class:
java Main
Output:
This is a method from MyClass.

3. Explain in detail about the basics of inheritance and elaborate on any two inheritance
mechanisms in java. Apr/May 2023

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

allows a class (known as the subclass or child class) to inherit properties and behaviors
(methods) from another class (known as the superclass or parent class). This promotes code
reusability and establishes a natural hierarchy between classes.

Two Inheritance Mechanisms in Java

Java supports different inheritance mechanisms, including single inheritance, multiple

inheritance (through interfaces), and hierarchical inheritance. Let’s elaborate on single
inheritance and multiple inheritance through interfaces.

1. Single Inheritance

Single inheritance is where a subclass inherits from a single superclass. This is the simplest
form of inheritance in Java and helps establish a straightforward parent-child relationship.

Example:

java
Copy code
// Superclass
class Animal {
void eat() {
System.out.println("This animal eats food.");
}
}

// Subclass inheriting from Animal

class Dog extends Animal {
void bark() {
System.out.println("The dog barks.");
}
}

public class Main {

public static void main(String[] args) {
Dog dog = new Dog();
dog.eat(); // Inherited method from Animal
dog.bark(); // Method of Dog
}
}
Explanation:
 Animal is the superclass with a method eat().
 Dog is a subclass that extends Animal and inherits its eat() method while adding its
own method bark().
 In the Main class, we create an instance of Dog and call both eat() and bark().

2. Multiple Inheritance through Interfaces

Java does not support multiple inheritance of classes to avoid complexity and ambiguity, but
it supports multiple inheritance through interfaces. A class can implement multiple interfaces,
which allows it to inherit abstract methods from multiple sources.
Example:
java
Copy code
// First interface
interface Animal {
void eat();
}

// Second interface
interface Pet {
void play();
}

// Class implementing multiple interfaces

class Dog implements Animal, Pet {
@Override
public void eat() {
System.out.println("The dog eats.");
}

@Override
public void play() {
System.out.println("The dog plays.");
}
}

public class Main {

public static void main(String[] args) {
Dog dog = new Dog();
dog.eat(); // Implemented method from Animal
dog.play(); // Implemented method from Pet
}
}
Explanation:
 Animal and Pet are interfaces with abstract methods eat() and play(), respectively.
 Dog implements both Animal and Pet, providing concrete implementations for both
methods.
 In the Main class, we create an instance of Dog and call eat() and play().
4. a.write a java program for library interface with drawbook(),returnbook( ) and
check status() methods. Nov/Dec 2022(8)

1. Define the Library Interface: This interface will include the methods drawBook(),
returnBook(), and checkStatus().
2. Implement the Interface: Create a class that implements the Library interface and
provides concrete implementations for these methods.
3. Use the Implementing Class: Write a Main class to demonstrate how the interface
and its implementation can be used.
Here's an example of how you can achieve this:
1. Define the Library Interface
public interface Library {
void drawBook(String bookTitle);
void returnBook(String bookTitle);
void checkStatus(String bookTitle);
}
2. Implement the Interface
For simplicity, the implementation will use an ArrayList to manage the books and their
statuses.
import java.util.HashMap;
import java.util.Map;

public class LibraryImpl implements Library {

private Map<String, Boolean> books;

public LibraryImpl() {
books = new HashMap<>();
// Adding some books to the library
books.put("Java Programming", true); // true indicates the book is available
books.put("Data Structures", true);
books.put("Algorithms", true);
}

@Override
public void drawBook(String bookTitle) {
if (books.containsKey(bookTitle)) {
if (books.get(bookTitle)) {
books.put(bookTitle, false); // Mark the book as drawn
System.out.println("You have drawn the book: " + bookTitle);
} else {
System.out.println("The book \"" + bookTitle + "\" is already drawn.");
}
} else {
System.out.println("The book \"" + bookTitle + "\" is not available in the library.");
}
}

@Override
public void returnBook(String bookTitle) {
if (books.containsKey(bookTitle)) {
 if (!books.get(bookTitle)) {
books.put(bookTitle, true); // Mark the book as returned
System.out.println("You have returned the book: " + bookTitle);
} else {
System.out.println("The book \"" + bookTitle + "\" was not drawn.");
}
} else {
System.out.println("The book \"" + bookTitle + "\" is not recognized.");
}
}

@Override
public void checkStatus(String bookTitle) {
if (books.containsKey(bookTitle)) {
if (books.get(bookTitle)) {
System.out.println("The book \"" + bookTitle + "\" is available.");
} else {
System.out.println("The book \"" + bookTitle + "\" is currently drawn.");
}
} else {
System.out.println("The book \"" + bookTitle + "\" is not available in the library.");
}
}
}
3. Use the Implementing Class
public class Main {
public static void main(String[] args) {
Library library = new LibraryImpl();

// Check status of books

library.checkStatus("Java Programming");
library.checkStatus("Data Structures");

// Draw a book
library.drawBook("Java Programming");
library.drawBook("Data Structures");

// Check status again

library.checkStatus("Java Programming");
library.checkStatus("Data Structures");

// Return a book
library.returnBook("Java Programming");
library.returnBook("Data Structures");

// Check status again

library.checkStatus("Java Programming");
library.checkStatus("Data Structures");
}
}
Explanation
 1. Library Interface (Library.java):
o Defines the methods that must be implemented by any class that provides
library functionality.
2. Library Implementation (LibraryImpl.java):
o Implements the Library interface.
o Uses a HashMap to keep track of books and their availability.
o Provides concrete implementations for drawing a book, returning a book, and
checking the status of a book.
3. Main Class (Main.java):
o Demonstrates how to use the LibraryImpl class to interact with the library
system.
o Checks the status of books, draws books, and returns books while showing
how the library responds to these actions.
This example provides a simple yet comprehensive way to manage library book operations
using interfaces and their implementations in Java.

4. b. Explain method overloading with an example. Nov/Dec 2022(5)

Method overloading in Java allows a class to have more than one method with the same
name but different parameters. This means you can define multiple methods with the same
name but differing in the number or type of their parameters. Overloading is a way to achieve
polymorphism, allowing methods to perform different tasks based on the number or type of
arguments passed.
Key Points of Method Overloading
1. Different Parameters: The overloaded methods must differ in the number of
parameters or the types of parameters.
2. Same Method Name: All overloaded methods share the same name but have
different parameter lists.
3. Return Type: Overloading is not determined by the return type alone. Methods with
the same name and different return types but the same parameter list will not be
considered overloaded.
Example of Method Overloading
Here’s a simple example to illustrate method overloading:
java
Copy code
class Calculator {

// Method to add two integers

public int add(int a, int b) {
return a + b;
}

// Method to add three integers

public int add(int a, int b, int c) {
return a + b + c;
}

// Method to add two double values

public double add(double a, double b) {
return a + b;
}
 // Method to add a variable number of integers (varargs)
public int add(int... numbers) {
int sum = 0;
for (int num : numbers) {
sum += num;
}
return sum;
}
}

public class Main {

public static void main(String[] args) {
Calculator calc = new Calculator();

// Calling different overloaded methods

System.out.println("Sum of 10 and 20: " + calc.add(10, 20)); // Calls add(int a,
int b)
System.out.println("Sum of 10, 20, and 30: " + calc.add(10, 20, 30)); // Calls add(int a,
int b, int c)
System.out.println("Sum of 10.5 and 20.5: " + calc.add(10.5, 20.5)); // Calls
add(double a, double b)
System.out.println("Sum of 1, 2, 3, 4, 5: " + calc.add(1, 2, 3, 4, 5)); // Calls add(int...
numbers)
}
}
Explanation
1. add(int a, int b):
o Adds two integers and returns the result.
2. add(int a, int b, int c):
o Adds three integers and returns the result. This is another overloaded version
of the add method.
3. add(double a, double b):
o Adds two double values and returns the result. This demonstrates overloading
by changing the parameter type.
4. add(int... numbers):
o Uses varargs (variable-length arguments) to accept any number of integer
arguments. It calculates the sum of all provided integers. This method is also
an overloaded version but uses a variable number of arguments.

5. What is an interface? How to define an interface? How one or more classes can
implement interface? Outline with code fragments
In Java, an interface is a reference type that can contain only constants, method signatur,
default methods, static methods, and nested types. It cannot contain instance fields or
constructors. Interfaces are used to specify a set of methods that a class must implement, thus
providing a form of abstraction. Interfaces define a contract for what a class can do, without
specifying how it does it.
Key Characteristics of Interfaces
1. Abstract Methods: An interface can include abstract methods (methods without a
body) that must be implemented by any class that implements the interface.
 2. Default Methods: Interfaces can have default methods with a body that provide a
default implementation.
3. Static Methods: Interfaces can have static methods that can be called without
creating an instance of the interface.
4. Constants: Interfaces can contain constants (public, static, and final variables).
5. No Constructors: Interfaces cannot have constructors.
Defining an Interface
To define an interface, use the interface keyword. Here’s how you can define an interface:
java
Copy code
// Define an interface
public interface Animal {
// Abstract method (does not have a body)
void eat();

// Default method with a body

default void sleep() {
System.out.println("This animal is sleeping.");
}

// Static method with a body

static void makeSound() {
System.out.println("Some generic animal sound.");
}
}
Implementing an Interface
A class implements an interface using the implements keyword. A class that implements an
interface must provide concrete implementations for all abstract methods defined in the
interface.
Example of a class implementing an interface:
java
Copy code
// Implementing the Animal interface
public class Dog implements Animal {

// Providing implementation for the abstract method

@Override
public void eat() {
System.out.println("The dog eats.");
}

// The sleep() method from the interface can be used as-is

// or overridden if needed

// The makeSound() method is static and can be called directly

}

public class Main {

public static void main(String[] args) {
Dog myDog = new Dog();
myDog.eat(); // Outputs: The dog eats.
 myDog.sleep(); // Outputs: This animal is sleeping.

// Call the static method using the interface name

Animal.makeSound(); // Outputs: Some generic animal sound.
}
}
Implementing Multiple Interfaces
A class can implement multiple interfaces by separating them with commas in the
implements clause.
Example:
java
Copy code
// Define another interface
public interface Pet {
void play();
}

// Implementing multiple interfaces

public class Cat implements Animal, Pet {

// Providing implementation for the abstract method from Animal

@Override
public void eat() {
System.out.println("The cat eats.");
}

// Providing implementation for the method from Pet

@Override
public void play() {
System.out.println("The cat plays.");
}
}

public class Main {

public static void main(String[] args) {
Cat myCat = new Cat();
myCat.eat(); // Outputs: The cat eats.
myCat.play(); // Outputs: The cat plays.
myCat.sleep(); // Outputs: This animal is sleeping.
}
}
PART C (15 x 1)
Case Study 1:
1. What is package? Explain in detail about how the package provide access control to
various categories of visibility for class members.
In Java, a package is a namespace that organizes a set of related classes and interfaces. It
provides a way to group related types together, which helps in managing large codebases and
avoiding name conflicts. Packages also play a crucial role in controlling access to classes,
methods, and other members, facilitating encapsulation and modularization in Java
applications.
Understanding Packages in Java
1. Definition and Structure
 Package Declaration: At the beginning of a Java source file, you can declare the
package to which the class belongs. For example:
java
Copy code
package com.example.myapp;
 Package Hierarchy: Packages can be hierarchical, where a package can contain sub-
packages. For instance:
o com.example (parent package)
 com.example.myapp (sub-package)
 com.example.utils (sub-package)
 Directory Structure: The directory structure on the file system should match the
package structure. For instance, the class MyClass in the package
com.example.myapp should be located in a directory com/example/myapp/.
2. Access Control and Visibility
Packages play a significant role in access control. Java provides several access modifiers that
define the visibility and accessibility of class members (fields, methods, and constructors).
Here’s how packages interact with these modifiers:
 Public: Members declared as public can be accessed from any other class in any
package. This means that a public class or member can be accessed across different
packages.
java
Copy code
package com.example.myapp;

public class MyClass {

public int publicField;
public void publicMethod() {}
}
java
Copy code
package com.example.other;

import com.example.myapp.MyClass;

public class Test {

public void test() {
MyClass obj = new MyClass();
obj.publicField = 10; // Accessible
obj.publicMethod(); // Accessible
}
}
 Protected: Members declared as protected can be accessed within the same package
and by subclasses (including subclasses in different packages). However, protected
members are not accessible to non-subclasses in other packages.
java
Copy code
package com.example.myapp;
 public class MyClass {
protected int protectedField;
protected void protectedMethod() {}
}
java
Copy code
package com.example.other;

import com.example.myapp.MyClass;

public class SubClass extends MyClass {

public void test() {
this.protectedField = 10; // Accessible because SubClass extends MyClass
this.protectedMethod(); // Accessible because SubClass extends MyClass
}
}
 Default (Package-Private): If no access modifier is specified, the member is
accessible only within the same package. This is also known as package-private
access. Members with default access cannot be accessed from classes in other
packages.
java
Copy code
package com.example.myapp;

class MyClass {
int defaultField;
void defaultMethod() {}
}
java
Copy code
package com.example.other;

import com.example.myapp.MyClass;

public class Test {

public void test() {
MyClass obj = new MyClass();
// obj.defaultField = 10; // Not accessible
// obj.defaultMethod(); // Not accessible
}
}
 Private: Members declared as private are accessible only within the class where they
are declared. They are not accessible from any other class, even within the same
package.
java
Copy code
package com.example.myapp;

public class MyClass {

private int privateField;
 private void privateMethod() {}

public void accessPrivateMembers() {

privateField = 10; // Accessible within the same class
privateMethod(); // Accessible within the same class
}
}
3. Importing and Accessing Classes
To use classes from other packages, you need to import them using the import statement. If
you don’t use an import statement, you need to use the fully qualified name of the class.
 Single Import:
java
Copy code
import com.example.myapp.MyClass;
 Wildcard Import: Imports all classes from a package.
java
Copy code
import com.example.myapp.*;
Example of Access Control
Here’s a practical example demonstrating how different access modifiers affect visibility
across packages:
File: com/example/parent/ParentClass.java
java
Copy code
package com.example.parent;

public class ParentClass {

public int publicField = 1;
protected int protectedField = 2;
int defaultField = 3; // package-private
private int privateField = 4;

public void printFields() {

System.out.println("Public: " + publicField);
System.out.println("Protected: " + protectedField);
System.out.println("Default: " + defaultField);
System.out.println("Private: " + privateField);
}
}
File: com/example/child/ChildClass.java
java
Copy code
package com.example.child;

import com.example.parent.ParentClass;

public class ChildClass extends ParentClass {

public void printAccess() {
System.out.println("Public: " + publicField); // Accessible
System.out.println("Protected: " + protectedField); // Accessible
 // System.out.println("Default: " + defaultField); // Not accessible
// System.out.println("Private: " + privateField); // Not accessible
}
}
File: com/example/other/OtherClass.java
java
Copy code
package com.example.other;

import com.example.parent.ParentClass;

public class OtherClass {

public void printAccess() {
ParentClass obj = new ParentClass();
System.out.println("Public: " + obj.publicField); // Accessible
// System.out.println("Protected: " + obj.protectedField); // Not accessible
// System.out.println("Default: " + obj.defaultField); // Not accessible
// System.out.println("Private: " + obj.privateField); // Not accessible
}
}

Case Study 2:
2. Explain simple interfaces and nested interfaces with example.
In Java, interfaces are a fundamental concept used to define methods that a class must
implement. They provide a way to achieve abstraction and multiple inheritance in Java.
Interfaces can be either simple or nested, depending on their context and usage.
Simple Interfaces
A simple interface is a standalone interface defined at the top level of a Java file. It can be
implemented by classes to define a contract for what methods a class must implement.
Key Characteristics of Simple Interfaces:
 Method Definitions: Interfaces can contain method signatures, but they cannot
provide method implementations (until Java 8, which introduced default methods).
 Constants: Interfaces can declare constants, which are implicitly public, static, and
final.
 No Constructor: Interfaces cannot have constructors.
 Inheritance: Interfaces can extend other interfaces but cannot extend classes.
Example of a Simple Interface
java
Copy code
// Define the simple interface
interface Animal {
// Abstract method (does not have a body)
void makeSound();

// Default method (has a body)

default void breathe() {
System.out.println("Breathing...");
}

// Static method (has a body)

static void sleep() {
 System.out.println("Sleeping...");
}
}

// Implement the interface in a class

class Dog implements Animal {
@Override
public void makeSound() {
System.out.println("Woof!");
}
}

public class Main {

public static void main(String[] args) {
Dog myDog = new Dog();
myDog.makeSound(); // Output: Woof!
myDog.breathe(); // Output: Breathing...
Animal.sleep(); // Output: Sleeping...
}
}
Nested Interfaces
A nested interface is an interface defined within another class or interface. It can be either
static or non-static. Nested interfaces are often used to logically group interfaces within a
class or another interface.
Key Characteristics of Nested Interfaces:
 Static: By default, nested interfaces are static. They do not require an instance of the
enclosing class.
 Access: Nested interfaces can be accessed directly using the enclosing class or
interface name.
 Use Case: Nested interfaces are used to define interfaces that are closely related to the
enclosing class or interface.
Example of Nested Interfaces
java
Copy code
// Outer class with nested interface
class OuterClass {
// Nested interface
interface InnerInterface {
void innerMethod();
}

// Implementation of the nested interface

static class InnerClass implements InnerInterface {
@Override
public void innerMethod() {
System.out.println("Inner method implementation.");
}
}

// Example method to use the nested interface

void useNestedInterface() {
 InnerClass inner = new InnerClass();
inner.innerMethod(); // Output: Inner method implementation.
}
}

public class Main {

public static void main(String[] args) {
OuterClass outer = new OuterClass();
outer.useNestedInterface(); // Output: Inner method implementation.

// Access nested interface directly

OuterClass.InnerInterface nestedInstance = new OuterClass.InnerClass();
nestedInstance.innerMethod(); // Output: Inner method implementation.
}
}