KTU OOP LAB JAVA CSL 203 BTech CS S3 - Dr Binu V P

Multilevel Inheritance Multilevel inheritance is a type of inheritance where a class is derived from another class, which in turn is derived from another class. This forms a hierarchy of inheritance where each class inherits properties and behaviors from its superclass. Example: class Animal {     void eat() {         System.out.println("This animal eats food.");     } } class Dog extends Animal {     void bark() {         System.out.println("The dog barks.");     } } class Puppy extends Dog {     void weep() {         System.out.println("The puppy weeps.");     } } public class Main {     public static void main(String[] args) {         Puppy puppy = new Puppy();         puppy.eat();         puppy.bark();         puppy.weep();     } } Program to Try // Base class class Shape {     double length;     double width;     // Default constructor     Shape() {         length = 0;         width = 0;     }     // Parameterized constructor     Shape(double length,

 In Java, an interface is a reference type, similar to a class, that can contain only constants, method signatures (methods without a body), default methods, static methods, and nested types. It defines a contract for what a class can do, without specifying how it does it. Here's a breakdown: Declaration : Interfaces are declared using the interface keyword. Purpose : They allow you to specify a set of methods that a class must implement. This helps in achieving abstraction and multiple inheritance of type. Example : // Define an interface interface Animal {     // Method signatures (implicitly public and abstract)     void makeSound();     void eat(); } // Implement the interface in a class class Dog implements Animal {     // Implementing the methods defined in the interface     @Override     public void makeSound() {         System.out.println("Woof!");     }          @Override     public void eat() {         System.out.println("Dog is eating...");     } } /

Method overriding in Java is a feature that allows a subclass to provide a specific implementation for a method that is already defined in its superclass. The method in the subclass should have the same name, return type, and parameters as the method in the superclass. Overriding is used to achieve runtime polymorphism, allowing a subclass to modify or enhance the behavior of a superclass method. Key Points about Method Overriding: Same Method Signature : The overridden method must have the same name, return type, and parameter list as the method in the superclass. Inheritance : Overriding can only occur in a subclass, which inherits a method from its superclass. Annotations : It is a good practice to use the @Override annotation to indicate that a method is intended to override a method in the superclass. Access Modifiers : The access level of the overriding method cannot be more restrictive than the overridden method. For example, if the superclass method is public , the subclass me

Exceptions in programming are events that occur during the execution of a program and disrupt the normal flow of its instructions. They are typically used to signal error conditions or other unusual circumstances that the program may encounter, such as trying to divide by zero, attempting to access an out-of-bounds index in an array, or failing to open a file. Types of Exceptions Runtime Exceptions : These exceptions occur during the execution of the program and are often due to programming errors, such as logic mistakes or incorrect use of APIs. Examples include: NullPointerException : When an application attempts to use null in a case where an object is required. ArrayIndexOutOfBoundsException : When an attempt is made to access an array element with an invalid index. ArithmeticException : When an exceptional arithmetic condition has occurred, like division by zero. Checked Exceptions : These exceptions are checked at compile time, and the programmer is required to handle them expli

Abstract classes in Java are classes that cannot be instantiated on their own and are meant to be subclassed. They serve as a blueprint for other classes. An abstract class can contain abstract methods (methods without a body) and concrete methods (methods with a body). Key Features of Abstract Classes: Abstract Methods : Methods declared without an implementation. Subclasses are required to provide the implementation for these methods. Concrete Methods : Methods with an implementation that can be inherited by subclasses. Cannot be Instantiated : Abstract classes cannot be used to create objects directly. Constructors : Abstract classes can have constructors, which can be called when a subclass object is created. Inheritance : Abstract classes are intended to be extended by other classes. A subclass must implement all abstract methods of the abstract class unless the subclass is also abstract. Example: abstract class Animal {     // Abstract method (does not have a body)     public abs

The StringTokenizer class in java.util can be used to parse a line of integers. Here is a Java program that reads a line of integers, displays each integer, and then calculates and displays the sum of all the integers. import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.util.StringTokenizer; public class IntegerProcessor {     public static void main(String[] args) {         BufferedReader reader = null;         try {             // Read input from the console             reader = new BufferedReader(new InputStreamReader(System.in));             System.out.println("Enter a line of integers separated by spaces:");             String line = reader.readLine();             // Use StringTokenizer to parse the line of integers             StringTokenizer tokenizer = new StringTokenizer(line);             int sum = 0;             System.out.println("The integers are:");             while (tokenizer.hasMoreTokens()) {  

Handling text files in Java involves performing operations like reading from, writing to, and appending to files. Here are some common techniques and examples for handling text files in Java: FileReader and BufferedReader are classes in Java used for reading text from files. Here’s a detailed explanation of each: FileReader FileReader is a class in Java that is used to read character files. It is a convenient class for reading text files using the default character encoding of the operating system. Key Points: Purpose : To read text files. Inheritance : It extends InputStreamReader , which in turn extends Reader . Encoding : Uses the default character encoding of the operating system unless specified otherwise. Basic Usage : Suitable for simple file reading tasks. Example: create a text file "example.txt" using any text editor and then run this program.In this example, FileReader reads the file character by character. import java.io.FileReader; import java.io.IOException;