OOPS Using Java

2mark Questions
1. Write any 2 features of Java.

• Platform Independence: Java is designed to be a "write once, run anywhere"

language. This is achieved through the use of the Java Virtual Machine (JVM), which
allows Java programs to run on any device or operating system that has the JVM
installed.

This means that a Java program written on one platform can be executed on another
without any modifications

• Object-Oriented Programming (OOP): Java is based on the concept of "objects."

Objects are instances of classes, which can contain data (attributes) and methods
(functions).

This approach encourages modular and reusable code, making it easier to manage and
maintain complex software systems.

OOP principles such as inheritance, encapsulation, polymorphism, and abstraction are

fundamental to Java, allowing developers to build robust and scalable applications.

2. How Java is platform independent?

When a Java program is written, it is compiled by the Java compiler into an intermediate form
known as bytecode. This bytecode is a set of instructions that are platform-independent.

When a Java program is executed, the JVM translates the platform-independent

bytecode into native machine code. This means that a Java program written on one
platform can be executed on another without any modification

3. What is JVM? Explain various parts of JVM

1. Class Loader
The class loader is like a librarian that finds and organizes the Java classes your
program needs, making sure everything is ready to go.
2. Runtime Data Area
The runtime data area serves as memory storage for different program execution
components, similar to a workspace that has multiple divisions.

1. Method Area
2. Heap Area
3. Stack Area
4. PC Register
5. Native Method Stack Area

3. Execution Engine
The execution engine acts as a skilled translator, converting your Java code into a
language that your computer can understand and execute. It does this through two
methods:

1. Interpreter
2. JIT Compiler

4.What is byte code?

Bytecode in Java is an intermediate, platform-independent code generated by the Java compiler

after a Java source file (.java) is compiled. It is stored in .class files and is not directly executable by
the operating system's hardware.

Instead, bytecode is executed by the Java Virtual Machine (JVM), which interprets or compiles it into
native machine code at runtime

5.Define Java API

The Java API(Java Application Program interface) is a collection of pre-written packages, classes, and
interfaces, along with their methods and fields, provided by the Java Development Kit (JDK).

Ex: classes from java.util package, classes from java.io for input/output operations
6.What is JIT Compiler

The Just-In-Time (JIT) compiler is a part of the Java Virtual Machine (JVM) , by compiling bytecode
into machine code, the JIT compiler optimizes execution speed and improves overall efficiency of Java
applications.

7.What is abstract class*****

An abstract class in Java is a class that cannot be instantiated, it contains abstract methods,
which are declared without implementation,

For example:

abstract class Animal

{
abstract void makeSound(); // Abstract method
-----
-----}

8. What is an Identifier

An identifier in Java is a name given to various elements in a program such as variables, methods,
classes, and objects.

Identifiers must start with a letter (A-Z or a-z), a dollar sign ($), or an underscore (_),

followed by any combination of letters, digits (0-9), dollar signs, and underscores. Identifiers are
case-sensitive

9. Write syntax to create class and object ****

Syntax to create a class

access specifier class ClassName

Fields (variables) ;

Methods public;

}
Syntax to create a object

ClassName objectName = new ClassName();

10. What is keyword? List some of the keywords in Java

Keyword in Java:

A keyword in Java is a reserved word that has a predefined meaning in the language syntax

cannot be used as identifiers (e.g., variable names, class names, method names).

List of Some Keywords in Java:

• Data Types: int, float, double, char, boolean, byte, short, long
• Control Flow: if, else, switch, case, default, while, do, for, break, continue,
return
• Access Modifiers: private, protected, public
• Class-Related: class, interface, extends, implements, abstract, final
• Exception Handling: try, catch, finally, throw, throws
• Object and Class: new, this, super, instanceof
• Others: static, void, volatile, package, import, enum

Can write any one example is enough

11.What is inheritance?

Inheritance in Java is concept where one class (child or subclass) inherits the properties and
behaviors (fields and methods) of another class (parent or superclass).

This allows for code reusability, method overriding

Syntax:
class ParentClass {
// Fields and methods
}

class ChildClass extends ParentClass {

// Additional fields and methods
}

12.What is interface?

An interface in Java is a reference type contain only method signatures, default methods, static
methods, and nested types. Interfaces cannot contain instance fields or constructors.
EX:

interface InterfaceName
{
// Abstract method
void method1();
// Default method
default void method2()
{
System.out.println("Default implementation");
}
// Static method
static void method3()
{
System.out.println("Static implementation");
}
}

13. What is exception handling in java

Exception handling in Java is used to handle runtime errors, ensuring the program can continue its
normal flow even when unexpected events occur

try {
// Code that may throw an exception
}
catch (ExceptionType1 e1)
{
// Code to handle exception of type ExceptionType1
}
catch (ExceptionType2 e2)
{
// Code to handle exception of type ExceptionType2
}
finally {
// Code that will always execute, whether exception is thrown or not
}

Key Components:

1. try: The block of code throw an exception is placed inside the try block.
2. catch: The catch block is used to handle the exception. It catches the exception
thrown by the try block and defines how to handle it.
3. finally: The finally block contains code that will always be executed, regardless of
whether an exception is thrown or not.
4. throw: The throw keyword is used to explicitly throw an exception.
5. throws: The throws keyword is used in the method signature to indicate that the
method might throw exceptions.
14. Define class and object

Class:

A class in Java is a blueprint or template for creating objects. It combines data and methods
as a single unit. A class encapsulates data and methods to manipulate that data.

access specifier class ClassName

{
// Fields (variables)
int field1;
// Methods
public void method1()
{
// Method code
}
}

Object:

An object is an instance of a class.Objects are created using the new keyword followed by the
class constructor.

ClassName objectName = new ClassName();

15. What is the use of the final keyword?*****

