Unit 1 — Using Objects and Methods

Introduction to Algorithms, Programming, and Compilers

An algorithm is a finite, ordered sequence of instructions that accomplishes a task. A program is an algorithm written in a language a computer can eventually execute. Java programs are written as human-readable source code, which cannot run directly — it must be translated.

• A compiler translates source code into a lower-level form, checking for syntax errors along the way. In Java, the compiler turns .java files into bytecode (.class files).
• The Java Virtual Machine (JVM) then executes that bytecode. This is why Java is "write once, run anywhere" — the same bytecode runs on any machine with a JVM.
• Syntax errors are caught at compile time (broken grammar). Logic errors slip past the compiler because the code runs, but produces the wrong result. Runtime errors occur during execution (e.g. dividing by zero).

Variables and Data Types

A variable is a named piece of memory that holds a value. Every variable in Java has a fixed data type, declared once, that determines what kind of value it can store and how much memory it uses.

int score = 0;
double price = 19.99;
boolean passed = true;
String course = "AP CSA";

A variable must be declared (type + name) before it's used, and typically initialized (given a starting value) in the same step.

int total;
total = 25;

Expressions and Output

An expression is any combination of values, variables, and operators that evaluates to a single value. Java uses the standard arithmetic operators: + - * / %.

• / between two ints performs integer division — the decimal part is truncated (7 / 2 is 3, not 3.5).
• % (modulo) returns the remainder of division (7 % 2 is 1).
• Operator precedence follows normal math rules: * / % before + -, evaluated left to right; use parentheses to force order.

System.out.println(7 / 2);      // 3  (integer division)
System.out.println(7 % 2);      // 1  (remainder)
System.out.println(7.0 / 2);    // 3.5 (a double is involved)
System.out.print("Score: ");
System.out.println(95);       // print vs println: println adds a newline

System.out.print() and System.out.println() send output to the console; println moves to a new line afterward, print does not.

Assignment Statements and Input

The assignment operator = stores the value of the right-hand expression into the variable on the left. The right side is fully evaluated first.

int x = 5;
x = x + 1;      // reads old x (5), computes 6, stores it back into x
System.out.println(x); // 6

To get input from the user, Java commonly uses the Scanner class from java.util:

import java.util.Scanner;

Scanner in = new Scanner(System.in);
System.out.print("Enter your age: ");
int age = in.nextInt();     // nextDouble(), nextLine() also exist

int a = 4;
int b = a;
a = 10;

Casting and Range of Variables

Every numeric type has a limited range of values it can hold (e.g. int typically spans about ±2.1 billion). Casting explicitly converts a value from one type to another.

double pi = 3.9;
int whole = (int) pi;      // 3 — truncates, does NOT round

int a = 7, b = 2;
double result = (double) a / b;  // 3.5 — cast forces real division

• Narrowing (double → int) loses information and needs an explicit cast.
• Widening (int → double) is automatic — no data is lost.
• Casting (int) on a decimal truncates toward zero; it never rounds.
• Integer overflow: exceeding a type's range wraps around silently (no error/crash) — a classic source of hard-to-find bugs.

Compound Assignment Operators

Compound operators combine an arithmetic operation with assignment in one step: var = var OP value becomes var OP= value.

int count = 10;
count += 5;   // count is now 15
count++;    // count is now 16

int score = 8;
score *= 3;
score -= 4;

Application Program Interface (API) and Libraries

An API is a collection of classes and methods someone else already wrote, that you can use without knowing how they're implemented internally. Java's built-in libraries are organized into packages (e.g. java.util, java.lang).

import java.util.Scanner;   // brings a class in from a package
import java.util.ArrayList;

• Classes in java.lang (like Math, String, System) are available automatically — no import needed.
• Everything else needs an explicit import statement.
• Using an API well means reading its documentation to know what a method needs (parameters) and what it gives back (return type) — not reading its source code.

Documentation with Comments

Comments are ignored by the compiler and exist purely to explain code to humans.

// single-line comment

/* multi-line
   comment */

/**
 * Javadoc comment — describes a class or method
 * @param n the number to square
 * @return the square of n
 */
public static int square(int n) {
    return n * n;
}

Good comments explain why, not just restate what the code already says clearly. Javadoc-style comments (/** ... */) placed above a method are used to auto-generate documentation and are the standard way to document parameters and return values.

Method Signatures

A method's signature is its name plus its parameter list — it's what the compiler uses to identify which method you're calling. The full header adds the access level and return type:

public static double average(int a, int b) {
    return (a + b) / 2.0;
}

A method with void as its return type performs an action but doesn't send back a value, so it can't be used inside an expression.

Calling (Static) Class Methods

A static method belongs to the class itself, not to any individual object, so it's called directly through the class name — no object needs to be created first.

ClassName.methodName(arguments);

// concrete example
double root = Math.sqrt(16);   // 4.0

• Parameters are the placeholders in the method definition; arguments are the actual values passed in when you call it.
• Arguments are matched to parameters by position and type, in order.
• If the method returns a value, you can store it, print it, or use it directly in another expression.

public static int triple(int n) {
    return n * 3;
}

The Math Class

Math lives in java.lang (no import needed) and provides static methods and constants for common numeric operations.

// random integer from 0 to 9 (inclusive)
int die = (int) (Math.random() * 10);

// random integer from 1 to 6 (inclusive) — classic die roll
int roll = (int) (Math.random() * 6) + 1;

Objects: Instances of Classes

A class is a blueprint that defines what data (fields) and behavior (methods) its objects will have. An object is a specific instance built from that blueprint, with its own copy of the fields.

public class Dog {
    String name;   // instance field — each Dog has its own
    int age;

    public Dog(String n, int a) {   // constructor
        name = n;
        age = a;
    }

    public void bark() {
        System.out.println(name + " says woof!");
    }
}

Think of the class Dog as the blueprint, and each individual dog object (like myDog, yourDog) as a house built from it — same structure, different data inside.

Object Creation and Storage (Instantiation)

Instantiation is the act of creating an actual object from a class, using the new keyword, which calls a constructor.

Dog myDog = new Dog("Rex", 3);
//  ^type    ^name   ^new keyword  ^constructor call

• Dog myDog declares a variable that can refer to a Dog object.
• new Dog("Rex", 3) actually builds the object in memory and runs its constructor.
• myDog stores a reference (essentially an address) to that object — not the object's data directly.

Dog a = new Dog("Fido", 2);
Dog b = a;
b.age = 9;

Calling Instance Methods

Unlike static methods, an instance method operates on a specific object's data, so it must be called through an object using dot notation.

Dog myDog = new Dog("Rex", 3);
myDog.bark();              // "Rex says woof!"

System.out.println(myDog.age);   // accessing a field the same way

String Manipulation

String is a built-in class (not a primitive) representing text. Strings are immutable — once created, a String's characters never change; methods that "modify" a string actually return a brand-new one.

String word = "Computer";
System.out.println(word.length());          // 8
System.out.println(word.substring(0, 3));    // "Com"
System.out.println(word.toUpperCase());     // "COMPUTER"