Top Java Interview Questions For 3 Years Of Experience

Introduction:

Top Java Interview Questions For 3 Years Of Experience

1.What is the use of the ‘transient’ keyword in Java?

Ans: In Java, the transient keyword is used to indicate that a variable should not be serialized when an object is converted to a stream of bytes. Serialization is the process of converting an object into a stream of bytes so that it can be stored in a file, sent over a network, or otherwise transported to another location.

2. What is the difference between an error and an exception in Java?

Ans: In Java, both errors and exceptions are subclasses of the Throwable class, but they represent different types of problems that can occur during program execution.

Here are some key differences between errors and exceptions in Java:

1. Error: An error is a serious problem that typically cannot be recovered from, such as an out-of-memory error (OutOfMemoryError) or a stack overflow error (StackOverflowError). Errors are typically caused by problems outside of the program’s control, such as hardware failures or operating system issues.
2. Exception: An exception is a less serious problem that can be handled by the program, such as a file-not-found exception (FileNotFoundException) or a null pointer exception (NullPointerException). Exceptions are typically caused by problems within the program’s logic or input data.

3. What is multithreading? How is it achieved in Java?

Multithreading is the ability of a program to execute multiple threads (smaller units of execution) concurrently. Each thread can perform a separate task while the other threads are running simultaneously, allowing for better utilization of resources and faster program execution.

In Java, multithreading is achieved by creating instances of the Thread class or implementing the Runnable interface. Here are some key concepts and classes related to multithreading in Java:

1. Thread: The Thread class represents a single thread of execution. To create a new thread, you can either extend the Thread class or implement the Runnable interface.
2. Runnable: The Runnable interface represents a task that can be executed by a thread. Implementing the Runnable interface allows you to separate the task logic from the thread management code.

4. What is the purpose of the ‘synchronized’ keyword in Java?

The synchronized keyword in Java is used to provide mutually exclusive access to a shared resource or critical section of code. When a method or block of code is marked as synchronized, only one thread at a time can execute that method or block of code. This is useful for preventing race conditions and ensuring that shared resources are accessed safely.

5. What is an exception in Java? How do you handle exceptions in Java?

An exception in Java is an event that occurs during the execution of a program and disrupts the normal flow of the program. An exception can be caused by a variety of reasons, such as attempting to divide by zero, trying to access an invalid index in an array, or attempting to read from a file that does not exist.

To handle exceptions in Java, you use a try-catch block. The try block contains the code that might throw an exception, and the catch block contains the code that handles the exception. Here is an example of using a try-catch block in Java:

try {
// code that might throw an exception
} catch (ExceptionType e) {
// code to handle the exception
}

In this example, ExceptionType is the type of exception that might be thrown by the code in the try block. If an exception of that type is thrown, the code in the catch block is executed to handle the exception.

6. What is the difference between String, StringBuilder, and StringBuffer?

All three classes, String, StringBuilder, and StringBuffer, represent sequences of characters in Java, but they differ in how they store and manipulate those sequences.

String is an immutable class, which means that once a String object is created, its value cannot be changed. If you want to modify a String object, you need to create a new String object with the modified value. This can be inefficient if you need to perform a lot of modifications on a String object.

StringBuilder and StringBuffer are mutable classes, which means that you can modify the value of an object of these classes. The main difference between StringBuilder and StringBuffer is that StringBuilder is not thread-safe, while StringBuffer is thread-safe.

Here is an example of using StringBuilder in Java:

StringBuilder sb = new StringBuilder(“Hello”);
sb.append(” world”);
String message = sb.toString(); // message is now “Hello world”

In this example, we create a StringBuilder object with the initial value “Hello”. We then append the string ” world” to the StringBuilder object using the append() method. Finally, we convert the StringBuilder object to a String using the toString() method.

Here is an example of using StringBuffer in Java:

StringBuffer sb = new StringBuffer("Hello");
sb.append(" world");
String message = sb.toString(); // message is now "Hello world"

This code is similar to the StringBuilder example, but uses StringBuffer instead of StringBuilder. Note that the code is identical, except for the class name.

7. What is the purpose of the ‘static’ keyword in Java?

In Java, the static keyword is used to declare a member variable or method that belongs to the class itself, rather than to any specific instance of the class. Here are some common uses of the static keyword in Java:

1. static variables: A static variable is shared among all instances of a class. It is initialized when the class is loaded, and its value is the same for all instances of the class. static variables are often used to represent constants or to maintain state across all instances of a class.
2. static methods: A static method is a method that belongs to the class itself, rather than to any specific instance of the class. static methods can be called directly on the class, without the need to create an instance of the class. They are often used for utility functions that do not require access to instance-specific data.

8. What is the difference between an interface and an abstract class?

Interfaces and abstract classes are both used to define abstract behavior that must be implemented by concrete classes, but they have some key differences:

1. An abstract class can have instance variables and non-abstract methods, while an interface cannot.
2. A class can implement multiple interfaces, but it can only extend one abstract class.
3. An abstract class can have constructors, while an interface cannot.
4. An abstract class is used to create a hierarchy of related classes with shared behavior, while an interface is often used to define a set of related behaviors that can be implemented by unrelated classes.

9. What is an annotation in Java? Why is it used?

In Java, an annotation is a special type of metadata that can be added to classes, methods, fields, parameters, and other program elements. Annotations provide additional information about program elements that can be used by the compiler, runtime system, or other tools that process Java code.

Annotations are defined using the @ symbol followed by the name of the annotation, optionally followed by one or more values in parentheses. For example, the @Override annotation is used to indicate that a method in a subclass is intended to override a method in its superclass:

@Override
public void someMethod() {
// method implementation
}

10. What is the difference between private, protected, and public access modifiers in Java?

In Java, access modifiers are used to control the level of access that other classes have to a class’s fields, methods, and constructors. There are three access modifiers in Java:

1. public: A public field, method, or constructor can be accessed from any other class.
2. protected: A protected field, method, or constructor can be accessed from within the same package, as well as from any subclass of the class that defines the field, method, or constructor.
3. private: A private field, method, or constructor can only be accessed from within the same class.