10. Leveraging Programming Languages

---

Java Lang.

✅ 오버라이딩(재정의)과 업캐스팅

class Parent {
    void show() {
        System.out.println("Parent");
    }
}

class Child extends Parent {
    void show() {
        System.out.println("Child");
    }
}

public class Test1 {
    public static void main(String[] args) {
        Parent obj = new Child();
        obj.show();
    }
}

🖍️ Child
해설: Parent obj = new Child(); 상태에서 obj.show() 호출 → 오버라이딩된 Child의 show() 실행

✅ 오버로딩(서로 다른 인수)

class Overload {
    void print(int a) {
        System.out.println("int");
    }
    
    void print(double a) {
        System.out.println("double");
    }
}

public class Test2 {
    public static void main(String[] args) {
        Overload obj = new Overload();
        obj.print(10.5f);
    }
}

🖍️ double
해설: 10.5f은 float이지만 정확히 일치하는 메서드가 없고, 자동 형변환으로 double 버전 호출됨

❌ 메서드 하이딩 vs 오버라이딩

class A {
    static void hello() {
        System.out.println("Hello from A");
    }
}

class B extends A {
    static void hello() {
        System.out.println("Hello from B");
    }
}

public class Test3 {
    public static void main(String[] args) {
        A obj = new B();
        obj.hello();
    }
}

🖍️ Hello from A
해설: static 메서드는 인스턴스 타입이 아니라 참조 변수 타입 기준으로 호출됨 → A obj = new B(); 이므로 A.hello() 호출
🙌 틀린 이유: static은 오버라이딩이 아닌 하이딩이며, 동적 바인딩이 적용되지 않음

✅ equals() vs ==

public class Test4 {
    public static void main(String[] args) {
        String s1 = new String("hello");
        String s2 = new String("hello");

        System.out.println(s1 == s2);
        System.out.println(s1.equals(s2));
    }
}

🖍️
false
true
해설:

• == → 주소 비교 (false),
• equals() → 문자열 내용 비교 (true)

✅ 오버라이딩 vs 멤버 변수 숨기기

class Super {
    String name = "Super";

    String getName() {
        return name;
    }
}

class Sub extends Super {
    String name = "Sub";

    String getName() {
        return name;
    }
}

public class Test5 {
    public static void main(String[] args) {
        Super obj = new Sub();
        System.out.println(obj.name);
        System.out.println(obj.getName());
    }
}

🖍️
Super
Sub
해설: obj.name은 변수 숨기기 때문에 Super 출력,
getName()은 오버라이딩된 Sub 쪽 실행

❌ 오버로딩 해석 순서

class Demo {
    void process(Object o) {
        System.out.println("Object");
    }

    void process(String s) {
        System.out.println("String");
    }
}

public class Test6 {
    public static void main(String[] args) {
        Demo demo = new Demo();
        demo.process(null);
    }
}

🖍️ String
해셜: 오버로딩은 가장 구체적인 타입 우선!
null은 Object, String 모두에 해당하지만, String이 더 구체적이므로 선택됨
❗ 틀린 이유: 오버로딩 해석 시 "더 구체적인 타입 우선" 이란 규칙을 놓침

✅ 업캐스팅과 오버라이딩 메서드 호출

class Animal {
    void speak() {
        System.out.println("Animal speaks");
    }
}

class Dog extends Animal {
    void speak() {
        System.out.println("Dog barks");
    }

    void wagTail() {
        System.out.println("Dog wags tail");
    }
}

public class Test7 {
    public static void main(String[] args) {
        Animal a = new Dog();
        a.speak();
        // a.wagTail(); // 컴파일 에러
    }
}

🖍️ Dog barks
해설: Animal a = new Dog(); → a.speak() 호출 시 오버라이딩된 Dog의 speak() 호출됨

✅ equals 오버라이딩

class Person {
    String name;

    Person(String name) {
        this.name = name;
    }

    public boolean equals(Object o) {
        if (o instanceof Person) {
            return this.name.equals(((Person) o).name);
        }
        return false;
    }
}

public class Test8 {
    public static void main(String[] args) {
        Person p1 = new Person("John");
        Person p2 = new Person("John");
        System.out.println(p1 == p2);      // Line A
        System.out.println(p1.equals(p2)); // Line B
    }
}

🖍️
false
true

🔎 Line A: p1 == p2

• ==는 객체의 참조값을 비교해.
• p1과 p2는 new 키워드로 서로 다른 객체로 생성됐기 때문에 참조가 다름.
• 따라서 결과는: ✅ false

🔎 Line B: p1.equals(p2)

• equals() 메서드를 오버라이딩 했기 때문에, 단순히 참조값이 아닌 내용 비교를 해.
• this.name.equals(((Person) o).name) → 즉 p1.name.equals(p2.name)
• 둘 다 "John"이니까 결과는: ✅ true

✅ 오버라이딩된 메서드와 생성자 순서

class Base {
    Base() {
        print();
    }

    void print() {
        System.out.println("Base");
    }
}

class Derived extends Base {
    int num = 10;

    void print() {
        System.out.println("Derived: " + num);
    }
}

public class Test9 {
    public static void main(String[] args) {
        new Derived();
    }
}

🖍️ Derived: 10
해설: Derived 생성자 호출 시, Base 생성자 내부에서 print() 호출
→ Derived.print() 오버라이딩됨 → num은 이미 초기화된 상태 → 10

❌ final, static, 오버라이딩 혼합

class One {
    final void show() {
        System.out.println("One");
    }

    static void greet() {
        System.out.println("Static One");
    }
}

class Two extends One {
    // void show() {} // 컴파일 에러: final 메서드는 오버라이딩 불가

    static void greet() {
        System.out.println("Static Two");
    }
}

public class Test10 {
    public static void main(String[] args) {
        One o = new Two();
        o.show();
        o.greet();
    }
}

🖍️
One
Static One
해설:

• show()는 final → 오버라이딩 불가 → One의 메서드 실행됨 (O)
• greet()는 static → 참조 타입 기준으로 호출 → One o = new Two(); → One.greet() 실행됨 → ❌ Static One이 맞는 출력