The final keyword in Java is used to define an entity that cannot be changed or modified.
It can be applied to variables, methods, and classes.

Final Variables:

A final variable is a constant; once assigned a value, it cannot be changed.

Ex:
final int a = 100;

Final Methods:

A final method cannot be overridden by subclasses. This is used to prevent altering the
method's implementation in subclasses.

public final void display() {

// Method body

}
16. List the different types of comments in Java?

1. Single-Line Comments:
Single-line comments begin with // and extend to the end of the line

// This is a single-line comment

2.Multi-Line Comments:

Multi-line comments, also known as block comments, begin with /* and end with */

17.Define multitasking and multithreading in java******

Multitasking is the ability of an operating system to execute multiple tasks or processes

There are two types of multitasking:

1. Process-Based Multitasking (Multiprocessing):

o Each process has its own address space and resources.
o Each process requires its own memory allocation.

Example: Running multiple Java applications simultaneously.

2. Thread-Based Multitasking (Multithreading):

o Multiple threads are executed within the same process.
o threads share the same memory space and resources.

Example: Running multiple threads within a single Java application

18.What is separator in java? List its types

Separators in Java:

Separators in Java are special characters that are used to separate different parts of a program

Types

Parentheses ()
Braces {}
Brackets []
Semicolon ;
Comma ,
Period .
Colon :

19.What is event in java? List out its types

An event is an object that represents an action by software, often generated as a result of user
interactions or other programmatic activities. They are used to trigger specific methods when
certain actions occur, such as : button click, mouse movement, or a key press.
High-level events.

ActionEvent:

• Generated when a button is clicked, a menu item is selected, or an item is double-

clicked

ItemEvent:

• Generated when an item is selected or deselected.

FocusEvent:

• Generated when a component gains or loses focus

Low-Level Events:

Low-level events are generated by low-level input devices such as the mouse and keyboard.

1. MouseEvent:
o Generated by mouse actions such as clicks, presses, releases, movements, and
drags.
2. KeyEvent:

• Generated by keyboard actions such as key presses and releases.

3. WindowEvent:

• Generated by window actions such as opening, closing.

20. What is Unicode character in java

Unicode is a universal character encoding standard that provides a unique number for every
character.

• 16-Bit Representation:

• Java uses 16-bit Unicode characters. This means each character is represented by a
16-bit (2-byte) value.
• This allows Java to support 65,536 unique characters.

• Character Data Type:

• The char data type in Java is used to store a single Unicode character.

21. What is null, true and false in java?

null, true, and false in Java:

These are special literals in Java that represent unique values or states within the
programming language.

null is a literal in Java that represents the absence of a value or a reference to an object. It can be
assigned to any reference type variable (e.g., objects, arrays).

String str = null; // str does not reference any String object

