‭ .

Discuss the various forms of inheritance and provide a sample program‬

1
‭to illustrate the concept of single inheritance.‬
I‭nheritance is a mechanism in Java where one class acquires the properties (fields) and‬
‭behaviors (methods) of another class. It promotes code reuse and establishes a parent-child‬
‭relationship. By using inheritance, developers can build a hierarchical organization of classes,‬
‭reduce redundancy, and simplify code maintenance. There are several forms of inheritance in‬
‭Java:‬

‭1.‬ S ‭ ingle Inheritance‬‭: A class inherits from a single superclass. This is the most basic‬
‭form and is straightforward to implement.‬
‭2.‬ ‭Multilevel Inheritance‬‭: A class inherits from a superclass, and another class inherits‬
‭from this subclass. This forms a chain-like structure of inheritance.‬
‭3.‬ ‭Hierarchical Inheritance‬‭: Multiple classes inherit from a single superclass. This allows‬
‭several classes to share common behavior defined in the parent class.‬
‭4.‬ ‭Hybrid Inheritance‬‭: A combination of multiple and hierarchical inheritance. Java doesn’t‬
‭directly support hybrid inheritance with classes to avoid ambiguity, but it can be achieved‬
‭using interfaces.‬
‭5.‬ ‭Multiple Inheritance‬‭: Achieved using interfaces in Java, as direct multiple inheritance of‬
‭classes is not supported due to the "diamond problem."‬

‭Example: Single Inheritance‬

 Dog‬‭class reuses‬‭the behavior of the‬‭
‭By utilizing single inheritance, the‬‭ Animal‬‭class without‬
eat‬‭method.‬
‭redefining the‬‭

‭2. Explain the multilevel inheritance with examples.‬

I‭n multilevel inheritance, a class is derived from another derived class. This type of inheritance‬
‭allows the properties and behaviors of multiple levels of classes to be passed down the‬
‭hierarchy. It is useful in cases where the functionality of a class builds incrementally upon its‬
‭parent.‬
‭Characteristics of Multilevel Inheritance:‬

‭‬ P
● ‭ romotes code reuse across multiple generations of classes.‬
‭●‬ ‭The final subclass inherits all the properties and methods of the preceding classes in the‬
‭hierarchy.‬

‭Example: Multilevel Inheritance‬

‭Output:‬
 Dog‬‭class indirectly inherits the‬‭
‭In this example, the‬‭ eat‬‭method from the‬‭
Animal‬‭class through‬
Mammal‬‭class.‬
‭the‬‭

‭ . Explain the application of the super keyword in Java with a relevant‬

3
‭example.‬

super‬‭keyword in Java is a powerful tool for managing inheritance. It refers to the‬

‭The‬‭
super‬
i‭mmediate superclass of the current object. By using‬‭ ‭, you can explicitly call methods,‬
‭fields, or constructors of the superclass.‬

super‬
‭Applications of‬‭ ‭:‬

‭1.‬ C ‭ alling Superclass Constructor‬‭: Use‬‭ super()‬‭to call the constructor of the‬
‭superclass.‬
‭2.‬ ‭Accessing Superclass Methods‬‭: Use‬‭ super.methodName()‬‭to invoke a method‬
‭from the superclass.‬
‭3.‬ ‭Accessing Superclass Fields‬‭: Use‬‭ super.fieldName‬‭to resolve field naming‬
‭conflicts when both the superclass and subclass define fields with the same name.‬

super‬
‭Example: Application of‬‭
‭Output:‬

‭ sing‬‭
U super‬ Dog‬‭class successfully accesses properties and methods from the‬‭
‭, the‬‭ Animal‬
‭class.‬
‭4. Explain abstract and final keyword with an example‬‭.‬

abstract‬‭and‬‭
‭ ava provides the‬‭
J final‬‭keywords to define‬‭specific characteristics of classes‬
‭and methods.‬

abstract‬‭Keyword:‬
‭

‭ he‬‭
T abstract‬‭keyword is used to declare a class that‬‭cannot be instantiated directly. It can‬
‭also be applied to methods that must be implemented by subclasses. Abstract classes act as‬
‭blueprints for other classes.‬

final‬‭Keyword:‬
‭

final‬‭keyword can:‬
‭The‬‭

‭ .‬ M
1 ‭ ark a class as non-inheritable.‬
‭2.‬ ‭Prevent method overriding when applied to methods.‬
‭3.‬ ‭Declare constants when applied to variables.‬

‭Example: Abstract Class and Final Method‬

‭Output:‬

