Unit 3 — Writing Classes

Abstraction and Program Design

Abstraction means hiding unnecessary detail behind a simple interface. When you call Math.sqrt(x), you don't need to know how square roots are computed internally — you just need to know what to give it and what you get back. Writing your own classes lets you create that same kind of simplicity for problems specific to your program.

• A well-designed class models one clear concept (a Dog, a BankAccount) and exposes only what other code actually needs.
• Breaking a large program into classes and methods makes each piece easier to write, test, and reason about on its own.
• Good program design asks: what data does this concept need to remember (fields), and what can it do (methods)?

Impact of Program Design

How you design a class affects more than whether the program works — it affects how easy it is to read, reuse, debug, and extend later.

• Encapsulation — keeping fields private and only exposing controlled access through methods — protects a class's data from being changed in invalid ways by outside code.
• Clear, descriptive names for classes, methods, and variables make code self-documenting and reduce bugs caused by misunderstanding what something does.
• Duplicated logic scattered across a program is harder to fix consistently; a well-placed method or class centralizes it in one place.

Anatomy of a Class

A class definition typically contains, in order: fields (instance data), one or more constructors, and methods (behavior).

public class Student {
    // fields — instance data, usually private
    private String name;
    private int gradeLevel;

    // constructor
    public Student(String n, int g) {
        name = n;
        gradeLevel = g;
    }

    // methods
    public String getName() {
        return name;
    }

    public void promote() {
        gradeLevel++;
    }
}

Constructors

A constructor is a special method that runs automatically when an object is created with new. It shares its name with the class and has no return type — not even void.

public class Rectangle {
    private double width, height;

    // constructor with parameters
    public Rectangle(double w, double h) {
        width = w;
        height = h;
    }

    // no-argument (default-style) constructor — overloaded
    public Rectangle() {
        width = 1.0;
        height = 1.0;
    }
}

Rectangle r1 = new Rectangle(4, 2);
Rectangle r2 = new Rectangle();   // uses the no-arg version, 1x1

• A class can have multiple constructors as long as their parameter lists differ — this is overloading, same idea as in 1.9.
• If you write no constructor at all, Java silently supplies a default no-argument one that does nothing extra. As soon as you write any constructor yourself, that free default disappears.

Methods: How to Write Them

Writing a method means deciding its signature (1.9) and then implementing the logic that fulfills it — every path through the method must return a value matching its declared return type (unless it's void).

public boolean isPassing(int score) {
    if (score >= 60) {
        return true;
    } else {
        return false;
    }
}

// equivalent, more direct — the comparison IS the boolean
public boolean isPassing(int score) {
    return score >= 60;
}

• A method with a non-void return type must return a value on every possible path — the compiler rejects a method where some branch falls through without returning.
• Once a return executes, the method ends immediately — code after it in the same block never runs.
• Prefer writing the logic as directly as possible; wrapping a boolean comparison in an if/else that returns true/false (like the first version above) is usually unnecessary.

Methods: Passing and Returning References of an Object

Recall from 1.13 that object variables hold references, not the object's data directly. When an object is passed as a method argument, the reference is copied — so the method gets its own variable pointing at the same object.

public static void birthday(Student s) {
    s.promote();   // modifies the ORIGINAL object — s points to the same Student
}

Student a = new Student("Ana", 9);
birthday(a);
// a's gradeLevel is now updated — the method changed the real object

• Because the reference is copied, reassigning the parameter itself (s = new Student(...)) inside the method does not affect the caller's variable — only calling methods or changing fields on the object it points to does.
• A method can also return a reference to an object, handing back either a brand-new object or an existing one.

public static Student olderOf(Student a, Student b) {
    return (a.getGradeLevel() > b.getGradeLevel()) ? a : b;
}

Class Variables and Methods

Fields and methods marked static belong to the class itself, shared by all objects, rather than to any one instance (recall 1.10's static Math calls).

public class Student {
    private String name;
    private static int totalStudents = 0;   // one copy, shared by ALL Students

    public Student(String n) {
        name = n;
        totalStudents++;    // every new Student increments the shared count
    }

    public static int getTotalStudents() {
        return totalStudents;
    }
}

Student a = new Student("Ana");
Student b = new Student("Ben");
System.out.println(Student.getTotalStudents());  // 2

Scope and Access

Scope is where in the code a variable name is visible and usable. Access modifiers control which other classes are allowed to see or use a field or method.

public class Counter {
    private int total;   // instance field: visible in every method below

    public void add(int amount) {
        int doubled = amount * 2;  // local variable: only exists inside add()
        total += doubled;
    }
    // doubled is NOT visible here — its scope already ended
}

this Keyword

this refers to "the current object" — the specific instance whose method is currently running. It's most often used to distinguish an instance field from a parameter or local variable that shares its name.

public class Student {
    private String name;

    public Student(String name) {   // parameter shadows the field
        this.name = name;      // this.name = the field; name = the parameter
    }

    public boolean hasSameName(Student other) {
        return this.name.equals(other.name);
    }
}

• Without this, writing name = name; in that constructor would just assign the parameter to itself and leave the field unset.
• this can also be used to call another constructor in the same class (this(...) as the first line), avoiding duplicated setup code.
• Using this is optional when there's no naming conflict — this.name and name mean the same thing if no local variable named name exists in that scope.