1. What is Polymorphism?
Polymorphism means one thing works in many forms. In Java, one method name can behave in different ways depending on the object calling it. Example: a Shape class has Circle and Square as child classes. Both use the same method draw(), but Circle draws a round shape and Square draws a box shape. This helps write flexible and reusable code.

2. What is Encapsulation?
Encapsulation means wrapping data and methods together in one unit, and hiding the inner details from outside. We make variables private so no one can change them directly. We give public getter and setter methods to read or update the value safely. This keeps our data protected and code easy to maintain.

3. What is Method Overloading?
Method Overloading means writing more than one method with the same name in the same class, but with different number or type of parameters. Java decides which method to run based on the arguments you pass. Example: add(int a, int b) can add two numbers, and add(int a, int b, int c) can add three numbers. Both have the same name “add” but work differently.

4. What is the use of the final keyword?
The final keyword is used to stop change. A final variable cannot change its value once set. A final method cannot be overridden by a child class. A final class cannot be extended by any other class. It is mostly used when we want to protect something from being modified later.

5. How do you create an immutable class in Java?
An immutable class is a class whose object value cannot change after creation. To make one: mark the class as final, make all fields private and final, do not provide setter methods, set values only through the constructor, and if a field holds a mutable object like a List, return a copy of it instead of the real one. The String class in Java is a good example of an immutable class.

6. Why is String immutable in Java?
String is made immutable for three main reasons. First, security, because Strings are used in things like file paths and network connections, so their value should not change by mistake. Second, caching, because Java keeps a String pool and reuses the same String object to save memory. Third, thread safety, because an immutable object can be shared between many threads without any risk.

7. What is Synchronization in Java?
Synchronization is a way to control access when many threads try to use the same method or block of code at the same time. It allows only one thread to enter at a time, and other threads must wait their turn. This is done using the synchronized keyword. It helps avoid data problems like two threads changing the same value together and causing wrong results.

8. Can we add or modify elements in a HashMap while iterating?
No, we should not directly add or remove elements from a HashMap while looping through it using a normal iterator or for-each loop. Doing this will throw an error at runtime. If we need to remove an element while looping, we should use the Iterator’s own remove() method. If we need safe modification while multiple threads are involved, we can use ConcurrentHashMap instead.

9. What is Fail-Fast behavior in HashMap?
Fail-Fast means the HashMap notices immediately if it is changed while someone is looping through it, and it stops the program right away instead of giving wrong results silently. If you add, remove, or update the map during iteration, Java throws a ConcurrentModificationException. This behavior helps catch bugs early during development.

10. Explain the internal working of HashMap.
A HashMap stores data as key-value pairs inside small storage units called buckets. When you add a key, Java calculates its hashCode and decides which bucket it should go into. If two different keys get the same bucket, this is called a collision, and Java stores both in a linked list inside that bucket. From Java 8 onward, if too many keys collide in one bucket, Java converts that list into a tree structure to make searching faster.

11. What is the equals() and hashCode() contract?
The rule says that if two objects are equal using equals(), then they must also return the same hashCode(). But the reverse is not always true, two objects can have the same hashCode and still not be equal. This is why we should always override both equals() and hashCode() together in a class, especially when we plan to use that class as a key in a HashMap or HashSet.

12. What are the new features in Java 21?
Java 21 brought many useful updates. Record Patterns let us break a record object into its parts directly. Pattern Matching for switch makes switch statements smarter and shorter. Virtual Threads make it easy to create thousands of lightweight threads without using much memory. Sequenced Collections give a proper order to first and last elements. Structured Concurrency, still in preview, helps manage many threads as one single task.

public record Employee(String name, int age, String department) {
    // Compact constructor for validation
    public Employee {
        if (age < 18) {
            throw new IllegalArgumentException("Age must be 18+");
        }
    }
}

// Usage
Employee emp = new Employee("Raj", 25, "IT");
System.out.println(emp.name() + " " + emp.age());

14. What is a @FunctionalInterface?
A FunctionalInterface is an interface that has exactly one abstract method inside it. It can still have default and static methods, but only one method needs to be implemented. This kind of interface is made to work with lambda expressions. Common examples in Java are Runnable, Comparator, and Callable.

import java.util.function.Function;

public class SumOfDigits {
    public static void main(String[] args) {
        Function<Integer, Integer> sumDigits = n -> {
            int sum = 0;
            while (n > 0) {
                sum += n % 10;
                n /= 10;
            }
            return sum;
        };
        System.out.println(sumDigits.apply(12345)); // Output: 15
    }
}

16. What are the new features in Java 17?
Java 17 is a long term support version with strong features. Sealed Classes let us control exactly which classes can extend or implement them. Pattern Matching for instanceof removes the need for manual type casting. Records give us a short way to create simple data-holding classes. Enhanced switch expressions let us write cleaner and shorter conditional code.

