🗂️ CED V.1 4 Units — 옛 10-Unit 체계 매핑

아래 카드의 옛 Unit 1~10은 본 cheat sheet 내 토픽 분류용. 2026 시험은 CED V.1 4-Unit 체계로 출제되므로 옛 Unit ↔ CED V.1 매핑을 우선 확인하라. 비중 표기: 15-25% / 25-35% / 10-18% / 30-40% (각각 Unit 1·2·3·4).

FRQ 4문항 매핑: Q1 Methods and Control Structures (Unit 1·2 통합, 7점) · Q2 Class Design (Unit 3, 7점) · Q3 Data Analysis with ArrayList (Unit 4, 5점) · Q4 2D Array (Unit 4, 6점) = 25점. 모두 Practice 2 평가.

🛠️ 5 Computational Thinking Practices (Big Idea 역할)

📝 3 Task Verbs (CED p.148)

• Assume — 증명·검증 없이 사실로 받아들임 (불필요한 if 검증 안 씀)
• Complete (program code) — 빈칸만 정확히 채움 (주변 코드 변경 금지)
• Implement / Write — 처음부터 끝까지 정확한 Java 코드 (class header, instance vars, constructor, method 모두)

기본 자료형 (Primitive Types)

Type Casting (형변환)

// int → double: 자동 변환 (widening)
int a = 5;
double b = a;  // b = 5.0

// double → int: 명시적 캐스팅 필요 (narrowing, 소수점 버림)
double x = 9.7;
int y = (int) x;  // y = 9 (반올림 아님!)

// 정수 나눗셈 주의!
int result = 7 / 2;       // result = 3 (정수끼리 → 정수)
double result2 = 7.0 / 2; // result2 = 3.5
double result3 = (double) 7 / 2; // result3 = 3.5

Integer Overflow

int max = Integer.MAX_VALUE;  // 2147483647
System.out.println(max + 1); // -2147483648 (overflow!)

연산자 우선순위 (시험 빈출)

String 메서드 (필수 암기)

String a = new String("hi");
String b = new String("hi");
a == b       // false (다른 객체)
a.equals(b)  // true  (같은 내용)

Math 클래스

Wrapper Classes

Integer num = new Integer(5);  // deprecated, but may appear
Integer num2 = 5;              // autoboxing
int val = num2;                 // unboxing
Integer.MAX_VALUE               // 2147483647
Integer.MIN_VALUE               // -2147483648

비교 연산자

if / else if / else 구조

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

논리 연산자 & Short-Circuit Evaluation

if (str != null && str.length() > 0) { ... }
// str이 null이면 &&에서 short-circuit → length() 호출 안 함

DeMorgan's Law (드모르간 법칙) ⭐ 매년 출제

기억법: NOT을 분배하면 && ↔ || 뒤집힘!

// 예시: "18세 미만이 아니고 65세 이상이 아닌" 사람
!(age < 18 || age >= 65)
// 드모르간 적용:
age >= 18 && age < 65

Compound Boolean 함정 문제

// 범위 체크: 1 <= x <= 10 (수학 표기)
// Java에서는:
x >= 1 && x <= 10   // ✅ 올바른 방법
1 <= x <= 10         // ❌ 컴파일 에러 또는 잘못된 결과

while 루프

int count = 0;
while (count < 5) {
    System.out.println(count);
    count++;  // 이걸 빼먹으면 무한루프!
}

for 루프

// 기본 구조: for(초기화; 조건; 갱신)
for (int i = 0; i < n; i++) {
    // i: 0, 1, 2, ..., n-1  (총 n번)
}

// 역순
for (int i = n - 1; i >= 0; i--) {
    // i: n-1, n-2, ..., 0
}

Off-by-One Errors (1 차이 오류) ⭐ 최다 함정

Nested Loops (중첩 루프)

// 구구단 출력 패턴
for (int i = 1; i <= 9; i++) {
    for (int j = 1; j <= 9; j++) {
        System.out.print(i * j + " ");
    }
    System.out.println();
}
// 바깥 루프 1회 = 안쪽 루프 전체 실행
// 총 실행 횟수 = 9 × 9 = 81회