if (str == null) {

System.out.println("The string is null.");

true and false:

true and false are boolean literals in Java that represent the two possible values of a
boolean type.

22. Dynamic Loading in Java:

Dynamic loading in Java refers to the process of loading classes into the Java Virtual
Machine (JVM) at runtime rather than at compile time

23. what is swing in java

Swing is a part of Java's standard library that provides a rich set of GUI components for building
graphical user interfaces (GUIs)

24.What is java beans

JavaBeans are reusable software components for Java that can be manipulated visually in a
builder tool.
JavaBeans have properties that can be accessed and modified using getter and setter methods.
JavaBeans can generate and listen to events.

25.What is applet in java

Java programs that can be embedded in web pages and run in web browser using applet, providing
interactive features
BIG Questions
1. Explain lifecycle of a thread. ****

1.Thread States:
2.New
3.Runnable:
4.Blocked:
5.Waiting:
6.Terminated:

Thread Lifecycle Diagram:

1. New: Thread is created but not started.

Thread t = new Thread();
3. Runnable: Thread is ready to run or running.
t. start (); // The thread is now in the Runnable state
4. Blocked: Thread is waiting to acquire a lock.
synchronized(obj) {
// thread acquires lock on obj
}
5. Waiting: Thread is waiting indefinitely for another thread's action.
t.join(); // The current thread waits for t to finish
6. Timed Waiting: Thread is waiting for a specified period.
Thread.sleep(1000); // The thread sleeps for 1 second
 7. Terminated: Thread has finished execution.
public void run() {
// Thread execution logic
}
// When run() completes, the thread is terminated

2. Explain advantages and dis advantages of applet

Applets are Java programs that can be embedded in web pages and executed in a web browser.

Advantages of Applets:

1. Platform Independence:
o Applets are written in Java, which is a platform-independent language. This means
they can run on any system that has a compatible Java Virtual Machine (JVM) and a
supporting web browser.
2. Rich User Interface:
o Applets can use the full power of the Java API, including Swing and AWT, to create
rich and interactive user interfaces.
3. Security:
o Applets run in a sandbox environment which restricts their ability to perform
potentially dangerous operations, such as file I/O on the client machine. This
sandboxing helps protect users from malicious code.
4. Easy to Deploy:
o Applets are easy to deploy since they can be embedded in HTML pages and loaded
over the network. Users do not need to install the applet explicitly; it is downloaded
and executed by the browser.
5. Automatic Updates:
o Since applets are loaded from a web server, updates to the applet can be made on
the server side. Users automatically get the latest version when they load the web
page.

Disadvantages of Applets:

1. Browser Support:
o Modern browsers have discontinued support for NPAPI (Netscape Plugin Application
Programming Interface), which is required for running Java applets. This has made it
difficult to run applets on most modern browsers.
2. Security Restrictions:
o The security restrictions of the applet sandbox can be limiting. Applets are not allowed
to perform many tasks that are necessary for advanced applications, such as accessing
the local file system or making network connections to arbitrary hosts.
3. Performance:
o Applets can suffer from performance issues, especially when compared to native
applications or other web technologies. This is due to the overhead of the JVM and
the browser plugin.
4. User Experience:
 o The user experience with applets can be inconsistent. They require a JVM to be
installed on the client machine, which can be a barrier for users. Additionally, the
loading time for applets can be significant, leading to a poor user experience.
5. Compatibility Issues:
o Different versions of the JVM and browser can lead to compatibility issues. An applet
that works in one environment might not work in another, causing frustration for
developers and users alike.
6. Declining Usage:
o With the rise of modern web technologies such as HTML5, CSS3, and JavaScript
frameworks, the need for applets has significantly diminished. These newer
technologies offer better performance, security, and cross-browser compatibility.

3. Explain the features of swing in java

Swing is a part of the Java Foundation Classes (JFC) and provides a rich set of components for building
graphical user interfaces (GUIs). Swing is built on top of the Abstract Window Toolkit (AWT) and
provides a more flexible and powerful framework for creating desktop applications.

• Lightweight Components: Swing components are written entirely in Java and do not rely
on native GUI components, making them platform-independent and lightweight.

• Pluggable Look and Feel: Swing allows developers to change the look and feel of the
application at runtime. You can use the default look and feel provided by the operating
system, or you can set a custom look and feel.

• Rich Set of Components: Swing provides a wide variety of components, including buttons,
checkboxes, radio buttons, text fields, text areas, tables, trees, and more.

• Customizable Components: Swing components are highly customizable. You can extend
existing components or create your own custom components by subclassing JComponent.

• Event-Driven Programming: Swing follows the event-driven programming model, where

components generate events (like button clicks) that can be handled by event listeners.

• Accessibility: Swing provides support for building accessible applications. It includes

features like keyboard navigation, support for screen readers, and customizable component
properties for better accessibility.

• Drag and Drop: Swing supports drag-and-drop functionality, making it easier to implement
interactive and intuitive user interfaces.

• High-Level Containers: Swing provides high-level containers like JFrame, JDialog,

JApplet, and JPanel to help organize the GUI and manage the layout.

• Layout Managers:

• Swing includes several layout managers (like BorderLayout, FlowLayout,

GridLayout, and BoxLayout) to help manage the positioning and sizing of
components within
4.Explain benefits of java Collection Framework
The Java Collection Framework (JCF) is a set of classes and interfaces that implement commonly
reusable collection data structures. Thus, used to handle collections of objects.

Key Benefits:

1. Unified Architecture:

The Collection Framework provides a standard way to handle collections of objects.

such as List, Set, and Map, which define the basic operations that can be performed
on collections.

2. Reusability:

The framework provides a variety of useful data structures (e.g., ArrayList,

LinkedList, HashSet, TreeSet, HashMap, TreeMap) that can be reused across
different applications, reducing the need to write custom data structures.

3. Interoperability:

Collections within the framework are designed to be interoperable. You can easily
convert from one type of collection to another (e.g., from a List to a Set), facilitating
flexible and efficient data handling.

4. Reduced Programming Effort:

By providing ready-to-use collection classes, the framework reduces the amount of

code needed to implement data structures and algorithms, leading to faster
development times.

5. Improved Performance:

The Collection Framework includes highly optimized implementations of data

structures and algorithms. These implementations are designed to be efficient in
terms of both time and space, often outperforming custom implementations.

6. Convenient Utility Methods:

The Collections class provides static methods for performing common operations,
such as sorting, searching, and shuffling, on collections.

5. Describe Hierarchy of java collection Framework

Root Interfaces and Classes

1. Iterable<T> (Interface):

The root interface for all collection classes. It defines the iterator() method, which
returns an Iterator object to traverse the collection
 public interface Iterable<T>
{
Iterator<T> iterator();
}

2. Collection<E> (Interface):

Extends Iterable. It is the root interface for the collection hierarchy, providing basic
operations like add, remove, size, and contains

a) Key Interfaces

1. List<E> (Interface): Extends Collection. It represents an ordered collection

(also known as a sequence). Lists can contain duplicate elements and provide
positional access and search operations.
2. Set<E> (Interface): Extends Collection. It represents an unordered collection of
unique elements. Sets do not allow duplicate elements.

3. Queue<E> (Interface): Extends Collection. It represents a collection designed for

holding elements prior to processing, typically following First-In-First-Out (FIFO) order

4.Deque<E> (Interface): Extends Queue. It represents a double-ended queue, allowing

elements to be added or removed from both ends.

5. Map<K, V> (Interface): Represents a collection of key-value pairs. Maps do not extend
Collection but are part of the framework. Each key maps to exactly one value.

b. Key Classes

ArrayList<E> (Class): Implements List. It uses a dynamic array to store the elements. It
allows random access and is good for frequent read operations.

LinkedList<E> (Class): Implements List, Deque. It uses a doubly-linked list to store the
elements. It is good for frequent insertions and deletions

HashSet<E> (Class): Implements Set. It uses a hash table to store the elements and provides
constant-time performance for basic operations.

TreeSet<E> (Class): Implements Set, NavigableSet. It uses a red-black tree to store the
elements in sorted order.

PriorityQueue<E> (Class): Implements Queue. It uses a priority heap to order the elements
and provides efficient access to the element with the highest priority.

HashMap<K, V> (Class): Implements Map. It uses a hash table to store key-value pairs and
provides constant-time performance for basic operations.

TreeMap<K, V> (Class): Implements Map, NavigableMap. It uses a red-black tree to store
key-value pairs in sorted order.
6. Explain the implementation of Multiple inheritance using interface
Java does not support multiple inheritance through classes to avoid complexity and ambiguity.
However, it allows multiple inheritance using interfaces.

Key Concepts:

