Dziedziczenie

Właściwość instancji, niezależnie od tego, czy została zdefiniowana za pomocą słowa kluczowego function , var , czy const , jest dziedziczona przez wszystkie podklasy, chyba że została w klasie bazowej zadeklarowana z atrybutem private . Na przykład klasa Event w języku ActionScript 3.0 ma szereg podklas dziedziczących właściwości wspólne dla wszystkich obiektów zdarzeń.

W przypadku niektórych typów obiektów klasa Event zawiera wszystkie właściwości potrzebne do zdefiniowania zdarzenia. Zdarzenia tego typu nie wymagają użycia właściwości instancji innych niż zdefiniowane w klasie bazowej Event. Do takich zdarzeń należą: zdarzenie complete wywoływane po pomyślnym załadowaniu danych i zdarzenie connect wywoływane po nawiązaniu połączenia sieciowego.

Poniższy przykład stanowi fragment klasy Event, który zawiera niektóre właściwości i metody dziedziczone przez podklasy. Ponieważ te właściwości są dziedziczone, instancja każdej podklasy ma do nich dostęp.

public class Event 
{ 
    public function get type():String; 
    public function get bubbles():Boolean; 
    ... 
 
    public function stopPropagation():void {} 
    public function stopImmediatePropagation():void {} 
    public function preventDefault():void {} 
    public function isDefaultPrevented():Boolean {} 
    ... 
}

Inne typy zdarzeń wymagają szczególnych właściwości, niedostępnych w klasie Event. Ter zdarzenia zdefiniowane są przy użyciu podklas klasy Event, co umożliwia dodawanie nowych właściwości do zestawu zdefiniowanego w klasie Event. Przykładem takiej podklasy jest klasa MouseEvent, która zawiera dodatkowe właściwości unikatowe dla zdarzeń związanych z ruchem myszy lub kliknięciami myszą, takich jak zdarzenia mouseMove i click . Poniższy przykład przedstawia fragment klasy MouseEvent zawierający definicję właściwości istniejących w podklasie, ale nie w klasie bazowej:

public class MouseEvent extends Event 
{ 
    public static const CLICK:String= "click"; 
    public static const MOUSE_MOVE:String = "mouseMove"; 
    ... 
 
    public function get stageX():Number {} 
    public function get stageY():Number {} 
    ... 
}

// Base.as in a folder named foo 
package foo 
{ 
    public class Base 
    { 
        public var str:String = "hello"; // change public on this line 
    } 
} 
 
// Extender.as in a folder named bar 
package bar 
{ 
    import foo.Base; 
    public class Extender extends Base 
    { 
        public function getString():String { 
            return str; 
        } 
    } 
} 
 
// main application class in file named AccessControl.as 
package 
{ 
    import flash.display.MovieClip; 
    import bar.Extender; 
    public class AccessControl extends MovieClip 
    { 
        public function AccessControl() 
        { 
            var myExt:Extender = new Extender(); 
            trace(myExt.str);// error if str is not public 
            trace(myExt.getString()); // error if str is private or internal 
        } 
    } 
}

trace(myExt.str);// error if str is not public

Przesłonięcie metody oznacza przedefiniowanie zachowania metody odziedziczonej. Metody statyczne nie są dziedziczone i nie mogą być przesłaniane. Jednak metody instancji są dziedziczone przez podklasy i mogą być przesłaniane, o ile spełnione są następujące dwa kryteria:

• Metoda instancji nie jest zadeklarowana w klasie bazowej ze słowem kluczowym final . Słowo kluczowe final w metodzie instancji oznacza, że programista chce zapobiec przesłanianiu tej metody w podklasach.

• Metoda instancji nie jest zadeklarowana w klasie bazowej ze specyfikatorem dostępu private . Jeśli metoda jest oznaczona w klasie bazowej jako private , można ją w podklasie zadeklarować pod tą samą nazwą nawet bez słowa kluczowego override , ponieważ metoda klasy bazowej nie jest widoczna w podklasie.

  Aby przesłonić metodę instancji spełniającą te kryteria, należy w definicji metody w podklasie użyć słowa kluczowego override , a wersja metody w podklasie musi być zgodna z metodą w nadklasie pod następującymi względami:

• Metoda przesłaniająca musi mieć ten sam specyfikator dostępu, co metoda klasy bazowej. Metody oznaczone jako internal są uznawane za posiadające ten sam specyfikator dostępu, co klasy zadeklarowane bez specyfikatora.

• Metoda przesłaniająca musi mieć tę samą liczbę parametrów, co metoda klasy bazowej.

• Parametry metody przesłaniającej musza mieć te same zadeklarowane typy danych, co parametry metody klasy bazowej.

• Metoda przesłaniająca musi mieć zadeklarowany ten sam typ wartości zwracanej, co metoda klasy bazowej.

Jednak nazwy parametrów w metodzie przesłaniającej nie muszą być identyczne z nazwami parametrów w klasie bazowej, jeśli tylko ich liczba i typy danych odpowiednich parametrów są zgodne z klasą bazową.

package { 
    import flash.display.MovieClip; 
    public class SuperExample extends MovieClip 
    { 
        public function SuperExample() 
        { 
            var myExt:Extender = new Extender() 
            trace(myExt.thanks()); // output: Mahalo nui loa 
        } 
    } 
} 
 
