int age = 25;           // 정수
double height = 175.5;  // 소수점이 있는 수
char grade = 'A';       // 문자 하나
boolean pass = true;    // 참/거짓
long big = 3000000000L; // int 범위(약 21억) 초과 시 반드시 L을 붙임

이 규칙은 객체 배열, 메서드 매개변수 전달 문제에서 반복 출제됩니다.

byte → short → int → long → float → double
//              ↑ char도 int 단계에서 합류

int a = 10;
double b = a;   // int → double 자동. b = 10.0
char c = 'A';
int num = c;    // char → int 자동. num = 65

double pi = 3.14;
int n1 = (int) pi;     // 3 (반올림 아님, 소수점 이하 버림)
int n2 = (int) 3.99;   // 3
char ch = (char) 65;   // 'A'

System.out.println(1 + 2);         // 3   (숫자 + 숫자)
System.out.println("A" + 1);       // A1  (문자열 + 숫자)
System.out.println(1 + 2 + "감자"); // 3감자 (1+2=3 먼저, 그 뒤 "3"+"감자")
System.out.println("감자" + 1 + 2); // 감자12 (좌결합: "감자1" → "감자12")
System.out.println("감자" + (1 + 2)); // 감자3 (괄호가 먼저)

int diff = 'C' - 'A';  // 67 - 65 = 2   (char 'B'가 아니라 int 2)
int sum  = 'A' + 1;    // 65 + 1 = 66
System.out.println(1 + '3');    // 52  (둘 다 숫자: 1 + 51)
System.out.println("1" + '3');  // 13  (문자열이 앞: 글자 그대로)
System.out.println("A" + 'B' + 1); // AB1 (("A"+'B')="AB", 그 뒤 +1)

함정: 앞에 문자열이 먼저 등장하면 그 뒤 char는 숫자 변환 없이 글자 그대로 붙습니다. 좌결합 계산 중 "어느 단계부터 String이 되었는가"가 핵심입니다.

int score = 75;
String result = score >= 60 ? "P" : "F";  // "P"

int n = 5;
String r = n > 5 ? "A" : n == 5 ? "B" : "C";
// 해석: n > 5 ? "A" : (n == 5 ? "B" : "C")
// n>5 는 false → (n==5 ? "B" : "C") → n==5 true → "B"

int score = 80;
boolean pass = score >= 60;  // true
if (pass) {
    System.out.println("합격");
}

int[] arr = {10, 20, 30};
for (int x : arr) {       // "arr에서 원소를 하나씩 꺼내 x에 담아라"
    System.out.println(x);
}
// 출력: 10 / 20 / 30 (각 줄)

함정: for-each의 변수는 배열에서 꺼낸 복사본입니다. 그 변수를 바꿔도 원본 배열은 그대로입니다.

int[] arr = {1, 2, 3};
for (int x : arr) {
    x = x * 10;   // x만 바뀜, arr는 그대로
}
// arr는 여전히 {1, 2, 3}

// 원본을 바꾸려면 인덱스로 접근하는 일반 for문 사용
for (int i = 0; i < arr.length; i++) {
    arr[i] = arr[i] * 10;  // arr가 {10, 20, 30}으로 바뀜
}

boolean[] visited = new boolean[10];  // 전부 false
int[] counts = new int[5];            // 전부 0

boolean[] seen = new boolean[256];
char c = 'a';
seen[c] = true;  // seen[97] = true

int[][] matrix = {
    {1, 2, 3},
    {4, 5, 6}
};

for (int[] row : matrix) {          // row = 각 행 (1차원 배열)
    for (int value : row) {          // value = 행 안의 각 값
        System.out.print(value + " ");
    }
    System.out.println();
}

1 2 3
4 5 6

class BO { int v; BO(int v) { this.v = v; } }

BO a = new BO(1), b = new BO(2), c = new BO(3);
BO[] arr = {a, b, c};

// (1) 참조 교환: 배열 안의 주소만 바뀜
BO t = arr[0];
arr[0] = arr[2];
arr[2] = t;
// a, b, c가 가리키는 대상은 그대로 → a.v=1, b.v=2, c.v=3

// (2) 필드 수정: 주소를 따라가 객체 자체를 변경 → 원본도 바뀜
arr[1].v = 99;   // arr[1]과 b는 같은 객체 → b.v도 99

시험 팁: 배열 요소 교환 후 a.v, b.v, c.v를 물으면 원본 변수 기준으로 답하세요. 바뀌는 것은 배열 안의 참조뿐입니다.

String s = "Hello";
s = s + " World";   // "Hello World"라는 새 객체 생성 → s가 새 객체를 가리킴
                    // 원래 "Hello" 객체는 그대로 남았다가 GC가 회수

String result = "";
for (int i = 0; i < 1000; i++) {
    result += "x";   // 매 반복마다 새 String (총 약 1000개 생성)
}

StringBuilder sb = new StringBuilder();
for (int i = 0; i < 1000; i++) {
    sb.append("x");        // 같은 sb 객체에 누적
}
String result = sb.toString();  // 마지막에 한 번만 String으로 변환

