CS203 Ultimate Study Hub

📗

Week 1: Java Fundamentals

Introduction to Java, OOP Concepts, Syntax Basics

🎯

Why OOP?

• Security: Bind data + functions together
• Complexity: Easier to manage large systems
• Reusability: Objects reused across applications
• Maintenance: Modular design for updates

🧩

Core OOP Concepts

• Abstraction: Extract common features
• Class: Blueprint/category of objects
• Encapsulation: Combine elements into entity
• Inheritance: "IS-A" relationship
• Polymorphism: Process objects differently

⚖️

Java vs Python

Python: Whitespace matters

Java: Braces { } matter

Python: Newline ends statement

Java: Semicolon ; ends

Python: Dynamic typing

Java: Static typing

📦

Primitive Types

int, long, short, byte

double, float

char

boolean

Types must be declared: int x = 10;

🔄

Control Flow

• if / else if / else
• switch statements
• while loop
• do-while loop (runs at least once!)
• for loop
• for-each loop

⚙️

Compiler & JVM

Python: Interpreted (line by line at runtime)

Java: Compiled → bytecode → JVM executes

javac MyFile.java → java MyFile

Hello World Comparison

// Python:
// print("Hello World")

// Java:
public class Main {
    public static void main(String[] args) {
        System.out.println("Hello World");
    }
}

💻 Week 1 Lab Code

Lab 1: Fibonacci & Numbers (Completed)

Fibonacci.java

import java.util.Scanner;

public class Fibonacci {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("Enter the value of n: ");
        int n = scanner.nextInt();

        int first = 0;
        int second = 1;

        for (int i = 1; i <= n; i++) {
            System.out.print(first + " ");
            int next = first + second;
            first = second;
            second = next;
        }
    }
}

Numbers.java

public class Numbers {
    public static void main(String[] args) {
        int x = 100;
        int sum = 0;
        for (int i = 0; i <= x; i++) {
            sum = sum + i;
        }
        System.out.println(sum);  // Output: 5050
    }
}

🎯 Week 1 Quiz

Test Your Java Fundamentals

1. In Java, what character ends a statement?

2. Which is NOT a primitive type in Java?

3. What does the JVM do?

4. Which loop is guaranteed to run at least once?

🎓

Week 1: Lecture Walkthrough

Step-by-step learning path through Java fundamentals

📖 Follow this guided walkthrough to master Week 1 concepts in the optimal learning order

Why OOP & Why Java?

⏱️ 15 min • Start Here

🎯

Learning Goal

Understand the motivation behind Object-Oriented Programming and why Java is a great language to learn it.

📚 Key OOP Benefits

▸ Security: Bind data and functions together — no unauthorized access
▸ Reusability: Objects can be reused across applications
▸ Easier Maintenance: Modular design allows updating specific parts
▸ Manageability: Handle complexity of large software systems

Abstraction

Encapsulation

Inheritance

Polymorphism

✅ Checkpoint

Can you name one advantage of OOP over procedural programming? (Answer: Modularity, reusability, security through encapsulation, etc.)

Java vs Python: Key Syntax Differences

⏱️ 20 min • Critical Foundation

Feature	Python	Java
Statement End	New line	Semicolon ;
Code Blocks	Indentation	Braces { }
Variable Types	Dynamic (inferred)	Static (declared)
Comments	# comment	// comment

⚠️ Common Mistake

Forgetting the semicolon at the end of statements is the #1 error for Python programmers learning Java. Your program will NOT compile!

✅ Checkpoint

