10 Hexaware Java Interview Questions and Answers

Java remains a cornerstone in the software development industry, known for its robustness, portability, and extensive community support. Hexaware, a global IT services company, frequently seeks professionals proficient in Java to develop scalable and efficient solutions for their diverse clientele. Mastery of Java can open doors to numerous opportunities within Hexaware, given the language’s versatility in building everything from enterprise-level applications to mobile apps.

This article aims to prepare you for your upcoming Hexaware Java interview by providing a curated list of questions and answers. By familiarizing yourself with these topics, you will gain the confidence and knowledge needed to demonstrate your Java expertise effectively during the interview process.

Hexaware Java Interview Questions and Answers

1. Explain the concept of Object-Oriented Programming (OOP) in Java and how it is implemented.

Object-Oriented Programming (OOP) in Java is a paradigm that uses “objects” to design applications. It is based on encapsulation, inheritance, polymorphism, and abstraction.

• Encapsulation: Bundles data and methods into a class, restricting direct access to some components to prevent misuse.
• Inheritance: Allows a new class to inherit properties and methods of an existing class, promoting code reusability.
• Polymorphism: Enables objects to be treated as instances of their parent class. It includes compile-time (method overloading) and runtime (method overriding).
• Abstraction: Hides complex implementation details, showing only essential features, achieved using abstract classes and interfaces.

Example:

// Encapsulation
public class Person {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

// Inheritance
public class Employee extends Person {
    private String employeeId;

    public String getEmployeeId() {
        return employeeId;
    }

    public void setEmployeeId(String employeeId) {
        this.employeeId = employeeId;
    }
}

// Polymorphism
public class Main {
    public static void main(String[] args) {
        Person person = new Employee();
        person.setName("John Doe");
        System.out.println(person.getName());
    }
}

// Abstraction
abstract class Animal {
    abstract void makeSound();
}

class Dog extends Animal {
    void makeSound() {
        System.out.println("Bark");
    }
}

2. Implement a Singleton pattern in Java.

The Singleton pattern in Java restricts a class to a single instance, providing a global access point. This is useful when one object is needed to coordinate actions across the system.

public class Singleton {
    private static Singleton instance;

