Module 2: Data Types and Variables

Welcome back to Java! In Module 1, you wrote your first program. Now, we’ll dive
into data types and variables, the building blocks of any Java program. You’ll learn
how to store and manage data, like numbers, text, or true/false values, and
understand where they live in your code. Let’s make sense of how Java handles
data!

1. What are Data Types and Variables?

A variable is like a labeled box that stores data (e.g., a number or name) in a
program. A data type defines what kind of data the box can hold (e.g., integer, text)
and how much space it needs.

Key Concepts

●​ Variable Declaration: Tell Java the type and name (e.g., int age;).
●​ Initialization: Assign a value (e.g., age = 20;).
●​ Data Types:
○​ Primitive Types: Basic building blocks (e.g., int, double, boolean).
○​ Reference Types: Complex types that refer to objects (e.g., String,
arrays).
●​ Naming Rules:
○​ Start with a letter, _, or $ (e.g., myAge, _count).
○​ No spaces or special characters (except _, $).
○​ Case-sensitive (Age ≠ age).
○​ Use meaningful names (e.g., studentName over x).
Analogy

A variable is like a labeled jar in your kitchen. The data type is the jar’s purpose (e.g.,
for sugar or spices), and the value is what you put inside (e.g., 2 cups of sugar).

2. Primitive Data Types

Java has 8 primitive data types for basic data like numbers, characters, and
true/false values. Each has a specific size and use.

Primitive Types
Example: Using Primitives

●​ Explanation:
○​ Declares and initializes variables of different primitive types.
○​ Prints their values using string concatenation (+).
Common Confusion

●​ Why use int vs. long? Use int for most integers; use long for very large
numbers (e.g., populations).
●​ Why f for float? Java assumes decimals are double; f specifies float (e.g.,
10.5f).

Analogy

Primitive types are like basic ingredients (flour, sugar). Each has a specific role and
size, unlike complex recipes (reference types).

3. Reference Data Types

Reference types store references (memory addresses) to objects, like String, arrays,
or custom classes. Unlike primitives, they can be null (no object).

Key Reference Types

●​ String: Represents text (e.g., String name = "Alice";).

●​ Arrays: Collections of data (covered in Module 6).
●​ Classes/Objects: User-defined types (covered in Module 7).
●​ null: Special value meaning “no object” (e.g., String text = null;).
Example: Using Strings

●​ Explanation:
○​ String name: Stores text.
○​ greeting: Initially null, then assigned a value.

○​

Common Confusion

●​ String vs. char: Use char for a single character (e.g., 'A'); use String for text
(e.g., "Hello").
●​ null vs. empty: null means no object; an empty String is "" (zero-length text).
Analogy

Reference types are like recipe cards. They point to instructions (objects) in memory,
not the raw ingredients (primitives).

4. Variable Scope and Lifetime

Scope defines where a variable can be used in a program. Lifetime is how long it
exists in memory.

Types of Variables

●​ Local Variables:
○​ Declared inside a method or block (e.g., {}).
○​ Scope: Within the block.
○​ Lifetime: Exists until the block ends.
○​ Must be initialized before use.
●​ Instance Variables:
○​ Declared inside a class, outside methods.
○​ Scope: Entire class (accessed via objects, covered in Module 7).
○​ Lifetime: As long as the object exists.
○​ Default values (e.g., 0 for int, null for String).
●​ Static Variables:
○​ Declared with static in a class.
○​ Scope: Shared across all objects of the class.
○​ Lifetime: Entire program duration.
Example: Variable Scope

●​ Explanation:
○​ localVar: Only accessible in main.
○​ classCount: Shared across all ScopeDemo instances.
○​ instanceValue: Tied to an object (obj).

○​
Common Confusion

●​ Uninitialized Local Variables: Java won’t let you use a local variable without a
value (e.g., int x; [Link](x); causes an error).
●​ Static vs. Instance: Use static for shared data (e.g., a counter for all objects);
use instance for per-object data (e.g., each student’s name).

Analogy

Variable scope is like access to a room. Local variables are only usable in one room
(method), instance variables are for one person’s house (object), and static variables
are shared by the whole neighborhood (class).
Module 3: Operators and Expressions
Welcome to Module 3! In Module 2, you learned how to store data using variables.
Now, we’ll explore operators and expressions, which let you manipulate that
data—think math, comparisons, and logic. You’ll learn how to perform calculations,
compare values, and combine conditions to make your programs smarter. Let’s get
started!

1. What are Operators and Expressions?

An operator is a symbol that performs an operation on one or more values (e.g., +
adds numbers). An expression is a combination of variables, constants, and
operators that produces a result (e.g., 5 + 3 is an expression yielding 8).

Key Concepts

Operands: Values or variables the operator acts on (e.g., in a + b, a and b are

operands).

