1.
OOP Concepts:
Classes and Objects:
o Defining classes, constructors, instance variables, methods.
o Object creation, instantiation, and reference variables.
Inheritance:
o Extending classes, superclass and subclass relationships.
o Method overriding, super keyword, access modifiers.
Polymorphism:
o Method overloading (compile-time polymorphism).
o Method overriding (run-time polymorphism).
Encapsulation:
o Access modifiers (public, private, protected, default).
o Getters and setters, encapsulating fields.
Abstraction:
o Abstract classes and methods.
o Interfaces, implementing interfaces, default methods, static methods.
2. Java Basics:
Data types, variables, and operators:
o Primitive data types (int, double, boolean, etc.).
o Reference types (objects, arrays).
o Operators (arithmetic, relational, logical, bitwise).
Control flow:
o if-else statements, switch-case statements.
o Loops (for, while, do-while).
o Break and continue statements.
Arrays and Strings:
o Declaring and initializing arrays.
o Array operations (traversal, sorting, searching).
o String manipulation (String class methods, StringBuilder, StringBuffer).
Exception handling:
o try-catch-finally blocks.
o Throwing exceptions (throw keyword).
o Custom exceptions, checked vs unchecked exceptions.
3. Java Core APIs:
String handling:
o Immutable nature of String class.
o StringBuilder and StringBuffer (mutable string manipulation).
o String methods (substring, indexOf, etc.).
Collections framework:
o List interface (ArrayList, LinkedList), Set interface (HashSet, TreeSet).
o Map interface (HashMap, TreeMap).
o Queue interface (LinkedList, PriorityQueue).
Date and Time API:
o LocalDate, LocalTime, LocalDateTime classes.
o Formatting and parsing dates.
o Date arithmetic and comparisons.
Wrapper classes:
o Conversion between primitive types and corresponding wrapper classes
(autoboxing, unboxing).
o Utility methods provided by wrapper classes.
4. Concurrency:
Threads and multi-threading:
o Creating threads (Thread class, Runnable interface).
o Thread lifecycle (new, runnable, blocked, waiting, timed waiting, terminated).
o Thread synchronization (synchronized keyword, locks).
Executors and thread pools:
o Executor framework (Executor, ExecutorService).
o ThreadPoolExecutor, managing thread pools.
Concurrent collections:
o ConcurrentHashMap, CopyOnWriteArrayList, etc.
o Atomic variables, synchronized collections.
5. Java I/O:
Input/Output streams:
o Byte streams (FileInputStream, FileOutputStream).
o Character streams (FileReader, FileWriter).
o Buffered streams (BufferedReader, BufferedWriter).
Serialization:
o Serializable interface, ObjectOutputStream, ObjectInputStream.
o Externalizable interface, custom serialization.
File handling:
o File class, File operations (creating, deleting, renaming files/directories).
o NIO (New I/O) package for non-blocking I/O operations.
6. Java Memory Management:
Garbage Collection:
o How GC works, different types of GC algorithms (generational, parallel,
CMS, G1).
o Object finalization and finalize method.
Memory allocation:
o Stack vs heap memory allocation.
o JVM memory model (method area, heap, stack, PC register).
7. Design Patterns:
Commonly used design patterns:
o Creational patterns (Singleton, Factory, Builder).
o Structural patterns (Adapter, Proxy, Decorator).
o Behavioral patterns (Observer, Strategy, Iterator).
Applying patterns:
o Understanding when to use each pattern.
o Implementing patterns in Java code.
8. Java Features and JVM Internals:
Generics:
o Generic classes, interfaces, methods.
o Wildcards (? extends, ? super).
Annotations:
o Built-in annotations (Override, Deprecated, SuppressWarnings).
o Custom annotations, retention policies.
Java Virtual Machine (JVM):
o JVM architecture (class loader, memory areas, execution engine).
o JVM tuning and monitoring tools.
9. Java EE (if applicable):
Servlets and JSP:
o Servlet lifecycle, handling HTTP requests.
o JSP syntax, JSP lifecycle, JSP directives.
JDBC:
o Connecting to databases, executing SQL queries.
o Handling transactions, JDBC drivers.
10. Testing:
Unit testing with JUnit or TestNG:
o Writing and executing unit tests.
o Assertions, test runners, parameterized tests.
11. Best Practices and Coding Standards:
Clean code practices:
o SOLID principles (Single Responsibility, Open/Closed, Liskov Substitution,
Interface Segregation, Dependency Inversion).
o Code readability and maintainability.
12. Recent Java Versions:
Features introduced in Java 8, Java 11, Java 14, etc.:
o Lambda expressions, functional interfaces.
o Stream API, Optional class.
o Modules (Java 9 onwards).
