Informatika4-2018/Gyakorlat6

A MathWikiből
(Változatok közti eltérés)
(Új oldal, tartalma: „== Overriding == == Interface ==”)
 
1. sor: 1. sor:
 
== Overriding ==
 
== Overriding ==
 +
=== Nem statikus ===
 +
Ha egy osztályban van egy ugyanolyan szignatúrájú metódus, mint az ősében, akkor beszélünk
 +
* felülírás, felüldefiniálás
 +
* override
 +
* túlterhelés
 +
-ról
 +
 +
<java>
 +
public class Parent
 +
{
 +
    float f(float x)
 +
    {
 +
        ...
 +
    }
 +
}
 +
 +
public class Child extends Parent
 +
{
 +
    float f(float x)
 +
    {
 +
        ...
 +
    }
 +
}
 +
</java>
 +
Ekkor az alábbi '''f''' hívások mást adnak vissza, attól függően, hogy hogyan írtuk felül.
 +
<java>
 +
Parent parent = new Parent();
 +
Child child = new Child();
 +
 +
parent.f(3.14f); // <- szülőben lévő f
 +
child.f(3.14f);  // <- gyerekben lévő f
 +
</java>
 +
 +
Viszont ez akkor is így történik, ha minkettőt az ősosztlyként tárolom.
 +
<java>
 +
Parent objects = new Parent[2];
 +
objects[0] = new Parent();
 +
objects[1] = new Child(); // leszármazott osztály az ősosztállyá konvertálódik
 +
 +
objects[0].f(3.14f); // <- szülőben lévő f
 +
objects[1].f(3.14f);  // <- gyerekben lévő f
 +
</java>
 +
Vagyis az íly módon meghívott '''f''' őrzi azt, hogy hogyan hoztuk létre az aktuális példányt.
 +
 +
Ez a ''dinamikus polimorfizmus'' és a hatását egy felüldefiniált metóduson keresztül láthattuk.
 +
 +
=== Statikus ===
 +
Nem ez a helyzet statikus metódusnál.
 +
<java>
 +
public class Parent
 +
{
 +
    static float f(float x)
 +
    {
 +
        ...
 +
    }
 +
}
 +
 +
public class Child extends Parent
 +
{
 +
    static float f(float x)
 +
    {
 +
        ...
 +
    }
 +
}
 +
</java>
 +
Ekkor hiába '''Child''' konstruktorral jött létre egy '''Parent''' típusú változó, akkor is a '''Parent.f''' hívódik meg.
 +
<java>
 +
Parent objects = new Parent[2];
 +
objects[0] = new Parent();
 +
objects[1] = new Child(); // leszármazott osztály az ősosztállyá konvertálódik
 +
 +
objects[0].f(3.14f); // <- Parent.f
 +
objects[1].f(3.14f);  // <- Parent.f
 +
</java>
 +
Figyeljük meg, hogy statikus metódust osztályra szoktunk hívni ('''Parent.f''' vagy '''Child.f'''), ezért warning-ot kapunk, de akkor is ugyanaz történik.
 +
 +
Vagyis a statikus felüldefiniálás elvész, az számít, hogy mely típus statikus metódusát hívjuk, nem pedig az hogy a konkrét példány hogyan jött létre.
  
 
== Interface ==
 
== Interface ==

A lap 2018. október 18., 13:05-kori változata

Tartalomjegyzék

Overriding

Nem statikus

Ha egy osztályban van egy ugyanolyan szignatúrájú metódus, mint az ősében, akkor beszélünk

  • felülírás, felüldefiniálás
  • override
  • túlterhelés

-ról

public class Parent
{
    float f(float x)
    {
        ...
    }
}
 
public class Child extends Parent
{
    float f(float x)
    {
        ...
    }
}

Ekkor az alábbi f hívások mást adnak vissza, attól függően, hogy hogyan írtuk felül.

Parent parent = new Parent();
Child child = new Child();
 
parent.f(3.14f); // <- szülőben lévő f
child.f(3.14f);  // <- gyerekben lévő f

Viszont ez akkor is így történik, ha minkettőt az ősosztlyként tárolom.

Parent objects = new Parent[2];
objects[0] = new Parent();
objects[1] = new Child(); // leszármazott osztály az ősosztállyá konvertálódik
 
objects[0].f(3.14f); // <- szülőben lévő f
objects[1].f(3.14f);  // <- gyerekben lévő f

Vagyis az íly módon meghívott f őrzi azt, hogy hogyan hoztuk létre az aktuális példányt.

Ez a dinamikus polimorfizmus és a hatását egy felüldefiniált metóduson keresztül láthattuk.

Statikus

Nem ez a helyzet statikus metódusnál.

public class Parent
{
    static float f(float x)
    {
        ...
    }
}
 
public class Child extends Parent
{
    static float f(float x)
    {
        ...
    }
}

Ekkor hiába Child konstruktorral jött létre egy Parent típusú változó, akkor is a Parent.f hívódik meg.

Parent objects = new Parent[2];
objects[0] = new Parent();
objects[1] = new Child(); // leszármazott osztály az ősosztállyá konvertálódik
 
objects[0].f(3.14f); // <- Parent.f
objects[1].f(3.14f);  // <- Parent.f

Figyeljük meg, hogy statikus metódust osztályra szoktunk hívni (Parent.f vagy Child.f), ezért warning-ot kapunk, de akkor is ugyanaz történik.

Vagyis a statikus felüldefiniálás elvész, az számít, hogy mely típus statikus metódusát hívjuk, nem pedig az hogy a konkrét példány hogyan jött létre.

Interface

Személyes eszközök