Types of Operators:

○​ Arithmetic: Math operations (e.g., +, -).

○​ Relational: Comparisons (e.g., ==, >).
○​ Logical: Combine conditions (e.g., &&, ||).
○​ Bitwise: Manipulate bits (e.g., &, |).
○​ Assignment: Assign values (e.g., =).
○​ Miscellaneous: Special operators (e.g., ++, instanceof).

Precedence: Determines order of operations (e.g., * before +).

Evaluation: Expressions are computed to a single value (e.g., 2 + 3 * 4

evaluates to 14).

Analogy

Operators are like kitchen tools (e.g., a knife for cutting, a mixer for blending).
Expressions are recipes that combine ingredients (operands) using these tools to
create a dish (result).
2. Arithmetic Operators
Arithmetic operators perform mathematical operations on numbers (primitives like
int, double).

Example: Arithmetic Operations

 ●​ Explanation:
○​ Performs basic math on int variables.
○​ Division (/) with integers truncates decimals (e.g., 10 / 3 = 3).
○​ Decremented b: 2

●​

Common Confusion

●​ Integer Division: 10 / 3 gives 3 (not 3.333). Use double for decimals (e.g., 10.0 /
3).
●​ Pre vs. Post Increment: x++ (post) returns x then increments; ++x (pre)
increments then returns.

Analogy

Arithmetic operators are like a calculator. You punch in numbers (operands) and
operations (+, *) to get results.

3. Relational Operators
Relational operators compare two values and return a boolean (true or false).

Relational Operators
Example: Relational Operations

●​ Explanation:
○​ Compares x and y, producing boolean results.
 ○​

Common Confusion

●​ = vs. ==: = assigns a value; == checks equality (e.g., x = 5 sets x; x == 5 checks

if x is 5).
●​ String Comparison: Don’t use == for String objects; it checks references, not
content. Use .equals() (covered in Module 6).

Analogy

Relational operators are like scales. They weigh two values (operands) to tell you
which is bigger or if they’re equal.

4. Logical Operators
Logical operators combine boolean expressions to make decisions.

Logical Operators
Example: Logical Operations

●​ Explanation:
○​ Combines boolean values with &&, ||, and !.

Common Confusion

●​ Short-Circuiting: In &&, if the left operand is false, the right isn’t evaluated. In
||, if the left is true, the right is skipped.
●​ & vs. &&: & is bitwise (below); && is logical and short-circuits.

Analogy

Logical operators are like traffic lights. They decide if you can go (true) based on
multiple conditions (e.g., “green AND clear road”).
5. Bitwise Operators

Bitwise operators manipulate individual bits of integers, used in low-level

programming (e.g., hardware control).

Bitwise Operators
Example: Bitwise Operations

●​ Explanation:
○​ Operates on binary representations of a and b.

○​

Common Confusion

●​ When to Use: Bitwise operators are rare in high-level apps but useful for flags,
masks, or optimization.
●​ Signed vs. Unsigned: Java uses signed integers, so >> preserves the sign bit;
use >>> for unsigned right shift (rare for beginners).
Analogy

Bitwise operators are like switches in a circuit. You flip or combine bits (0s and 1s) to
control the output.

6. Assignment and Miscellaneous Operators

Assignment operators assign values, often combining with other operations.
Miscellaneous operators include special cases like instanceof.

Assignment Operators

Miscellaneous Operators

●​ instanceof: Checks if an object is of a type (e.g., obj instanceof String → true

if obj is a String). Covered more in Module 7.
●​ Ternary Operator (?:): Short if-else (e.g., x > 0 ? "Positive" : "Non-positive").
Example: Assignment and Ternary

●​ Explanation:
○​ += combines addition and assignment.
○​ Ternary operator picks a String based on x.

○​

Analogy

Assignment operators are like updating a scoreboard. You add points (+=) or reset it
(=). The ternary operator is a quick referee call.
Module 4: Control Statements
Welcome to Module 4! In Module 3, you learned how to manipulate data with
operators. Now, we’ll explore control statements, which let your program make
decisions and repeat tasks. You’ll master if-else, loops (for, while, do-while), and
switch to control the flow of your code. Let’s make your programs smarter and more
dynamic!

1. What are Control Statements?

Control statements direct the flow of a program, allowing it to make choices (e.g.,
“Is the student passing?”) or repeat actions (e.g., “Print numbers 1 to 10”). They use
conditions (often with operators from Module 3) to decide what to do next.

Types of Control Statements

●​ Decision-Making: if, if-else, switch (choose based on conditions).

●​ Looping: for, while, do-while (repeat code).
●​ Branching: break, continue (alter flow within loops or switch).

Analogy

Control statements are like traffic signs. They guide your program’s journey,
deciding whether to stop (if), take a detour (else), or loop back (for).

