Java Handout · ⁨Material de Java⁩

Todo programa Java vive dentro de una clase 类. Comienza en un método 方法 llamado main. System.out.println(...) imprime una línea; System.out.print(...) imprime sin salto de línea.

public class Main {
    public static void main(String[] args) {
        System.out.println("Hello, world!");
        System.out.println("I am learning Java.");
    }
}

• Java se compila 编译: el compilador 编译器 revisa todo el programa y luego lo ejecuta.
• Cada sentencia 语句 termina con punto y coma ;.

Una variable variable debe declarar su tipo. Tipos primitivos comunes 基本类型: int (número entero), double (decimal), boolean (true/false), char (una letra).

public class Main {
    public static void main(String[] args) {
        int age = 17;
        double price = 9.99;
        boolean passed = true;
        System.out.println(age + " " + price + " " + passed);
    }
}

Un comentario 注释 es // (una línea) o /* ... */ (un bloque). Indenta el código dentro de las llaves { }. Los nombres de clases empiezan con mayúscula; las variables y métodos usan camelCase 驼峰命名 (minúscula inicial).

public class Main {
    public static void main(String[] args) {
        // greet the user
        String firstName = "Mei";
        System.out.println("Hi, " + firstName);
    }
}

Errores comunes

• Toda sentencia termina con punto y coma ;.
• main debe ser exactamente public static void main(String[] args).
• println añade un salto de línea; print no lo hace.

La aritmética de Java 算术 usa + - * / y % (residuo). Con dos ints, / es división entera 整数除法 — elimina la parte decimal. +=, -= y ++ son atajos.

public class Main {
    public static void main(String[] args) {
        int a = 7, b = 2;
        System.out.println(a / b);    // 3 (integer division)
        System.out.println(a % b);    // 1
        double x = 7.0 / 2;           // 3.5 (one side is double)
        System.out.println(x);
    }
}

Algunos valores son objetos 对象 con métodos. String tiene .length(), .substring(), .toUpperCase(). Math tiene Math.max, Math.sqrt, Math.pow. Las clases wrapper 包装类 (Integer, Double) envuelven un primitivo — por ejemplo, Integer.parseInt("42").

public class Main {
    public static void main(String[] args) {
        String s = "Hello";
        System.out.println(s.length());                  // 5
        System.out.println(s.toUpperCase());             // HELLO
        System.out.println(Math.max(3, 9));              // 9
        System.out.println(Integer.parseInt("42") + 1);  // 43
    }
}

Math.random() devuelve un aleatorio 随机 double desde 0.0 hasta (sin incluir) 1.0. Escálalo y conviértelo para obtener números enteros — esta es la idiomática AP:

public class Main {
    public static void main(String[] args) {
        // a random whole number from 1 to 6 (a dice roll)
        int roll = (int) (Math.random() * 6) + 1;
        System.out.println(roll >= 1 && roll <= 6);   // true
    }
}

• Integer.MAX_VALUE (2147483647) y Integer.MIN_VALUE son los límites de int; pasarlo hace que se reenvuelva (un desbordamiento).
• Una variable objeto que no apunta a ningún objeto contiene null; llamar un método sobre ella lanza un NullPointerException.

Un cast 强制转换 cambia el tipo de un valor. (int) elimina la parte decimal; (double) evita la división entera cuando necesitas un resultado exacto.

public class Main {
    public static void main(String[] args) {
        double pi = 3.99;
        System.out.println((int) pi);            // 3
        int total = 7, n = 2;
        System.out.println((double) total / n);  // 3.5
    }
}

Errores comunes

• División entera: 5 / 2 es 2, no 2.5. Castea primero: (double) 5 / 2.
• Compara Strings (y otros objetos) con .equals(), no con ==.
• == en dos objetos prueba si son el MISMO objeto, no si se ven iguales.

if ejecuta un bloque cuando una condición es verdadera; else if y else añaden más casos. La condición va entre paréntesis ( ), y el bloque entre llaves { }.