// StringBuilder — 같은 객체
StringBuilder sb1 = new StringBuilder("abc");
StringBuilder sb2 = sb1;
sb1.append("def");
System.out.println(sb1 == sb2);     // true (같은 객체)
System.out.println(sb2.toString()); // "abcdef" (sb2도 같이 변함)

// String — 새 객체
String s1 = "abc";
String s2 = s1;
s1 = s1 + "def";
System.out.println(s1 == s2);       // false (s1은 새 객체)
System.out.println(s2);             // "abc" (s2는 그대로)

==는 같은 주소를 가리키는지 비교합니다. 내용 비교는 equals()로 따로 해야 합니다.

int a = Integer.valueOf("5");    // 문자열 → 정수 5
int b = Integer.parseInt("42");  // 문자열 → 정수 42 (valueOf와 동일하게 이해)

System.out.printf("%s는 %d살입니다", "감자", 3); // 감자는 3살입니다
System.out.printf("%5d", 42);   // "   42" (5칸 확보, 오른쪽 정렬)
System.out.printf("%-5d", 42);  // "42   " (왼쪽 정렬)
System.out.printf("%.2f", 3.14);// "3.14"
System.out.printf("%f", 3.14);  // "3.140000" (기본 소수점 6자리)

class Student {
    String name;    // 속성(필드)
    String dream;
    void study() {  // 메서드
        System.out.println(name + "이(가) 공부합니다");
    }
}

Student s1 = new Student();  // 설계도로 실체 생성, s1에는 주소가 저장됨
s1.name = "감자";
s1.study();                  // 감자이(가) 공부합니다

class Student {
    String name;
    String dream;
    Student(String name, String dream) {  // 생성자
        this.name = name;    // this.name = 필드, name = 매개변수
        this.dream = dream;
    }
}

Student s = new Student("감자", "개발자");

기본 생성자 함정: 생성자를 하나도 정의하지 않으면 컴파일러가 매개변수 없는 기본 생성자 Student() {}를 자동 생성합니다. 하지만 매개변수 생성자를 직접 정의하면 기본 생성자는 자동 생성되지 않으므로 new Student()는 컴파일 에러가 됩니다.

class Student {
    String name; String dream;
    Student() {
        this("이름없음", "미정");  // 아래 생성자 호출 (반드시 첫 줄)
    }
    Student(String name, String dream) {
        this.name = name;
        this.dream = dream;
    }
}

캡슐화 패턴(빈출): 필드는 private으로 감추고 public getter/setter로만 접근하게 하면 잘못된 값 유입을 막을 수 있습니다.

class Student {
    private int score;                 // 외부 직접 접근 차단
    public void setScore(int s) {
        if (s >= 0 && s <= 100) score = s;  // 유효성 검사
    }
    public int getScore() { return score; }
}

class Gamja {
    static int count = 0;             // 클래스 변수: 모든 객체가 공유
    static String check(int num) {    // 클래스 메서드
        return (num >= 0) ? "positive" : "negative";
    }
    String name;                      // 인스턴스 변수: 객체마다 별도
}

Gamja.check(1);   // static: 객체 없이 클래스명으로 호출

시험 핵심: 클래스명.메서드() 형태로 호출한다면 그 메서드에는 반드시 static이 필요합니다.

Gamja a = new Gamja();
Gamja b = new Gamja();
a.increase();  // count = 1
b.increase();  // count = 2 (a와 b가 같은 count 공유)
System.out.println(Gamja.count);  // 2

class Parent {
    static { System.out.print("1 "); }   // 부모 static
    { System.out.print("2 "); }           // 부모 인스턴스 초기화 블록
    Parent() { System.out.print("3 "); }  // 부모 생성자
}
class Child extends Parent {
    static { System.out.print("4 "); }
    { System.out.print("5 "); }
    Child() { System.out.print("6 "); }
}
public class Main {
    public static void main(String[] args) {
        new Child();
        System.out.println();
        new Child();  // 두 번째: static은 이미 실행됨 → 건너뜀
    }
}

1 4 2 3 5 6 
2 3 5 6 

세 규칙: (1) static이 먼저, 인스턴스가 나중 (2) 부모가 먼저, 자식이 나중 (3) static은 한 번만, 인스턴스는 매번.

class Rectangle {
    int width, height;
    Rectangle(int width, int height) {   // 매개변수 생성자만 있음 → 기본 생성자 없음
        this.width = width; this.height = height;
    }
}
class Square extends Rectangle {
    Square(int s) {
        super(s, s);   // 부모에 기본 생성자가 없으므로 반드시 명시해야 함
    }
}

class Animal { String sound() { return "..."; } }
class Dog extends Animal { String sound() { return "멍멍"; } }
class Cat extends Animal { String sound() { return "야옹"; } }

Animal a = new Dog();
System.out.println(a.sound());  // 멍멍 (실제 객체 Dog 기준)

static int calc(int value)  { return value * 2; }
static int calc(String str) { return Integer.valueOf(str) * 3; }