2. Decision-Making: if, if-else, Nested if

The if statement executes code if a condition is true. if-else provides alternatives,
and nested if statements handle multiple conditions.
Syntax

Example: if-else

●​ Explanation:
○​ Checks score against conditions using relational operators (>=).
 ○​ Only one block executes based on the first true condition.
○​ Output: Grade: B

Nested if Example

●​ Explanation:
○​ Checks age first, then hasID within the if.
○​ Output: Eligible to vote!

Common Confusion

●​ Braces {}: Optional for single statements but recommended to avoid errors
(e.g., forgetting to group multiple lines).
●​ Dangling else: In nested if, else pairs with the nearest if. Use braces to clarify.

Analogy

An if-else statement is like a menu. If you’re hungry for pizza (condition), order it;
else, pick pasta or salad.
3. Switch Statement
The switch statement selects one of many code blocks based on a variable’s value,
ideal for multiple fixed options.

Syntax

●​ break: Exits the switch to prevent fall-through.

●​ default: Optional catch-all for unmatched cases.
Example: Switch

●​ Explanation:
○​ Matches day to a case and prints the day.
○​ break prevents executing other cases.
○​ Output: Wednesday

Common Confusion

●​ Forgetting break: Causes fall-through, executing all cases after a match until
a break or end.
●​ Supported Types: switch works with int, char, String (Java 7+), enum, and a
few others, but not double or boolean.

Analogy

A switch is like a vending machine. You pick a number (value), and it drops the right
snack (code block).
4. Looping: for Loop
The for loop repeats code a specific number of times, ideal for counted iterations.

Syntax

●​ initialization: Runs once (e.g., int i = 0).

●​ condition: Checked before each iteration.
●​ update: Runs after each iteration (e.g., i++).

Example: for Loop

●​ Explanation:
○​ Loops 5 times, printing numbers 1 to 5.
Common Confusion

●​ Off-by-One Errors: Miscounting loops (e.g., i <= 5 vs. i < 5) can include/exclude
an iteration.
●​ Infinite Loops: If the condition never becomes false (e.g., for(;;)), the loop runs
forever.

Analogy

A for loop is like counting reps in a workout. You set a goal (iterations), check if
you’re done (condition), and increment after each rep (update).

5. Looping: while and do-while Loops

The while loop repeats code while a condition is true. The do-while loop runs at least
once, checking the condition afterward.
Syntax

Example: while and do-while

 ●​ Explanation:
○​ while: Checks condition first, loops 3 times.
○​ do-while: Runs once, then checks, also loops 3 times.

Common Confusion

●​ while vs. do-while: while may skip the loop if the condition is false initially;
do-while always runs at least once.
●​ Infinite Loops: Forgetting to update the condition (e.g., not incrementing
count) causes endless loops.

Analogy

A while loop is like waiting for a bus. You check if it’s here (condition) before
boarding. A do-while is like trying the door first, then checking if it’s locked.

6. Branching: break and continue

break exits a loop or switch early. continue skips the current iteration and moves to
the next.
Example: break and continue

●​
Explanation:
○​ break: Stops the loop at i == 3.
○​ continue: Skips printing when i == 3, continues the loop.
 ○​

Common Confusion

●​ break in Nested Loops: Only exits the innermost loop; use labeled breaks (e.g.,
break label;) for outer loops (advanced, not covered here).
●​ continue vs. break: continue skips one iteration; break stops the entire loop.

Analogy

break is like leaving a party early. continue is like skipping a song on a playlist but
staying at the party.
Module 5: Methods in Java
Welcome to Module 5! In Module 4, you learned to control program flow with if-else
and loops. Now, we’ll explore methods, which let you organize code into reusable,
task-specific blocks. You’ll learn how to define methods, pass data to them, return
results, and make your programs more modular. Let’s make your code cleaner and
smarter!

1. What are Methods?

A method is a block of code that performs a specific task and can be called when
needed. Think of it as a mini-program within your program, like a recipe for a single
dish.

Key Concepts

●​ Declaration: Define a method with its name, parameters, return type, and
body.
●​ Calling: Execute a method by using its name and passing arguments.
●​ Parameters: Inputs a method uses (e.g., numbers to add).
●​ Return Type: The type of value a method sends back (e.g., int, void for none).
●​ Modularity: Methods make code reusable and easier to read.

Why Use Methods?

●​ Reusability: Write once, use multiple times (e.g., a method to calculate

grades).
●​ Organization: Break complex programs into smaller, manageable pieces.
●​ Maintainability: Easier to debug or update specific tasks.

Analogy

A method is like a kitchen appliance (e.g., a blender). You give it ingredients

(parameters), it processes them (body), and produces a result (return value).
2. Defining and Calling Methods
A method is defined with a signature (name, parameters, return type) and a body
(code to execute). You call it by name, passing arguments if needed.

