오버라이딩 인스턴스 메소드의 멤버 접근

[오버라이딩 인스턴스 메소드의 멤버 접근]
====================
멤버 접근:
서브클래스의 인스턴스 메소드

예제 :
class A{
        public function over():Void{
        }
}

class B extends A{
        public function methOfB():Void{
        }
        public function over():Void{
                methOfB(); //B.methOfB()를 실행한다.
        }
}

설명 :
서브클래스에 정의된 메소드는 어느 하나가 오버라이딩 메소드라도 서로 접근할 수 있다. 따라서 오버라이딩 메소드

B.over()는 B.methOfB()를 정상적으로 실행한다. [표]상속받은 메소드에서 서브클래스의 인스턴스 메소드를 실행할

때 오류가 발생한 것과 비교해본다.
====================
멤버 접근:
상속받은 인스턴스 메소드(슈퍼클래스에 정의됨)

예제 :
class A{
        public function over():Void{
        }
        public function otherMethOfA():Void{
        }
}

class B extends A{
        public function over():Void{
                //otherMethOfA()를 실행함
                otherMethOfA();
        }
}

설명 :
[표]에서, 서브클래스(B)의 모든 메소드는, 심지어 오버라이딩 메소드라 하더라도, 슈퍼클래스(A)의 메소드에 접근할

수 있다.
====================
멤버 접근:
오버라이드된 인스턴스 메소드(슈퍼클래스와 서브클래스에 모두 정의됨)

예제 :
class A{
        public function over():Void{
        }
        public function over2():Void{
        }
}

class B extends A{
        public function over():Void{
                //B.over()를 실행. A.over2()가 아니다.
                over2();
        }
        public function over2():Void{
        }
}

설명 :
모든 상황에 있어서, 컴파일러는 불분명한 참조에 대해, 슈퍼클래스를 찾지 않고 서브클래스 안에서 참조를 모두 결

정한다. 예제에서 오버라이딩한 over() 메소드는 over2()를 실행하는데, 이 메소드가 서브클래스에 동일하게 존재하

기 때문에 B.over2()를 실행한다.
====================
멤버 접근:
서브클래스의 인스턴스 속성

예제 :
class A{
        public function over():Void{
        }

        class B extends A{
                public var propOfB:Number = 1;
                public function over():Void{
                        trace(propOfB); // 출력 : 1
                }
        }

        설명 :
        서브클래스에 정의된 메소드는 동일한 서브클래스의 속성에 접근 할 수 있다. 따라서 오버라이딩 메소드 B.over()는

        propOfB에 접근하는 것이 가능하다. [표]과 비교해 보면 상속받은 메소드에서 서브클래스의 인스턴스 속성에 접근하

        는 것은 오류가 발생한다.
        ====================
        멤버 접근:
        상속받은 인스턴스 속성(슈퍼클래스에 정의됨)

        예제 :
        class A{
                public var propOfA:Number = 2;
                public function over():Void{
                }
        }

        class B extends A{
                public function over():Void{
                        trace(propOfA); // 출력 : 2
                }
        }

        설명 :
        서브클래스에 정의된 메소드는, 오버라이딩한 메소드라 하더라도 슈퍼클래스의 속성에 접근할 수 있다. 따라서 오버

        라이딩 메소드 B.over()는 propOfA에 접근하는 것이 가능하다.
        ====================
        멤버 접근:
        오버라이딩된 인스턴스 속성(슈퍼클래스와 서브클래스 모두 정의됨)

        예제 :
        class A{
                public var overriddenProp:Number = 3;
                public function over():Void{
                }
        }

        class B extends A{
                public var overriddenProp:Number = 4;
                public function over():Void{
                        trace(overriddenProp); // 출력 : 4
                }
        }

        설명 :
        서브클래스의 메소드는 서브클래스의 오버라이드된 속성의 값을 출력한다(3이 아닌 4). 왜냐하면 bInstance는

