1단원 쪽지시험 정답: Java OOP — 클래스와 객체¶

문제 1. 객체는 같은가?¶

① 5
② Java
③ true
④ false

해설

항목	식	결과	이유
①	`obj1.x`	`5`	클래스에서 `int x = 5`로 초기화됨
②	`obj2.name`	`Java`	클래스에서 `String name = "Java"`로 초기화됨
③	`obj1.x == obj2.x`	`true`	두 객체 모두 `x = 5`, 값 비교
④	`obj1 == obj2`	`false`	`==`는 객체 참조(주소) 비교 — `new`로 각각 생성한 별개의 객체

③과 ④가 핵심 함정입니다. 값이 같아도 new로 만든 객체는 서로 다른 인스턴스이므로 ==는 false입니다.

문제 2. 속성은 독립적이다¶

① 100
② 85
③ false
④ 85

해설

s1 = new Main()  →  s1.score = 100
s2 = new Main()  →  s2.score = 100
s2.score = 85    →  s2.score = 85   (s1.score는 여전히 100)

항목	결과	이유
①	`100`	`s2`를 바꿔도 `s1`은 영향 없음 — 각 객체의 속성은 독립적
②	`85`	`s2.score`를 직접 수정함
③	`false`	`100 ≠ 85`
④	`85`	`s1.score = s2.score` — `s2`의 값을 `s1`에 복사

s2.score = 85는 s2 객체의 속성만 바꿉니다. s1은 전혀 영향을 받지 않습니다.

문제 3. static vs 인스턴스 메서드¶

① Car class ready!
② Brand: Hyundai
③ Max speed: 180 km/h

해설

항목	호출 방식	결과	이유
①	`announce()`	`Car class ready!`	`static` 메서드 — 객체 없이 바로 호출 가능
②	`myCar.showBrand()`	`Brand: Hyundai`	인스턴스 메서드 — `new`로 객체 생성 후 `.`으로 호출
③	`myCar.speed(180)`	`Max speed: 180 km/h`	매개변수 `180`이 `maxSpeed`에 전달됨

static 메서드는 클래스 이름으로 호출하거나 직접 호출할 수 있고, 인스턴스 메서드는 반드시 객체가 있어야 합니다.

문제 4. 생성자(Constructor)¶

① Alice is 20 years old.
② Bob is 17 years old.
③ true

해설

Main p1 = new Main("Alice", 20);  // 생성자 호출: name="Alice", age=20
Main p2 = new Main("Bob",   17);  // 생성자 호출: name="Bob",   age=17

항목	결과	이유
①	`Alice is 20 years old.`	생성자에서 초기화된 값 그대로 출력
②	`Bob is 17 years old.`	생성자에서 초기화된 값 그대로 출력
③	`true`	`20 > 17`

생성자는 이름이 클래스 이름과 동일해야 하고, 반환 타입을 쓰지 않습니다.

문제 5. 다중 속성과 final¶

① Name: John Doe
② Age: 24
③ Age: 30
④ true

해설

항목	식	결과	이유
①	`p.fname + " " + p.lname`	`Name: John Doe`	두 속성을 문자열 연결
②	`p.age`	`Age: 24`	초기값 `24`
③	`p.age = 30` 후 출력	`Age: 30`	일반 속성은 수정 가능
④	`p.age < p.MAX_AGE`	`true`	`30 < 100`

final 속성(MAX_AGE)은 선언 후 값을 변경하면 컴파일 에러가 발생합니다. 반면 일반 속성(age)은 자유롭게 수정할 수 있습니다.

문제 6. 캡슐화 — getter / setter¶

① Alice
② 25
③ 30
④ true

해설

private String name = "Alice";  // 외부에서 직접 접근 불가
private int age = 25;           // 외부에서 직접 접근 불가

항목	식	결과	이유
①	`p.getName()`	`Alice`	getter가 `name`을 반환
②	`p.getAge()`	`25`	getter가 `age`를 반환
③	`p.setAge(30)` 후 `p.getAge()`	`30`	setter로 수정 후 getter로 확인
④	`p.getAge() > 25`	`true`	`30 > 25`

