Tv t = new Tv();  // Tv 클래스의 인스턴스 t를 생성

public class Tv {
    // 속성 (멤버변수)
    String color;       // 색상
    boolean power;      // 전원 상태 (on/off)
    int channel;        // 채널

    // 기능 (메서드)
    void power() {
        power = !power;
    }
    void channelUp() {
        ++channel;
    }
    void channelDown() {
        --channel;
    }
}

public class TvTest {
    public static void main(String[] args) {
        Tv t;                 // 1. Tv 참조변수 선언
        t = new Tv();         // 2. Tv 인스턴스 생성
        t.channel = 7;        // 3. 인스턴스 멤버변수 접근
        t.channelDown();      // 4. 인스턴스 메서드 호출
        System.out.println("현재 채널은 " + t.channel + "입니다.");
    }
}

// 두 개의 독립적인 인스턴스
Tv t1 = new Tv();
Tv t2 = new Tv();
t1.channel = 7;
System.out.println(t2.channel);  // 0 (서로 다른 인스턴스)

// 참조 복사
Tv t3 = new Tv();
Tv t4 = t3;  // t3와 t4는 같은 인스턴스를 가리킴
t3.channel = 7;
System.out.println(t4.channel);  // 7 (같은 인스턴스 참조)

Tv[] tvArr = new Tv[3];  // 참조변수 배열만 생성됨

// 각 요소에 인스턴스를 생성해야 사용 가능
for (int i = 0; i < tvArr.length; i++) {
    tvArr[i] = new Tv();         // 인스턴스 생성
    tvArr[i].channel = i + 10;   // 초기화
}

// 사용
for (int i = 0; i < tvArr.length; i++) {
    tvArr[i].channelUp();
    System.out.printf("tvArr[%d].channel=%d%n", i, tvArr[i].channel);
}

// 기본형 사용
int hour1, minute1, second1;
int hour2, minute2, second2;

// 클래스 (사용자정의 타입) 사용
class Time {
    int hour;
    int minute;
    int second;
}

Time t1 = new Time();
Time t2 = new Time();

class Variables {
    int iv;           // 인스턴스 변수
    static int cv;    // 클래스 변수 (static 변수, 공유 변수)

    void method() {
        int lv = 0;   // 지역 변수
    }
}

public class Card {
    // 인스턴스 변수 (카드마다 다른 값)
    String kind;
    int number;

    // 클래스 변수 (모든 카드가 공유)
    static int width = 100;
    static int height = 250;
}

public class CardTest {
    public static void main(String[] args) {
        // 클래스 변수는 인스턴스 생성 없이 사용 가능
        System.out.println("Card.width = " + Card.width);
        System.out.println("Card.height = " + Card.height);

        Card c1 = new Card();
        c1.kind = "Heart";
        c1.number = 7;

        Card c2 = new Card();
        c2.kind = "Spade";
        c2.number = 4;

        System.out.println("c1은 " + c1.kind + ", " + c1.number);
        System.out.println("c2는 " + c2.kind + ", " + c2.number);

        // 클래스 변수 변경 (모든 인스턴스에 영향)
        c1.width = 50;
        c1.height = 80;

        System.out.println("c1 크기: (" + c1.width + ", " + c1.height + ")");
        System.out.println("c2 크기: (" + c2.width + ", " + c2.height + ")");
        // 둘 다 (50, 80) 출력 - 클래스 변수이므로 공유됨
    }
}

// 예시
int add(int x, int y) {          // 반환타입: int
    int result = x + y;          // 지역변수
    return result;               // 반환값
}

void power() {                   // 반환타입: void (반환값 없음)
    power = !power;
}

long multiply(long a, long b) {  // 매개변수 2개
    long result = a * b;
    return result;
}

// 단일 반환값
int max(int a, int b) {
    return a > b ? a : b;
}

// 조건부 반환
int abs(int x) {
    if (x >= 0) {
        return x;
    } else {
        return -x;
    }
}

// void 메서드에서의 return (조기 종료)
void printGugudan(int dan) {
    if (dan < 2 || dan > 9) {
        return;  // 메서드 종료
    }
    for (int i = 1; i <= 9; i++) {
        System.out.printf("%d * %d = %d%n", dan, i, dan * i);
    }
}

메서드이름(값1, 값2, ...);  // 메서드 호출

public static void main(String[] args) {
    int result = add(3, 5);  // 3, 5는 인자(argument)
}

int add(int x, int y) {      // x, y는 매개변수(parameter)
    return x + y;
}

long add(int a, long b) {
    return a + b;
}

// 호출
add(3, 5L);      // OK
add(3L, 5);      // OK (int → long 자동 형변환)
add(3, 5);       // OK (int → long 자동 형변환)

public class CallStackTest {
    public static void main(String[] args) {
        System.out.println("main 시작");
        firstMethod();
        System.out.println("main 끝");
    }

    static void firstMethod() {
        System.out.println("firstMethod 시작");
        secondMethod();
        System.out.println("firstMethod 끝");
    }

    static void secondMethod() {
        System.out.println("secondMethod 시작");
        System.out.println("secondMethod 끝");
    }
}

public class PrimitiveParam {
    public static void main(String[] args) {
        int x = 10;
        change(x);
        System.out.println("x = " + x);  // 10 (변경 안됨)
    }

    static void change(int x) {
        x = 100;  // 복사본만 변경
    }
}

class Data {
    int x;
}

public class ReferenceParam {
    public static void main(String[] args) {
        Data d = new Data();
        d.x = 10;
        change(d);
        System.out.println("d.x = " + d.x);  // 100 (변경됨)
    }

    static void change(Data d) {
        d.x = 100;  // 같은 인스턴스를 가리키므로 원본 변경
    }
}