Syntax

Example: Simple Method

●​ Explanation:
○​ printGreeting: A void method (no return) that prints a message.
○​ Called from main using printGreeting().
○​ Output: Welcome to Groot Academy!

Common Confusion
 ●​ Static Methods: Use static for methods called without an object (like main).
Non-static methods need an object (covered in Module 7).
●​ Method Name: Case-sensitive and should be descriptive (e.g., calculateSum
over cs).

Analogy

Defining a method is like writing a recipe. Calling it is like cooking the dish using
that recipe.

3. Methods with Parameters

Parameters let you pass data to a method for processing. They act like variables
local to the method.

Example: Method with Parameters

 ●​ Explanation:
○​ addNumbers: Takes two int parameters (a, b).
○​ Called with different arguments, computes and prints the sum.

Common Confusion

●​ Parameters vs. Arguments: Parameters are defined in the method (e.g., int a);
arguments are values passed when calling (e.g., 5).
●​ Scope: Parameters are local to the method and can’t be accessed outside.

Analogy

Parameters are like ingredients you hand to a chef (method). The chef uses them to
make a dish (result).

4. Methods with Return Types

A method can return a value to the caller using a return statement. The return type
specifies what kind of value (e.g., int, String).
Example: Return Method

●​ Explanation:
○​ multiply: Returns an int (product of x and y).
○​ return sends the value back to main, stored in result.
○​ Output: Result: 20

Common Confusion

●​ void vs. Return: void methods don’t return anything; others need a return
statement matching the declared type.
●​ Missing Return: For non-void methods, every code path must return a value,
or you’ll get a compilation error.

Analogy

A return method is like a vending machine. You input money (parameters), and it
gives you a snack (return value).

5. Method Overloading
Method overloading lets you define multiple methods with the same name but
different parameter lists (number, type, or order).
Rules

●​ Same method name.

●​ Different parameters (e.g., int vs. double, or different count).
●​ Return type can differ but isn’t enough alone to overload.

Example: Method Overloading

●​ Explanation:
○​ calculateArea: Overloaded for square (1 parameter) and rectangle (2
parameters).
○​ Java picks the right method based on arguments.
Common Confusion

●​ Overloading vs. Overriding: Overloading is same name, different parameters

in the same class; overriding is redefining a method in a subclass (Module 8).
●​ Ambiguity: Overloading with similar types (e.g., int vs. long) can cause
confusion—be clear with parameter types.

Analogy

Method overloading is like a multi-tool. One name (tool) but different functions
based on the attachment (parameters).
Module 6: Arrays and Strings
Welcome to Module 6! In Module 5, you learned to organize code with methods.
Now, we’ll explore arrays and strings, which let you store and manipulate collections
of data (like lists of numbers or text). You’ll master 1D and 2D arrays, String
operations, and how to combine them with loops and methods. Let’s dive into
managing data like a pro!

1. What are Arrays?

An array is a fixed-size collection of elements of the same data type (e.g., a list of
ints or Strings). It’s like a row of lockers, each holding one value.

Key Concepts

●​ Declaration: Specify type and size (e.g., int[] numbers = new int[5];).
●​ Indexing: Access elements with zero-based indices (e.g., numbers[0]).
●​ Fixed Size: Arrays can’t grow or shrink after creation.
●​ Types: Can store primitives (e.g., int, double) or references (e.g., String,
objects).

Analogy

An array is like a train with fixed cars. Each car (index) holds one passenger (value),
and you can’t add or remove cars after the train is built.

2. One-Dimensional Arrays
1D arrays store a single list of elements, accessed by one index.
Syntax

Example: 1D Array
 ●​ Explanation:
○​ scores: Array of 3 ints, filled manually.
○​ marks: Initialized directly with values.
○​ [Link]: Returns array size (3).

Common Confusion

●​ Array Bounds: Accessing scores[3] in a 3-element array causes an

ArrayIndexOutOfBoundsException. Indices are 0 to length - 1.
●​ Default Values: Uninitialized array elements get defaults (e.g., 0 for int, null
for String).

Analogy

A 1D array is like a bookshelf. Each slot (index) holds one book (value), and you can’t
add more slots.

3. Two-Dimensional Arrays
2D arrays store data in a grid (rows and columns), like a table or matrix, accessed by
two indices.
Syntax

Example: 2D Array
 ●​ Explanation:
○​ matrix: 2 rows, 3 columns.
○​ Nested for loops print each element.

○​

Common Confusion

Jagged Arrays: Rows can have different lengths (e.g., int[][] jagged = {{1, 2},
{3, 4, 5}};). Use matrix[i].length for column size.

Accessing: matrix[2][3] on a 2x3 array throws an exception—check bounds!

Analogy