sound‬‭method is implemented in the‬‭

‭In this example, the‬‭ Dog‬‭class, while the‬‭
breathe‬‭method‬
final‬
‭is marked as‬‭ ‭, ensuring that it cannot be overridden in subclasses.‬

‭ . Explain method overriding and dynamic method dispatching in java with‬

5
‭example .‬

‭Method Overriding:‬

‭ ethod overriding in Java occurs when a subclass provides a specific implementation for a‬
M
‭method that is already defined in its superclass. The overridden method in the subclass should‬
‭have the same name, return type, and parameters as the method in the superclass. Overriding‬
‭allows a subclass to provide its version of a method, enabling runtime polymorphism.‬

‭Rules for Method Overriding:‬

‭ .‬ T
1 ‭ he method must have the same name and parameter list.‬
‭2.‬ ‭The overriding method cannot have a lower access modifier than the overridden method.‬
‭3.‬ ‭The method must belong to an inheritance hierarchy.‬

‭Dynamic Method Dispatch:‬

‭ ynamic method dispatch is a mechanism in Java where the call to an overridden method is‬
D
‭resolved at runtime rather than compile time. It allows Java to achieve runtime polymorphism by‬
‭determining the actual method to be invoked based on the object type, not the reference type.‬

‭Example:‬
‭Output:‬

‭ . Explain the concept of interfaces in Java and provide an example‬

6
‭featuring an interface with default methods.‬
‭ n interface in Java is a blueprint for a class that contains abstract methods. It defines a‬
A
‭contract that the implementing classes must follow. Interfaces help achieve abstraction and‬
‭support multiple inheritance by allowing a class to implement multiple interfaces.‬

‭Default Methods in Interfaces:‬

‭ ava 8 introduced default methods in interfaces to allow developers to define methods with a‬
J
‭body. This enables interfaces to evolve without breaking existing implementations.‬

‭Example: Interface with Default Method‬

‭Output:‬

‭7. How do you achieve multiple inheritance in java explain with an example‬‭.‬

‭ ava does not support multiple inheritance with classes to avoid ambiguity (commonly known as‬
J
‭the diamond problem). However, it allows multiple inheritance using interfaces. A class can‬
‭implement multiple interfaces and inherit their behaviors.‬
‭Output:‬

‭ . Define package. Explain the steps involved in creating a user-defined‬

8
‭package with an example.‬
‭ package in Java is a namespace that organizes classes and interfaces. Packages help‬
A
‭prevent naming conflicts, control access, and make it easier to manage related classes. Java‬
‭provides two types of packages:‬

‭ .‬ B
1 java.util‬
‭ uilt-in Packages‬‭: Predefined packages like‬‭ java.io‬
‭,‬‭ ‭, etc.‬
‭2.‬ ‭User-defined Packages‬‭: Custom packages created by the user.‬

‭Steps to Create and Use a User-Defined Package:‬

package‬‭keyword.‬
‭1.‬ ‭Create a package using the‬‭
‭2.‬ C -d‬‭option to place them in the appropriate directory‬
‭ ompile the classes with the‬‭
‭structure.‬
‭3.‬ ‭Import the package into another program using the‬‭ import‬‭keyword.‬
‭4.‬ ‭Use the classes defined in the package.‬

‭Example:‬

‭Step 1: Create a Package‬

Animal.java‬
‭Save the following code in‬‭ ‭.‬

‭Step 2: Compile the Package‬

‭Step 3: Use the Package‬

Main.java‬
‭Save the following code in‬‭ ‭.‬
‭Step 4: Compile and Run‬

‭Output:‬

‭By organizing classes into packages, Java applications become modular and easier to maintain.‬

‭ . Examine the various levels of access protections available for packages‬

9
‭and their implications with suitable example.‬
I‭n Java, access control modifiers regulate the visibility and accessibility of classes, methods,‬
‭and variables in different contexts (within the same class, package, subclass, or external‬
‭package). Java offers four levels of access protection, which vary in terms of which classes and‬
‭code components can access the protected element. These levels are:‬

‭1.‬ ‭
private‬
‭2.‬ ‭
default‬‭(also known as "package-private")‬
‭3.‬ ‭
protected‬
 ‭4.‬ ‭
public‬

‭Let's break down each of these access modifiers with examples and implications.‬

private‬‭Access Modifier‬
‭1.‬‭

