Answer: Constructor Overloading is a concept in Java where multiple Answer: Method Overloading in Java refers to the ability to define

constructors with the same name but different parameter lists are multiple methods with the same name but different parameter lists
defined within the same class. Like method overloading, constructor within the same class. The methods can differ by the number of
overloading allows the creation of objects in different ways, giving parameters or the type of parameters. Overloading allows the same
flexibility in object initialization. method to be used in different contexts, reducing the need for distinct
Constructor overloading is useful when you want to initialize objects with method names.
different sets of data, allowing you to provide default values or other Java determines which method to call based on the number and types of
initialization based on the parameters provided. arguments passed during method invocation. This is resolved at compile
Example Program: time, making method overloading an example of compile-time
java Copy code class Vehicle { private String name; polymorphism.
private int wheels; Example Program:
java Copy code class Calculator {
// Default constructor public Vehicle() { name = "Unknown"; // Method to add two integers public int add(int a, int b) { return
wheels = 4; a + b;
} }

// Overloaded constructor with one parameter public Vehicle(String // Overloaded method to add three integers public int add(int a, int
name) { this.name = name; this.wheels = 4; b, int c) { return a + b + c;
} }

// Overloaded constructor with two parameters public Vehicle(String // Overloaded method to add two double values public double
name, int wheels) { this.name = name; this.wheels = wheels; add(double a, double b) { return a + b;
} }
}
public void displayDetails() {
System.out.println("Vehicle Name: " + name); public class Main { public static void main(String[] args) {
System.out.println("Number of Wheels: " + wheels); Calculator calc = new Calculator();
}
} // Calling different overloaded methods
System.out.println("Sum of two integers: " + calc.add(5,
public class Main { public static void main(String[] args) { 10));
Vehicle v1 = new Vehicle(); // Calls default constructor Vehicle v2 System.out.println("Sum of three integers: " + calc.add(5,
= new Vehicle("Car"); // Calls constructor with one parameter 10, 15));
Vehicle v3 = new Vehicle("Bike", 2); // Calls constructor with two System.out.println("Sum of two doubles: " + calc.add(5.5,
parameters 10.5));
}
v1.displayDetails(); v2.displayDetails(); v3.displayDetails(); }
}
} Explanation:
• The add() method is overloaded with different parameter combinations:
two integers, three integers, and two doubles. The correct method is
invoked based on the arguments passed.

Answer: Object-Oriented Programming (OOP): OOP is a programming Answer: An interface in Java is a reference type, similar to a class, that
paradigm based on the concept of objects. An object represents a real- can contain only constants, method signatures, default methods, static
world entity, encapsulating data (attributes) and behavior (methods). methods, and nested types. Interfaces cannot contain instance fields or
Key OOP concepts include: constructors. A class implements an interface by providing

• Encapsulation: Bundling data and methods

implementations for all its methods.
Interfaces are used to define a contract for what a class can do, without
together, restricting access to certain components and specifying how it does it. A class that implements an interface must
ensuring that data is only modified through predefined provide concrete implementations for the methods declared in the
functions. interface.
• Inheritance: Creating a new class from an
Example Program:
java Copy code interface Animal { void sound(); // Abstract method
existing class, promoting code reuse.
}
• Polymorphism: Allowing a method to
class Dog implements Animal { public void sound() {
perform different functions based on the object that calls
it, enhancing flexibility. System.out.println("Bark");
}
• Abstraction: Hiding complex }
implementation details and showing only the necessary
features. class Cat implements Animal { public void sound() {
Procedure-Oriented Programming (POP): POP is a programming System.out.println("Meow");
paradigm that relies on functions or procedures to perform operations. }
The focus is on writing sequences of instructions to perform tasks, not }
on representing entities. POP is typically less modular and more difficult
to manage for larger codebases compared to OOP. public class InterfaceExample {
Differences: public static void main(String[] args) {

• Focus: OOP focuses on objects; POP

Animal dog = new Dog();
Animal cat = new Cat();
focuses on functions.

• Modularity: OOP promotes code

dog.sound(); // Calls Dog's implementation of sound
// Calls Cat's implementation of sound
cat.sound();
modularity and reusability; POP is less modular.
}
• Security: OOP has better data protection }
through encapsulation; POP allows unrestricted access to
data. Explanation:
• The Animal interface defines an abstract method sound(). Both Dog and
• Example Languages: OOP includes Java, Cat classes implement this interface and provide their own
C++, and Python; POP includes C and Fortran. implementation of the sound() method.
Answer: Exception handling in Java is a mechanism that handles runtime In Java, literals are fixed values that are directly assigned to variables or used
errors, ensuring that the normal flow of execution is not disrupted. Java in expressions. There are several types of literals:
provides a powerful model for exception handling using the try, catch, throw,
and finally blocks. 1. Integer Literals: Represent whole numbers and
Key Components: can be written in decimal, octal, hexadecimal, or binary
formats.
• try block: Code that might throw an exception Example: int decimal = 100;, int hex = 0x1A;
is placed inside the try block.
2. Floating-Point Literals: Represent decimal
• catch block: If an exception occurs, the catch values with fractional parts and are written as float or double.
block is executed. It specifies the type of exception to catch. Example: double pi = 3.14;, float price = 5.99f;

