Month 1: Foundations of Java

Author: BLARD
Objective: Establish a solid grounding in Java syntax, control flow constructs, and method fundamentals to enable structured problem-solving using core language features.

---

Table of Contents

Java Modules

1. Java Module 001
2. Java Module 002
3. Java Module 003
4. Java Module 004
5. Java Module 005
6. Java Module 006
7. Java Module 007
8. Java Module 008
9. Java Module 009
10. Java Module 010
11. Java Module 011
12. Java Module 012

Projects

1. Project 001
2. Project 002
3. Project 003

Basic Capstone Projects

1. LibraryManagementSystem

---

Learning Outcomes

By the end of Month 1, learners should be able to:

• Configure a functional Java development environment.
• Write, compile, and execute Java programs from the command line or IDE.
• Apply variables, data types, operators, and expressions effectively.
• Implement conditional logic and iterative control structures.
• Design and invoke reusable methods with appropriate parameters and return types.

---

Week 1: Java Setup and Language Basics

Focus: Environment configuration, syntax fundamentals, and primitive data handling.

• Day 1: Understand Java architecture (JDK, JRE, JVM); install the JDK; create and run HelloWorld.java.
  Practice: Print your name and a welcome message.

• Day 2: Study comment styles (//, /* */); explore primitive data types (int, double, char, boolean).
  Practice: Declare and print variables of each primitive type.

• Day 3: Introduce non-primitive types (String); understand variables and constants (final).
  Practice: Concatenate multiple strings and utilize a constant value.

• Day 4: Learn arithmetic operators (+, -, *, /, %).
  Practice: Implement a program that calculates the area of a rectangle.

• Day 5: Examine comparison (==, !=, >, <) and logical operators (&&, ||, !).
  Practice: Determine whether a number is both positive and even.

• Weekend Review: Consolidate Week 1 concepts by developing a program that performs calculations and comparisons between two numbers.

---

Week 2: Control Flow – Conditional Statements

Focus: Decision-making constructs and logical branching.

• Day 1: Implement if, else if, and else statements.
  Practice: Classify a number as positive, negative, or zero.

• Day 2: Explore nested conditional logic.
  Practice: Categorize age groups (child, teen, adult).

• Day 3: Introduce the switch statement for structured branching.
  Practice: Map numbers (1–7) to corresponding day names.

• Day 4: Integrate if and switch for menu-driven workflows.
  Practice: Create a console menu to perform arithmetic operations.

• Day 5: Validate logical conditions and handle edge cases.
  Practice: Implement a grading system with input validation (A–F).

• Weekend Review: Build a simple quiz simulator that evaluates answers using conditional logic.

---

Week 3: Control Flow – Iterative Constructs

Focus: Looping mechanisms and iterative problem solving.

• Day 1: Learn the for loop and iteration patterns.
  Practice: Print numbers from 1 to 10 and compute their sum.

• Day 2: Understand the while loop and condition-driven repetition.
  Practice: Print all even numbers up to 20.

• Day 3: Study the do-while loop and its execution semantics.
  Practice: Prompt the user repeatedly until valid input is provided.

• Day 4: Use loop control statements (break, continue).
  Practice: Terminate a loop at a specific value and skip odd numbers.

• Day 5: Combine loops with conditionals for dynamic logic.
  Practice: Generate a multiplication table for a given number.

• Weekend Review: Develop a program to compute prime numbers up to 50 using loops and conditional checks.

---

Week 4: Methods and Monthly Project

Focus: Modular programming and method abstraction.

• Day 1: Define methods, return types, and invocation patterns.
  Practice: Implement a method to compute the square of a number.

• Day 2: Work with parameterized methods.
  Practice: Create a method that adds two numbers.

• Day 3: Introduce method overloading.
  Practice: Overload a method to support both int and double inputs.

• Day 4: Understand variable scope and lifecycle.
  Practice: Experiment with local versus class-level variables.

• Day 5: Emphasize clean method design and reusability.
  Practice: Implement a method that determines if a number is prime.

• Weekend Project:
  Build a console-based Simple Calculator that performs arithmetic operations using conditionals, loops, and modular methods. Include robust input validation and clear user prompts.

• Monthly Milestone:
  Deliver a functional calculator application demonstrating structured control flow, reusable methods, and defensive input handling.

---

Month 2: Object-Oriented Programming and Collections

Objective: Master core OOP principles and utilize Java’s collection framework for structured data management.

---

Week 5: Classes and Objects

Focus: Object modeling, constructors, and encapsulation.

• Day 1: Define classes, attributes, and object instantiation.
  Practice: Create a Book class with title and author fields.

• Day 2: Implement default and parameterized constructors.
  Practice: Extend the Book class with appropriate constructors.

• Day 3: Apply the this keyword for context reference.
  Practice: Use this within constructors and instance methods.

• Day 4: Enforce encapsulation using private fields and getters/setters.
  Practice: Encapsulate all attributes of the Book class.

• Day 5: Model object interactions.
  Practice: Instantiate multiple Book objects and display their details.

• Weekend Review: Develop a mini library manager to handle multiple book records.

---

Week 6: Inheritance and Polymorphism

Focus: Hierarchical design and dynamic behavior.

• Day 1: Implement inheritance using extends.
  Practice: Create a Vehicle superclass and a Car subclass.

• Day 2: Apply method overriding to demonstrate polymorphism.
  Practice: Override a describe() method in the Car class.

• Day 3: Understand access modifiers (public, private, protected, default`).
  Practice: Refactor class members using appropriate visibility levels.

• Day 4: Organize code with packages.
  Practice: Structure classes into logical packages.

• Day 5: Expand class hierarchies.
  Practice: Add a Truck subclass extending Vehicle.

• Weekend Review: Simulate a vehicle showroom system using inheritance and polymorphism.

---

Week 7: Arrays and Collections

Focus: Structured data storage and collection manipulation.

• Day 1: Work with one-dimensional arrays.
  Practice: Store and print five numbers.

• Day 2: Introduce multi-dimensional arrays.
  Practice: Create and display a 2×3 matrix.

• Day 3: Use ArrayList for dynamic collections.
  Practice: Manage a list of student names.

• Day 4: Iterate using enhanced for-each loops.
  Practice: Traverse and print elements of an ArrayList.

• Day 5: Ensure uniqueness with HashSet.
  Practice: Store unique city names.

• Weekend Review: Build a student-grade manager using arrays and ArrayList.

---

Week 8: Advanced Collections and Monthly Project

Focus: Key-value data structures and collection interoperability.

• Day 1: Implement HashMap for key-value storage.
  Practice: Map student IDs to names.

• Day 2: Combine multiple collection types.
  Practice: Associate students with grades using HashMap and ArrayList.

• Day 3: Iterate through maps and complex structures.
  Practice: Print all key-value pairs in a HashMap.

• Day 4: Utilize collection utility methods (size(), contains()).
  Practice: Validate element existence within collections.

• Day 5: Apply collections to real-world scenarios.
  Practice: Simulate an inventory management system.

• Weekend Project:
  Develop a console-based Student Management System using OOP and collections to manage student records (name, ID, grades).

• Monthly Milestone:
  Deliver a modular system employing encapsulation, inheritance, and Java Collections Framework.

---

Month 3: Exception Handling, File I/O, and Advanced Topics

Objective: Implement robust error handling, persistent storage, and functional-style operations using Streams and Lambdas.

---

Week 9: Exception Handling

Focus: Runtime stability and defensive programming.

• Day 1: Implement try, catch, and finally.
  Practice: Safely handle division-by-zero errors.

• Day 2: Use throw and throws for controlled error propagation.
  Practice: Validate numeric input and throw exceptions for invalid values.

• Day 3: Create custom exception classes.
  Practice: Define and use an InvalidAgeException.

• Day 4: Combine loops with exception handling.
  Practice: Continuously prompt until valid input is received.

• Day 5: Differentiate checked vs unchecked exceptions.
  Practice: Handle multiple exception types in one program.

• Weekend Review: Implement a user input validator leveraging custom exceptions.

---

Week 10: File Handling

Focus: Persistent data storage and retrieval.

• Day 1: Write data using FileWriter.
  Practice: Persist a list of names to a text file.

• Day 2: Read data using FileReader and BufferedReader.
  Practice: Load and display file contents.

• Day 3: Perform combined read/write operations.
  Practice: Append new records to an existing file.

• Day 4: Handle file-related exceptions robustly.
  Practice: Wrap all I/O operations with appropriate exception handling.

• Day 5: Apply file handling to practical use cases.
  Practice: Log user inputs to a persistent file.

• Weekend Review: Build a simple contact list manager with file persistence.

---

Week 11: Streams, Lambda Expressions, and Build Tools

Focus: Functional programming constructs and project tooling.

• Day 1: Use Streams API (filter, map).
  Practice: Extract even numbers from a list using streams.

• Day 2: Implement lambda expressions for concise behavior definitions.
  Practice: Sort a list using lambda-based comparators.

• Day 3: Combine Streams with lambdas for transformations.
  Practice: Filter and square numbers greater than five.

• Day 4: Introduce Maven/Gradle fundamentals and project structure.
  Practice: Initialize and build a simple Maven project.

• Day 5: Refactor previous work into a build-managed project.
  Practice: Convert an earlier project to Maven structure.

• Weekend Review: Enhance a previous application using Streams and lambdas.

---

Week 12: Capstone Project and Comprehensive Review

Focus: End-to-end application design integrating all learned concepts.

• Day 1: Design a console-based Banking Application (accounts, transactions).

• Day 2: Implement account lifecycle operations (create, deposit, withdraw).

• Day 3: Persist transaction history using file I/O.

• Day 4: Integrate exception handling and Streams for validation and filtering.

• Day 5: Refine UX prompts and perform comprehensive testing.

• Weekend Capstone:
  Finalize the Banking Application, ensuring integration of OOP, collections, file handling, exception management, and Streams.

• Final Milestone:
  Deliver a robust, modular console application demonstrating full-spectrum Java proficiency across three months.

---

Professional Study Recommendations

• Daily Coding Discipline: Reinforce concepts through consistent implementation.
• Debugging Practices: Use structured logging and step-through debugging tools.
• Authoritative References: Consult official Java documentation and standard language specifications.
• Project-Centric Learning: Prioritize practical implementations over passive reading.
• Periodic Reviews: Revisit weak areas weekly and solve incremental coding challenges to validate mastery.