‭●‬ V private‬‭access modifier restricts access to the member (variable or‬

‭ isibility‬‭: The‬‭
‭method) to within the class in which it is declared. No other class, even within the same‬
‭package, can access private members.‬
‭●‬ ‭Implications‬‭: This is the most restrictive level of access control, ensuring the highest‬
‭level of encapsulation. It prevents external classes from directly modifying or accessing‬
‭the data.‬

‭2. Default (Package-Private)‬

‭●‬ V ‭ isibility‬‭: When no access modifier is specified (i.e., default access), the member is‬
‭accessible only within classes that are part of the‬‭same package‬‭. It is not accessible‬
‭from outside the package.‬
‭●‬ ‭Implications‬‭: This level allows classes within the same package to interact with each‬
‭other more freely, but it restricts access from classes outside the package.‬

protected‬‭Access Modifier‬
‭3.‬‭

‭●‬ V protected‬‭access modifier allows access to the member within the‬

‭ isibility‬‭: The‬‭
‭same package and to subclasses (even if they are in different packages).‬
‭●‬ ‭Implications‬‭: This modifier provides a balance between restricting access and allowing‬
‭inherited classes to access inherited members. It is commonly used in inheritance‬
‭hierarchies.‬

public‬‭Access Modifier‬
‭4.‬‭

‭●‬ V public‬‭access modifier allows the member to be accessed from‬

‭ isibility‬‭: The‬‭
‭anywhere‬‭—both inside and outside the package, and even in other projects that import‬
‭the class.‬
 ‭●‬ I‭mplications‬‭: This is the least restrictive access modifier, and it is typically used for API‬
‭methods and fields that should be universally accessible.‬

‭Output:‬
‭ 0.Write a program that contains one method that will throw an‬
1
‭IllegalAccessException and use proper exception handles so that the‬
‭exception should be printed.‬

‭ n‬‭
A IllegalAccessException‬‭is a checked exception that occurs when a program attempts‬
‭to reflectively access a field, method, or constructor that it does not have access to. This often‬
‭happens in scenarios involving reflection, but it can also be manually thrown.‬

‭Output:‬

‭Explanation:‬
 checkAccess()‬‭method explicitly throws an‬‭
‭1.‬ ‭The‬‭ IllegalAccessException‬
‭.‬
main()‬‭method, the exception is caught using a‬‭
‭2.‬ ‭In the‬‭ try-catch‬‭block.‬
‭3.‬ T e.getMessage()‬‭method provides the custom message passed when the‬
‭ he‬‭
‭exception is thrown.‬
‭4.‬ ‭The‬‭e.printStackTrace()‬‭method displays the exception’s stack trace.‬

‭11. Explain multiple catch block in java with an example.‬

‭ ultiple catch blocks allow a program to handle different types of exceptions separately. This is‬
M
‭useful when you anticipate multiple possible exceptions from a block of code. When an‬
‭exception is thrown, it is matched against the catch blocks in sequence, starting from the first.‬

‭Rules for Multiple Catch Blocks:‬

‭ .‬ C
1 ‭ atch blocks are evaluated in the order they appear.‬
‭2.‬ ‭The first matching catch block is executed, and the remaining blocks are ignored.‬
‭3.‬ ‭The most specific exceptions should come first, followed by more generic exceptions‬
Exception‬
‭(e.g.,‬‭ ‭).‬

‭Example:‬

‭Output:‬

‭Explanation:‬

try‬‭block attempts to access an invalid array index, which triggers an‬

‭1.‬ ‭The‬‭
ArrayIndexOutOfBoundsException‬
‭ ‭.‬
 ‭2.‬ T ArrayIndexOutOfBoundsException‬‭handles the‬
‭ he specific catch block for‬‭
‭exception and prints a message.‬
ArithmeticException‬
‭3.‬ ‭If another exception (e.g.,‬‭ ‭) were thrown, its corresponding‬
‭catch block would execute instead.‬

‭12. How do you create your own exception class? Explain with a program.‬
‭ reating a custom exception class allows developers to define specific error conditions for their‬
C
‭applications. This is particularly useful when built-in exceptions do not adequately describe the‬
‭problem.‬

‭Steps to Create a Custom Exception:‬

‭ .‬ E
1 Exception‬‭class (or‬‭
‭ xtend the‬‭ RuntimeException‬‭for unchecked exceptions).‬
‭2.‬ ‭Define constructors to pass custom messages and exception details.‬
toString()‬‭for custom behavior.‬
‭3.‬ ‭Optionally override methods like‬‭

‭Example:‬

‭Output:‬

‭Explanation:‬
 MyException‬‭class is a custom checked exception.‬
