Java backend
30 important interview questions.

Answer

• Encapsulation: keep data private inside a class and expose it through methods.
• Inheritance: a class reuses and extends another class with extends.
• Polymorphism: one method call behaves differently depending on the object (overriding) or the arguments (overloading).
• Abstraction: show what an object does and hide how, using abstract classes and interfaces.

Answer

• JVM: runs Java bytecode and makes Java platform-independent.
• JRE: the JVM plus the core libraries needed to run Java programs.
• JDK: the JRE plus development tools such as the compiler (javac) and debugger.

You install the JDK to write Java and the JRE (or a JDK) to run it.

Answer

• An abstract class can have state (fields), constructors and both abstract and concrete methods. A class can extend only one.
• An interface defines a contract. Since Java 8 it can have default and static methods, but no instance state. A class can implement many.

Use an interface for a capability ("can be saved", "can be compared") and an abstract class to share common code between closely related classes.

Answer

• Overloading: same method name, different parameter lists, in the same class. Decided at compile time.
• Overriding: a subclass provides its own version of a parent method with the same signature. Decided at runtime.

class Shape { double area() { return 0; } }
class Circle extends Shape {
  double r;
  @Override double area() { return Math.PI * r * r; }
}

Answer

A String can't change after it's created. That makes strings safe to share between threads, lets Java reuse them from the string pool, and keeps hash codes stable for use as map keys.

Each change to a String creates a new object, so when you build text in a loop, use StringBuilder, which changes one buffer in place.

Answer

• == compares references: are both variables pointing to the same object?
• equals() compares content, if the class overrides it (String, Integer and most library classes do).

String a = new String("java");
String b = new String("java");
a == b;      // false – different objects
a.equals(b); // true  – same content

If you override equals(), also override hashCode() so equal objects have equal hash codes.

Answer

A process is a running program with its own memory. A thread is a unit of execution inside a process; threads of the same process share its memory. Threads are lighter to create, but shared memory means you must handle synchronisation.

Answer

It lets only one thread at a time run a block or method on the same lock (object). This prevents race conditions when threads update shared data. Overusing it can slow the program or cause deadlocks, so keep synchronised sections small.

Answer

volatile makes every read of a variable come from main memory, so all threads see the latest value. It guarantees visibility but not atomicity — count++ on a volatile is still unsafe. For atomic counters use AtomicInteger.

Answer

ExecutorService manages a pool of reusable threads. You submit tasks and it runs them, which avoids the cost of creating a new thread for every task and limits how many run at once.

ExecutorService pool = Executors.newFixedThreadPool(4);
Future<Integer> result = pool.submit(() -> computeTotal());
pool.shutdown();

Answer

The JVM automatically frees memory used by objects that are no longer reachable from any live reference. The heap is split into generations: new objects start in the young generation, and long-lived objects move to the old generation. Most objects die young, so collecting the young generation often is efficient. You can't force GC; System.gc() is only a request.

Answer

JPA is the Java standard for mapping objects to database tables (ORM). Hibernate is the most common implementation of JPA. Spring Data JPA adds repositories so you can write findByEmail(String email) and get the query generated for you.

Answer

It happens when you load a list of N parent records with one query, then each parent's children are loaded lazily with one more query each — N+1 queries in total. Fix it with a fetch join (JOIN FETCH), an entity graph, or batch fetching, so related data comes in one or a few queries.

Answer

• Lazy: related data loads only when you access it. It's the default for collections and saves memory, but can cause N+1 queries or a LazyInitializationException outside a transaction.
• Eager: related data loads immediately with the parent. Simple, but can pull in much more data than needed.

Answer

It runs a method inside a database transaction: if the method finishes, changes are committed; if a runtime exception is thrown, they are rolled back. It works through Spring proxies, so calling a @Transactional method from inside the same class bypasses it.

Answer

Microservices split an application into small, independently deployable services, each owning one business area and its own data.

• Pros: independent deployment and scaling, smaller codebases, teams can work separately.
• Cons: network calls between services, harder debugging, distributed data and more infrastructure (service discovery, monitoring, API gateway).

A well-structured monolith is often the better start for a small team.

Answer

Use Spring Security. Common setup: users log in and receive a JWT (or OAuth2 token), every request sends it in the Authorization header, and a filter validates it. Add role-based access with @PreAuthorize or URL rules, hash passwords with BCrypt, use HTTPS and validate all input.

Answer

1. Measure first: logs, APM tools or the database's slow query log.
2. Fix database issues: add indexes, remove N+1 queries, fetch only needed columns, paginate results.
3. Cache repeated reads (@Cacheable, Redis).
4. Move slow work to background jobs or message queues.
5. Tune connection pool and thread pool sizes.