public class ArrayParam {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        change(arr);
        System.out.println(Arrays.toString(arr));  // [10, 2, 3, 4, 5]
    }

    static void change(int[] arr) {
        arr[0] = 10;  // 같은 배열을 참조하므로 원본 변경
    }
}

// println 메서드의 오버로딩 예시
void println()
void println(boolean x)
void println(char x)
void println(double x)
void println(String x)

// 올바른 오버로딩
int add(int a, int b) { return a + b; }
long add(long a, long b) { return a + b; }
int add(int a, int b, int c) { return a + b + c; }

// 잘못된 오버로딩 (컴파일 에러)
int add(int a, int b) { return a + b; }
long add(int x, int y) { return (long)(x + y); }  // 에러!
// 매개변수는 같고 반환타입만 다름

// 오버로딩 없이
int addInt(int a, int b) { ... }
long addLong(long a, long b) { ... }
double addDouble(double a, double b) { ... }

// 오버로딩 사용
int add(int a, int b) { ... }
long add(long a, long b) { ... }
double add(double a, double b) { ... }

// 형식: 타입... 변수명
public String concatenate(String... args) {
    // args는 배열처럼 사용
}

// 호출
concatenate("a");
concatenate("a", "b");
concatenate("a", "b", "c");
concatenate();  // 인자 없이도 가능

// 올바른 선언
void method(String s, int... args) { }

// 잘못된 선언
void method(int... args, String s) { }  // 에러!

void method(int... args) { }
void method(int a, int b) { }

// 호출 시 모호함 발생 가능
method(1, 2);  // 어느 메서드를 호출해야 하는가?

// 생성자 정의 형식
클래스이름(타입 변수명, 타입 변수명, ...) {
    // 인스턴스 생성 시 수행될 코드
    // 주로 인스턴스 변수의 초기화 코드
}

class Card {
    Card() {  // 매개변수가 없는 생성자
        // 초기화 작업
    }

    Card(String kind, int number) {  // 매개변수가 있는 생성자
        this.kind = kind;
        this.number = number;
    }
}

Card c = new Card();

// 소스 코드
class Card {
    String kind;
    int number;
}

// 컴파일 후 (컴파일러가 자동 추가)
class Card {
    String kind;
    int number;

    Card() { }  // 기본 생성자 자동 추가
}

class Car {
    String color;
    String gearType;
    int door;

    // 매개변수가 없는 생성자
    Car() {
        color = "white";
        gearType = "auto";
        door = 4;
    }

    // 매개변수가 있는 생성자
    Car(String c, String g, int d) {
        color = c;
        gearType = g;
        door = d;
    }
}

// 사용
Car c1 = new Car();                       // 기본값으로 초기화
Car c2 = new Car("blue", "manual", 2);    // 지정한 값으로 초기화

// 매개변수 없는 생성자 사용
Car c = new Car();
c.color = "blue";
c.gearType = "manual";
c.door = 2;

// 매개변수 있는 생성자 사용 (더 간결)
Car c = new Car("blue", "manual", 2);

class Car {
    String color;
    String gearType;
    int door;

    // 매개변수 3개인 생성자
    Car(String color, String gearType, int door) {
        this.color = color;
        this.gearType = gearType;
        this.door = door;
    }

    // 매개변수 2개인 생성자
    Car(String color, String gearType) {
        this(color, gearType, 4);  // 다른 생성자 호출
    }

    // 기본 생성자
    Car() {
        this("white", "auto", 4);  // 다른 생성자 호출
    }
}

class Car {
    String color;

    // 매개변수와 인스턴스 변수 이름이 같을 때
    Car(String color) {
        this.color = color;  // this.color는 인스턴스 변수
                             // color는 매개변수
    }
}

class Car {
    String color;
    String gearType;
    int door;

    Car(String color, String gearType, int door) {
        this.color = color;
        this.gearType = gearType;
        this.door = door;
    }

    // 복사 생성자
    Car(Car c) {
        this(c.color, c.gearType, c.door);
        // 또는
        // this.color = c.color;
        // this.gearType = c.gearType;
        // this.door = c.door;
    }
}

// 사용
Car c1 = new Car("blue", "manual", 2);
Car c2 = new Car(c1);  // c1의 복사본 c2 생성

class Car {
    int door = 4;                    // 기본형 초기화
    String color = "white";          // 참조형 초기화
    Engine engine = new Engine();    // 객체 생성
}

class InitBlock {
    static int cv;     // 클래스 변수
    int iv;            // 인스턴스 변수

    // 클래스 초기화 블럭 (static 블럭)
    static {
        cv = 10;
        System.out.println("클래스 초기화 블럭 실행");
    }

    // 인스턴스 초기화 블럭
    {
        iv = 20;
        System.out.println("인스턴스 초기화 블럭 실행");
    }

    // 생성자
    InitBlock() {
        System.out.println("생성자 실행");
    }
}

class Car {
    static int count = 0;  // 생성된 Car의 개수

    String color;
    String gearType;

    // 인스턴스 초기화 블럭 (모든 생성자에서 공통 수행)
    {
        count++;  // 인스턴스 생성 시마다 증가
        System.out.println("Car 생성됨. 총 " + count + "대");
    }

    Car() {
        this("white", "auto");
    }

    Car(String color, String gearType) {
        this.color = color;
        this.gearType = gearType;
    }
}

class InitTest {
    static int cv = 1;   // 명시적 초기화
    int iv = 1;          // 명시적 초기화

    static { cv = 2; }   // 클래스 초기화 블럭
    { iv = 2; }          // 인스턴스 초기화 블럭

    InitTest() {         // 생성자
        iv = 3;
    }
}