‭1.‬ ‭The‬‭
validateAge()‬‭method throws‬‭
‭2.‬ ‭The‬‭ MyException‬‭if the‬‭
age‬‭is less than 18.‬
main()‬‭method.‬
‭3.‬ ‭The exception is caught and handled in the‬‭

‭13. Demonstrate the working of a nested try block with an example.‬

‭ nested try block is a try block inside another try block. It is useful for handling exceptions that‬
A
‭occur at different levels in a program. Each try block can have its own associated catch blocks.‬

‭Example:‬

‭Output:‬

‭Explanation:‬

try‬‭block handles array index errors.‬

‭1.‬ ‭The inner‬‭
‭ .‬ T
2 try‬‭block handles arithmetic errors, such as division by zero.‬
‭ he outer‬‭
‭3.‬ ‭Each exception is caught by its corresponding catch block.‬

‭ 4. Describe the concept of exception handling in Java, provide an‬

1
‭example, and explore various types of exceptions.‬
‭ xception handling in Java is a mechanism that allows a program to handle runtime errors,‬
E
‭maintaining the flow of the program and preventing abrupt termination. Instead of the program‬
‭crashing when an error occurs, exceptions are thrown, caught, and handled in a controlled‬
‭manner, enabling the program to either recover or provide meaningful error messages.‬

‭Key Concepts in Exception Handling:‬

‭1.‬ E ‭ xception:‬‭An exception is an event that disrupts the normal flow of the program. It’s an‬
‭object that wraps an error, such as division by zero, file not found, or accessing an array‬
‭out of bounds.‬
‭2.‬ ‭Try Block:‬‭This is the block where you write code that might throw an exception. If an‬
‭exception occurs, the catch block (if defined) will handle it.‬
‭3.‬ ‭Catch Block:‬‭This block is used to catch exceptions that occur in the try block. You can‬
‭define multiple catch blocks to handle different types of exceptions.‬
‭4.‬ ‭Finally Block:‬‭This block is optional and executes regardless of whether an exception‬
‭occurs or not. It's typically used for cleanup tasks like closing resources.‬
‭5.‬ ‭Throw Keyword:‬‭This is used to explicitly throw an exception from a method or block of‬
‭code.‬
‭6.‬ ‭Throws Keyword:‬‭It is used in the method signature to declare that the method might‬
‭throw certain exceptions. This allows the calling method to handle or propagate the‬
‭exception.‬

‭Output:‬
 I‭n the example, an‬‭ArrayIndexOutOfBoundsException‬‭is thrown because the array‬
‭has only 5 elements, but the code attempts to access the 11th element. The exception is‬
catch‬‭block, and the‬‭
‭caught in the‬‭ finally‬‭block executes regardless of the outcome.‬

‭Types of Exceptions in Java‬

‭Exceptions in Java can be categorized into two main types:‬

‭1.‬ ‭Checked Exceptions:‬

‭○‬ ‭These are exceptions that are checked at compile-time. The compiler forces you‬
‭to either catch them using a‬‭try-catch‬‭block or declare them using the‬‭
throws‬
‭keyword in the method signature.‬
‭○‬ ‭Example:‬‭ IOException‬ SQLException‬
‭,‬‭ ClassNotFoundException‬
‭,‬‭

‭2.Unchecked Exceptions (Runtime Exceptions):‬

‭●‬ T
‭ hese are exceptions that are not checked at compile time but are checked at runtime.‬
‭Unchecked exceptions are subclasses of‬‭RuntimeException‬ ‭.‬
NullPointerException‬
‭●‬ ‭Example:‬‭ ArithmeticException‬
‭,‬‭ ‭,‬
ArrayIndexOutOfBoundsException‬
‭ ‭.‬

‭Common Exception Types in Java:‬

‭1. ArithmeticException:‬

‭●‬ ‭Occurs when an illegal arithmetic operation is performed, such as dividing by zero.‬

‭2. NullPointerException:‬
 ‭●‬ ‭Occurs when a program attempts to use an object reference that is null‬

‭3. ArrayIndexOutOfBoundsException:‬

‭●‬ H
‭ appens when trying to access an array with an invalid index (less than 0 or greater‬
‭than the array length)‬

‭ 5. Describe how a divide-by-zero error can be managed in Java, providing‬

1
‭an example‬
I‭n Java, a‬‭divide-by-zero error‬‭occurs when a number‬‭is divided by zero. Specifically, it triggers‬
‭an‬‭ ArithmeticException‬ ‭, which is a runtime exception.‬‭This exception can be caught and‬
‭handled using Java's exception handling mechanism to prevent the program from crashing and‬
‭to manage the error gracefully.‬

