ItsRunTym

JAVA Developer Fresher

IBM interview questions/answers

1. What is Exception Handling? Write a Program

2. How will you make threads synchronize?
3. Types of Constructors in Java, Which Constructor Compiler Automatically
Make
4. What is Pass by Value and Pass by Reference in Java
5. Output of this:

int a = 1;

System.out.println((a++) * (++a));

6. What is Abstract Function in Java?

7. What is Polymorphism?

8. What is Compile-time & Runtime Polymorphism?

9. What are Interfaces? How are they useful in Java?

10. Write a code for interfaces?

11. What is Lambda Expression?

12. Write a program for palindrome?

13. Write a program to find the number of occurrences of each character in a given
string?

14. Remove element from linked list for given index

1. What is Exception Handling? Write a Program

Exception handling in Java is a mechanism to handle runtime errors such as
ClassNotFoundException, IOException, SQLException, RemoteException, etc. , allowing the
normal flow of the application to be maintained. It uses try, catch, finally, and throw
keywords.

Major reasons why an exception Occurs

• Invalid user input

• Device failure
• Loss of network connection
• Physical limitations (out-of-disk memory)
• Code errors
• Opening an unavailable file

public class ExceptionHandlingExample {

public static void main(String[] args) {
try {
int divideByZero = 5 / 0;
} catch (ArithmeticException e) {
System.out.println("ArithmeticException: Division
by Zero.");
} finally {
System.out.println("This block is always
executed.");
}
}
}

Finally- Always executed whether an exception is handled or

not, providing a way to clean up resources.

2. How will you make threads synchronize?

In Java, synchronization is used to control the access of multiple threads to shared resources.
The synchronized keyword is used to synchronize methods or blocks.

class Counter {
private int count = 0;

public synchronized void increment() {

count++;
}

public int getCount() {

return count;
}
}

public class SynchronizationExample {

 public static void main(String[] args) throws
InterruptedException {
Counter counter = new Counter();

Thread t1 = new Thread(() -> {

for (int i = 0; i < 1000; i++) {
counter.increment();
}
});

Thread t2 = new Thread(() -> {

for (int i = 0; i < 1000; i++) {
counter.increment();
}
});

t1.start();
t2.start();

t1.join();
t2.join();

System.out.println("Count: " + counter.getCount());

}
}

3. Types of Constructors in Java, Which Constructor Compiler Automatically Make

There are three types of constructors in Java:

• Default Constructor: A no-argument constructor automatically created by the

compiler if no constructor is defined.
• No-argument Constructor: Explicitly defined by the user with no parameters.
• Parameterized Constructor: A constructor that takes arguments.

The compiler automatically provides a default constructor if no other constructors are

defined.

Example:

public class ConstructorExample {

private int value;

// No-argument constructor
public ConstructorExample() {
this.value = 0;
}

// Parameterized constructor
public ConstructorExample(int value) {
this.value = value;
 }

public int getValue() {

return value;
}

public static void main(String[] args) {

ConstructorExample obj1 = new ConstructorExample();
ConstructorExample obj2 = new ConstructorExample(10);
System.out.println("Default Constructor: " +
obj1.getValue()); // Output: 0
System.out.println("Parameterized Constructor: " +
obj2.getValue()); // Output: 10
}
}

4. What is Pass by Value and Pass by Reference in Java

Java is strictly "pass by value".

• Pass by Value: The method receives a copy of the argument passed. Changes to the
parameter do not affect the argument.
• Pass by Reference: The method receives a reference to the argument passed,
meaning changes to the parameter affect the argument.

In Java, when you pass an object, you pass the reference to that object by value, meaning the
reference itself is copied. Hence, changes to the object affect the original object.

Example:

public class PassByValueExample {

public static void main(String[] args) {
int x = 5;
modifyValue(x);
System.out.println("After modifyValue: " + x); //
Output: 5

MyObject obj = new MyObject();

obj.value = 5;
modifyObject(obj);
System.out.println("After modifyObject: " +
obj.value); // Output: 10
}

public static void modifyValue(int a) {

a = 10;
}
 public static void modifyObject(MyObject o) {
o.value = 10;
}
}

class MyObject {
int value;
}

➔ if we pass array, it will be pass by value or pass by reference?

In Java, when you pass an array to a method, it is passed by value, but this can be a bit
misleading due to how references work. Specifically, the reference to the array is passed by
value, meaning the method gets a copy of the reference. This means changes to the array
elements inside the method will affect the original array, but changing the reference itself will
not affect the original reference.

Let's illustrate this with an example:

Example to Demonstrate Array Passing

public class PassArrayExample {

public static void main(String[] args) {
int[] arr = {1, 2, 3, 4, 5};

// Print the original array

System.out.println("Original array:");
printArray(arr);

// Modify the array

modifyArray(arr);

// Print the modified array

System.out.println("Modified array:");
printArray(arr);

// Change the array reference

changeArrayReference(arr);

// Print the array after trying to change its

reference
System.out.println("Array after attempting to change
reference:");
printArray(arr);
}

// Method to print the array

public static void printArray(int[] arr) {
for (int i : arr) {
System.out.print(i + " ");
 }
System.out.println();
}

// Method to modify array elements

public static void modifyArray(int[] arr) {
for (int i = 0; i < arr.length; i++) {
arr[i] = arr[i] * 2; // Modify array elements
}
}

// Method to change array reference

public static void changeArrayReference(int[] arr) {
arr = new int[]{10, 20, 30, 40, 50}; // Attempt to
change reference
System.out.println("Inside changeArrayReference
method:");
printArray(arr);
}
}

Output:

Original array:
1 2 3 4 5
Modified array:
2 4 6 8 10
Inside changeArrayReference method:
10 20 30 40 50
Array after attempting to change reference:
2 4 6 8 10

Explanation:

1. Original array: We print the original array [1, 2, 3, 4, 5].

2. modifyArray Method: This method doubles each element in the array. Since the
array reference is passed by value (the reference itself is copied), the modifications to
the array elements affect the original array.
3. changeArrayReference Method: This method attempts to change the reference of
the array to a new array [10, 20, 30, 40, 50]. However, this change is local
to the method because the reference itself is passed by value. The original reference in
the main method still points to the modified array [2, 4, 6, 8, 10].

Thus, when passing an array to a method in Java:

• The reference to the array is passed by value.

• Changes to the array elements affect the original array.
• Changing the reference itself inside the method does not affect the original reference.
5. Output of this:

int a = 1;
System.out.println((a++) * (++a)); // Output will be 3

1. a++: (Postincrement) This returns the current value of a (which is 1), and then a is
incremented to 2.
2. ++a: (Preincrement) This increments a to 3 and then returns the new value of a
(which is 3).

So the expression (a++) * (++a) becomes 1 * 3, which results in 3.

public class ExpressionEvaluation {

public static void main(String[] args) {
int a = 1;
System.out.println((a++) * (++a)); // Output will be
3
// Explanation: a++ returns 1 (a becomes 2), ++a
increments to 3, so 1 * 3 = 3.
}
}

6. What is Abstract Function in Java?

Abstract functions (or abstract methods) in Java are methods that are declared without an
implementation. These methods are defined in abstract classes, which cannot be instantiated
on their own. Instead, subclasses of the abstract class must provide implementations for all
abstract methods.

The primary use of abstract functions is to enforce a contract for subclasses. They ensure that
any subclass that extends the abstract class provides implementations for the specified
abstract methods, thus maintaining a consistent interface.

Example Use of Abstract Function

Let's consider an example involving an abstract class Animal and its subclasses Dog and
Cat.

Abstract Class and Abstract Method Example

abstract class Animal {

// Abstract method (does not have a body)
abstract void makeSound();

// Regular method
void sleep() {
System.out.println("Sleeping...");
}
}
class Dog extends Animal {
// Providing implementation for abstract method
void makeSound() {
System.out.println("Bark");
}
}

class Cat extends Animal {

// Providing implementation for abstract method
void makeSound() {
System.out.println("Meow");
}
}

public class AbstractFunctionExample {

public static void main(String[] args) {
Animal myDog = new Dog();
Animal myCat = new Cat();

myDog.makeSound(); // Outputs: Bark

myDog.sleep(); // Outputs: Sleeping...

myCat.makeSound(); // Outputs: Meow

myCat.sleep(); // Outputs: Sleeping...
}
}

7. What is Polymorphism?

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

objects of different classes to be treated as objects of a common superclass. It enables one
interface to be used for a general class of actions, allowing the same method to behave
differently based on the object that invokes it. This facilitates code reusability and flexibility.

Benefits of Polymorphism:

• Code Reusability: Promotes the reuse of code and reduces redundancy.

• Flexibility and Scalability: Makes it easier to extend and maintain code. New
functionality can be added with minimal changes to existing code.
• Decoupling: Reduces the dependency between the client code and the actual
implementation, making the system more modular and easier to manage.

8. What is Compile-time & Runtime Polymorphism?

1. Compile-time Polymorphism (Static Binding): This is achieved through method

overloading, where multiple methods have the same name but different parameters.
The method to be invoked is determined at compile time.
2. Runtime Polymorphism (Dynamic Binding): This is achieved through method
overriding, where a subclass provides a specific implementation of a method that is
already defined in its superclass. The method to be invoked is determined at runtime.
Example of Compile-time Polymorphism

Method Overloading: Define multiple methods with the same name but different
parameters.

class MathOperation {
// Method to add two integers
int add(int a, int b) {
return a + b;
}

// Method to add three integers

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

// Method to add two double values

double add(double a, double b) {
return a + b;
}
}

public class CompileTimePolymorphism {

public static void main(String[] args) {
MathOperation math = new MathOperation();

System.out.println("Sum of 10 and 20: " + math.add(10,

20)); // Calls add(int, int)
System.out.println("Sum of 10, 20, and 30: " +
math.add(10, 20, 30)); // Calls add(int, int, int)
System.out.println("Sum of 10.5 and 20.5: " +
math.add(10.5, 20.5)); // Calls add(double, double)
}
}

Example of Runtime Polymorphism

Method Overriding: Subclass provides a specific implementation of a method defined in its

superclass.

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

class Dog extends Animal {

@Override
void sound() {
System.out.println("Bark");
}
}

class Cat extends Animal {

@Override
void sound() {
System.out.println("Meow");
}
}

public class RuntimePolymorphism {

public static void main(String[] args) {
Animal myDog = new Dog();
Animal myCat = new Cat();

myDog.sound(); // Outputs: Bark

myCat.sound(); // Outputs: Meow
}
}

Explanation of the Example:

1. Compile-time Polymorphism:
o The add method is overloaded with different parameter lists.
o The compiler determines which add method to call based on the method
signature and the arguments provided.
2. Runtime Polymorphism:
o The sound method in the Animal class is overridden by the Dog and Cat
classes.
o The actual method to be called is determined at runtime based on the object's
runtime type (Dog or Cat).

9. What are Interfaces? How are they useful in Java?

In Java, an interface is a reference type, similar to a class, that can contain only constants,
method signatures, default methods, static methods, and nested types. Interfaces cannot
contain instance fields or constructors. Interfaces provide a way to achieve abstraction and
multiple inheritance in Java.

Key Characteristics of Interfaces:

• Abstract Methods: All methods in an interface are abstract (do not have a body) by
default unless they are static or default methods.
• Default Methods: Interfaces can have default methods, which have a default
implementation.
• Static Methods: Interfaces can have static methods, which can be called
independently of any instance.
• Constants: All variables in an interface are implicitly public, static, and
final.
• Multiple Inheritance: A class can implement multiple interfaces, overcoming the
limitation of single inheritance in Java.
How Are Interfaces Useful in Java?

1. Achieving Abstraction: Interfaces allow you to define methods that must be

implemented by any class that implements the interface, thus providing a way to
enforce certain functionalities without specifying how they should be implemented.
2. Multiple Inheritance: Java does not support multiple inheritance of classes, but a
class can implement multiple interfaces. This allows a class to inherit the behavior
from multiple sources.
3. Loose Coupling: By using interfaces, you can decouple the definition of methods
from their implementations. This makes the code more modular and easier to manage,
as you can change the implementation without affecting the code that uses the
interface.
4. Polymorphism: Interfaces enable polymorphic behavior. A variable of an interface
type can reference any object that implements the interface, allowing for flexible and
interchangeable use of objects.

10. Write a code for interfaces?

// Define an interface
interface Animal {
void sound(); // Abstract method
default void sleep() { // Default method
System.out.println("Sleeping...");
}
}

// Implementing the interface in a class

class Dog implements Animal {
@Override
public void sound() {
System.out.println("Bark");
}
}

// Implementing the interface in another class

class Cat implements Animal {
@Override
public void sound() {
System.out.println("Meow");
}
}

public class InterfaceExample {

public static void main(String[] args) {
Animal myDog = new Dog();
Animal myCat = new Cat();

myDog.sound(); // Outputs: Bark

myDog.sleep(); // Outputs: Sleeping...

myCat.sound(); // Outputs: Meow

 myCat.sleep(); // Outputs: Sleeping...
}
}

Explanation of the Example:

1. Interface Definition:
o The Animal interface defines an abstract method sound() and a default
method sleep().
2. Implementation of Interface:
o The Dog and Cat classes implement the Animal interface by providing their
own implementations of the sound() method.
3. Usage:
o In the main method, instances of Dog and Cat are created and assigned to
variables of type Animal.
o The sound() method is called on these instances, demonstrating
polymorphic behavior.
o The sleep() method (a default method in the interface) is also called on
these instances.

11. What is Lambda Expression?

Lambda expressions in Java are a way to represent anonymous functions (function literals)
concisely. They were introduced in Java 8 and provide a means to implement the abstract
method of a functional interface directly inline, without needing to define a separate class or
even an anonymous class.

Functional Interface

An interface which has only one abstract method is called functional interface. Java provides
an anotation @FunctionalInterface, which is used to declare an interface as functional
interface.

Why use Lambda Expression

1. To provide the implementation of Functional interface.
2. Less coding.

Java Lambda Expression Syntax

(argument-list) -> {body}

@FunctionalInterface //It is optional

interface Drawable{

public void draw();

}
public class LambdaExpressionExample2 {

public static void main(String[] args) {

int width=10;

//with lambda

Drawable d2=()->{

System.out.println("Drawing "+width);

};

d2.draw();

12. Write a program for palindrome?

public boolean isPalindrome(String s) {

s= s.toLowerCase(); //ask if it should be case

sensitive or not

int n = s.length();

for(int i=0;i<n/2;i++){

if(s.charAt(i) != s.charAt(n-1-i)){

return false;

return true;

13. Write a program to find the number of occurrences of each character in a given
string?
import java.util.HashMap;
import java.util.Map;

public class CharacterCount {

public static void main(String[] args) {
String str = "hello world";

// Create a HashMap to store character counts

Map<Character, Integer> charCountMap = new
HashMap<>();

// Convert the string to char array

char[] charArray = str.toCharArray();

// Iterate through each character in the array

for (char c : charArray) {
// If the character is already present in the map,
increment its count
if (charCountMap.containsKey(c)) {
charCountMap.put(c, charCountMap.get(c) + 1);
} else {
// If the character is encountered for the
first time, add it to the map with count 1
charCountMap.put(c, 1);
}
}

// Print the character counts

for (Map.Entry<Character, Integer> entry :
charCountMap.entrySet()) {
System.out.println(entry.getKey() + ": " +
entry.getValue());
 }
}
}

14. Remove element from linked list for given index

// Class representing a node in the linked list

class Node {
int data;
Node next;

Node(int data) {
this.data = data;
this.next = null;
}
}

public class LinkedList {

Node head;

// Method to add a new node to the end of the list

public void add(int data) {
Node newNode = new Node(data);
if (head == null) {
head = newNode;
} else {
Node temp = head;
while (temp.next != null) {
temp = temp.next;
}
 temp.next = newNode;
}
}

// Method to remove a node by index

public void removeAtIndex(int index) {
if (head == null) { // Check if the list is empty
System.out.println("List is empty.");
return;
}

Node temp = head;

// If the head node needs to be removed

if (index == 0) {
head = temp.next; // Change the head to the next node
return;
}

// Traverse to the node just before the one to be deleted

for (int i = 0; temp != null && i < index - 1; i++) {
temp = temp.next;
}

// If the index is greater than the number of nodes

if (temp == null || temp.next == null) {
System.out.println("Index out of bounds.");
return;
}
 // Node temp.next is the node to be deleted
// Store the next node of the node to be deleted
Node next = temp.next.next;

// Unlink the node to be deleted

temp.next = next;
}

// Method to display the list

public void display() {
Node temp = head;
while (temp != null) {
System.out.print(temp.data + " -> ");
temp = temp.next;
}
System.out.println("null");
}

public static void main(String[] args) {

LinkedList list = new LinkedList();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);

System.out.println("Original List:");
list.display();
 int indexToRemove = 2;
list.removeAtIndex(indexToRemove);

System.out.println("List after removing element at index " + indexToRemove + ":");

list.display();
}
}