A 2D array is like a chessboard. Each square (row, column) holds a piece (value), and
you navigate it with two coordinates.

4. Strings in Java
A String is a reference type for text, part of the [Link] package. It’s immutable
(can’t change after creation) and supports many methods.

Key Features

●​ Creation: String str = "Hello"; or String str = new String("Hello");.

●​ Immutability: Operations like concatenation create new Strings.
●​ Common Methods:
○​ length(): Returns length (e.g., "Hello".length() → 5).
○​ toUpperCase(), toLowerCase(): Change case.
 ○​ charAt(int index): Get character at index.
○​ substring(int begin, int end): Extract part of the string.
○​ equals(String other): Compare content (not ==).

Example: String Operations

●​ Explanation:
○​ Uses String methods to manipulate and inspect text.
○​ equals checks content, not reference.

○​
Common Confusion

●​ Immutability: [Link]() doesn’t change text; it returns a new String.

Assign it (e.g., text = [Link]();).
●​ == vs. equals: == checks if two String objects are the same instance; equals
checks content.

Analogy

A String is like a printed book. You can read it or quote parts, but you can’t edit the
pages (immutable); you make a new book for changes.

5. Combining Arrays and Strings

Arrays and strings often work together with loops and methods to process data (e.g.,
storing names in an array, splitting text).

Example: Array of Strings

●​ Explanation:
○​ students: Array of Strings.
○​ Enhanced for loop (foreach) iterates over elements.
 ○​

Analogy

Combining arrays and strings is like a class roster. The roster (array) lists names
(strings), and you process each name with operations (methods).
Module 7: Object-Oriented
Programming I: Classes and Objects
Welcome to Module 7! In Module 6, you mastered arrays and strings for data
storage. Now, we’ll dive into object-oriented programming (OOP), a core feature of
Java, starting with classes and objects. You’ll learn to create custom data types and
use them to model real-world entities, like students or books. Let’s bring your
programs to life with OOP!

1. What is Object-Oriented Programming?

OOP is a programming paradigm that organizes code around objects, which
combine data (attributes) and behavior (methods). Java is built for OOP, making it
ideal for modeling real-world systems.

Key OOP Concepts

●​ Class: A blueprint for objects (e.g., a “Student” template).

●​ Object: An instance of a class (e.g., a specific student, “Alice”).
●​ Attributes: Data stored in objects (e.g., name, age).
●​ Methods: Actions objects can perform (e.g., calculate grade).
●​ Encapsulation: Bundling data and methods (covered more in Module 8).

Why Use OOP?

●​ Modularity: Organize code into logical units (classes).

●​ Reusability: Create multiple objects from one class.
●​ Real-World Modeling: Mimic entities like students, cars, or bank accounts.

Analogy

A class is like a cookie cutter, defining the shape (attributes and methods). An object
is a cookie, a specific instance made from the cutter.
2. Defining a Class
A class is defined with fields (instance variables) for data and methods for behavior.
It’s declared using the class keyword.

Syntax

Example: Class Definition

●​ Explanation:
○​ Student: Class with three fields (name, age, grade) and one method
(displayInfo).
○​ No main here; this is a blueprint, not a running program.
Common Confusion

●​ Instance vs. Static: Instance variables/methods belong to objects; static ones

belong to the class (e.g., main is static).
●​ Access: Fields and methods are accessible based on visibility (e.g., public,
private, covered in Module 8).

Analogy

Defining a class is like designing a car blueprint. It specifies parts (fields) and
features (methods), but no car exists yet.

3. Creating and Using Objects

An object is created from a class using the new keyword. You access its fields and
methods using the dot operator (.).

Syntax
Example: Creating Objects

●​ Explanation:
○​ Creates two Student objects (s1, s2).
○​ Sets fields and calls displayInfo for each.
 ○​

Common Confusion

●​ Null References: If an object is null (e.g., Student s = null;), calling

[Link]() throws a NullPointerException.
●​ Default Values: Uninitialized fields get defaults (e.g., 0 for int, null for String).

Analogy

Creating an object is like building a car from a blueprint. You use the design (class)
to make a real car (object) with specific features.

4. Constructors
A constructor is a special method that initializes a new object. It has the same name
as the class and no return type.

Syntax
Example: Constructor

●​ Explanation:
○​ Student constructor initializes fields when the object is created.
○​ Output: Name: Charlie, Age: 20, Grade: 88.0

Default Constructor

●​ If no constructor is defined, Java provides a default constructor (no

parameters, sets fields to defaults).
●​ Defining any constructor removes the default; add it manually if needed (e.g.,
Student() {}).

Common Confusion

●​ Constructor vs. Method: Constructors have no return type and match the class
name; methods don’t.
 ●​ Overloading: Constructors can be overloaded (multiple versions with different
parameters).

Analogy