public class Main {
    public static void main(String[] args) {
        int score = 72;
        if (score >= 80) {
            System.out.println("A");
        } else if (score >= 60) {
            System.out.println("B");
        } else {
            System.out.println("fail");
        }
    }
}

Compare con ==, !=, <, >, <=, >= — una comparación devuelve un valor de tipo boolean. Combine con && (y), || (o), ! (no) — los operadores lógicos. Para objetos String, utilice .equals(...), no ==.

public class Main {
    public static void main(String[] args) {
        int age = 16;
        boolean member = true;
        System.out.println(age >= 18 && member);   // false
        String a = "hi";
        System.out.println(a.equals("hi"));        // true
    }
}

switch elige entre varios valores fijos. Cada case debe terminar con break; default sirve como opción por defecto.

public class Main {
    public static void main(String[] args) {
        int day = 3;
        switch (day) {
            case 1: System.out.println("Mon"); break;
            case 3: System.out.println("Wed"); break;
            default: System.out.println("other");
        }
    }
}

Errores comunes

• Una condición debe ser de tipo boolean; if (x = 5) no compila (utilice ==).
• Cada caso en un switch necesita un break;, de lo contrario el control caerá al siguiente caso.
• && y || son los operadores lógicos; & y | son operadores bit a bit.

Un bucle while se repite mientras una condición sea verdadera. Si no se modifica algo en su interior, el bucle se ejecutará indefinidamente.

public class Main {
    public static void main(String[] args) {
        int n = 1;
        while (n <= 3) {
            System.out.println(n);
            n++;
        }
    }
}

Un bucle for agrupa el inicio, la condición y el paso en una sola línea. Es ideal cuando se conoce la cantidad de iteraciones.

public class Main {
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            System.out.print(i + " ");
        }
        System.out.println();   // 0 1 2 3 4
    }
}

El patrón del acumulador: iniciar una variable antes del bucle y luego actualizarla en cada vuelta.

public class Main {
    public static void main(String[] args) {
        int total = 0;
        for (int i = 1; i <= 5; i++) {
            total += i;
        }
        System.out.println(total);   // 15
    }
}

Un bucle dentro de otro es un bucle anidado. El bucle interno se ejecuta completamente en cada vuelta del bucle externo.