1. Interface Declaration:
Interfaces are declared using the interface keyword. An interface can contain
abstract methods, default methods, and static methods.
2. Class Implementation:
A class implements an interface using the implements keyword. A class can
implement multiple interfaces by separating them with commas.
// Interface 1
interface Printable {
void print();
}

// Interface 2
interface Showable {
void show();
}

// Class implementing both interfaces

class Document implements Printable, Showable {
// Implementing the method from Printable
public void print() {
System.out.println("Printing document...");
}

// Implementing the method from Showable

public void show() {
System.out.println("Showing document...");
}

public static void main(String[] args) {

Document doc = new Document();
doc.print(); // Calls the print method
doc.show(); // Calls the show method
}
}

Let's consider an example where we have two interfaces, Printable and Showable, and a class
Document that implements both interfaces.
Explanation:

1. Interface Declaration:
o Printable and Showable are two interfaces, each with one abstract method:
print() and show(), respectively.
2. Class Implementation:
o Document implements both Printable and Showable interfaces.
o The class provides implementations for both print() and show() methods.
3. Using the Class:
o In the main method, an instance of Document is created.
o The print() and show() methods are called on the Document instance,
demonstrating that it can handle methods from both interfaces.

7. What is interface? How it is implemented in java?

Interfaces define set of methods that a class must implement. An interface can contain only constants,
method signatures, default methods, static methods, and nested types. Interfaces cannot contain
instance fields or constructors

An interface is defined using the interface keyword. It can include abstract methods (methods
without a body), default methods (methods with a default implementation), and static methods.

// Defining an interface
public interface Animal {
// Abstract method
void eat();

// Default method
default void sleep() {
System.out.println("Sleeping...");
}

// Static method
static void breathe() {
System.out.println("Breathing...");
}
}

Implementing an Interface

A class implements an interface using the implements keyword. A class can implement
multiple interfaces, providing concrete implementations for all abstract methods defined in the
interfaces.

// Class implementing an interface

public class Dog implements Animal {
// Implementing the abstract method
@Override
public void eat() {
System.out.println("Dog is eating...");
 }

// Overriding the default method (optional)

@Override
public void sleep() {
System.out.println("Dog is sleeping...");
}

public static void main(String[] args) {

Dog dog = new Dog();
dog.eat(); // Calls the implemented method
dog.sleep(); // Calls the overridden default method
Animal.breathe(); // Calls the static method of the interface
}
}

8.Explain GUI Components in java

Java provides a rich set of classes and interfaces for creating graphical user interfaces (GUIs) through
its Abstract Window Toolkit (AWT) and Swing libraries.

These libraries offer a wide range of GUI components, from basic ones like buttons and labels to more
complex ones like tables and trees.

Basic AWT Components:

Frame: A top-level window with a title and a border.

Frame frame = new Frame("AWT Frame");

frame.setSize(300, 200);
frame.setVisible(true);

Button: A push button.

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

frame.add(button);

Label: A non-editable text component.

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

frame.add(label);

TextField: A single-line text input field.

TextField textField = new TextField("Enter text here");

frame.add(textField);
Checkbox: A checkbox component.

Checkbox checkbox = new Checkbox("Check me");

frame.add(checkbox);

List: A component that presents a list of items.

List list = new List();

list.add("Item 1");
list.add("Item 2");
frame.add(list);

Swing (Advanced GUI components)

Swing is a more advanced GUI toolkit that builds on AWT but provides a richer set of
components, better look and feel, and more powerful features.

Basic Swing Components:

JFrame: A top-level container that represents a window

JFrame frame = new JFrame("Swing Frame");

frame.setSize(300, 200);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setVisible(true);

JButton: A push button.

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

frame.add(button);

JLabel: A non-editable text component.

JLabel label = new JLabel("Hello, Swing!");

frame.add(label);

JTextField: A single-line text input field.

JTextField textField = new JTextField("Enter text here", 20);

frame.add(textField);
9. Write a program to read and write characters*********

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class ReadWriteCharacters