        overriddenProp에 단 하나의 값만을 저장하며, 오버라이딩 메소드는 슈퍼클래스의 오버라이드된 값을 참조하지 않는

        다.
        ====================
        멤버 접근:
        서브클래스의 클래스 메소드 불분명한 참조

        예제 :
        class A{
                public function over():Void{
                }
        }

        class B extends A{
                public static function classMethOfB():Void{
                }
                ublic function over():Void{
                        classMethOfB(); // B.classMethOfB()를 실행함
                }
        }

        설명 :
        컴파일 과정에서 클래스 케소드에 대한 불분명한 참조는 현재 클래스에 따라 결정된다(classMethOfB()는 해당 메소드

        가 존재하는 곳이 B이므로, B.classMethOfB()로 결정된다) [표]과 비교하면 상속받은 메소드(슈퍼클래스에 정의된)에

        서 static메소드에 대한 불분명한 참조는 오류가 발생했다.
        ====================
        멤버 접근:
        서브클래스의 클래스 메소드 불분명한 참조

        예제 :
        class A{
                public function over():Void{
                }
        }

        class B extends A{
                public static function classMethOfB():Void{
                }
                public function over():Void{
                        B.classMethOfB(); /// 정상적으로 실행됨.
                }
        }

        설명 :
        B.classMethOfB()는 분명한 참조이므로, 컴파일러는 클래스 B에서 해당 클래스 메소드를 찾게 된다.(이것은 오버라이

        딩 메소드라 하더라도 모든 상황에서 통용되는 사실이다.)
        ====================
        멤버 접근:
        상속받은 클래스 메소드(슈퍼클래스에 정의됨)

        예제 :
        class A{
                public static function classMethOfA():Void{
                }
                public function over():Void{
                }
        }

        class B extends A{
                public function over():Void{
                        classMethOfA(); // A.classMethOfA()를 실행함
                }
        }

        설명 :
        컴파일 과정에서 클래스 메소드에 대한 불분명한 참조는 현재 클래스에 따라 결정된다. 따라서 classMethOfA()는

        B.classMethOfA()로 결정된다. 비록 서브클래스 B에 classMethOfA()를 정의하지 않았지만 서브클래스에서 상속받은

        클래스 메소드를 사용할 수 있기 때문에 참조하는 것이 가능하다. 따라서 이 예에서는 B.classMethOfA()와

        A.classMethOfA()가 동일한 작업을 수행한다.
        ====================
        멤버 접근:
        오버라이드된 클래스 메소드(슈퍼클래스와 서브클래스에 모두 정의됨)

        예제 :
        class A{
                public static function overriddenClassMeth():Void{
                }
                public function over():Void{
                        //A.overriddenClassMeth()를 실행함
                        overriddenClassMeth();
                }
        }

        class B extends A{
                public static function overriddenClassMeth():Void{
                }
                public function over():Void{
                        //B.overriddenClassMeth()를 실행함
                        overriddenClassMeth();
                }
        }

        // 사용법
        var aInstance:A = new A();
        var bInstance:B = new B();
        // A의 overriddenClassMeth()를 실행함
        aInstance.over();
        // B의 overriddenClassMeth()를 실행함
        bInstance.over();

        설명 :
        컴파일 과정에서 클래스 메소드에 대한 불분명한 참조는 현재 클래스에 따라 결정된다. 따라서 B의 over()에서

        overriddenClassMeth()는 B.overriddenClassMeth()로 결정된다. A의 메소드를 실행하려면 명확히

        A.overriddenClassMeth()를 사용하면 된다. 불분명한 참조를 사용하면, 메소드를 호출하고 있는 클래스에 존재하는

        것을 사용한다고 생각하면 된다.
        ====================
        A 클래스 메소드와 마찬가지로 클래스 속성에 대해서도 동일한 접근 규칙을 사용한다.



        출처 : 콜린 무크의 Flash ActionScript 2.0에서 발췌