public class Main {
    public static void main(String[] args) {
        for (int r = 0; r < 3; r++) {
            for (int c = 0; c < 3; c++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

Errores comunes

• for (int i = 0; i < n; i++) se ejecuta n veces (0 a n - 1); usar <= ejecuta una vez más.
• No coloque un punto y coma inmediatamente después de for (...) o while (...), ya que esto crea un bucle vacío.
• Declare el contador en el encabezado del for para que su alcance termine junto con el bucle.

Una String cadena es texto. Métodos útiles: .length(), .charAt(i), .substring(a, b), .indexOf(x), .toUpperCase(), .equals(...). Las cadenas son inmutables — cada método devuelve una nueva String.

public class Main {
    public static void main(String[] args) {
        String s = "Python";
        System.out.println(s.length());          // 6
        System.out.println(s.charAt(0));         // P
        System.out.println(s.substring(0, 3));   // Pyt
        System.out.println(s.toUpperCase());     // PYTHON
    }
}

Los métodos que usarás a diario:

compareTo coloca las cadenas de texto en orden alfabético — el examen AP lo utiliza para preguntas de clasificación:

public class Main {
    public static void main(String[] args) {
        String a = "apple", b = "banana";
        System.out.println(a.compareTo(b) < 0);    // true (apple comes first)
        System.out.println(a.compareTo("apple"));  // 0 (equal)
    }
}

Une cadenas con + (concatenación). Visita cada carácter mediante un bucle y .charAt(i).

public class Main {
    public static void main(String[] args) {
        String word = "banana";
        int count = 0;
        for (int i = 0; i < word.length(); i++) {
            if (word.charAt(i) == 'a') count++;
        }
        System.out.println(count);   // 3
    }
}

Al construir una cadena larga dentro de un bucle, StringBuilder es mucho más rápido: se concatenan las piezas y luego se llama a .toString() una sola vez.

public class Main {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        for (int i = 1; i <= 5; i++) {
            sb.append(i).append(" ");
        }
        System.out.println(sb.toString().trim());   // 1 2 3 4 5
    }
}

Errores comunes

• Las cadenas son inmutables: s.toUpperCase() devuelve una nueva cadena, por lo que debe almacenar el resultado.
• Lea un carácter con s.charAt(i); la longitud es s.length() (un método, con ()).
• Construir una cadena con += en un bucle grande es lento; utilice un StringBuilder.

Un array 数组 contiene un número fijo de valores de un mismo tipo. Los índices comienzan en 0, y se obtiene el tamaño con .length.

public class Main {
    public static void main(String[] args) {
        int[] scores = {88, 71, 95};
        System.out.println(scores[0]);       // 88
        System.out.println(scores.length);   // 3
        scores[1] = 100;
        System.out.println(scores[1]);       // 100
    }
}

Recorra el array con un bucle para encontrar un máximo, un total, un conteo o para buscar 查找. Un bucle for-each (for (int x : a)) lee cada valor por turno.

public class Main {
    public static void main(String[] args) {
        int[] a = {3, 9, 2, 7};
        int max = a[0], total = 0;
        for (int x : a) {
            if (x > max) max = x;
            total += x;
        }
        System.out.println(max + " " + total);   // 9 21
    }
}

Un array 2-D 二维数组 es una cuadrícula 网格 de filas y columnas: grid[row][col].

public class Main {
    public static void main(String[] args) {
        int[][] grid = {{1, 2, 3}, {4, 5, 6}};
        System.out.println(grid[1][2]);   // 6
        for (int[] row : grid) {
            for (int v : row) System.out.print(v + " ");
        }
        System.out.println();             // 1 2 3 4 5 6
    }
}

Errores comunes

• El tamaño de un array es a.length (sin corchetes, sin ()), y es fijo cuando se crea.
• Los índices válidos van de 0 a a.length - 1; a[a.length] lanza ArrayIndexOutOfBoundsException.
• Un nuevo int[5] se rellena con ceros, no queda vacío.

Un ArrayList es una lista de tamaño variable — crece y se encoge a medida que agregas o eliminas elementos. Almacena objetos, por lo que debes usar un tipo envoltorio (wrapper) como Integer (no int). La parte <Integer> es un tipo genérico (generic type). Métodos clave: .add(x), .get(i), .set(i, x), .size(), .remove(i).

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        ArrayList<Integer> nums = new ArrayList<Integer>();
        nums.add(10);
        nums.add(20);
        nums.add(30);
        System.out.println(nums.size());   // 3
        System.out.println(nums.get(1));   // 20
        nums.set(0, 99);
        System.out.println(nums);          // [99, 20, 30]
    }
}

.remove(i) desplaza cada elemento posterior un lugar hacia la izquierda. Si eliminas mientras cuentas i hacia arriba, omitirás el siguiente elemento. Solución: recorre el bucle hacia atrás, o no incrementes i después de una eliminación.

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        ArrayList<Integer> nums = new ArrayList<Integer>();
        for (int n : new int[]{4, 7, 4, 9, 4}) nums.add(n);
        // Remove every 4 — loop backwards so removals don't skip items.
        for (int i = nums.size() - 1; i >= 0; i--) {
            if (nums.get(i) == 4) nums.remove(i);
        }
        System.out.println(nums);   // [7, 9]
    }
}

Errores comunes

• ArrayList utiliza .size(), .get(i) y .add(...) — no los corchetes [] que usas en los arrays.
• Eliminar elementos mientras se itera hacia adelante por índice omite el siguiente elemento (el error de remove). Recorre hacia atrás, o usa un iterator.
• Almacena objetos, no primitivas: usa ArrayList<Integer>, y Java hace el autoboxing automático de valores int.