‭How to Handle Divide-by-Zero in Java‬

try-catch‬‭block. The idea is to attempt the‬

‭To manage a divide-by-zero error, you can use a‬‭
try‬‭block, and if a division by‬‭zero occurs, catch the‬
‭division inside the‬‭
‭rithmeticException‬‭in the‬‭
A catch‬‭block and handle‬‭it appropriately (e.g., logging the error‬
‭or providing a user-friendly message).‬
‭Example of Handling Divide-by-Zero in Java:‬

‭Output:‬

‭Explanation:‬

numerator / denominator‬‭is attempted. Since‬

‭●‬ ‭try block: The division operation‬‭
denominator‬‭is‬‭
‭ 0‭,‬this causes an‬‭
ArithmeticException‬‭to be thrown.‬
‭●‬ c catch‬‭block, where a user-friendly‬
‭ atch block: The exception is caught in the‬‭
‭error message "Error: Cannot divide by zero." is printed.‬
‭●‬ ‭Program Continuation: After the exception is caught and handled, the program‬
‭continues executing normally, printing "Program continues after exception‬
‭handling."‬

‭16. Explain Built in Exception classes in java with an example program.‬

‭ ava provides a rich set of built-in exception classes that can be used to handle various types of‬
J
‭errors that occur during the execution of a program. These exceptions are part of the Java‬
java.lang‬‭package and fall into two main categories:‬
‭

‭ .‬ C
1 ‭ hecked Exceptions:‬‭Exceptions that are checked at compile-time.‬
‭2.‬ ‭Unchecked Exceptions (RuntimeExceptions):‬‭Exceptions that are checked at‬
‭runtime.‬
‭These built-in exception classes form the foundation of Java's exception-handling mechanism.‬

‭Common Built-in Exception Classes in Java‬

‭Here are some of the commonly used built-in exception classes in Java:‬

ArithmeticException‬
‭1.‬‭

‭‬ T
● ‭ hrown when an exceptional arithmetic condition occurs, such as division by zero.‬
int result = 10 / 0;‬
‭●‬ ‭Example:‬‭

NullPointerException‬
‭2.‬‭

null‬‭where an object is required (e.g.,‬

‭●‬ ‭Thrown when an application attempts to use‬‭
null‬‭object).‬
‭calling methods on a‬‭
String str = null; str.length();‬
‭●‬ ‭Example:‬‭

ArrayIndexOutOfBoundsException‬
‭3.‬‭

‭●‬ T ‭ hrown when trying to access an array with an invalid index (either negative or beyond‬
‭the size of the array).‬
‭●‬ ‭Example:‬‭ int[] arr = new int[3]; arr[5] = 10;‬

FileNotFoundException‬
‭4.‬‭

‭‬ T
● ‭ hrown when an attempt to open the file denoted by a specified pathname has failed.‬
FileReader file = new FileReader("nonexistent_file.txt");‬
‭●‬ ‭Example:‬‭

IOException‬
‭5.‬‭

‭‬ T
● ‭ hrown when an input/output operation fails or is interrupted.‬
BufferedReader br = new BufferedReader(new‬
‭●‬ ‭Example:‬‭
FileReader("file.txt"));‬
‭

ClassNotFoundException‬
‭6.‬‭

‭●‬ T ‭ hrown when an application tries to load a class by its name, but the class cannot be‬
‭found.‬
Class.forName("com.example.NonExistentClass");‬
‭●‬ ‭Example:‬‭

NumberFormatException‬
‭7.‬‭

‭●‬ T
‭ hrown when a string cannot be parsed into a numeric type (e.g., attempting to convert‬
‭a non-numeric string to an integer).‬
 int number = Integer.parseInt("abc");‬
‭●‬ ‭Example:‬‭

IllegalArgumentException‬
‭8.‬‭

‭‬ T
● ‭ hrown to indicate that a method has been passed an illegal or inappropriate argument.‬
‭●‬ ‭Example:‬‭Thread.sleep(-1000);‬‭(sleep duration cannot be negative)‬

InterruptedException‬
‭9.‬‭

‭●‬ T ‭ hrown when a thread is interrupted during a blocking operation (e.g., sleeping or‬
‭waiting).‬
‭●‬ ‭Example:‬‭ Thread.sleep(1000);‬‭might throw‬‭ InterruptedException‬‭if the thread‬
‭is interrupted during sleep.‬
‭Example Program Demonstrating Built-in Exceptions:‬

‭Output:‬