A constructor is like setting up a new phone. You configure it (initialize fields) right
after unboxing (object creation).

5. Combining Classes with Previous Concepts

Classes work with variables, methods, arrays, and control statements to create
robust programs. Objects can be stored in arrays, and methods can use control
statements.

Example: Array of Objects

 ●​ Explanation:
○​ Stores Student objects in an array.
○​ Uses enhanced for loop to call displayInfo.

○​

Analogy

An array of objects is like a classroom. Each student (object) has their own details
(fields) and actions (methods), organized in a roster (array).
Module 8: Object-Oriented
Programming II: Inheritance and
Polymorphism
Welcome to Module 8! In Module 7, you learned to create classes and objects. Now,
we’ll dive deeper into object-oriented programming (OOP) with inheritance and
polymorphism, two powerful concepts that let you reuse and extend code. You’ll
learn to build class hierarchies and write flexible programs that adapt to different
object types. Let’s level up your OOP skills!

1. What is Inheritance?
Inheritance allows a class (subclass) to inherit fields and methods from another
class (superclass), promoting code reuse and modeling relationships like “is-a” (e.g.,
a Student is a Person).

Key Concepts

●​ Superclass: The parent class (e.g., Person).

●​ Subclass: The child class that extends the parent (e.g., Student).
●​ extends Keyword: Links subclass to superclass (e.g., class Student extends
Person).
●​ Access: Subclasses inherit non-private members (fields/methods).
●​ Hierarchy: Classes form a tree-like structure (single inheritance in Java).

Why Use Inheritance?

●​ Reuse: Avoid duplicating code by sharing common features.

●​ Extensibility: Add or modify behavior in subclasses.
●​ Organization: Model real-world relationships (e.g., Dog is an Animal).
Analogy

Inheritance is like a family tree. A child (subclass) inherits traits (fields/methods)

from a parent (superclass) but can add unique characteristics.

2. Defining Inheritance
Use the extends keyword to make a subclass inherit from a superclass. Subclasses
can use or override inherited members.

Syntax
Example: Inheritance
 ●​ Explanation:
○​ Student inherits name, age, and displayInfo from Person.
○​ Adds grade and displayStudentInfo.

○​

Common Confusion

●​ Private Members: Subclasses can’t directly access private fields/methods; use

getters/setters (Module 9).
●​ Single Inheritance: Java allows a class to extend only one superclass (unlike
C++’s multiple inheritance).

Analogy

A subclass is like a specialized chef. They inherit basic cooking skills (superclass
methods) but add their own recipes (subclass methods).

3. Constructors in Inheritance
Subclasses call the superclass constructor using super() to initialize inherited fields.
If not explicitly called, Java inserts a call to the superclass’s no-arg constructor.
Example: Constructors

●​ Explanation:
○​ Student constructor calls Person’s constructor with super.
○​ Initializes grade in Student.
○​ Output: Name: Bob, Age: 19, Grade: 90.0
Common Confusion

●​ super(): Must be the first statement in the subclass constructor if used.

●​ No Default Constructor: If the superclass has no no-arg constructor, you must
explicitly call super with parameters.

Analogy

Using super is like a child calling their parent for help setting up their room (fields)
before adding their own decorations (subclass fields).

4. Method Overriding
Method overriding lets a subclass redefine a superclass method with the same
name, parameters, and return type to provide specific behavior.

Rules

●​ Same method signature (name, parameters, return type).

●​ Use @Override annotation for clarity and error checking.
●​ Can’t reduce visibility (e.g., public to private).
Example: Method Overriding
 ●​ Explanation:
○​ Student overrides display to include grade.
○​ @Override ensures correctness.
○​

○​

Common Confusion

●​ Overriding vs. Overloading: Overriding redefines a method in a subclass;

overloading uses different parameters in the same class (Module 5).
●​ final Methods: Declaring a method final prevents overriding.

Analogy

Overriding is like a child reinterpreting a family recipe. The dish (method) keeps the
same name but gets a unique twist (new implementation).

5. Polymorphism
Polymorphism (“many forms”) allows objects of different classes to be treated as
objects of a common superclass, enabling flexible behavior via method overriding.

Types

●​ Compile-Time (Static): Method overloading (Module 5).

●​ Run-Time (Dynamic): Method overriding, where the actual object type
determines the method called.
Example: Run-Time Polymorphism

●​ Explanation:
○​ Animal reference holds Dog or Cat objects (upcasting).
○​ Method called depends on the actual object type at runtime.

○​
Common Confusion

●​ Upcasting: Storing a subclass object in a superclass reference (safe).

●​ Downcasting: Converting a superclass reference back to a subclass (risky,
needs instanceof check, covered in Module 9).
●​ Dynamic Binding: Java decides which overridden method to call at runtime.

Analogy