Una clase (class) es un plano para objetos. Sus campos (fields) almacenan datos, su constructor (constructor) configura un nuevo objeto, y sus métodos (methods) son las acciones. this.name significa "el campo name de este objeto". Crea un objeto con new.

public class Main {
    public static void main(String[] args) {
        Dog d = new Dog("Rex", 3);
        System.out.println(d.describe());   // Rex is 3 years old
        d.haveBirthday();
        System.out.println(d.describe());   // Rex is 4 years old
    }
}

class Dog {
    private String name;
    private int age;

    public Dog(String name, int age) {   // constructor
        this.name = name;
        this.age = age;
    }

    public String describe() {
        return name + " is " + age + " years old";
    }

    public void haveBirthday() {
        age++;
    }
}

Un miembro static pertenece a la propia clase, no a ningún objeto en particular. Llama a un método estático usando el nombre de la clase —como Math.max—, y un campo estático es compartido por todos los objetos:

public class Main {
    public static void main(String[] args) {
        System.out.println(Counter.made());   // 0
        new Counter();
        new Counter();
        System.out.println(Counter.made());   // 2
    }
}

class Counter {
    private static int count = 0;      // shared by ALL Counter objects

    public Counter() { count++; }

    public static int made() {         // called on the class: Counter.made()
        return count;
    }
}

El encapsulamiento (encapsulation) significa ocultar los datos detrás de métodos. Marca los campos como private para que el código externo no pueda acceder a ellos directamente; expón un accesor (getter) para leerlos y un método para cambiarlos de forma segura. El método puede proteger los datos —aquí, un depósito debe ser positivo.

public class Main {
    public static void main(String[] args) {
        Account a = new Account(100);
        a.deposit(50);
        a.deposit(-999);                       // rejected by the guard
        System.out.println(a.getBalance());    // 150
    }
}

class Account {
    private int balance;                       // hidden from outside

    public Account(int start) {
        balance = start;
    }

    public void deposit(int amount) {
        if (amount > 0) balance += amount;     // guard keeps balance valid
    }

    public int getBalance() {                  // accessor (getter)
        return balance;
    }
}

Errores comunes

• Un constructor tiene el nombre de la clase y no tiene tipo de retorno (ni siquiera void).
• Usa this.field para distinguir un campo de un parámetro con el mismo nombre.
• Define los campos como private y accede a ellos mediante métodos getter/setter (encapsulamiento).

La herencia (Inheritance) permite que una subclase reutilice un superclase. Escribe class Cat extends Animal y Cat obtendrá los campos y métodos de Animal gratuitamente. Llama al constructor del padre con super(...).

public class Main {
    public static void main(String[] args) {
        Cat c = new Cat("Milo");
        c.eat();      // Milo is eating  (inherited from Animal)
        c.speak();    // Meow            (Cat's own method)
    }
}

class Animal {
    protected String name;
    public Animal(String name) { this.name = name; }
    public void eat() { System.out.println(name + " is eating"); }
}

class Cat extends Animal {
    public Cat(String name) { super(name); }     // call Animal's constructor
    public void speak() { System.out.println("Meow"); }
}

Una subclase puede sobrescribir un método para reemplazar la versión del padre. El polimorfismo significa que una variable Shape puede contener cualquier subtipo, y Java elige el toString correcto en tiempo de ejecución. System.out.println(obj) llama automáticamente a obj.toString().

public class Main {
    public static void main(String[] args) {
        Shape[] shapes = { new Circle(2), new Square(3) };
        for (Shape s : shapes) {
            System.out.println(s);          // each calls its own toString
        }
    }
}

class Shape {
    public String toString() { return "a shape"; }
}

class Circle extends Shape {
    private int r;
    public Circle(int r) { this.r = r; }
    public String toString() { return "Circle r=" + r; }     // override
}

class Square extends Shape {
    private int side;
    public Square(int side) { this.side = side; }
    public String toString() { return "Square side=" + side; }   // override
}