Loop Tracing (추적) 기법

// 문제: 출력값은?
int s = 0;
for (int i = 1; i <= 4; i++) {
    s += i;
}
// 추적: i=1,s=1 → i=2,s=3 → i=3,s=6 → i=4,s=10
// 답: s = 10

String 순회 패턴

String str = "Hello";
// 각 문자 접근
for (int i = 0; i < str.length(); i++) {
    char c = str.charAt(i);
}

// 역순 출력
String reversed = "";
for (int i = str.length() - 1; i >= 0; i--) {
    reversed += str.charAt(i);
}

빈출 루프 패턴

int sum = 0;
for (int v : arr)
    sum += v;
double avg = (double)sum / arr.length;

int max = arr[0];
for (int v : arr)
    if (v > max) max = v;

클래스 기본 구조

public class Student {
    // Instance variables (private!)
    private String name;
    private int grade;
    private static int count = 0; // 클래스 변수

    // Constructor (생성자)
    public Student(String name, int grade) {
        this.name = name;
        this.grade = grade;
        count++;
    }

    // Accessor (getter)
    public String getName() { return name; }

    // Mutator (setter)
    public void setGrade(int g) { grade = g; }

    // toString
    public String toString() {
        return name + ": " + grade;
    }

    // Static method
    public static int getCount() { return count; }
}

static vs instance

this 키워드

Encapsulation (캡슐화)

배열 선언 & 초기화

// 방법 1: 크기 지정 (기본값으로 초기화)
int[] arr = new int[5]; // {0, 0, 0, 0, 0}

// 방법 2: 초기값 지정
int[] arr = {1, 2, 3, 4, 5};

// 길이: arr.length (메서드 아님! 괄호 없음!)

배열 순회

// 인덱스 기반 (값 수정 가능)
for (int i = 0; i < arr.length; i++) {
    arr[i] = arr[i] * 2;
}

// enhanced for-loop (읽기 전용)
for (int val : arr) {
    System.out.println(val);
    // val을 수정해도 원본 배열은 변하지 않음!
}

핵심 배열 알고리즘

int sum = 0;
for (int v : arr) sum += v;
double avg = (double) sum / arr.length;

int max = arr[0];
for (int i = 1; i < arr.length; i++)
    if (arr[i] > max) max = arr[i];

int count = 0;
for (int v : arr)
    if (v == target) count++;

int first = arr[0];
for (int i = 0; i < arr.length-1; i++)
    arr[i] = arr[i+1];
arr[arr.length-1] = first;

ArrayList 메서드

// ❌ 잘못된 방법 - 요소를 건너뜀!
for (int i = 0; i < list.size(); i++) {
    if (list.get(i).equals("remove")) {
        list.remove(i);  // 삭제 후 뒤 요소가 앞으로 이동
    }                     // 다음 i++로 하나 건너뜀!
}

// ✅ 방법 1: 뒤에서부터 순회
for (int i = list.size() - 1; i >= 0; i--) {
    if (list.get(i).equals("remove"))
        list.remove(i);
}

// ✅ 방법 2: 삭제 후 i-- (또는 i 그대로 유지)
for (int i = 0; i < list.size(); i++) {
    if (list.get(i).equals("remove")) {
        list.remove(i);
        i--;  // 인덱스 보정
    }
}

ArrayList vs Array

2D 배열 선언

int[][] grid = new int[3][4]; // 3행 4열
int[][] grid = {{1,2,3}, {4,5,6}}; // 2행 3열

grid.length     // 행(row) 수
grid[0].length  // 열(column) 수

Row-Major 순회 (행 우선) ⭐ 기본 패턴

for (int r = 0; r < grid.length; r++) {
    for (int c = 0; c < grid[r].length; c++) {
        System.out.print(grid[r][c] + " ");
    }
    System.out.println();
}
// 출력: 1 2 3
//       4 5 6

Column-Major 순회 (열 우선)