class Base { 
    public function thanks():String 
    { 
        return "Mahalo"; 
    } 
} 
 
class Extender extends Base 
{ 
    override public function thanks():String 
    { 
        return super.thanks() + " nui loa"; 
    } 
}

package 
{ 
    import flash.display.MovieClip; 
    public class OverrideExample extends MovieClip 
    { 
        public function OverrideExample() 
        { 
            trace(currentLabel) 
        } 
        override public function get currentLabel():String 
        { 
            var str:String = "Override: "; 
            str += super.currentLabel; 
            return str; 
        } 
    } 
}

Właściwości statyczne nie są dziedziczone przez podklasy. Oznacza to, że właściwości statyczne nie są dostępne dla instancji podklas. Właściwość statyczne jest dostępna tylko za pośrednictwem obiektu klasy, w którym jest zdefiniowana. Na przykład w poniższym kodzie zdefiniowano klasę bazową o nazwie Base oraz podklasę o nazwie Extender rozszerzająca klasę Base. W klasie Base zdefiniowana jest zmienna statyczna o nazwie test . Fragment kodu przedstawiony poniżej nie zostanie bezbłędnie skompilowany w trybie ścisłym i spowoduje błąd w czasie wykonywania w trybie standardowym.

package { 
    import flash.display.MovieClip; 
    public class StaticExample extends MovieClip 
    { 
        public function StaticExample() 
        { 
            var myExt:Extender = new Extender(); 
            trace(myExt.test);// error 
        } 
    } 
} 
 
class Base { 
    public static var test:String = "static"; 
} 
 
class Extender extends Base { }

Dostęp do zmiennej statycznej test można uzyskać wyłącznie za pośrednictwem obiektu klasy, co ilustruje poniższy kod:

Base.test;

Dozwolone jest natomiast zdefiniowanie właściwości instancji o tej samej nazwie, co nazwa właściwości statycznej. Taka właściwość instancji może być zdefiniowana w tej samej klasie, co właściwość statyczna, lub w podklasie. Na przykład klasa Base z poprzedniego przykładu mogłaby zawierać właściwość instancji o nazwie test . Poniższy kod zostanie skompilowany i wykonany bez błędów, ponieważ właściwość instancji jest dziedziczona przez klasę Extender. Kod dałoby się również skompilować i wykonać, gdyby definicja zmiennej instancji test została przeniesiona, ale nie skopiowana, do klasy Extender.

package 
{ 
    import flash.display.MovieClip; 
    public class StaticExample extends MovieClip 
    { 
        public function StaticExample() 
        { 
            var myExt:Extender = new Extender(); 
            trace(myExt.test);// output: instance 
        } 
    } 
} 
 
class Base 
{ 
    public static var test:String = "static"; 
    public var test:String = "instance"; 
} 
 
class Extender extends Base {}

Mimo że właściwości statyczne nie są dziedziczone, należą do łańcuchu zasięgów klasy, która je definiuje, oraz wszystkich podklas tej klasy. Dlatego mówimy, że właściwości statyczne są w zasięgu zarówno klasy, w której są zdefiniowane, jak i wszystkich jej podklas. Oznacza to, że właściwość statyczna jest bezpośrednio dostępna w treści klasy, w której została zdefiniowana oraz we wszystkich podklasach tej klasy.

Poniższy przykład modyfikuje klasy zdefiniowane w poprzednim przykładzie, aby zademonstrować, że statyczna zmienna test zdefiniowana w klasie Base jest w zasięgu klasy Extender. Innymi słowy, klasa Extender może odwoływać się do zmiennej statycznej test bez konieczności poprzedzania nazwy tej zmiennej nazwą klasy, w której zmienna test została zdefiniowana.

package 
{ 
    import flash.display.MovieClip; 
    public class StaticExample extends MovieClip 
    { 
        public function StaticExample() 
        { 
            var myExt:Extender = new Extender(); 
        } 
    } 
} 
 
class Base { 
    public static var test:String = "static"; 
} 
 
class Extender extends Base 
{ 
    public function Extender() 
    { 
        trace(test); // output: static 
    } 
     
}

W wypadku zadeklarowania właściwości instancji o tej samej nazwie, którą ma już właściwość statyczna w tej samej klasie lub nadklasie, właściwość instancji będzie miała wyższy priorytet w łańcuchu zasięgów. Mówimy, że właściwość instancji jest cieniem właściwości statycznej, co oznacza, że zamiast właściwości statycznej będzie używana wartość właściwości instancji. Poniższy przykładowy kod dowodzi, że w razie zdefiniowania w klasie Extender zmiennej instancji o nazwie test instrukcja trace() wyświetli wartość zmiennej instancji, a nie wartość zmiennej statycznej:

package 
{ 
    import flash.display.MovieClip; 
    public class StaticExample extends MovieClip 
    { 
        public function StaticExample() 
        { 
            var myExt:Extender = new Extender(); 
        } 
    } 
} 
 
class Base 
{ 
    public static var test:String = "static"; 
} 
 
class Extender extends Base 
{ 
    public var test:String = "instance"; 
    public function Extender() 
    { 
        trace(test); // output: instance 
    } 
     
}