    private Singleton() {}

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

The constructor is private, preventing external instantiation. The getInstance method creates a new instance if none exists, otherwise, it returns the existing one.

3. What are Java Generics and why are they used? Provide an example.

Java Generics allow defining classes, interfaces, and methods with a placeholder for types, replaced with concrete types at runtime. They provide stronger type checks at compile time and eliminate explicit type casting.

Example:

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

public class GenericExample {
    public static void main(String[] args) {
        List<String> stringList = new ArrayList<>();
        stringList.add("Hello");
        stringList.add("World");

        for (String s : stringList) {
            System.out.println(s);
        }
    }
}

4. Explain the difference between checked and unchecked exceptions in Java.

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

Checked exceptions are checked at compile-time and must be caught or declared in the method signature. Examples include IOException and SQLException. They enforce error handling, ensuring potential issues are addressed.

Unchecked exceptions are not checked at compile-time. They are subclasses of RuntimeException and do not need to be explicitly caught or declared. Examples include NullPointerException and IllegalArgumentException. They typically represent programming errors.

Key differences:

• Checked exceptions are checked at compile-time, while unchecked exceptions are checked at runtime.
• Checked exceptions must be caught or declared, whereas unchecked exceptions do not have this requirement.
• Checked exceptions handle anticipated errors, while unchecked exceptions indicate programming errors.

5. Explain the concept of Java Reflection API and provide a use case where it might be useful.

Java Reflection API allows inspection and manipulation of classes, methods, and fields at runtime. It is useful for debugging, testing, and creating frameworks that operate generically.

Example:

import java.lang.reflect.Method;

public class ReflectionExample {
    public static void main(String[] args) {
        try {
            Class<?> clazz = Class.forName("java.util.ArrayList");
            Method[] methods = clazz.getDeclaredMethods();
            for (Method method : methods) {
                System.out.println(method.getName());
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

This example uses Reflection to load the ArrayList class at runtime and print its method names, useful for dynamic interaction with unknown classes.

6. What is the difference between HashMap and ConcurrentHashMap in Java?

HashMap and ConcurrentHashMap are part of the Java Collections Framework with distinct characteristics.

• HashMap:
  • Not thread-safe: Concurrent access can lead to inconsistent data.
  • Faster in single-threaded environments due to lack of synchronization.
  • Suitable for non-concurrent applications.
• ConcurrentHashMap:
  • Thread-safe: Allows concurrent access without data inconsistency.
  • Uses lock stripping for improved performance in multi-threaded environments.
  • Ideal for applications requiring high concurrency.

7. Write a Java program to sort a list of objects based on multiple fields.

To sort a list of objects based on multiple fields in Java, use the Comparator interface, which allows custom sorting logic by chaining comparators.

Example:

import java.util.*;

class Employee {
    String name;
    int age;
    double salary;

    Employee(String name, int age, double salary) {
        this.name = name;
        this.age = age;
        this.salary = salary;
    }

    @Override
    public String toString() {
        return name + " - " + age + " - " + salary;
    }
}

public class Main {
    public static void main(String[] args) {
        List<Employee> employees = Arrays.asList(
            new Employee("John", 25, 50000),
            new Employee("Jane", 22, 60000),
            new Employee("John", 22, 70000),
            new Employee("Jane", 25, 80000)
        );

        employees.sort(Comparator.comparing(Employee::getName)
                                 .thenComparing(Employee::getAge)
                                 .thenComparing(Employee::getSalary));

        employees.forEach(System.out::println);
    }
}

The Employee class is sorted by name, age, and salary using the Comparator interface.

8. Explain the concept of Java Streams and provide an example of its usage.

Java Streams, part of the java.util.stream package, provide a high-level abstraction for processing sequences of elements. They allow operations like filtering, mapping, and reducing, forming a pipeline.

Example:

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class StreamExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

        List<Integer> evenNumbers = numbers.stream()
                                           .filter(n -> n % 2 == 0)
                                           .collect(Collectors.toList());

        System.out.println(evenNumbers); // Output: [2, 4, 6, 8, 10]
    }
}

A list of integers is filtered to retain even numbers, collected into a new list.

9. Explain the concept of dependency injection and how it is implemented in Java frameworks like Spring.

Dependency injection (DI) is a design pattern allowing an object to receive its dependencies externally, promoting loose coupling. In Java frameworks like Spring, DI is implemented using constructor, setter, and field injection.

Example using annotations:

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
class Engine {
    public void start() {
        System.out.println("Engine started");
    }
}

@Component
class Car {
    private Engine engine;

    @Autowired
    public Car(Engine engine) {
        this.engine = engine;
    }

    public void drive() {
        engine.start();
        System.out.println("Car is driving");
    }
}

The Car class depends on the Engine class. The @Autowired annotation injects the Engine dependency into the Car class.

10. Discuss the importance of design patterns in Java and provide examples of commonly used patterns.

Design patterns in Java offer solutions to recurring design problems, making development more efficient. They help in achieving code reusability, scalability, and maintainability, improving communication among developers.

Some commonly used patterns include:

• Singleton Pattern: Ensures a class has only one instance and provides a global access point.
• Factory Pattern: Defines an interface for creating an object but lets subclasses alter the type of objects created.
• Observer Pattern: Defines a one-to-many dependency between objects so that when one changes state, all dependents are notified and updated.
• Decorator Pattern: Allows behavior to be added to an individual object dynamically, without affecting other objects from the same class.

Example of Singleton Pattern:

public class Singleton {
    private static Singleton instance;

    private Singleton() {}

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