for (int c = 0; c < grid[0].length; c++) {
    for (int r = 0; r < grid.length; r++) {
        System.out.print(grid[r][c] + " ");
    }
    System.out.println();
}
// 출력: 1 4
//       2 5
//       3 6

Enhanced For-Loop (2D)

for (int[] row : grid) {
    for (int val : row) {
        System.out.print(val + " ");
    }
}

빈출 2D 알고리즘

for (int r = 0; r < grid.length; r++) {
    int rowSum = 0;
    for (int c = 0; c < grid[r].length; c++)
        rowSum += grid[r][c];
}

for (int c = 0; c < grid[0].length; c++) {
    int colSum = 0;
    for (int r = 0; r < grid.length; r++)
        colSum += grid[r][c];
}

상속 기본

public class Animal {
    private String name;
    public Animal(String name) { this.name = name; }
    public String speak() { return "..."; }
    public String getName() { return name; }
}

public class Dog extends Animal {
    public Dog(String name) {
        super(name);  // 반드시 첫 줄!
    }

    @Override
    public String speak() { return "Woof!"; }
}

핵심 규칙

Polymorphism (다형성) ⭐

Animal a = new Dog("Rex");
a.speak();  // "Woof!" — 런타임에 실제 객체 타입의 메서드 실행

// 컴파일 타입 vs 런타임 타입
// 컴파일: Animal → Animal 메서드만 호출 가능
// 런타임: Dog → Dog에서 override된 메서드 실행

Object 클래스

모든 클래스는 Object를 자동 상속. toString()과 equals()를 override하여 사용.

재귀 구조

public static int factorial(int n) {
    // Base case (기저 조건) — 반드시 필요!
    if (n == 0 || n == 1) return 1;

    // Recursive case (재귀 호출)
    return n * factorial(n - 1);
}

재귀 추적 방법

// factorial(4) 추적:
factorial(4)
  = 4 * factorial(3)
  = 4 * 3 * factorial(2)
  = 4 * 3 * 2 * factorial(1)
  = 4 * 3 * 2 * 1
  = 24

빈출 재귀 패턴

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

public static int power(int b, int e) {
    if (e == 0) return 1;
    return b * power(b, e - 1);
}

public static int binSearch(
    int[] a, int lo, int hi, int t) {
  if (lo > hi) return -1;
  int mid = (lo + hi) / 2;
  if (a[mid] == t) return mid;
  if (a[mid] < t)
    return binSearch(a, mid+1, hi, t);
  return binSearch(a, lo, mid-1, t);
}

public static int sum(int[] a, int i) {
    if (i < 0) return 0;
    return a[i] + sum(a, i - 1);
}

재귀 vs 반복

Type 1: Methods & Control Structures

// 패턴: if/else + 루프 조합
public returnType methodName(parameters) {
    // 결과 변수 초기화
    for (순회 조건) {
        if (조건) {
            // 처리
        }
    }
    return result;
}

Type 2: Class Design (클래스 설계)

public class ClassName {
    // 1. private instance variables
    private Type var1;
    private Type var2;

    // 2. Constructor
    public ClassName(Type param1, Type param2) {
        var1 = param1;
        var2 = param2;
    }

    // 3. Methods (문제에서 요구하는 것들)
    public Type methodName() {
        // 구현
    }
}

Type 3: Array / ArrayList

// 패턴: 순회 → 조건 확인 → 수집/변환
public ArrayList<Type> filterMethod(Type[] arr) {
    ArrayList<Type> result = new ArrayList<>();
    for (Type item : arr) {
        if (조건) {
            result.add(변환(item));
        }
    }
    return result;
}

Type 4: 2D Array

// 패턴: 이중 루프 순회
public ReturnType process2D(int[][] grid) {
    for (int r = 0; r < grid.length; r++) {
        for (int c = 0; c < grid[r].length; c++) {
            // grid[r][c] 처리
        }
    }
}

FRQ 채점 팁

Binary Search (이진 탐색)

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

Selection Sort (선택 정렬)