Errores comunes

• Un método que sobrescribe debe coincidir exactamente con la firma; añade @Override para que el compilador detecte errores.
• super(...) debe ser la primera línea de un constructor de subclase.
• Un objeto de subclase ES UN objeto de superclase, pero no al revés.

La recursión 递归 es un método que se llama a sí mismo. Toda recursión necesita un caso base 基准情形 (cuándo detenerse) y una llamada recursiva 递归调用 que la acerque a ese caso. Sin un caso base, nunca se detiene y falla con un desbordamiento de pila (stack overflow).

public class Main {
    public static void main(String[] args) {
        System.out.println(factorial(5));   // 120
    }

    public static int factorial(int n) {
        if (n <= 1) return 1;            // base case
        return n * factorial(n - 1);     // recursive call: n * (n-1)!
    }
}

Rastrea el proceso: factorial(5) espera a factorial(4), que espera a factorial(3)… hasta que factorial(1) retorna 1. Luego las respuestas se multiplican hacia arriba: 1 → 2 → 6 → 24 → 120.

La recursión también funciona con Cadenas — separa un carácter por llamada:

public class Main {
    public static void main(String[] args) {
        System.out.println(reverse("PYTHON"));   // NOHTYP
    }

    static String reverse(String s) {
        if (s.length() <= 1) return s;               // base case
        return reverse(s.substring(1)) + s.charAt(0);
    }
}

Merge sort 归并排序 es el ordenamiento recursivo en el examen AP: divide el array a la mitad, ordena cada mitad recursivamente, luego fusiona 合并 las dos mitades ordenadas. Ejecuta en O(n log n) — mucho más rápido que los ordenamientos O(n²) en arrays grandes.

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] a = {5, 2, 9, 1, 7, 3};
        mergeSort(a, 0, a.length - 1);
        System.out.println(Arrays.toString(a));   // [1, 2, 3, 5, 7, 9]
    }

    static void mergeSort(int[] a, int lo, int hi) {
        if (lo >= hi) return;                 // base case: one element
        int mid = (lo + hi) / 2;
        mergeSort(a, lo, mid);                // sort the left half
        mergeSort(a, mid + 1, hi);            // sort the right half
        merge(a, lo, mid, hi);                // merge the two halves
    }

    static void merge(int[] a, int lo, int mid, int hi) {
        int[] tmp = new int[hi - lo + 1];
        int i = lo, j = mid + 1, k = 0;
        while (i <= mid && j <= hi) {
            if (a[i] <= a[j]) tmp[k++] = a[i++];
            else              tmp[k++] = a[j++];
        }
        while (i <= mid) tmp[k++] = a[i++];
        while (j <= hi)  tmp[k++] = a[j++];
        for (k = 0; k < tmp.length; k++) a[lo + k] = tmp[k];
    }
}

Errores comunes

• La recursión necesita un caso base, o lanzará StackOverflowError.
• Cada llamada recursiva debe acercarse MÁS al caso base.
• Rastrea un ejemplo pequeño a mano para verificar que la recursión retorna el valor correcto.
• En merge sort, el paso de fusión hace el trabajo real; la recursión solo divide el array.

La búsqueda lineal 线性查找 revisa cada elemento — funciona con cualquier arreglo. La búsqueda binaria 二分查找 es mucho más rápida, pero necesita un arreglo ordenado 已排序: examina el elemento central y descarta la mitad del rango en cada paso. Ambas devuelven el índice, o -1 si no se encuentra.

public class Main {
    public static void main(String[] args) {
        int[] a = {2, 5, 8, 12, 16, 23};      // sorted, so binary search works
        System.out.println(linear(a, 12));    // 3
        System.out.println(binary(a, 12));    // 3
        System.out.println(binary(a, 9));     // -1 (not found)
    }

    static int linear(int[] a, int target) {
        for (int i = 0; i < a.length; i++)
            if (a[i] == target) return i;
        return -1;
    }

