AP Computer Science A — Code Patterns Checklist

public class Student {
    private String name;
    private int grade;

    // constructor — same name as class, no return type
    public Student(String name, int grade) {
        this.name = name;
        this.grade = grade;
    }
}

• public class + 클래스명 일치
• 생성자는 return type 없음 (void도 안 씀)
• 매개변수 == 필드명일 때 this. 필수

public class Book {
    private String title;
    private int pages;

    // no-arg constructor
    public Book() {
        this.title = "Untitled";
        this.pages = 0;
    }

    // parameterized constructor
    public Book(String title, int pages) {
        this.title = title;
        this.pages = pages;
    }
}

// instance method — needs object
public boolean isPassing() {
    return grade >= 60;
}

// static method — no object needed
public static int max(int a, int b) {
    if (a > b) return a;
    return b;
}

• public 키워드 빠뜨리면 컴파일 X (FRQ 자동 감점)
• return type과 실제 반환 타입 일치 (cast 필요시 명시)
• void가 아니면 모든 분기에서 return

// sum 1 to n (inclusive)
int sum = 0;
for (int i = 1; i <= n; i++) {
    sum += i;
}

• < vs <= 정확히 (off-by-one 검증)
• 인덱스 변수 선언 위치 (int i) — for문 안에서 선언 권장
• update 누락 시 무한 루프

// halve until below 1
double x = 100.0;
int count = 0;
while (x >= 1.0) {
    x = x / 2;
    count++;
}

• 조건이 false가 되는 시점 명확히
• update statement 누락 = 무한 루프
• 초기화 변수는 while 바깥에 선언

// sum array values — read-only iteration
int total = 0;
for (int n : nums) {
    total += n;
}

• 컬렉션 안 element 타입과 변수 타입 일치
• 요소 수정 / 삭제가 필요하면 표준 for 사용
• 인덱스가 필요하면 표준 for 사용

if (score >= 90) {
    grade = "A";
} else if (score >= 80) {
    grade = "B";
} else {
    grade = "F";
}

• 대입 = vs 비교 == 구분
• String/Object 비교는 .equals() (절대 == X)
• else if 순서 — 위에서부터 평가

int[] arr = new int[5];
for (int i = 0; i < arr.length; i++) {
    arr[i] = i * i;  // 0, 1, 4, 9, 16
}

• arr.length (속성) — 괄호 X
• 인덱스 범위 0 ~ arr.length - 1
• String 배열은 String[] s = new String[n]; → 모두 null

ArrayList<Integer> nums = new ArrayList<>();
nums.add(10);
nums.add(20);
nums.set(0, 99);  // nums = [99, 20]
nums.remove(0);     // nums = [20]; indices shift
int n = nums.size();

• 제네릭은 wrapper (Integer/Double/Boolean) — primitive 불가
• .size() 메서드 (괄호 필수) vs 배열 .length
• .remove(i) 후 인덱스가 앞으로 시프트

// WRONG — for-each + remove → ConcurrentModificationException
// for (int x : list) if (x % 2 == 0) list.remove(...);

// RIGHT — backwards index loop
ArrayList<Integer> list = ...;
for (int i = list.size() - 1; i >= 0; i--) {
    if (list.get(i) % 2 == 0) {
        list.remove(i);
    }
}

// row-major traversal — sum all elements
int[][] grid = new int[3][4];
int sum = 0;
for (int r = 0; r < grid.length; r++) {
    for (int c = 0; c < grid[0].length; c++) {
        sum += grid[r][c];
    }
}

• grid.length = 행 수 / grid[0].length = 열 수
• row-major 순회: 바깥 = 행, 안쪽 = 열
• 2D for-each: for (int[] row : grid) for (int x : row)

public static int factorial(int n) {
    if (n <= 1) return 1;          // base case
    return n * factorial(n - 1); // recursive case → converges to n=1
}

• Base case 명시 (n <= 1 등)
• 재귀 호출이 base case로 수렴 (n - 1, n / 2 등)
• return 값 정확 (factorial은 1, sum은 0)

public class Vehicle {
    private int wheels;
    public Vehicle(int wheels) { this.wheels = wheels; }
}

public class Car extends Vehicle {
    private String model;
    public Car(String model) {
        super(4);  // must be FIRST line
        this.model = model;
    }
}

• super(...)는 생성자 첫 줄에만 가능
• 부모에 no-arg constructor 없으면 자식에서 super(...) 명시 필수
• private 필드는 직접 접근 불가 → getter 사용

public class Score implements Comparable<Score> {
    private int value;

    public Score(int value) { this.value = value; }

    public int compareTo(Score other) {
        return this.value - other.value;  // neg / 0 / pos
    }
}

• interface의 모든 메서드 구현 (안 하면 컴파일 X)
• compareTo 반환은 음수(less) / 0(equal) / 양수(greater)
• 제네릭 Comparable<Score> 명시

Object obj = "hello";
if (obj instanceof String) {
    String s = (String) obj;     // safe downcast
    System.out.println(s.length());
}

• downcast 전 instanceof로 안전 체크
• 호출 메서드는 실제 객체 타입의 override 버전 (dynamic dispatch)
• 접근 가능한 멤버는 참조 타입에 따름 (정적)

String s = "hello";
int n   = s.length();        // 5
String t = s.substring(1, 4);  // "ell"
int p   = s.indexOf("l");     // 2
char c  = s.charAt(0);       // 'h'
boolean b = s.equals("hello"); // true

• substring(i, j)는 [i, j) 반-개구간 (j 미포함)
• charAt 반환은 char (String 아님!)
• String 비교는 항상 .equals()

int a = Math.abs(-5);              // 5
double p = Math.pow(2, 10);         // 1024.0
int q = (int) Math.pow(2, 10);   // 1024 — cast required
double r = Math.sqrt(16);            // 4.0

// random integer in [low, high]
int rand = (int)(Math.random() * (high - low + 1)) + low;

• Math.pow 반환 = double (int에 대입하려면 cast)
• Math.random()은 < 1.0 (1.0 미포함)
• 정수 범위 [low, high] 랜덤 공식 암기

// NPE example — uninitialized String[]
String[] words = new String[3];
words[0].length();  // NullPointerException — words[0] is null

// AIOOBE example
int[] arr = {1, 2, 3};
int x = arr[3];   // ArrayIndexOutOfBoundsException

// ArithmeticException — int only
int y = 5 / 0;     // ArithmeticException

• 각 예외의 발생 조건 한 줄 암기 (MCQ 빈출)
• FRQ에서 try/catch는 출제 안 됨 — 발생 조건만 알면 됨
• NPE 방지: 객체 사용 전 null 체크

String a = new String("hi");
String b = new String("hi");

boolean x = (a == b);         // false — different memory
boolean y = a.equals(b);     // true  — same content

// primitive — == is correct
int p = 5, q = 5;
boolean z = (p == q);         // true

• primitive: == / 객체: .equals()
• String literal끼리 ==는 종종 true (string pool) — 운에 의존하지 말 것
• 사용자 정의 클래스에서 .equals() override 안 하면 Object의 == 동작