// 매 단계마다 최솟값을 찾아 앞으로 이동
for (int i = 0; i < arr.length - 1; i++) {
    int minIdx = i;
    for (int j = i + 1; j < arr.length; j++) {
        if (arr[j] < arr[minIdx]) minIdx = j;
    }
    // swap
    int temp = arr[i];
    arr[i] = arr[minIdx];
    arr[minIdx] = temp;
}
// 시간: O(n²) 항상

Insertion Sort (삽입 정렬)

// 각 요소를 정렬된 부분의 올바른 위치에 삽입
for (int i = 1; i < arr.length; i++) {
    int key = arr[i];
    int j = i - 1;
    while (j >= 0 && arr[j] > key) {
        arr[j + 1] = arr[j];
        j--;
    }
    arr[j + 1] = key;
}
// 최선: O(n) 이미 정렬, 최악: O(n²)

Merge Sort (병합 정렬) — 개념만

정렬 비교표

String 메서드

int length()
String substring(int from, int to)  // from 포함, to 미포함
String substring(int from)
int indexOf(String str)
int compareTo(String other)
boolean equals(String other)

Math 메서드

static int abs(int x)
static double abs(double x)
static double pow(double base, double exponent)
static double sqrt(double x)
static double random()  // 0.0 <= x < 1.0

Integer 메서드

Integer.MIN_VALUE  // -2147483648
Integer.MAX_VALUE  // 2147483647

ArrayList 메서드

int size()
boolean add(E obj)
void add(int index, E obj)
E get(int index)
E set(int index, E obj)
E remove(int index)

List Interface

// 시험에서 사용 가능한 선언:
List<E> list = new ArrayList<E>();

✂️ 메서드 헤더 (-1점 단골)

• 문제지 헤더 그대로 복사 — public, 반환 타입, 메서드명, 파라미터 한 글자라도 달라도 -1점
• static 빠뜨리지 말 것 (정적 메서드일 때)
• 파라미터 순서와 타입 정확히

🚫 다른 클래스 인스턴스 변수 직접 접근 금지

// ❌ 직접 접근 — 감점
obj.score = 0;

// ✅ getter/setter 호출
obj.setScore(0);
int s = obj.getScore();

🔢 length / size / get / set 혼동

🔁 Boundary (경계) 명시

• i = 0; i < arr.length ← 표준
• i <= arr.length-1 ← 동등하지만 가독성 ↓
• i <= arr.length ← 버그 (IndexOutOfBoundsException)

↩️ return 누락

• 반환 타입이 있는 메서드(void 아님)는 모든 경로에서 return 필수
• if/else 분기 둘 다 return 있어야 함

📦 부분 점수 노리기

public int countX(String s) {
    // 시간 없으면 일단 헤더 + return 만 쓰기
    int count = 0;
    return count;
}

📲 시험 형식 (2026년 기준)

• Bluebook 앱 으로 PC/iPad 응시 (학교 지정 환경)
• Section I — Multiple-Choice 42문항 / 90 minutes / 55%
• Section II — Free-Response 4문항 / 90 minutes / 45% (총 25점)
• 전체 시험 시간: 3시간 (180분)
• FRQ 답안은 키보드로 코드 입력 (들여쓰기·괄호 자동완성 없음)

📖 Quick Reference 항상 열람 가능

• String, Math, ArrayList, Object 메서드 시그니처가 시험 중 내장으로 제공됨
• 완벽 암기 부담 ↓ — 하지만 어디 있는지 미리 알아두기
• College Board 공식 PDF: apcentral.collegeboard.org/courses/ap-computer-science-a/exam

⌨️ 디지털 FRQ 환경 팁

• 들여쓰기는 스페이스 4칸 또는 탭 직접 입력. IDE 처럼 자동 안 됨
• 복사·붙여넣기 가능 — 메서드 헤더 문제지에서 복사해서 붙여 쓰면 헤더 오류 방지
• 저장은 자동 — 진행 중 자동 저장됨
• 코드 색상 강조 없음 — 변수명·키워드 직접 확인

⏰ 시간 분배