private 속성은 클래스 외부에서 p.name 처럼 직접 접근하면 컴파일 에러입니다. 반드시 getter/setter를 통해 접근해야 합니다.

문제 7. 상속(Inheritance)¶

① Tuut, tuut!
② Ford Mustang
③ Ford

해설

class Car extends Vehicle { ... }
// Car는 Vehicle의 모든 속성과 메서드를 물려받음

항목	식	결과	이유
①	`myCar.honk()`	`Tuut, tuut!`	`Car`에 없는 메서드 → 부모 `Vehicle`의 `honk()` 호출
②	`myCar.brand + " " + myCar.model`	`Ford Mustang`	`brand`는 부모에서, `model`은 자식에서
③	`myCar.brand`	`Ford`	부모의 `protected` 속성에 자식이 직접 접근 가능

extends 키워드로 부모 클래스의 속성과 메서드를 그대로 사용할 수 있습니다.

문제 8. 다형성(Polymorphism) — 메서드 오버라이딩¶

① ...
② Meow
③ Woof

해설

Animal a = new Animal();  // Animal 객체
Animal c = new Cat();     // 변수 타입은 Animal, 실제 객체는 Cat
Animal d = new Dog();     // 변수 타입은 Animal, 실제 객체는 Dog

항목	호출	결과	이유
①	`a.sound()`	`...`	`Animal`의 `sound()` 실행
②	`c.sound()`	`Meow`	실제 객체가 `Cat` → `Cat`의 오버라이딩 메서드 실행
③	`d.sound()`	`Woof`	실제 객체가 `Dog` → `Dog`의 오버라이딩 메서드 실행

핵심 함정: Animal c = new Cat()에서 변수 타입이 Animal이어도, 실제로 담긴 객체가 Cat이므로 Cat의 sound()가 호출됩니다. 이것이 다형성(Polymorphism) 입니다.

문제 9. 은행 계좌¶

class BankAccount {
    private int balance = 0;

    public int getBalance() {
        return balance;
    }

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

public class Main {
    public static void main(String[] args) {
        BankAccount acc = new BankAccount();
        acc.deposit( 500 );
        System.out.println( acc.getBalance() );
        acc.deposit( 300 );
        System.out.println( acc.getBalance() );
    }
}

빈칸 정답

빈칸 위치	정답	이유
`______ int balance`	`private`	외부 직접 접근 차단 — 캡슐화의 핵심
`return ______`	`balance`	getter가 반환할 값
`balance ______ amount`	`+=`	잔액에 입금액을 더함
`acc.______( 500 )`	`deposit`	입금 메서드 호출
`acc.______()`	`getBalance`	잔액 조회 getter 호출

문제 10. 도형 클래스¶

class Shape {
    String color;

    public Shape(String c) {
        color = c;
    }

    public void draw() {
        System.out.println(color + " shape");
    }
}

class Circle extends Shape {
    int radius;

    public Circle(String c, int r) {
        super(c);
        radius = r;
    }

    public void draw() {
        System.out.println(color + " circle, r=" + radius);
    }
}

public class Main {
    public static void main(String[] args) {
        Shape s = new Shape("Red");
        Shape c = new Circle("Blue", 5);
        s.draw();
        c.draw();
    }
}

빈칸 정답

빈칸 위치	정답	이유
`System.out.println(______ + " shape")`	`color`	부모 속성 `color` 출력
`class Circle ______ Shape`	`extends`	`Circle`이 `Shape`를 상속
`______ = r`	`radius`	매개변수 `r`을 속성 `radius`에 대입
`" circle, r=" + ______`	`radius`	반지름 속성 출력
`new ______("Blue", 5)`	`Circle`	`Circle` 생성자 호출
`c.______()`	`draw`	오버라이딩된 `draw()` 호출

핵심 포인트

super(c) : 부모 생성자 Shape(String c)를 호출하여 color를 초기화
Shape c = new Circle(...) : 변수 타입은 Shape지만 실제 객체는 Circle → 다형성
c.draw() : Circle이 draw()를 오버라이딩했으므로 Circle의 draw() 실행