public record Product(String name, double price) {
}

// Usage
Product p = new Product("Laptop", 55000.0);
System.out.println(p.name() + " costs " + p.price());

18. What are the different types of Exceptions?
Java exceptions are mainly of two types. Checked Exceptions are checked by the compiler at compile time itself, and we must handle them using try-catch or throws, example IOException and SQLException. Unchecked Exceptions happen at runtime and the compiler does not force us to handle them, example NullPointerException and ArithmeticException. There is also Error, which is a serious problem like OutOfMemoryError that we usually cannot recover from.

public class InvalidAgeException extends Exception {
    public InvalidAgeException(String message) {
        super(message);
    }
}

// Usage
public class Test {
    static void checkAge(int age) throws InvalidAgeException {
        if (age < 18) {
            throw new InvalidAgeException("Age must be 18 or above");
        }
    }
}

public class ExceptionDemo {
    public static void main(String[] args) {
        try {
            int result = 10 / 0;
        } catch (ArithmeticException e) {
            System.out.println("Cannot divide by zero: " + e.getMessage());
        } finally {
            System.out.println("This block always runs");
        }
    }
}

21. What is the use of the super keyword?
The super keyword is used inside a child class to call something from its parent class. We can use super() to call the parent class constructor, super.methodName() to call a parent class method that we have overridden, and super.variableName to access a parent class variable. It is very useful when the child class wants to reuse and extend the parent’s behavior instead of writing it again.

22. Difference between Comparator and Comparable?
Comparable is implemented inside the class itself to define one single natural sorting order, using the compareTo() method, example sorting Employee objects by employee id. Comparator is written as a separate class or lambda outside the object’s class, using the compare() method, and it lets us create many different sorting orders, example sorting the same Employee list by name, or by salary, without changing the Employee class.

23. What methods are present in the Object class?
Every class in Java extends the Object class directly or indirectly, so it gets these methods by default: toString() to get a text form of the object, equals() to compare two objects, hashCode() to get a unique number for the object, getClass() to know the runtime class, clone() to create a copy, and wait(), notify(), notifyAll() which are used for thread communication.

24. Commonly used Spring annotations?
Some annotations used almost daily in Spring Boot projects are @Component, @Service, and @Repository for marking classes as Spring beans, @Controller and @RestController for handling web requests, @Autowired for injecting dependencies automatically, @RequestMapping, @GetMapping, and @PostMapping for defining API endpoints, and @Configuration with @Bean for setting up custom beans manually.

25. Use of @Query annotation in Spring Data JPA?
The @Query annotation lets us write our own custom query directly above a repository method, instead of depending only on Spring’s method name rules. We can write it using JPQL, which works with entity objects, or native SQL, which works directly with database tables. This is useful when the query logic is complex and cannot be created just from a method name.

26. How to connect two databases in one Spring Boot app?
To connect two databases, we create two separate DataSource configuration classes, one for each database, along with two separate EntityManagerFactory beans and two separate TransactionManager beans. We also need to separate our entity and repository packages for each database, and mark one DataSource as @Primary so Spring knows which one to use by default when it is not specified.

public class SumEvenDigits {
    public static void main(String[] args) {
        int num = 122345;
        int sum = 0;
        while (num > 0) {
            int digit = num % 10;
            if (digit % 2 == 0) {
                sum += digit;
            }
            num /= 10;
        }
        System.out.println("Sum of even digits: " + sum); // Output: 8
    }
}

📄 Want all Accenture Java Backend Developer Interview Questions in one PDF?

👉 Click Here to Download PDF

Q1. Is the Accenture Java Backend interview tough for 3 YOE?
No, it is mostly basic to moderate level. It focuses on Core Java, Collections, Spring Boot, and simple coding logic, not on very advanced or tricky topics.

Q2. Does Accenture ask Java 21 questions?
Yes, they do ask about the newer Java versions like Java 17 and Java 21, especially about Records, Virtual Threads, and Pattern Matching, since many companies are moving to these versions.

Q3. Is the coding round hard in the Accenture Java interview?
No, the coding questions are simple and logic based, like finding the sum of digits or writing a small exception handling program. They test your basic thinking, not complex algorithms.

Q4. What topics should I prepare for the Accenture Java Backend Developer role?
Focus on Core Java and OOPS concepts, Collections framework, Java 17 and 21 features, Exception Handling, and Spring Boot basics like annotations and database connections.

Q5. How many rounds are there in the Accenture Java interview process?
Usually there are 2 to 3 rounds in total, which include one or two Technical rounds followed by an HR or Managerial round.