calc(5);    // calc(int) 호출 → 10
calc("5");  // calc(String) 호출 → 15

오버로딩 + 재귀 전환(빈출): calc(String)으로 진입 후 Integer.valueOf()로 int로 바꾸면, 이후 calc(value - 1)은 int 인자이므로 calc(int)로 전환됩니다. calc(String)은 처음 한 번만 실행됩니다.

class Parent {
    String x = "Parent";
    int m(int i) { return i + 2; }              // 인스턴스 메서드
    public static String id() { return "P"; }   // static 메서드
}
class Child extends Parent {
    String x = "Child";                          // 필드 하이딩
    int m(int i) { return i + 3; }               // 오버라이딩
    public static String id() { return "C"; }    // 별개의 static 메서드
}

Parent ref = new Child();
System.out.println(ref.m(2));  // 5   (인스턴스 메서드 → 실제 객체 Child)
System.out.println(ref.x);     // Parent (필드 → 선언 타입 Parent)
System.out.println(ref.id());  // P   (static → 선언 타입 Parent로 치환)

class A { String f(Object x) { return "1"; } }
class B extends A {
    String f(Object x) { return "2"; }  // A의 f(Object) 오버라이딩
    String f(String x) { return "3"; }  // B에만 있는 오버로드
}

A a = new B();
System.out.println(a.f("hello"));  // 2

abstract class Vehicle {
    String name;
    Vehicle(String name) { this.name = name; }
    abstract String sound();                                 // 추상 메서드 (자식이 구현)
    String describe() { return name + " 소리: " + sound(); } // 일반 메서드
}
class Car extends Vehicle {
    Car(String name) { super(name); }
    String sound() { return "부릉부릉"; }
}
class Bike extends Vehicle {
    Bike(String name) { super(name); }
    String sound() { return "따르릉"; }
}

Vehicle v1 = new Car("스파크");
System.out.println(v1.describe());  // 스파크 소리: 부릉부릉
Vehicle v2 = new Bike("자전거");
System.out.println(v2.describe());  // 자전거 소리: 따르릉

다형성 함정: 부모의 일반 메서드 describe()가 부른 추상 메서드 sound()도 실제 객체(자식)의 구현이 실행됩니다. 전체 흐름은 부모가 정하고 달라지는 부분만 자식이 채우는 구조가 다형성입니다.

interface Person { void sayHello(); }   // public 생략해도 자동 public

class OliveYoung implements Person {
    public void sayHello() {            // 반드시 public
        System.out.println("어서오세요 올리브영입니다~");
    }
}
class Starbucks implements Person {
    public void sayHello() {
        System.out.println("주문하신 아메리카노 나왔습니다~");
    }
}

Person p1 = new OliveYoung();  // 다형성: 인터페이스 타입에 구현 객체
Person p2 = new Starbucks();
p1.sayHello();  // 어서오세요 올리브영입니다~
p2.sayHello();  // 주문하신 아메리카노 나왔습니다~

class Duck implements Walkable, Swimmable { /* walk(), swim() 모두 구현 */ }
class Dog extends Animal implements Walkable { /* ... */ }

정처기 실기에서는 "인터페이스 = 추상 메서드만"으로 이해하면 충분합니다(Java 8+ default 메서드는 기출 없음).

try {
    int result = 10 / 0;       // 예외 발생! 이 줄 이후는 건너뜀
    System.out.print("성공");   // 실행 안 됨
} catch (Exception e) {
    System.out.print("실패");   // 실행됨
}
// 출력: 실패

static String test() {
    try {
        System.out.print("A");
        return "try";       // 반환값 "try"를 정해둠
    } catch (Exception e) {
        System.out.print("B");
        return "catch";
    } finally {
        System.out.print("C");  // return 전에 실행됨
    }
}
// 출력: AC,  반환값: "try"

더 큰 함정: finally에 return이 있으면 try/catch의 반환값을 덮어씁니다.

static int test2() {
    try { return 1; }        // 1을 정해둠
    finally { return 2; }    // finally의 return이 최종 → 1은 버려짐
}
// 반환값: 2

Throwable
 └── Exception
      ├── RuntimeException
      │    ├── ArithmeticException
      │    ├── ArrayIndexOutOfBoundsException
      │    ├── NullPointerException
      │    └── ClassCastException
      └── IOException
           └── FileNotFoundException

순서 함정: 구체적 예외를 먼저, 넓은 예외(Exception)를 나중에 써야 합니다. Exception을 먼저 쓰면 아래 구체적 catch는 도달 불가라 컴파일 에러가 납니다.

// 올바른 순서
try {
    int result = 10 / 0;
} catch (ArithmeticException e) {  // 구체적 예외 먼저
    System.out.print("산술");
} catch (Exception e) {            // 넓은 예외 나중
    System.out.print("기타");
}
// 출력: 산술

public static int check(int x) {
    try {
        if (x > 2) throw new Exception();  // throw: 예외 직접 발생
        return x * 2;
    } catch (Exception e) {
        return 7;
    }
}
// check(1) → 2,  check(3) → 7