• throw statement: This is used to explicitly 3. Character Literals: Represent a single character
throw an exception. enclosed in single quotes.

•
Example: char letter = 'A';
finally block: This block is always executed,
regardless of whether an exception occurred or not. It is 4. String Literals: Represent sequences of
commonly used for clean-up operations like closing files or characters enclosed in double quotes.
releasing resources. Example: String greeting = "Hello, World!";
Syntax:
java Copy code try { 5. Boolean Literals: Represent true or false
// Code that may throw an exception values.
} catch (ExceptionType e) { Example: boolean isJavaFun = true;
// Handling the exception
} finally {
6. Null Literal: Represents a null reference, which
points to no object.
// Code that will run no matter what Example: String str = null;
} Example code with different literals:
public class LiteralsExample {
Example Program: public static void main(String[] args) { int decimal = 100; // integer
java Copy code literal double price = 99.99; // floating-point literal char letter = 'A';
public class ExceptionHandlingExample { public static void main(String[] // character literal
args) { try { String message = "Welcome to Java!"; // string literal boolean isTrue
int result = 10 / 0; // This will throw = true; // boolean literal
ArithmeticException
} catch (ArithmeticException e) { System.out.println("Decimal: " + decimal);
System.out.println("Error: Division by zero"); System.out.println("Price: " + price);
} finally { System.out.println("Letter: " + letter);
System.out.println("This block is always executed"); System.out.println("Message: " + message);
} System.out.println("Boolean value: " + isTrue);
}
try { int[] numbers = new int[2]; numbers[5] = 10; // This }
will throw
ArrayIndexOutOfBoundsException
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println("Error: Array index out of bounds");
} finally {
System.out.println("This block is also always executed");
}}}
Answer: Java provides several built-in methods for manipulating strings. Answer: In Java Swing, JLabel and JButton are used for building Graphical
Strings in Java are objects of the String class, and these methods allow you User Interface (GUI) components.
to perform common operations like comparison, modification, and
transformation. • JLabel: It is used to display a short string or an
Common String Methods: image. It doesn't interact with the user but simply provides
information or displays content. It is a non-editable
• length(): Returns the length of the string. component.

• charAt(int index): Returns the character at the • JButton: It is a push button that can be clicked
specified index. to perform an action. When the user clicks on it, an event is

• substring(int beginIndex, int endIndex):

triggered, and an action listener can respond to this event.
These components are often used together to create interactive applications.
Returns a substring from the string. For example, a JLabel can be used to display instructions or messages, and a
• toLowerCase(): Converts the string to
JButton can be used to trigger actions when clicked, such as submitting a
form or closing a window. Example Program:
lowercase.
java Copy code import javax.swing.*; import java.awt.*; import
• toUpperCase(): Converts the string to java.awt.event.*;
uppercase.
public class ButtonLabelExample {
• trim(): Removes leading and trailing spaces. public static void main(String[] args) {

• equals(String anotherString): Compares two

// Create a frame
JFrame frame = new JFrame("JLabel and JButton Example");
strings for equality. // Create a JLabel
• contains(CharSequence sequence): Checks if
JLabel label = new JLabel("Click the button to change the text!");
// Create a JButton
the string contains a specified sequence.
JButton button = new JButton("Click Me");
• replace(CharSequence oldChar, CharSequence // Add an ActionListener to the button
button.addActionListener(new ActionListener() { public void
newChar): Replaces occurrences of a character or sequence
with another. actionPerformed(ActionEvent e) { label.setText("Text has been
Example Program: changed!");
java Copy code } });
public class StringManipulation { public static void main(String[] args) { // Set layout manager
String str = " Hello, Java World! "; frame.setLayout(new FlowLayout());
// Add components to the frame frame.add(label);
System.out.println("Length of string: " + str.length()); frame.add(button);
System.out.println("Character at index 6: " + str.charAt(6)); // Set frame size and visibility frame.setSize(300, 200);
System.out.println("Substring (7, 11): " + str.substring(7, frame.setVisible(true);
11)); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
System.out.println("Lowercase: " + str.toLowerCase()); }}
System.out.println("Uppercase: " + str.toUpperCase()); • A JLabel is used to display initial text, and a JButton is created to change
System.out.println("Trimmed string: '" + str.trim() + "'"); the label text when clicked. The event handling mechanism is used to trigger
System.out.println("String contains 'Java': " + str.contains("Java")); the action.
System.out.println("Replace 'Java' with 'Python': " + str.replace("Java",
"Python"));
}
}