    static int binary(int[] a, int target) {
        int lo = 0, hi = a.length - 1;
        while (lo <= hi) {
            int mid = (lo + hi) / 2;
            if (a[mid] == target) return mid;
            else if (a[mid] < target) lo = mid + 1;
            else hi = mid - 1;
        }
        return -1;
    }
}

El ordenamiento por selección 选择排序 encuentra repetidamente el valor restante más pequeño y lo intercambia hacia el principio. El ordenamiento por inserción 插入排序 toma cada valor y lo desliza hacia atrás para colocarlo entre los valores ya ordenados.

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] a = {5, 2, 9, 1, 7};
        for (int i = 0; i < a.length - 1; i++) {
            int min = i;
            for (int j = i + 1; j < a.length; j++)
                if (a[j] < a[min]) min = j;
            int t = a[min]; a[min] = a[i]; a[i] = t;   // swap into place
        }
        System.out.println(Arrays.toString(a));   // [1, 2, 5, 7, 9]
    }
}

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] a = {5, 2, 9, 1, 7};
        for (int i = 1; i < a.length; i++) {
            int key = a[i], j = i - 1;
            while (j >= 0 && a[j] > key) {    // shift bigger values right
                a[j + 1] = a[j];
                j--;
            }
            a[j + 1] = key;                  // drop key into the gap
        }
        System.out.println(Arrays.toString(a));   // [1, 2, 5, 7, 9]
    }
}

Comparación de velocidades:

Errores comunes

• La búsqueda binaria solo funciona en un arreglo ordenado.
• La búsqueda lineal es O(n); la búsqueda binaria es O(log n) pero requiere primero el ordenamiento.
• El ordenamiento por selección y por inserción son O(n²) — fáciles de aprender, lentos con grandes volúmenes de datos.

Un Scanner lee texto línea por línea. Para un archivo real, se escribe new Scanner(new File("scores.txt")); aquí enmarcamos un String para que el ejemplo funcione en cualquier lugar. Use .split(" ") para dividir una línea en partes y Integer.parseInt(...) para analizar un número a partir de texto.

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        // Real file:  Scanner in = new Scanner(new File("scores.txt"));
        String data = "Alice 80\nBob 95\nCara 72";
        Scanner in = new Scanner(data);
        int total = 0, count = 0;
        while (in.hasNextLine()) {
            String line = in.nextLine();
            String[] parts = line.split(" ");      // break the line on the space
            total += Integer.parseInt(parts[1]);
            count++;
        }
        System.out.println("average = " + (total / count));   // average = 82
    }
}

El examen de AP CS A tiene cuatro preguntas de respuesta libre, cada una con una forma fija:

• P1 — Métodos y control: escribir métodos según una especificación dada; bucles, if, String/Math.
• P2 — Diseño de clases: escribir una clase completa (campos, constructor, métodos) a partir de una descripción.
• P3 — Arreglo / ArrayList: procesar un arreglo 1-D o ArrayList (búsqueda, conteo, construir una nueva lista).
• P4 — Arreglo 2-D: recorrer una cuadrícula por fila y columna.

La habilidad siempre es la misma: leer la especificación, escribir el método exactamente como se describe y devolver el tipo correcto.

public class Main {
    public static void main(String[] args) {
        // Q1 style: implement a method to a spec, then it is tested.
        System.out.println(countEven(new int[]{4, 7, 10, 3, 6}));   // 3
    }

    /** Returns how many values in arr are even. */
    public static int countEven(int[] arr) {
        int count = 0;
        for (int x : arr)
            if (x % 2 == 0) count++;
        return count;
    }
}

Errores comunes

• nextInt() deja el salto de línea pendiente, por lo que un nextLine() posterior lee una línea vacía; léala primero para eliminarla.
• Verifique hasNext() antes de leer, para evitar excederse al final del archivo.
• En el FRQ, lea cuidadosamente el encabezado del método: coincida exactamente con el tipo de retorno y los parámetros.