Study Plan (4 Weeks)
Weeks 1-4: Foundations
Week 1 (5 days): Core Java
Day 1: Introduction to Java & Setup
What is Java? Features & Uses
Installing JDK & Setting up IDE (IntelliJ/Eclipse)
Writing and running your first Java program
Java Compilation Process
Day 2: Java Fundamentals - Data Types & Operators
Variables and Data Types (int, float, double, boolean, etc.)
Operators (Arithmetic, Relational, Logical, Bitwise, Assignment)
Type Casting & Type Promotion
Day 3: Control Statements
Decision-making (if-else, switch-case)
Loops (for, while, do-while)
Break, Continue, and Return Statements
Day 4: Methods & Functions
Defining and Calling Methods
Method Overloading
Recursion in Java
Day 5: Object-Oriented Programming (OOPs) - Part 1
Classes and Objects
Constructors & 'this' Keyword
Encapsulation & Getters/Setters
Day 6: OOPs - Part 2
Inheritance & Types of Inheritance
Method Overriding & 'super' Keyword
Polymorphism (Compile-time & Runtime)
Day 7: OOPs - Part 3 & Exception Handling
Abstract Classes & Interfaces
Static & Final Keywords
Exception Handling (try-catch, throws, finally)
Week 2 (5 days): Junit
Day 8: Introduction to JUnit
What is JUnit? Importance of Unit Testing
JUnit Installation & Setup
Writing Your First Test Case
Day 9: Assertions & Test Case Execution
Assertions in JUnit (assertEquals, assertTrue, assertFalse, etc.)
Running Tests & Understanding Results
Day 10: Annotations in JUnit
@Test, @BeforeEach, @AfterEach, @BeforeAll, @AfterAll
Writing Setup and Teardown Methods
Day 11: Parameterized Tests & Test Suites
Writing Parameterized Tests
Using @TestFactory for Dynamic Tests
Combining Tests into a Suite
Day 12: Mocking & Mockito Basics
What is Mocking? Why use Mockito?
Writing Test Cases with Mocks
Dependency Injection for Testing
Day 13: Handling Exceptions & Edge Cases in Tests
Testing Exception Scenarios
Handling Edge Cases in Testing
Improving Test Coverage
Day 14: Best Practices in Unit Testing
Writing Maintainable Tests
Understanding Code Coverage
Continuous Testing in CI/CD
Week 3 (5 days): Data Structures and Algorithms (DSA)
Day 15: Introduction to DSA & Time Complexity
Understanding Big-O Notation
Best, Worst & Average Cases of an Algorithm
Day 16: Arrays & Strings
1D & 2D Arrays, Operations
String Manipulation & StringBuilder
Day 17: Linked Lists (Singly & Doubly)
Creating & Traversing Linked Lists
Insertion & Deletion Operations
Day 18: Stacks & Queues
Implementing Stack (LIFO) using Array & Linked List
Implementing Queue (FIFO), Circular Queue, and Deque
Day 19: Recursion & Sorting Algorithms
Understanding Recursion with Examples
Sorting Algorithms (Bubble, Selection, Insertion, Merge, Quick Sort)
Day 20: Trees & Binary Search Trees (BST)
Introduction to Trees
Binary Trees vs. BST
Tree Traversal (Inorder, Preorder, Postorder)
Day 21: Graphs & Hashing
Graph Representation (Adjacency Matrix & List)
BFS vs. DFS
HashMaps & HashSets
Week 4 (5 days): Git and JDBC
Day 22: Introduction to Git & Version Control
What is Git? Why Version Control?
Installing Git & Setting Up GitHub
Basic Git Commands (git init, clone, add, commit, status)
Day 23: Branching, Merging & Collaboration
Creating and Managing Branches
Merging & Resolving Conflicts
Pull Requests & Code Reviews
Day 24: Advanced Git Operations
Git Rebase, Stash, Reset, and Cherry-pick
Working with Remote Repositories
Git Workflows (Feature Branching, GitFlow)
Day 25: Introduction to JDBC & Database Connectivity
What is JDBC? Setting up MySQL/PostgreSQL
Connecting Java to Database (JDBC API)
Writing Basic SQL Queries in Java
Day 26: CRUD Operations in JDBC
Executing SQL Queries (INSERT, UPDATE, DELETE, SELECT)
Using PreparedStatements & Statement Objects
Handling SQL Exceptions
Day 27: Connection Pooling & Transaction Management
Connection Pooling with HikariCP
Transaction Management (Commit & Rollback)
Day 28: Mini Project - Database Application
Building a Simple Java CRUD App
Storing & Fetching Data from Database
Testing & Debugging JDBC Code