What happens if you forget a semicolon in Java? (Answer: Compile error! The code won't even run.)

Compilation: Source → Bytecode → JVM

⏱️ 15 min • How Java Runs

Java Execution Pipeline

┌─────────────────┐    javac     ┌─────────────────┐    java     ┌─────────────────┐
│  Hello.java    │───────────▸│  Hello.class   │───────────▸│      JVM       │
│  (Source Code) │  Compiler  │  (Bytecode)    │  Runtime   │  (Execution)   │
└─────────────────┘            └─────────────────┘            └─────────────────┘

🔨 Interpreted (Python)

Code is read and executed line by line at runtime. Errors found during execution.

⚙️ Compiled (Java)

Code is validated and converted to bytecode BEFORE running. Many errors caught early!

✅ Checkpoint

What is the JVM? (Answer: Java Virtual Machine — it executes bytecode. This allows "Write Once, Run Anywhere"!)

Primitive Types & Type Declarations

⏱️ 20 min • Core Concept

🔑 The Big Rule

In Java, you MUST declare the type of every variable. The type cannot change!

int x = 10; // x is an int FOREVER

int

Integer

double

Decimal

boolean

true/false

char

Character

💡 String is NOT a primitive!

String is a class (reference type). Primitives are: int, long, short, byte, float, double, char, boolean.

✅ Checkpoint

Is String a primitive type? (Answer: NO! String is a class/reference type.)

Control Flow: if, switch, loops

⏱️ 25 min • Essential Syntax

If Statement Syntax

if (condition) {      // Parentheses required!
    // code block       // Braces for multiple statements
} else if (other) {
    // other code
} else {
    // default
}

while

Check BEFORE loop

May run 0 times

do-while

Check AFTER loop

Runs at least once!

for

Init; condition; update

Counter-based

⚠️ Logical Operators

&& = AND || = OR ! = NOT

✅ Checkpoint

Which loop runs at least once even if the condition is false? (Answer: do-while)

Hello World: The Java Program Structure

⏱️ 15 min • Final Topic

Hello.java

public class Hello {                // Class name = filename!
    public static void main(String[] args) {  // Entry point
        System.out.println("Hello World");
    }
}

🔑 Key Points

• Class name MUST match filename (Hello.java)
• public static void main(String[] args) is the entry point
• Everything lives inside a class in Java

🎉 Week 1 Complete!

You've learned Java basics: OOP concepts, syntax differences from Python, compilation, types, and control flow. Take the quiz to test your knowledge!

📘

Week 2: Classes & Objects

State, Functionality, Object References, Constructors

⚠️ Note: No Lab this week — focus on understanding class structure

🏗️

Class vs Object

Class: Blueprint / description / template
Object: Instance of a class
"Dog" = class, "Scooby Doo" = object

📊

State & Functionality

State: Data, properties, attributes

e.g., Dog's name, weight, color

Functionality: Behaviors, methods

e.g., bark(), eat(), sleep()

🔗

Object References

• Variables hold references to objects
• Multiple references → same object
• Modifying through one reference affects all!

Greeter a = new Greeter("World");
Greeter b = a; // Same object!

👆

The "this" Keyword

• Refers to current object instance
• Like Python's self
• Used when parameter names match field names

this.name = name;

📝

Greeter Class Structure

1. Private Data

private String person;

2. Constructor

public Greeter(String who)

3. Public Method

public String greeting()

Dog.java — State & Functionality Example

public class Dog {
    // STATE (private member variables)
    private String name;
    private int weight;
    private int stomachSpace = 100;

    // CONSTRUCTOR
    public Dog(String name, int weight) {
        this.name = name;
        this.weight = weight;
    }

    // FUNCTIONALITY (methods)
    public void bark() { System.out.println(name + " says Woof!"); }
    public void eat() {
        if (stomachSpace < 25) poop();
        stomachSpace -= 25;
    }
    public void poop() { stomachSpace = 100; }
}

💻 Week 2 Code Examples

No Lab — Lecture examples: Greeter & Dog classes

Greeter.java

/**
 * Greeter class demonstrates basic OOP structure
 */
public class Greeter {
    // Private member variable (state)
    private String person;

    // Constructor - initializes the object
    public Greeter(String who) {
        person = who;
    }

    // Public method (functionality)
    public String greeting() {
        return "Hello " + person;
    }

    // Setter method
    public void setName(String name) {
        person = name;
    }
}

GreeterTester.java (Driver)

public class GreeterTester {
    public static void main(String[] args) {
        // Create object of type Greeter
        Greeter greetUndergrads = new Greeter("CS203 Students");
        
        // Call the greeting() method
        System.out.println(greetUndergrads.greeting());
        
        // Object references - both point to same object!
        Greeter anotherGreeter = greetUndergrads;
        anotherGreeter.setName("Everyone");
        
        // Now greetUndergrads.greeting() also says "Hello Everyone"
        System.out.println(greetUndergrads.greeting());
    }
}

📋 Week 2 SOP

Understanding Classes & Objects

Identify State vs Functionality

List the attributes (data) your object needs List the behaviors (methods) your object performs

Create the Class File

Declare private member variables (state) Write constructor to initialize variables Add public methods (functionality)

Create a Driver/Tester File

Create separate file with main() method Instantiate objects: new ClassName() Call methods and print results

🎯 Week 2 Quiz

Classes, Objects, and References

1. What is an object?

2. What keyword in Java is similar to Python's "self"?

3. If `Greeter a = new Greeter("Hi"); Greeter b = a;`, what happens when you modify through b?

4. Where should the main() method typically be placed?

🎓

Week 2: Lecture Walkthrough

Step-by-step learning path through Classes & Objects

📖 Follow this guided walkthrough to master Week 2 concepts in the optimal learning order

Class vs Object: The Blueprint Analogy

⏱️ 15 min • Start Here

🎯

Learning Goal

Understand that a class is a blueprint/template, while an object is an actual instance created from that blueprint.

📐 Class

• Blueprint / Template
• Describes what data & methods
• Not a "thing" itself

Dog

🐕 Object

• Instance of a class
• Has actual data values
• IS a "thing"

Scooby Doo, Hector, Fliggle

💡 Analogy

"Dog" is the class (blueprint). "Scooby Doo" is an object (actual dog created from that blueprint).

✅ Checkpoint

If "Vehicle" is a class, what would be examples of objects? (Answer: "My Honda Civic", "Bus #42", "The Red Truck")

State & Functionality

⏱️ 20 min • Core Concept

🎯

Learning Goal

Objects have STATE (data/attributes) and FUNCTIONALITY (behaviors/methods). This is the heart of OOP!

Dog Example

public class Dog {
    // STATE (member variables)
    private String name;      // "Hector"
    private int weight;       // 120
    private String color;     // "Gray"

    // FUNCTIONALITY (methods)
    public void bark() { ... }
    public void eat() { ... }
    public void sleep() { ... }
}

📊 State = Nouns

Properties, attributes, data. What the object has or is.

name, weight, color, age

⚡ Functionality = Verbs

Behaviors, methods. What the object does.

bark(), eat(), sleep(), run()

✅ Checkpoint

For a BankAccount class, what might be state vs functionality? (Answer: State: balance, accountNumber. Functionality: deposit(), withdraw())

Constructors: Creating Objects

⏱️ 20 min • Essential Pattern

🔑 What is a Constructor?

A special method that runs when you create a new object. It initializes the object's state.

Constructor Pattern

public class Greeter {
    private String person;

    // CONSTRUCTOR - same name as class, NO return type!
    public Greeter(String who) {
        person = who;
    }

    public String greeting() {
        return "Hello " + person;
    }
}

⚠️ Constructor Rules

• Same name as the class
• NO return type (not even void!)
• Called automatically with new ClassName()

📝 Python vs Java Constructors

Python: __init__(self)

Java: ClassName()

✅ Checkpoint

What's wrong with: public void Dog() { }? (Answer: void makes it a regular method, not a constructor!)

Object References: Variables Hold Addresses

⏱️ 25 min • Critical Concept

⚠️ Key Insight

When you declare an object variable, it doesn't hold the object itself — it holds a reference (memory address) pointing to the object!

Multiple References, Same Object

Greeter worldGreeter = new Greeter("World");
Greeter anotherGreeter = worldGreeter;  // SAME object!

anotherGreeter.setName("Dave");

// Now worldGreeter.greeting() returns "Hello Dave"!
// Both variables point to the SAME object in memory.

Memory Visualization

Variables              Heap Memory
┌────────────────┐      ┌───────────────────┐
│ worldGreeter ──┼──┐   │ Greeter object    │
└────────────────┘  ├──▸│ person: "Dave"    │
┌────────────────┐  │   └───────────────────┘
│ anotherGreeter─┼──┘
└────────────────┘
Both point to same memory location!

✅ Checkpoint

If Point a = new Point(5,5); Point b = a;, then you do b.x = 99;, what is a.x? (Answer: 99! They're the same object.)

The "this" Keyword (like Python's self)

⏱️ 15 min • Quick Win

🔑 What is "this"?

this refers to the current object — the one calling the method. It's like Python's self, but in Java it's implicit!

Using "this" to Disambiguate

public class Dog {
    private String name;

    public Dog(String name) {
        this.name = name;  // this.name = instance variable
                           // name = parameter
    }
}

✅ Checkpoint

Why use this.name = name; instead of name = name;? (Answer: To distinguish the instance variable from the parameter with the same name!)

Driver/Tester Class Pattern

⏱️ 15 min • Best Practice

🏗️ Two-Class Pattern

Separate your data class (the blueprint) from your tester class (the one with main()).

📘 Greeter.java

The CLASS (blueprint)

• Defines state (member variables)
• Defines functionality (methods)
• NO main() method

📗 GreeterTester.java

The DRIVER (tester)

• Contains main() method
• Creates objects
• Calls methods on objects

🎉 Week 2 Complete!

You've learned: Class vs Object, State & Functionality, Constructors, Object References, this keyword, and the Driver pattern. Take the quiz!

📙

Week 3: Inheritance & Encapsulation

Constructors, Getters/Setters, Access Modifiers, extends, super

✅ Lab 3: Book class with private fields, constructor, getters/setters

🏗️

State vs Functionality

State: Member variables (numWheels, name)
Functionality: Methods (drive(), getName())

private int numWheels; // state
public void drive() { } // functionality

🔨

Constructors

• Same name as class
• NO return type (not even void!)
• Called when you do new ClassName()

🛡️

Access Modifiers

publicEveryone

privateSame class only

protectedClass + subclasses

99.9% of fields should be private!

🔐

Getters & Setters

Getter: Returns field value
Setter: Modifies field (with validation)

⚠️ Some fields shouldn't have setters (e.g., odometer)

🧬

Inheritance (extends)

• Use for IS-A relationships
• Child inherits public/protected members
• super() calls parent constructor

public class Car extends Vehicle { }

📦

Constructor Overloading

Multiple constructors with different parameters

public Car(String name) { }
public Car(String name, int doors) { }

🔄

Polymorphism

✅ Vehicle v = new Car();
❌ Car c = new Vehicle();

A Car IS-A Vehicle, but not vice versa!

🌳

Object Class & toString()

• All classes extend Object
• Default toString(): ClassName@hash
• Override for useful output

⚖️

equals() vs ==

Reference equality
Same object in memory?

.equals()

Logical equality
Same values?

💻 Week 3 Lab & Study Code

Book class (Lab 3) + Week03StudyGuide (Vehicle/Car)

Book.java Lab 3

public class Book {
    // Private fields (state)
    private String name;
    private int page;
    private boolean stock;

    // Constructor - no return type!
    public Book(String n, int p, boolean s) {
        name = n;
        page = p;
        stock = s;
    }

    // Getters
    public String getName() { return name; }
    public int getPage() { return page; }
    public boolean getStock() { return stock; }

    // Setters
    public void setName(String n) { name = n; }
    public void setPage(int p) { page = p; }
    public void setStock(boolean s) { stock = s; }
}

BookTester.java

public class BookTester {
    public static void main(String[] args) {
        System.out.println("Creating a new Book object...");
        Book myBook = new Book("The Great Gatsby", 180, true);

        System.out.println("--- Initial Values ---");
        System.out.println("Book Name: " + myBook.getName());
        System.out.println("Page Count: " + myBook.getPage());
        System.out.println("In Stock: " + myBook.getStock());

        System.out.println("\nUpdating Book details...");
        myBook.setPage(200);
        myBook.setStock(false);

        System.out.println("--- Updated Values ---");
        System.out.println("Book Name: " + myBook.getName());
        System.out.println("Page Count: " + myBook.getPage());
        System.out.println("In Stock: " + myBook.getStock());
    }
}

Week03StudyGuide.java Study

/**
 * CS203 Week 03 — Complete OOP Study Guide
 * Demonstrates: Inheritance, Constructors, Access Modifiers, Polymorphism
 */
public class Week03StudyGuide {
    public static void main(String[] args) {
        Vehicle v = new Vehicle("Truck", 4, 2, 1000);
        v.drive(25);
        System.out.println(v);

        Car c = new Car("Civic");
        c.drive(10);
        System.out.println(c);

        // Polymorphism: Vehicle reference → Car object
        Vehicle v2 = new Car("Accord");
        System.out.println(v2);
    }

    static class Vehicle {
        private final int numWheels;
        private int numDoors;
        private String name;
        private int odometerMiles;

        public Vehicle(String name, int w, int d, int o) {
            this.name = name;
            this.numWheels = w;
            this.numDoors = d;
            this.odometerMiles = o;
        }

        public String getName() { return name; }
        public int getNumWheels() { return numWheels; }
        public int getNumDoors() { return numDoors; }
        public int getOdometerMiles() { return odometerMiles; }

        public void drive(int miles) { odometerMiles += miles; }

        @Override
        public String toString() {
            return "Vehicle{" + name + ", wheels=" + numWheels + ", odo=" + odometerMiles + "}";
        }
    }

    static class Car extends Vehicle {
        public Car(String name) {
            super(name, 4, 4, 0); // Must be first line!
        }
        public Car(String name, int doors) {
            super(name, 4, doors, 0);
        }
        @Override
        public String toString() {
            return "Car{" + getName() + ", odo=" + getOdometerMiles() + "}";
        }
    }
}

🎯 Week 3 Quiz

Inheritance, Encapsulation & OOP Principles

1. What is the return type of a constructor?

2. What % of member variables should be private (per lecture)?

3. Why can't Car directly set numWheels if it extends Vehicle?

4. What must be the FIRST statement when calling parent constructor?

5. Is `Vehicle v = new Car("Civic");` valid?

6. What does default toString() return?

🎓

Week 3: Lecture Walkthrough

Step-by-step learning path through Inheritance & Encapsulation

📖 Follow this guided walkthrough to master Week 3 concepts in the optimal learning order

Building the Vehicle Class

⏱️ 20 min • Start Here

🎯

Learning Goal

Design a Vehicle class with proper encapsulation — private member variables, constructor, and getters/setters.

🚗 Vehicle State & Functionality

State:

• numWheels (int)
• numDoors (int)
• name (String)
• odometerReading (int)

Functionality:

• drive(miles)
• getNumWheels()
• getOdometerReading()
• etc.

Vehicle.java Structure

public class Vehicle {
    private int numWheels;
    private int numDoors;
    private String name;
    private int odometerReading;

    // Constructor sets initial values
    public Vehicle(int wheels, int doors, String name) {
        this.numWheels = wheels;
        this.numDoors = doors;
        this.name = name;
        this.odometerReading = 0;
    }
}

✅ Checkpoint

Why should odometerReading NOT have a setter? (Answer: An odometer should only go up via driving, never be set directly!)

Inheritance: extends Keyword

⏱️ 25 min • Core OOP Concept

🎯

Learning Goal

Understand the "IS-A" relationship. A Car IS-A Vehicle, so Car extends Vehicle and inherits all its public/protected members.

Class Hierarchy

            ┌─────────────┐
            │   Vehicle   │  ← Parent/Superclass
            └──────┬──────┘
       ┌───────────┼───────────┐
       ▼           ▼           ▼
┌─────────┐  ┌─────────┐  ┌─────────┐
│   Car   │  │  Truck  │  │   Bus   │  ← Children/Subclasses
└─────────┘  └─────────┘  └─────────┘

🔑 The extends Keyword

public class Car extends Vehicle { }

Now Car has all of Vehicle's public and protected members automatically!

⚠️ Private Members Not Inherited

Private members in Vehicle are NOT accessible in Car. That's why we use protected or getters/setters!

✅ Checkpoint

If Car extends Vehicle, can a Car call the drive() method? (Answer: YES! It inherits all public methods.)

The super Keyword

⏱️ 20 min • Calling Parent

🔑 What is super?

super refers to the parent class. Use it to call the parent's constructor or methods.

Car Constructor Using super()

public class Car extends Vehicle {

    // Car always has 4 wheels
    public Car(int doors, String name) {
        super(4, doors, name);  // Call Vehicle constructor
    }

    // Convenience: most cars have 4 doors, new odometer
    public Car(String name) {
        super(4, 4, name);
    }
}

⚠️ Critical Rule

super() MUST be the first statement in a constructor! No exceptions.

✅ Checkpoint

What happens if you put code before super()? (Answer: Compile error! super() must be first.)

Access Modifiers: public, private, protected

⏱️ 20 min • Encapsulation

Modifier	Same Class	Subclass	Other Classes
public	✅	✅	✅
protected	✅	✅	❌
private	✅	❌	❌

🔒 The 99.9% Rule

99.9% of member variables should be private! Use getters/setters for controlled access.

✅ Checkpoint

Can a subclass access a parent's private field directly? (Answer: NO! Use getters or make it protected.)

Object Class & toString()

⏱️ 20 min • Root of All Classes

🌳 Object is the Root

Every class in Java ultimately extends Object. This means every object has toString(), equals(), etc.

Default toString() Output

Vehicle v = new Vehicle(4, 4, "Civic");
System.out.println(v);
// Output: Vehicle@15db9742  ← Not helpful!

Override toString() for Useful Output

@Override
public String toString() {
    return name + " with " + numWheels + " wheels";
}
// Output: Civic with 4 wheels  ← Much better!

✅ Checkpoint

What does the default toString() return? (Answer: ClassName@hashcode — not human-friendly!)

Polymorphism: IS-A Relationships

⏱️ 20 min • Powerful Concept

🔮 What is Polymorphism?

A variable of type Vehicle can hold a Car, Truck, or Bus object. The IS-A relationship allows this flexibility!

Polymorphism Examples

Vehicle v = new Car("Civic");    // ✅ Works! Car IS-A Vehicle
Vehicle t = new Truck("F150");   // ✅ Works! Truck IS-A Vehicle

Car c = new Vehicle(4,4,"X");   // ❌ Error! Vehicle is NOT a Car

💡 The Rule

A parent reference can hold a child object. But NOT the other way around!

🎉 Week 3 Complete!

You've learned: Building classes, Inheritance, super keyword, Access Modifiers, Object/toString, and Polymorphism. Take the quiz!

📕

Week 4: Graphics, References & Encapsulation

JFrame, Graphics2D, Pass By Value, this, Accessor/Mutator, Local vs Instance

📝 HW2 Assigned: Focus on graphical applications and object references

🖼️

JFrame Basics

• new JFrame() creates window
• setSize(width, height)
• setTitle("Title")
• setDefaultCloseOperation(EXIT_ON_CLOSE)
• setVisible(true)

🎨

Graphics2D Drawing

• Extend JComponent
• Override paintComponent(Graphics g)
• Cast to Graphics2D g2
• g2.draw(shape) or g2.fill(shape)

⬜

Drawing Shapes

Rectangle2D.Double(x, y, w, h)

Ellipse2D.Double(x, y, w, h)

Line2D.Double(x1, y1, x2, y2)

💡 Circle = Ellipse with equal width & height

🎨

Colors

• new Color(r, g, b) (0-255)
• g2.setColor(color)
• g2.fill(shape) for solid

BLACK BLUE RED GREEN

🔗

Object References

• Reference = memory location
• Variable stores reference, not object
• Multiple vars → same object

⚠️ Point p2 = p1; → both point to same memory!

📤

Java Is Pass By Value

• Primitives: Copy of value sent
• Objects: Copy of reference sent
• swap(a, b) on primitives → originals unchanged!

❌ Can't swap object references themselves
✅ CAN modify object's internal state

👆

The "this" Reference

• Refers to current object instance
• Implicit first parameter to all methods
• Like Python's self
• Disambiguates parameter vs member

this.name = name; // member = param

🔒

Encapsulation

• Bundle data + methods in class
• Hide internal state (private)
• Access via public getters/setters

Data Hiding

Abstraction

🔐

Accessor vs Mutator

Accessor: Returns data, no changes

getNumWheels()

Mutator: Changes internal data

setNumWheels(16)

💡 Design methods as one OR the other, not both!

🔄

Overloading vs Overriding

Overloading: Same class, same name, different params
Compile-time

Overriding: Subclass redefines parent method
Runtime

📊

Local vs Instance Variables

Local Variables

• Declared inside method/block
• Die when method exits
• Must initialize before use!
• No default values

Instance Variables

• Declared in class, outside methods
• Live as long as object exists
• Default values (0, null, false)
• Each object has own copy

Drawing a Circle with Graphics2D

// Draw circle at center (100, 100) with radius 25
// Ellipse takes (x, y, width, height) of bounding box
g2.draw(new Ellipse2D.Double(75, 75, 50, 50));

// Fill with color
g2.setColor(Color.RED);
g2.fill(new Ellipse2D.Double(75, 75, 50, 50));

💻 Week 4 Code Examples

Graphics, Pass By Value, Object References

SomeGraphics.java JComponent

import javax.swing.*;
import java.awt.*;
import java.awt.geom.*;

public class SomeGraphics extends JComponent {
    
    @Override
    public void paintComponent(Graphics g) {
        // Cast to Graphics2D for advanced drawing
        Graphics2D g2 = (Graphics2D) g;
        
        // Draw a rectangle
        Rectangle2D.Double box = new Rectangle2D.Double(50, 50, 100, 60);
        g2.draw(box);
        
        // Draw a circle (Ellipse with equal width/height)
        Ellipse2D.Double circle = new Ellipse2D.Double(75, 75, 50, 50);
        g2.setColor(Color.RED);
        g2.fill(circle);
        
        // Draw a line
        Line2D.Double line = new Line2D.Double(200, 50, 250, 150);
        g2.setColor(Color.BLUE);
        g2.draw(line);
        
        // Draw text
        g2.setColor(Color.BLACK);
        g2.drawString("Hello Graphics!", 50, 200);
    }
}

SomeGraphicsTester.java

import javax.swing.*;

public class SomeGraphicsTester {
    public static void main(String[] args) {
        // Create the frame
        JFrame frame = new JFrame();
        frame.setSize(400, 300);
        frame.setTitle("Graphics Demo");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        
        // Add the component
        SomeGraphics component = new SomeGraphics();
        frame.add(component);
        
        // Make visible
        frame.setVisible(true);
    }
}

PassByValueDemo.java Concept

public class PassByValueDemo {

    // Point class with public fields for demo
    static class Point {
        public int x, y;
        public Point(int x, int y) {
            this.x = x;
            this.y = y;
        }
    }

    // This WON'T swap the actual variables!
    public static void swap(int a, int b) {
        int temp = a;
        a = b;
        b = temp;
    }

    // This WON'T swap the references!
    public static void swapPoints(Point a, Point b) {
        Point temp = a;
        a = b;
        b = temp;
    }

    // This WILL modify the object's data!
    public static void swapX(Point a, Point b) {
        int temp = a.x;
        a.x = b.x;
        b.x = temp;
    }

    public static void main(String[] args) {
        // Primitive swap - doesn't work!
        int intA = 10, intB = 20;
        swap(intA, intB);
        System.out.println("intA=" + intA + ", intB=" + intB);
        // Output: intA=10, intB=20 (unchanged!)

        // Object reference swap - doesn't swap refs!
        Point p1 = new Point(1, 1);
        Point p2 = new Point(0, 0);
        swapPoints(p1, p2);
        System.out.println("p1.x=" + p1.x + ", p2.x=" + p2.x);
        // Output: p1.x=1, p2.x=0 (refs unchanged!)

        // Mutating object data - DOES work!
        swapX(p1, p2);
        System.out.println("After swapX: p1.x=" + p1.x + ", p2.x=" + p2.x);
        // Output: p1.x=0, p2.x=1 (data swapped!)
    }
}

EncapsulationDemo.java Best Practice

public class Vehicle {
    // Private fields - encapsulated!
    private String name;
    private int numWheels;
    private int odometerMiles;

    // Constructor
    public Vehicle(String name, int numWheels) {
        this.name = name;          // 'this' disambiguates
        this.numWheels = numWheels;
        this.odometerMiles = 0;
    }

    // ACCESSOR (getter) - returns data, no change
    public int getNumWheels() {
        return this.numWheels;
    }

    // ACCESSOR
    public int getOdometerMiles() {
        return odometerMiles;
    }

    // MUTATOR (setter) - changes data
    public void setNumWheels(int numWheels) {
        this.numWheels = numWheels;
    }

    // MUTATOR - adds miles (no setter for odometer!)
    public void drive(int miles) {
        odometerMiles += miles;  // Can only go up!
    }
}

🎯 Week 4 Quiz

Graphics, References, Encapsulation

1. To draw in a frame, you must extend which class?

2. How do you draw a circle using Ellipse2D?

3. After `swap(intA, intB)` on primitives, what happens?

4. What does "this" refer to in Java?

5. Which type of method changes internal data?

6. When do local variables "die"?

🎓

Week 4: Lecture Walkthrough

Step-by-step learning path through the lecture material

📖 Follow this guided walkthrough to master Week 4 concepts in the optimal learning order

Graphics Foundation: JFrame & JComponent

⏱️ 20 min • Start Here

🎯

Learning Goal

Understand how Java creates graphical windows and the relationship between JFrame (the window) and JComponent (the drawing surface).

📚 Key Concepts

▸ JFrame is the window container - think of it as the picture frame
▸ JComponent is where you draw - think of it as the canvas inside the frame
▸ You never call paintComponent() yourself - Java calls it automatically!

Mental Model

┌──────────────────────────────────────┐
│  JFrame (The Window)                 │
│  ┌────────────────────────────────┐  │
│  │                                │  │
│  │  JComponent (Your Drawing)     │  │
│  │                                │  │
│  │    ○  ← shapes go here        │  │
│  │   ▭                           │  │
│  │                                │  │
│  └────────────────────────────────┘  │
└──────────────────────────────────────┘

✅ Checkpoint

Can you explain why we need BOTH a JFrame AND a JComponent class? (Answer: JFrame is the window, JComponent is where drawing happens. Separation of concerns!)

Drawing with Graphics2D

⏱️ 25 min • Core Skill

🎯

Learning Goal

Master the pattern for drawing shapes using Graphics2D, understanding coordinates and the draw vs fill distinction.

🔄 The Drawing Pattern (Memorize This!)

Override paintComponent(Graphics g)
Cast to Graphics2D: Graphics2D g2 = (Graphics2D) g;
Create shape objects (Rectangle2D, Ellipse2D, Line2D)
Set color with g2.setColor()
Draw outline with g2.draw(shape) OR fill with g2.fill(shape)

▭

Rectangle2D.Double

(x, y, width, height)

⬭

Ellipse2D.Double

(x, y, width, height)

╱

Line2D.Double

(x1, y1, x2, y2)

💡 Pro Tip: Circle from Ellipse

There's no Circle2D class! To draw a circle, use Ellipse2D with equal width and height.

new Ellipse2D.Double(x, y, 50, 50) // 50x50 = circle!

✅ Checkpoint

Draw a red filled circle at position (100, 100) with radius 30. What are the x, y, width, height parameters? (Answer: 70, 70, 60, 60 - because x,y is top-left corner!)

Object References & Memory

⏱️ 30 min • Critical Concept

🎯

Learning Goal

Understand the difference between objects and references, and why assignment creates aliases, not copies.

⚠️ Common Misconception Alert!

When you write Point p2 = p1; you are NOT copying the Point object. You're copying the reference (memory address). Now both variables point to the SAME object!

Memory Visualization

Point p1 = new Point(5, 10);
Point p2 = p1;

Variables (Stack)        Objects (Heap)
┌─────────────┐          ┌─────────────────┐
│ p1: 0x1234  │────┐     │ Point object    │
└─────────────┘    ├────▸│ x: 5, y: 10     │
┌─────────────┐    │     └─────────────────┘
│ p2: 0x1234  │────┘
└─────────────┘
Both p1 and p2 hold the SAME address!

🔑 Key Insight

If you modify p1.x = 99, then p2.x is also 99! They're the same object in memory.

✅ Checkpoint

What does p1 == p2 check? (Answer: It checks if both variables hold the same memory address, NOT if the objects have the same values!)

Java is ALWAYS Pass By Value

⏱️ 25 min • Exam Favorite

🎯

Learning Goal

Understand why swap methods don't work in Java and what "pass by value" really means for objects.

Primitives

The actual value is copied.

int x = 10;
increment(x);
// x is still 10!

Objects

The reference (address) is copied.

Point p = new Point(5,5);
modify(p);
// p.x CAN change!

❌ Why swap(a, b) Doesn't Work

When you call swap(intA, intB):

Java copies the values into new local variables
The swap happens on the copies
Original variables are untouched

✅ What DOES Work

You CAN modify an object's internal state through a passed reference. You just can't make the original variable point to a different object.

✅ Checkpoint

If you pass a Point to a method and do p.x = 100, does the original object change? (Answer: YES! The reference copy still points to the same object.)

The "this" Reference

⏱️ 15 min • Quick Win

🎯

Learning Goal

Understand that "this" is an implicit reference to the current object, similar to Python's "self".

💡 The Big Idea

this is a hidden first parameter passed to every instance method. It's how the method knows which object it's working on!

Common Use: Disambiguating Parameters

public class Person {
    private String name;  // instance variable

    public Person(String name) {  // parameter also called "name"
        this.name = name;  // this.name = instance variable
                           // name = parameter
    }
}

✅ Checkpoint

In the constructor above, what happens if you write name = name; without "this"? (Answer: You assign the parameter to itself! The instance variable stays null.)

Encapsulation & Data Hiding

⏱️ 20 min • Design Principle

🎯

Learning Goal

Understand why we hide data (private) and provide controlled access through getters and setters.

🔒 The Encapsulation Rule

99.9% of instance variables should be private! This is a core OOP principle. Control access through methods.

❌ Without Encapsulation

public int balance;

// Anyone can do this:
account.balance = -9999;

No protection! Invalid states possible.

✅ With Encapsulation

private int balance;

public void deposit(int amt) {
if (amt > 0) balance += amt;
}

Validation! Only valid operations allowed.

✅ Checkpoint

Why might you have a getter but NO setter for a field? (Answer: Read-only access! Like an odometer that can only go up.)

Accessor vs Mutator Methods

⏱️ 10 min • Terminology

👀 Accessor (Getter)

• Returns information
• Does NOT change state
• Usually starts with get

public int getAge() {
return age;
}

✏️ Mutator (Setter)

• Changes internal state
• Usually returns void
• Usually starts with set

public void setAge(int a) {
age = a;
}

⚡ Design Tip

A method should be an accessor OR a mutator, not both! This makes code easier to reason about.

Local vs Instance Variables

⏱️ 15 min • Final Topic

Property	Local Variable	Instance Variable
Declared	Inside method/block	In class, outside methods
Lifetime	Dies when method exits	Lives with the object
Default Value	NONE! Must initialize	0, null, false
Access	Only in that method	All methods in class

⚠️ Common Error

Using a local variable without initializing it causes a compile error! Unlike instance variables, they have no defaults.

🎉 Week 4 Complete!

You've covered: Graphics, References, Pass By Value, this, Encapsulation, Accessor/Mutator, and Variable Scope. Take the quiz to test your knowledge!

Week 1: Java Fundamentals

Why OOP?

Core OOP Concepts

Java vs Python

Primitive Types

Control Flow

Compiler & JVM

💻 Week 1 Lab Code

📋 Week 1 SOP

Install JDK & IDE

Create Your First Program

Compile & Run

Lab 1: Fibonacci & Numbers

🎯 Week 1 Quiz

1. In Java, what character ends a statement?

2. Which is NOT a primitive type in Java?

3. What does the JVM do?

4. Which loop is guaranteed to run at least once?

Week 1: Lecture Walkthrough

Why OOP & Why Java?

Java vs Python: Key Syntax Differences

Compilation: Source → Bytecode → JVM

Primitive Types & Type Declarations

Control Flow: if, switch, loops

Hello World: The Java Program Structure

Week 2: Classes & Objects

Class vs Object

State & Functionality

Object References

The "this" Keyword

Greeter Class Structure

💻 Week 2 Code Examples

📋 Week 2 SOP

Identify State vs Functionality

Create the Class File

Create a Driver/Tester File

🎯 Week 2 Quiz

1. What is an object?

2. What keyword in Java is similar to Python's "self"?

3. If Greeter a = new Greeter("Hi"); Greeter b = a;, what happens when you modify through b?

4. Where should the main() method typically be placed?

Week 2: Lecture Walkthrough

Class vs Object: The Blueprint Analogy

State & Functionality

Constructors: Creating Objects

Object References: Variables Hold Addresses

The "this" Keyword (like Python's self)

Driver/Tester Class Pattern

Week 3: Inheritance & Encapsulation

State vs Functionality

Constructors

Access Modifiers

Getters & Setters

Inheritance (extends)

Constructor Overloading

Polymorphism

Object Class & toString()

equals() vs ==

💻 Week 3 Lab & Study Code

📋 Week 3 SOP

Create Book.java

Declare Private Fields

Write Constructor

Add Getters & Setters

Create BookTester.java

🎯 Week 3 Quiz

1. What is the return type of a constructor?

2. What % of member variables should be private (per lecture)?

3. Why can't Car directly set numWheels if it extends Vehicle?

4. What must be the FIRST statement when calling parent constructor?

5. Is Vehicle v = new Car("Civic"); valid?

6. What does default toString() return?

Week 3: Lecture Walkthrough

Building the Vehicle Class

Inheritance: extends Keyword

The super Keyword

Access Modifiers: public, private, protected

Object Class & toString()

Polymorphism: IS-A Relationships

Week 4: Graphics, References & Encapsulation

3. If `Greeter a = new Greeter("Hi"); Greeter b = a;`, what happens when you modify through b?

5. Is `Vehicle v = new Car("Civic");` valid?

3. After `swap(intA, intB)` on primitives, what happens?