[Progra] "Kurze Fragen"-Sammelthread

[NightmareVirus]

Hab keinen vergleichbaren Thread gefunden, da sich bei mir in naher Zukunft sicherlich noch einige Fragen ergeben, mach ich einfach mal n Thread dafür auf

1. Wann genau macht man eine Methode static.

2. Semestralklausur vom 11.1.06 - Aufgabe 3b:

In der Lösung wird vorrgeschlagen:

Code: Alles auswählen

8 if ( array [ i ] instance of Kuehlbehaelter ) {
9 anzahl++;
10 aktuellerBehaelter = ( Kuehlbehaelter ) array [ i ] ;

Meine Frage:
Wieso muss ich in der 10 Zeile explizit casten, wenn ich in der 8. Zeile den Typ schon mit instance of geprüft hab?

mfg & bis zur nächsten Fragen

[Alexander Urban]

Wenn du ihn nicht castest, ist er ja nicht vom Typ Kuehlbehaelter, sondern noch vom übergeordneten Typ.

Mit der Abfrage wird nur sichergestellt, dass du beim expliziten Casten keine Fehlermeldung bekommst.

EDIT:

"Static" bedeutet, dass es die Methode/Variable genau ein einziges Mal für alle Instanzen gibt.
Du DARFST eine Methode nur dann static machen, wenn sie nur auf static-Variablen zugreift.
Sie MUSS static sein, wenn du aus einer static-Methode direkt auf sie zugreifen willst (d.h. ohne den Umweg über Objekte).
Die main ist IIRC zwingend static...

Ich hoffe der Code ist so einigermaßen richtig, Progra ist schon ein wenig her...

Code: Alles auswählen

public static void main() { /* zwingende Vorgabe */
 Objekt = new ObjectClass();
 Objekt.Methode() /* Methode() muss nicht static sein */
 AndereMethode() /* AndereMethode() muss static sein */
}

public void ObjectClass.Methode() { /* korrekt */
}

public void AndereMethode() {
/* bringt die Fehlermeldung: non-static method AndereMethode() cannot be referenced from a static context. */
}

[theTux]

Wann genau macht man eine Methode static.

Statische Methoden sind, analog zu statischen Attributen, allgemein verfügbar und nicht auf eine spezielle Instanz der Klasse beschränkt. Eine solche Methode benutzt man dann, wenn man sie braucht. Im Allgemeinen nimmt man das für Bibliotheksfunktionen. Die Klasse Math ist ein Beispiel für eine Bibliothek, man kann ihre Methoden verwenden, ohne eine Instanz davon anzulegen.

Wieso muss ich in der 10 Zeile explizit casten, wenn ich in der 8. Zeile den Typ schon mit instance of geprüft hab?

Wie bereits gesagt wurde, weiß der Compiler an der Stelle nicht, um welchen Typ es sich handelt, er muss also davon ausgehen, dass es sich um die Oberklasse handelt. Auch wenn du das vorher mit dem instanceof-Operator überprüft hast, gilt es eben nur für dich und nicht für den Compiler. Compiler sind im Allgemeinen etwas Dummes.

[Coolcat]

Das Beispiel von Alexander mal Java-konform...

Code: Alles auswählen

public class Test {
   public static void main(String[] args) { /* zwingende Vorgabe */
      Test test = new Test();

      /* methode() muss nicht static sein, da sie in Bezug auf
       * ein Objekt aufgerufen wird. */
      test.methode();

      /* andereMethode() muss static sein */
      andereMethode();
   }
   
   public void methode() {
      /* korrekt */
   }
   
   public void andereMethode() {
      /* bringt die Fehlermeldung:
       * non-static method andereMethode() cannot be referenced from a static context */
   }
}

[Der Fuß]

Hallo, mir ist nicht wirklich klar, was instanceof macht, oder wie ich es verwenden muss.
Wäre super, wenn einer das kurz erklären könnte.

[theTux]

Mit dem instanceof-Operator überprüfst du, ob das Objekt, auf das eine Variable zeigt, von einem bestimmten Typ ist.

Beispiel:

Code: Alles auswählen

public class Tier {...}
public class Katze extends Tier {...}
public class Hund extends Tier {,,,}
public class Spitz extends Hund {...}


Tier s = new Spitz();
Tier d = new Hund();
Tier k = new Katze();
Tier t = new Tier();

Folgende Aufrufen würden true ergeben:

Code: Alles auswählen

s instanceof Tier
s instanceof Hund
s instanceof Spitz
d instanceof Tier
d instanceof Hund
k instanceof Tier
k instanceof Katze
t instanceof Tier

Und die hier false:

Code: Alles auswählen

k instanceof Hund
s instanceof Katze
h instanceof Spitz

[Stasik]

Man kann viele Klassen die von einer Oberklasse erben in einer Variable von dieser Oberklasse speichern.

Mensch <- Student
^
|
Obdachloser

Mensch ist hier die Oberklasse.

Code: Alles auswählen

Mensch mensch1 = new Student();
Mensch mensch2 = new Obdachloser();


Du schränkst quasi deine Sicht ein, nur auf die gemeinsamen Eigenschaften der Oberklasse.

Wenn du jetzt z.B. mensch1 betrachtest kannst du nicht auf die neue, studententypische Eigenschaften zugreifen. D.h. du musst ihn wieder Runtercasten, hier kommt instanceof ins spiel. Das sagt dir nämlich von welcher klasse die Instanz wirklich ist.

Code: Alles auswählen

if(mensch1 insanceof Student){student1 = (Student) mensch1;}


[Coolcat]

Mit instanceof kann man gefahrlos ausprobieren ob eine Referenz auf ein Objekt einer bestimmten Unterklasse zeigt. Hier mal auf die schnelle ein kleines Beispielprogramm:

Code: Alles auswählen

class A {
   public void methodeA() { /* ... */ }
}
class B extends A {
   public void methodeB() { /* ... */ }
}
interface I {
    public void methodeI();
}
class C extends B implements I {
   public void methodeC() { /* ... */ }
   public void methodeI() { /* Implementierung des Interfaces */ }
}
class D extends A implements I {
   public void methodeD() { /* ... */ }
   public void methodeI() { /* Implementierung des Interfaces */ }
}

public class Test {
   public static void main(String[] args) {
      test(new A());
      test(new B());
      test(new C());
      test(new D());
   }

   public static void test(A a) {
      a.methodeA(); // sicher, unsere Objekt ist mindestens vom Typ A

      C x = (C)a; // könnte schief gehen => ClassCastException
                  // darum vorher testen ob's auch geht!

      if (a instanceof B) {
         B b = (B)a; // Objekt ist vom Typ B oder einer Unterklasse davon, jedenfalls können wir casten
         b.methodeB();
      }

      if (a instanceof I) {
         I i = (I)a; // das Interface I wird implementiert, wir können also casten
                     // das Objekt könnte aber vom Typ C oder D sein
         i.methodeI();
      }

      if (a instanceof C) {
         B b = (B)a; // B ist Oberklasse von C, wir können casten

         C c = (C)a; // Objekt ist mindestens vom Typ C
         c.methodeB();
         c.methodeC();
      }
   }
}

Edit: bin wohl zu langsam

[Der Fuß]

Danke!

[Der Fuß]

Folie II.4.2 Seite 14 (Abstrakte Klassen und Interfaces)

Warum führt j.b(5) die Methode b(double d) aus C aus?

[theTux]

Du hast eine Variable vom Typ J. Das heißt, du kannst ohne expliziten Cast nur auf Attribute und Methoden des Interfaces J zugreifen, das nur die Methode b (double) enthält, nicht aber die Methode b (int).

[Der Fuß]

ok, das heißt also ich führe die Methode im interface J aus. Ich hatte mir aber in der Vorlesung mitgeschrieben, das man die Methode in der Klasse C ausführen würde, kann mich aber auch verhört haben.

Danke, Grüße

[theTux]

Stichwort "Polymorphie".
Du führst die Methode der Klasse C aus, aber welche Methoden sichtbar sind, wird durch den Typ der Variablen entschieden. Also in J steht drin, welche Methoden verfügbar sind, und in C steht drin, was diese Methoden machen.

Geht auch schlecht anders, da Interfaces keine Implementierung beinhalten.

[Der Fuß]

Auch wenn das schon ein alter Hut ist und ich vielleicht nicht die korrekten Terme verwende:

Wenn ich zwei Klassen A und B habe, dann bedeutet

A a = new A();

dass ich ein neues Objekt der Klasse A erzeuge und dass dann unter dem Namen a abspeichere. Das große A am Anfang bedeutet, dass das neue a, wieder ein Objekt des Typs A ist, oder?

Was bedeutet und vor allem bringt dann die folgende Zeile?

A a = new B();

Ich erzeuge ein neues Objekt der Klasse b und speichere das unter dem Namen a ab. Und dieses neue Objekt der Klasse B ist eigentlich ein Objekt der Klasse A???

[aRo]

A a = new B();

Du erzeugst ein Objekt der Klasse B (die, so bin ich mir ziemlich sicher, eine Unterklasse der Klasse A sein muss). a ist der Zeiger, der nun vom Keller auf die Halde auf das erzeugte Objekt verweist.

a ist allerdings vom Typ A, und damit schränkst du die Sichtweise der Referenzvariable ein. Sie zeigt nämlich sozusagen auf den inneren Kasten, wenn du dir die Vorlesungsfolien nochmal anschaust, und nicht auf das komplette Objekt.