Polymorphism is like a remote control. You press “play” (call a method) on different
devices (objects), and each responds in its own way (overridden method).

6. The super Keyword and final

●​ super: Accesses superclass fields, methods, or constructors.
●​ final: Prevents modification:
○​ final class: Can’t be extended.
○​ final method: Can’t be overridden.
○​ final variable: Constant (value can’t change).

Example: super and final

 ●​ Explanation:
○​ This code won’t compile because Vehicle is final.
○​ If final is removed, [Link]() calls the superclass method.
○​ brand is a constant, unchangeable.

Analogy

Super is like calling your parents for advice, and final is like locking a door to
prevent changes.
Module 9: Object-Oriented
Programming III: Interfaces and
Abstract Classes
Welcome to Module 9! In Module 8, you mastered inheritance and polymorphism to
reuse and extend code. Now, we’ll explore interfaces and abstract classes, which
provide abstraction and flexibility in object-oriented programming (OOP). You’ll
learn to define contracts, enforce behavior, and create partially implemented
classes. Let’s take your OOP skills to the next level!

1. What are Interfaces and Abstract Classes?

Interfaces and abstract classes are tools for abstraction, letting you define what a
class should do without specifying how. They promote flexibility and modularity in
code design.

Key Concepts

●​ Interface: A contract specifying methods that implementing classes must

define (e.g., “all vehicles must have a move method”).
●​ Abstract Class: A class that can’t be instantiated, often with some
implemented methods and some abstract (unimplemented) ones.
●​ Abstraction: Hiding implementation details, focusing on functionality.
●​ Multiple Inheritance: Interfaces allow a class to implement multiple contracts,
unlike single-class inheritance.

Why Use Them?

●​ Standardization: Ensure classes follow a common structure.

●​ Flexibility: Enable polymorphism across unrelated classes.
●​ Modularity: Separate interface (what) from implementation (how).
Analogy

An interface is like a job description—it lists required tasks (methods) but not how to
do them. An abstract class is like a half-built house—some rooms (methods) are
finished, others (abstract methods) need completion.

2. Interfaces
An interface defines methods (and constants) that implementing classes must
provide. It’s declared with the interface keyword and implemented using
implements.

Syntax
Example: Interface

●​ Explanation:
○​ Printable interface requires printDetails.
○​ Student implements it, defining printDetails.
○​ Output: Student: Alice, Grade: 85.5
Key Features

●​ Multiple Interfaces: A class can implement multiple interfaces (e.g., class X

implements A, B).
●​ Default Methods: Since Java 8, interfaces can have default methods with
implementation.
●​ Constants: Interface fields are implicitly public static final.

Common Confusion

●​ Abstract Methods: Interface methods are implicitly public abstract (no body
unless default).
●​ No Constructors: Interfaces can’t be instantiated or have constructors.

Analogy

An interface is like a plug standard. Devices (classes) must fit the plug (implement
methods) to work with the system (program).

3. Abstract Classes
An abstract class is a class that can’t be instantiated and may include both
implemented and abstract methods. It’s declared with the abstract keyword.
Syntax
Example: Abstract Class
 ●​ Explanation:
○​ Shape is abstract with one implemented method (displayColor) and
one abstract method (calculateArea).
○​ Circle extends Shape, implementing calculateArea.

○​

Common Confusion

●​ Instantiation: You can’t create a Shape object (e.g., new Shape() is an error).
●​ Abstract Methods: Subclasses must implement all abstract methods or be
abstract themselves.

Analogy

An abstract class is like a car chassis. It provides some parts (implemented

methods) but needs wheels and an engine (abstract methods) to be complete.

4. Interfaces vs. Abstract Classes

Example: Combining Both
 ●​ Explanation:
○​ Rectangle extends Shape and implements Drawable.
○​ Provides calculateArea and draw.

○​

Analogy

Using both is like a job with a uniform. The job description (interface) lists tasks, and
the uniform template (abstract class) provides some gear, but you customize it
(subclass).

5. Polymorphism with Interfaces and Abstract

Classes
Both enable polymorphism, allowing objects of different classes to be treated as the
interface or abstract class type.
Example: Polymorphism
 ●​ Explanation:
○​ Guitar implements Playable and extends Instrument.
○​ Polymorphism lets Playable and Instrument references call Guitar’s
methods.

○​

Common Confusion

●​ Interface References: Can only call interface methods unless cast to the
concrete class.
●​ Downcasting: Casting an interface/abstract class reference to a subclass
(e.g., ((Guitar)p).tune()) requires instanceof to avoid errors.

Analogy

Polymorphism with interfaces is like a universal remote. It controls any device

