Question 1

What is the Singleton design pattern in Java and how does it differ from the Factory design pattern?

Accepted Answer

The Singleton design pattern ensures that a class has only one instance and provides a global point of access to it. This is typically implemented by making the constructor private and providing a static method that returns the instance. Here's a simple implementation:

```java
public class Singleton {
    private static Singleton instance;

private Singleton() {} // Private constructor

public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}
```

On the other hand, the Factory design pattern is used to create objects without specifying the exact class of object that will be created. It defines an interface for creating an object but allows subclasses to alter the type of objects that will be created. Here’s an example:

```java
interface Shape {
    void draw();
}

class Circle implements Shape {
    public void draw() { System.out.println("Drawing Circle"); }
}

class Square implements Shape {
    public void draw() { System.out.println("Drawing Square"); }
}

class ShapeFactory {
    public static Shape getShape(String shapeType) {
        if (shapeType.equalsIgnoreCase("CIRCLE")) {
            return new Circle();
        } else if (shapeType.equalsIgnoreCase("SQUARE")) {
            return new Square();
        }
        return null;
    }
}
```

The key difference is that Singleton restricts instantiation to one object, while Factory provides a way to create different objects based on input parameters.

Question 2

What is the difference between checked and unchecked exceptions in Java? Provide code examples to illustrate your answer.

Accepted Answer

In Java, exceptions are divided into checked and unchecked exceptions.

1. **Checked Exceptions**: These are exceptions that must be either caught or declared in the method signature using the `throws` keyword. They are checked at compile-time.
   ```java
   import java.io.File;
   import java.io.FileReader;
   import java.io.IOException;

public class CheckedExceptionExample {
       public void readFile(String filePath) throws IOException {
           File file = new File(filePath);
           FileReader fr = new FileReader(file);
           fr.read();
           fr.close();
       }
   }
   ```

2. **Unchecked Exceptions**: These exceptions do not need to be declared or caught. They occur during the runtime and are subclasses of `RuntimeException`.
   ```java
   public class UncheckedExceptionExample {
       public void divide(int a, int b) {
           int result = a / b; // This may throw ArithmeticException if b is 0
           System.out.println("Result: " + result);
       }
   }
   ```

In summary, the key difference lies in the way they are handled: checked exceptions must be handled explicitly, while unchecked exceptions do not require any explicit handling.

Question 3

What are some of the key features introduced in Java 8, and how do you use Streams and Lambda expressions with examples?

Accepted Answer

Java 8 introduced several key features including Lambdas, Streams, and the new Date and Time API. 1. **Lambda Expressions**: These provide a clear and concise way to represent one method interface using an expression. They are used primarily to define the behavior of the method (functional interfaces). ```java import java.util.Arrays; import java.util.List; public class LambdaExample { public static void main(String[] args) { List names = Arrays.asList("Alice", "Bob", "Charlie"); names.forEach(name -> System.out.println(name)); } } ``` 2. **Streams**: A stream represents a sequence of elements and provides a functional approach to processing sequences of elements (collections). ```java import java.util.Arrays; import java.util.List; import java.util.stream.Collectors; public class StreamExample { public static void main(String[] args) { List names = Arrays.asList("Alice", "Bob", "Charlie"); List filteredNames = names.stream() .filter(name -> name.startsWith("A")) .collect(Collectors.toList()); System.out.println(filteredNames); // Output: [Alice] } } ``` In summary, Java 8's Lambda expressions simplify the syntax when working with functional interfaces, while Streams provide a powerful abstraction for processing sequences of data in a functional style.

Question 4

Can you explain the Java JVM architecture and how garbage collection works within it?

Accepted Answer

The Java Virtual Machine (JVM) architecture consists of several components including the class loader, execution engine, and garbage collector. The class loader is responsible for loading class files, while the execution engine executes the bytecode. The garbage collection (GC) process automatically manages memory by reclaiming memory used by objects that are no longer referenced. In Java, garbage collection is not explicitly done by the programmer but rather by the JVM. Common algorithms include Mark-and-Sweep, Generational GC, and G1 GC. For example, the following code snippet demonstrates the use of a simple object that will be eligible for garbage collection:

```java
public class GarbageCollectionExample {
    public static void main(String[] args) {
        GarbageCollectionExample obj = new GarbageCollectionExample();
        obj = null; // The object is now eligible for garbage collection
        System.gc(); // Suggests JVM to perform garbage collection
    }
}
```

In the above code, setting `obj` to null removes the reference to the `GarbageCollectionExample` object, making it eligible for garbage collection. The `System.gc()` method is a suggestion to the JVM to run the garbage collector, although it is not guaranteed to execute immediately.

Question 5

How do you manipulate strings in Java and what is the purpose of the String Pool?

Accepted Answer

String manipulation in Java can be performed using various methods provided by the `String` class, such as `substring()`, `indexOf()`, `replace()`, and `toUpperCase()`. Java strings are immutable, meaning once a string object is created, it cannot be changed. Instead, any modification creates a new string object.

The String Pool, also known as the string intern pool, is a special memory area where Java stores string literals. When a string is created, the JVM checks the pool to see if an identical string already exists. If it does, the reference to the existing string is returned; if not, the new string is added to the pool.

Here's an example:

```java
public class StringManipulationExample {
    public static void main(String[] args) {
        String str1 = "Hello";
        String str2 = "Hello";
        String str3 = new String("Hello");

System.out.println(str1 == str2); // true, references the same object in the pool
        System.out.println(str1 == str3); // false, different object in memory

// Manipulating strings
        String substring = str1.substring(1, 4); // "ell"
        System.out.println(substring);
    }
}
```

In the code above, `str1` and `str2` reference the same string in the String Pool, while `str3` creates a new string object. The `substring()` method is used to manipulate the string and extract a portion of it.

SarthiQ

Interview Preparation Guide

Java
Questions & Answers

Document Details

Need Help?

Top Java Interview Questions

Java Interview Questions

A Software Engineer was asked

A Software Engineer was asked

Software Engineer

Software Engineer

Interview Preparation Guide

JavaQuestions & Answers

Document Details

Need Help?

Top Java Interview Questions

Java Interview Questions

A Software Engineer was asked

A Software Engineer was asked

Software Engineer

Software Engineer

Java
Questions & Answers