{
public static void main(String[] args)
{
// Input and output file paths
String inputFilePath = "input.txt";
String outputFilePath = "output.txt";

// Using FileReader to read characters from the input file

try (FileReader reader = new FileReader(inputFilePath);
FileWriter writer = new FileWriter(outputFilePath))
{
int character;
// Read characters one by one
while ((character = reader.read()) != -1) {
// Write each character to the output file
writer.write(character);
}
System.out.println("Characters have been successfully read from " + inputFilePath + " and
written to " + outputFilePath);
} catch (IOException e) {
e.printStackTrace();
}
}
}

10. Write a program to read and write bytes

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class ReadWriteBytes {

public static void main(String[] args) {
// Input and output file paths
String inputFilePath = "input.dat";
String outputFilePath = "output.dat";

// Using FileInputStream to read bytes from the input file

try (FileInputStream inputStream = new FileInputStream(inputFilePath);
FileOutputStream outputStream = new FileOutputStream(outputFilePath)) {
int byteData;
// Read bytes one by one
while ((byteData = inputStream.read()) != -1) {
// Write each byte to the output file
outputStream.write(byteData);
}
 System.out.println("Bytes have been successfully read from " + inputFilePath + " and written to " +
outputFilePath);
} catch (IOException e) {
e.printStackTrace();
}
}

11. Explain classification of byte stream *****

Byte streams in Java provide a powerful way to handle binary data efficiently and are essential for file operations, data
serialization, and network communications.

Byte streams are classified into two main categories: Input Streams and Output Streams

• Input Streams: Used for reading data from sources.

• Key subclasses: FileInputStream, ByteArrayInputStream,

BufferedInputStream, DataInputStream, ObjectInputStream.

• Output Streams: Used for writing data to destinations.

• Key subclasses: FileOutputStream, ByteArrayOutputStream,

BufferedOutputStream, DataOutputStream, ObjectOutputStream.

Key Subclasses of InputStream:

• FileInputStream:
o Reads bytes from a file.

FileInputStream fis = new FileInputStream("input.dat");

ByteArrayInputStream:

• Reads bytes from a byte array.

byte[] buffer = {1, 2, 3, 4};

ByteArrayInputStream bais = new ByteArrayInputStream(buffer);

BufferedInputStream:

• Buffers input to provide efficient reading of bytes.

BufferedInputStream bis = new BufferedInputStream(new FileInputStream("input.dat"));

DataInputStream:

• Allows an application to read primitive Java data types from an underlying input
stream in a machine-independent way.

DataInputStream dis = new DataInputStream(new FileInputStream("input.dat"));

Key Subclasses of OutputStream:

• FileOutputStream:
o Writes bytes to a file.

FileOutputStream fos = new FileOutputStream("output.dat");

ByteArrayOutputStream:

• Writes bytes to a byte array.

ByteArrayOutputStream baos = new ByteArrayOutputStream();

BufferedOutputStream:

• Buffers output to provide efficient writing of bytes.

BufferedOutputStream bos = new BufferedOutputStream(new

FileOutputStream("output.dat"));

12. Explain methods of sting class. ************

Key Methods of the String Class

charAt(int index)

• Returns the character at the specified index.

String str = "Hello";

char ch = str.charAt(1); // 'e'

length()

• Returns the length of the string.

String str = "Hello";

int len = str.length(); // 5
substring(int beginIndex)

• Returns a new string that is a substring of this string starting from beginIndex.

String str = "Hello";

String substr = str.substring(2); // "llo"

substring(int beginIndex, int endIndex)

• Returns a new string that is a substring of this string from beginIndex to endIndex
(exclusive).

String str = "Hello";

String substr = str.substring(1, 4); // "ell"

indexOf(char ch)

• Returns the index of the first occurrence of the specified character.

String str = "Hello";

int index = str.indexOf('e'); // 1

lastIndexOf(char ch)

• Returns the index of the last occurrence of the specified character.

String str = "Hello";

int index = str.lastIndexOf('l'); // 3

toLowerCase()

• Converts all characters in the string to lower case.

String str = "Hello";

String lowerStr = str.toLowerCase(); // "hello"

toUpperCase()

• Converts all characters in the string to upper case.

String str = "Hello";

String upperStr = str.toUpperCase(); // "HELLO"

trim()

• Removes whitespace from both ends of the string.

String str = " Hello ";
String trimmedStr = str.trim(); // "Hello"

13. Write a java Program for function overloading

public class OverloadingExample
{
// Overloaded method to add two integers
public int add(int a, int b)
{
return a + b;
}

// Overloaded method to add three integers

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

public static void main(String[] args)

{
OverloadingExample example = new OverloadingExample();

// Calling the add method with two integers

int sum1 = example.add(10, 20);
System.out.println("Sum of two integers: " + sum1);

// Calling the add method with three integers

int sum2 = example.add(10, 20, 30);
System.out.println("Sum of three integers: " + sum2);

}
}

14. Explain method overriding with a example

Method overriding in Java is a concept where a subclass provides a specific implementation of 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.

// Base class
class Animal {
// Method in the superclass
public void sound() {
System.out.println("Some generic animal sound");
}
}

// Subclass that extends Animal

class Dog extends Animal {
// Overriding the sound method
@Override
 public void sound() {
System.out.println("Bark");
}
}

// Main class to test the method overriding

public class MethodOverridingExample {
public static void main(String[] args) {
// Creating an object of Animal class
Animal myAnimal = new Animal();
myAnimal.sound(); // Output: Some generic animal sound

// Creating an object of Dog class

Dog myDog = new Dog();
myDog.sound(); // Output: Bark
}
}

In the above example dog override the method in dog class , so we will get a output bark
instead of some generic animal sound

• When we create an Animal object and call sound, it uses the method in the Animal class.

• When we create a Dog object and call sound, it uses the overridden method in the Dog class.

15. Explain types of inheritance in java*******

nheritance is a fundamental concept in object-oriented programming that allows a new class

(subclass or derived class) to inherit the properties and behaviors (fields and methods) of an
existing class (superclass or base class). Java supports different types of inheritance, which
can be classified as follows:

Types of Inheritance in Java

1. Single Inheritance
2. Multilevel Inheritance
3. Hierarchical Inheritance

1. Single Inheritance

Single inheritance is when a class inherits from only one superclass. This is the most
straightforward form of inheritance.

class Animal {
void eat() {
System.out.println("Eating...");
}
}

class Dog extends Animal {

void bark() {
 System.out.println("Barking...");
}
}

public class SingleInheritanceExample {

public static void main(String[] args) {
Dog dog = new Dog();
dog.eat(); // Inherited method
dog.bark(); // Method from Dog class
}
}

Multilevel Inheritance

Multilevel inheritance is when a class is derived from another derived class, forming a chain
of inheritance.
class Animal {
void eat() {
System.out.println("Eating...");
}
}

class Dog extends Animal {

void bark() {
System.out.println("Barking...");
}
}

class Puppy extends Dog {

void weep() {
System.out.println("Weeping...");
}
}

public class MultilevelInheritanceExample {

public static void main(String[] args) {
Puppy puppy = new Puppy();
puppy.eat(); // Inherited method from Animal class
puppy.bark(); // Inherited method from Dog class
puppy.weep(); // Method from Puppy class
}
}

Hierarchical Inheritance

Hierarchical inheritance is when multiple classes inherit from a single superclass. This forms
a tree structure of classes.
class Animal {
void eat() {
System.out.println("Eating...");
}
}

class Dog extends Animal {

void bark() {
System.out.println("Barking...");
}
}

class Cat extends Animal {

void meow() {
System.out.println("Meowing...");
}
}

public class HierarchicalInheritanceExample {

public static void main(String[] args) {
Dog dog = new Dog();
dog.eat(); // Inherited method
dog.bark(); // Method from Dog class

Cat cat = new Cat();

cat.eat(); // Inherited method
cat.meow(); // Method from Cat class
}
}

16. What is Constructor? Explain two constructors

A constructor in Java is a special method that is used to initialize objects. The constructor is
called when an object of a class is created. It has the same name as the class and does not
have a return type.

1. Default Constructor

A default constructor is a constructor that does not take any arguments. If no constructor is
defined in a class, Java provides a default constructor automatically.
class Animal {
String name;

// Default constructor
public Animal() {
name = "Unknown";
}

void display() {
 System.out.println("Animal name: " + name);
}
}

public class DefaultConstructorExample {

public static void main(String[] args) {
Animal animal = new Animal(); // Calls the default constructor
animal.display(); // Output: Animal name: Unknown
}
}.

Parameterized Constructor

A parameterized constructor is a constructor that takes one or more arguments. This allows
the object to be initialized with specific values at the time of creation.

class Animal {
String name;

// Parameterized constructor
public Animal(String name) {
this.name = name;
}

void display() {
System.out.println("Animal name: " + name);
}
}

public class ParameterizedConstructorExample {

public static void main(String[] args) {
Animal animal = new Animal("Dog"); // Calls the parameterized constructor
animal.display(); // Output: Animal name: Dog
}
}

17. Explain this keyword with example

• this Keyword: Refers to the current object.

• Its used To distinguish between instance variables and parameters with the same
name.
• This is especially useful in situations where local variables or parameters have the
same names as instance variables.

By using the this keyword, we ensure that the instance variable name is correctly assigned
the value of the parameter name passed to the constructor.
class Student {
String name;
// Constructor that takes a parameter 'name'
public Student(String name) {
// Using 'this' to refer to the instance variable 'name'
this.name = name;
}

// Method to display the student's name

public void display() {
System.out.println("Student name: " + name);
}
}

public class ThisKeywordExample {

public static void main(String[] args) {
// Creating a new Student object with the name "Alice"
Student student = new Student("Alice");
// Calling the display method to print the name
student.display(); // Output: Student name: Alice
}
}

In the above example

• The constructor Student(String name) takes a parameter name.

• Inside the constructor, we use this.name = name; to assign the parameter name to
the instance variable name.
• Here, this.name refers to the instance variable, while name refers to the parameter
passed to the constructor

18. Explain Try, catch and finally block with example

Try , catch and finally used in the exception handling technique

• try: The block of code that is likely to throw an exception is placed inside the try block.

• catch: The catch block is used to handle the exception. It catches the exception thrown by
the try block and defines how to handle it.

• finally: The finally block contains code that will always be executed, regardless of
whether an exception is thrown or not. It is typically used for cleanup activities, like closing
resources.
Syntax:

try {
// Code that may throw an exception
} catch (ExceptionType1 e1) {
// Code to handle exception of type ExceptionType1
} catch (ExceptionType2 e2) {
// Code to handle exception of type ExceptionType2
} finally {
// Code that will always execute, whether exception is thrown or not
}

public class Main {

public static void main(String[] args) {
try {
int divideByZero = 5 / 0; // This will throw an ArithmeticException
} catch (ArithmeticException e) {
System.out.println("ArithmeticException caught: " + e.getMessage());
} finally {
System.out.println("This block is always executed.");
}
}
}

The above program will throw an exception and caught in catch block with the message
ArithmeticException caught

19. Explain the categories of Control statement in java

In Java, control statements are used to control the flow of execution of the program. These
statements can be broadly categorized into three main types:

1. Selection (or Conditional) Statements

2. Iteration (or Loop) Statements
3. Jump Statements

1. Selection (or Conditional) Statements

Selection statements are used to choose different paths of execution based on the outcome of
an expression or condition.

• if Statement: Executes a block of code if a specified condition is true.

if (condition) {
// code to be executed if condition is true
}

if-else Statement: Executes one block of code if a specified condition is true and another block of code
if it is false.
if (condition) {
// code to be executed if condition is true
} else {
// code to be executed if condition is false
}

if-else-if Ladder: Checks multiple conditions sequentially and executes a block of code for the first true
condition.

if (condition1) {
// code to be executed if condition1 is true
} else if (condition2) {
// code to be executed if condition2 is true
} else {
// code to be executed if all conditions are false
}

switch Statement: Selects one of many blocks of code to be executed, based on the value of an
expression.

switch (expression) {
case value1:
// code to be executed if expression == value1
break;
case value2:
// code to be executed if expression == value2
break;
// other cases
default:
// code to be executed if expression doesn't match any case
}

2. Iteration (or Loop) Statements

iteration statements are used to repeatedly execute a block of code as long as a specified
condition is true.

• for Loop: Executes a block of code a specific number of times.

for (initialization; condition; update) {

// code to be executed
}

while Loop: Repeatedly executes a block of code as long as a specified condition is true.

while (condition) {
// code to be executed
}
do-while Loop: Similar to the while loop, but it guarantees that the block of code is executed at
least once
do {
// code to be executed
} while (condition);

3. Jump Statements

Jump statements are used to transfer control to another part of the program.

• break Statement: Terminates the nearest enclosing loop or switch statement.

for (int i = 0; i < 10; i++) {

if (i == 5) {
break; // exit the loop
}
}

continue Statement: Skips the current iteration of the nearest enclosing loop and proceeds with the
next iteration.
for (int i = 0; i < 10; i++) {
if (i == 5) {
continue; // skip the rest of this loop iteration
}
// code to be executed for each iteration
}

Summary

• Selection Statements/CONDITIONAL STATEMENTS: if, if-else, if-else-if, switch.

• Iteration Statements/Looping Statements: for, while, do-while.
• Jump Statements: break, continue, return.

Examples for selection/Conditional Statements

public class IfExample {

public static void main(String[] args) {
int number = 10;
if (number > 0) {
System.out.println("The number is positive.");
}
}
}

If else

public class IfElseExample {

public static void main(String[] args) {
int number = -5;
if (number > 0) {
 System.out.println("The number is positive.");
} else {
System.out.println("The number is negative or zero.");
}
}
}

20. Explain switch statement with an example

switch Statement

The switch statement selects one of many blocks of code to be executed based on the value
of an expression.

Syntax
switch (expression) {
case value1:
// code to be executed if expression equals value1
break;
case value2:
// code to be executed if expression equals value2
break;
// other cases
default:
// code to be executed if expression doesn't match any case
}

public class SwitchExample {

public static void main(String[] args) {
int day = 3;
String dayName;
switch (day) {
case 1:
dayName = "Monday";
break;
case 2:
dayName = "Tuesday";
break;
case 3:
dayName = "Wednesday";
break;
case 4:
dayName = "Thursday";
break;
case 5:
dayName = "Friday";
break;
case 6:
dayName = "Saturday";
break;
case 7:
dayName = "Sunday";
break;
 default:
dayName = "Invalid day";
break;
}
System.out.println("Day: " + dayName);
}
}

In the above example particular case will be executed based on the condition. If any condition is not matching
the control will transfer to default statement

21. Explain looping statements in java

Looping statements are used to repeatedly execute a block of code as long as a specified
condition is true. There are three main types of looping statements:

1. for Loop
2. while Loop
3. do-while Loop

1. for Loop

The for loop is used when the number of iterations is known beforehand. It consists of three
parts: initialization, condition, and update.

Syntax:

for (initialization; condition; update) {

// code to be executed
}
public class ForLoopExample {
public static void main(String[] args) {
for (int i = 0; i < 5; i++) {
System.out.println("i = " + i);
}
}
}

while Loop

The while loop is used when the number of iterations is not known beforehand, and it
depends on a condition. The loop continues to execute as long as the condition is true.

Syntax:
while (condition) {
// code to be executed
}
public class WhileLoopExample {
public static void main(String[] args) {
int i = 0;
while (i < 5) {
System.out.println("i = " + i);
i++;
}
}
}

do-while Loop

The do-while loop is similar to the while loop, but it guarantees that the loop's body will be
executed at least once, regardless of the condition.

Syntax:

do {
// code to be executed
} while (condition);

public class DoWhileLoopExample {

public static void main(String[] args) {
int i = 0;
do {
System.out.println("i = " + i);
i++;
} while (i < 5);
}
}

Summary

• for Loop: Used when the number of iterations is known. It consists of initialization,
condition, and update parts.
• while Loop: Used when the number of iterations is not known and depends on a condition.
The loop executes as long as the condition is true.
• do-while Loop: Similar to the while loop but ensures that the loop body is executed at
least once, regardless of the condition.

22. What is conditional Operator? Explain with an example program

The conditional operator, also known as the ternary operator, is a shorthand way of expressing
conditional statements.

condition ? expression1 : expression2;

public class ConditionalOperatorExample {
public static void main(String[] args) {
int number = 10;

// Using the conditional operator to check if the number is positive or negative

String result = (number >= 0) ? "Positive" : "Negative";

// Printing the result

System.out.println("The number is " + result);
}
}
In the above example condition is true , we will get the out put as positive

23. Explain features of java

1. Simple

Java is designed to be easy to learn and use. Its syntax is clean and easy to understand, making
it an excellent choice for beginners. It also removes complex features of other languages like
pointers and multiple inheritance, making it more straightforward to work with.

2. Object-Oriented

Java follows the object-oriented programming (OOP) paradigm, which means it uses objects
and classes to organize code. This approach promotes code reuse, modularity, and scalability.
The four main principles of OOP in Java are:

• Encapsulation: Bundling data (attributes) and methods (functions) that operate on the data
into a single unit called a class.
• Inheritance: Creating new classes from existing ones, inheriting attributes and behaviors.
• Polymorphism: Allowing methods to do different things based on the object it is acting upon.
• Abstraction: Hiding complex implementation details and showing only the essential features
of the object.

3. Platform-Independent

Java is platform-independent at both the source and binary levels, which means that Java
programs can run on any device that has the Java Virtual Machine (JVM) installed. This feature
is often summarized by the phrase "write once, run anywhere."

4. Secure

Java provides a secure environment for developing applications. It has built-in security features
such as bytecode verification, access control, and a robust exception-handling mechanism.
Java's security manager and various APIs help in creating secure applications by protecting
against viruses and tampering.

5. Robust
Java is designed to be reliable and robust. It has strong memory management, automatic
garbage collection, exception handling, and type checking at compile time. These features help
in developing applications that are less prone to crashes and bugs.

6. Multithreaded

Java supports multithreading, which allows concurrent execution of two or more threads
(smallest unit of a process). This feature is useful for performing multiple tasks simultaneously
within a program, leading to efficient use of CPU resources.

7. Architectural Neutral

Java's bytecode is not specific to any processor or operating system, which makes Java
programs highly portable. The Java compiler generates an intermediate bytecode that can be
executed on any machine equipped with a JVM.

8. High Performance

While Java is not as fast as compiled languages like C or C++, it achieves high performance
through the use of Just-In-Time (JIT) compilers. The JIT compiler compiles bytecode into
native machine code at runtime, which improves the execution speed of Java applications.

9. Distributed

Java provides built-in support for networked (distributed) applications. It includes a rich set of
APIs for handling TCP/IP protocols, enabling developers to create applications that can access
resources across a network seamlessly. Java RMI (Remote Method Invocation) and CORBA
(Common Object Request Broker Architecture) are examples of APIs that support distributed
computing.

10. Dynamic

Java is dynamic in nature due to its ability to load classes at runtime. This means that new
methods and fields can be added to classes and objects without affecting the existing code. The
reflection feature in Java allows inspection of classes, interfaces, fields, and methods at runtime
without knowing their names at compile time.

24.Explain Access control Modifier/Access specifier in java

Access control modifiers, also known as access specifiers, in Java are keywords that set the
accessibility (visibility) of classes, methods, and other members

Types:

• Public
• Protected
• Private
Public

• Scope: The member is accessible from any other class

public class PublicExample {

public int number = 10;

public void display() {

System.out.println("Number: " + number);
}
}

public class Test {

public static void main(String[] args) {
PublicExample example = new PublicExample();
System.out.println(example.number); // Accessible
example.display(); // Accessible
}
}

Protected

• Scope: The member is accessible within the same package and by subclasses (even if they
are in different packages).

package mypackage;

public class ProtectedExample {

protected int number = 20;

protected void display() {

System.out.println("Number: " + number);
}
}

package mypackage;

public class Test {

public static void main(String[] args) {
ProtectedExample example = new ProtectedExample();
System.out.println(example.number); // Accessible within the same package
example.display(); // Accessible within the same package
}
}

package otherpackage;

import mypackage.ProtectedExample;

public class SubclassExample extends ProtectedExample {

public void show() {
System.out.println(number); // Accessible in subclass
display(); // Accessible in subclass
}
}
Private

• Scope: The member is accessible only within the same class.

public class PrivateExample {

private int number = 40;

private void display() {

System.out.println("Number: " + number);
}

public void show() {

display(); // Accessible within the same class
}
}

public class Test {

public static void main(String[] args) {
PrivateExample example = new PrivateExample();
// System.out.println(example.number); // Not accessible
// example.display(); // Not accessible
example.show(); // Indirectly accessing the private method
}
}

Summary

• Public: Members are accessible from any other class. Use the public keyword.
• Protected: Members are accessible within the same package and by subclasses. Use the
protected keyword.
• Private: Members are accessible only within the same class. Use the private keyword.

These access specifiers help in encapsulating the details of the implementation and exposing
only the necessary parts of the code, enhancing the modularity and maintainability of the
software.

25. Explain different types of operators in Java with an example

• Arithmetic Operators
• Relational Operators
• Logical Operators
• Bitwise Operators
• Assignment Operators
• Unary Operators
• Ternary Operator

Arithmetic operators

Arithmetic Operators
Arithmetic operators are used to perform basic mathematical operations.

• Addition (+)
• Subtraction (-)
• Multiplication (*)
• Division (/)
• Modulus (%)

public class ArithmeticOperators {

public static void main(String[] args) {
int a = 10;
int b = 5;

System.out.println("a + b = " + (a + b)); // 15

System.out.println("a - b = " + (a - b)); // 5
System.out.println("a * b = " + (a * b)); // 50
System.out.println("a / b = " + (a / b)); // 2
System.out.println("a % b = " + (a % b)); // 0
}
}

For Explanation of other operators refer class notes

26.Explain Operator Precedence in Java

Operator precedence determines the order in which operators are evaluated in an expression.
Operators with higher precedence are evaluated before operators with lower precedence. If
operators have the same precedence, their associativity (left-to-right or right-to-left)
determines the order of evaluation.
27. Explain Wild card in generics

Wildcards in Java Generics provide a way to handle different types more flexibly while still
maintaining type safety. They are used when you want to relax the restrictions on a variable
that uses generics. There are three types of wildcards in Java:

1. Unbounded Wildcards (<?>)

2. Upper Bounded Wildcards (<? extends Type>)
3. Lower Bounded Wildcards (<? super Type>)

1. Unbounded Wildcards (<?>)

The unbounded wildcard represents an unknown type. It can be used when the specific type is
not important. This wildcard is useful when you want to write a method that can operate on
collections of any type.

2. Upper Bounded Wildcards (<? extends Type>)

The upper bounded wildcard restricts the unknown type to be a specific type or a subtype of
that type. This is useful when you want to read items from a data structure.

3. Lower Bounded Wildcards (<? super Type>)

The lower bounded wildcard restricts the unknown type to be a specific type or a supertype of
that type. This is useful when you want to write items into a data structure.

Example program for unbounded wildcards

import java.util.List;

public class UnboundedWildcardExample {

public static void printList(List<?> list) {
for (Object elem : list) {
System.out.println(elem);
}
}

public static void main(String[] args) {

List<Integer> intList = List.of(1, 2, 3);
List<String> strList = List.of("one", "two", "three");

printList(intList);
printList(strList);
}
}
Output
1
2
3
One
Two
Three

Example program for upperbound wildcards

import java.util.List;

public class UpperBoundedWildcardExample {

public static double sumOfList(List<? extends Number> list) {
double sum = 0.0;
for (Number num : list) {
sum += num.doubleValue();
}
return sum;
}

public static void main(String[] args) {

List<Integer> intList = List.of(1, 2, 3);
List<Double> doubleList = List.of(1.5, 2.5, 3.5);

System.out.println("Sum of intList: " + sumOfList(intList)); // Output: 6.0

System.out.println("Sum of doubleList: " + sumOfList(doubleList)); // Output: 7.5
}
}

Example program for lower bound wildcards

import java.util.List;
import java.util.ArrayList;

public class LowerBoundedWildcardExample {

public static void addNumbers(List<? super Integer> list) {
list.add(1);
list.add(2);
list.add(3);
}

public static void main(String[] args) {

List<Number> numberList = new ArrayList<>();
addNumbers(numberList);

for (Number num : numberList) {

System.out.println(num);
}
}
}