(class) that follows the remote’s standard (interface).
Module 10: Exception Handling and
File I/O
Welcome to Module 10! In Module 9, you learned to use interfaces and abstract
classes for flexible OOP design. Now, we’ll explore exception handling and file
input/output (I/O), which help you manage errors and work with external files. You’ll
learn to handle runtime issues gracefully and read/write data to files, making your
programs more robust and practical. Let’s dive in!

1. What is Exception Handling?

An exception is an error or unexpected event that occurs during program execution
(e.g., dividing by zero). Exception handling lets you catch and manage these errors
to prevent crashes.

Key Concepts

●​ Exception: An object representing an error (e.g., ArithmeticException).

●​ try-catch: Block to attempt risky code and handle exceptions.
●​ throw: Explicitly trigger an exception.
●​ throws: Declare that a method might throw exceptions.
●​ Checked vs. Unchecked: Checked exceptions (e.g., IOException) must be
handled or declared; unchecked (e.g., NullPointerException) don’t require it.

Why Use Exception Handling?

●​ Robustness: Prevent crashes by handling errors.

●​ Clarity: Separate error-handling logic from normal code.
●​ Recovery: Allow programs to continue after errors.

Analogy

Exception handling is like a safety net at a circus. If a performer (code) falls (throws
an exception), the net (try-catch) catches them, letting the show go on.
2. Try-Catch and Finally
The try-catch block attempts risky code and catches exceptions. The finally block
runs regardless of whether an exception occurs.

Syntax

Example: Try-Catch
 ●​ Explanation:
○​ try: Attempts to access an invalid array index.
○​ catch: Handles the ArrayIndexOutOfBoundsException.
○​ finally: Runs cleanup code.

Output:​

Common Confusion

●​ Multiple catch: Handle different exceptions with multiple catch blocks (order
matters: specific to general).
●​ finally: Always executes unless the program exits (e.g., [Link](0)).

Analogy

A try-catch block is like trying a new recipe. If it burns (exception), you handle it
(catch); finally is cleaning the kitchen afterward.

3. Throwing and Custom Exceptions

You can throw exceptions manually with throw and create custom exceptions by
extending Exception or RuntimeException.
Example: Custom Exception

●​ Explanation:
○​ InvalidAgeException: Custom exception class.
○​ checkAge: Throws exception if age is invalid.
○​ try-catch: Catches and displays the error.
○​ Output: Error: Age must be 18 or older.

Common Confusion

●​ Checked vs. Unchecked: Extend Exception for checked (must be handled);

RuntimeException for unchecked (optional).
●​ throws: Declares exceptions a method might throw, forcing callers to handle
or declare them.
Analogy

Throwing an exception is like ringing an alarm. A custom exception is a specific

alarm you design for your needs.

4. File Input/Output (I/O)

File I/O lets you read from and write to files using classes like File, FileReader,
FileWriter, BufferedReader, and BufferedWriter.

Key Classes

●​ File: Represents a file or directory.

●​ FileReader/FileWriter: Read/write characters.
●​ BufferedReader/BufferedWriter: Efficient reading/writing with buffering.
●​ PrintWriter: Convenient for writing formatted text.

Example: Writing to a File

●​ Explanation:
○​ Creates [Link] and writes two lines.
○​ BufferedWriter improves efficiency.
 ○​ close() ensures data is saved.
○​ Output: Data written to file. (creates [Link] with text).

Example: Reading from a File

●​ Explanation:
○​ Reads [Link] line by line.
○​ Handles FileNotFoundException and IOException.

○​

Common Confusion

●​ Closing Resources: Always close files (close()) to avoid leaks;

try-with-resources simplifies this (below).
●​ FileNotFound: Ensure the file exists or handle the exception.
●​ Relative Paths: File paths are relative to the project directory unless specified
(e.g., C:/path/to/[Link]).
Analogy

File I/O is like writing/reading a notebook. You open it (FileReader/Writer), jot down
or read notes (read/write), and close it (cleanup).

5. Try-with-Resources
Try-with-resources automatically closes resources (e.g., files) implementing
AutoCloseable, simplifying cleanup.

Syntax

Example: Try-with-Resources
 ●​ Explanation:
○​ BufferedWriter is automatically closed after the try block.
○​ No explicit close() needed.
○​ Output: Data written. (creates [Link]).

Analogy

Try-with-resources is like a self-cleaning kitchen. You cook (use resources), and it

cleans up (closes) when you’re done.
Module 3 Swing GUI
What's Happening:

●​ Frame = top-level window (native OS frame).

●​ add() attaches children to container.
●​ Output: Native-looking button (changes appearance per OS).

Example: BorderLayout (Most Common):

What's Happening:

●​ Center takes all extra space.

●​ Gaps (10px) between components.
What's Happening:

●​ addActionListener registers callback.

●​ On click → actionPerformed invoked on Event Dispatch Thread (EDT).

Always run GUI code on EDT:

Swing Components
Advanced Example: Login Form: