OOP Syntax beim Instanziieren mit new

[wilmaed]

Hallo,
Warum kann ich mit dieser Syntax die static Klasse Hund instanziieren?
Tier.Hund snoopy = new Tier.Hund();


Beispiel foo.java2: static Nested Class Hund
Das klappt:
Tier.Hund snoopy = new Tier.Hund();

Das klappt nicht:
Tier snoopy = new Tier();
Tier.Hund snoopy2 = snoopy.new Hund();

class Tier
   {
       static class Hund
           {
                void sprich()
                       {
                           System.out.println("wuff");
                       }
           }
   }

public class Foo2
   {
       public static void main(String[] args)
           {
               Tier.Hund snoopy = new Tier.Hund();   
               snoopy.sprich();
           }
   }

Und umgekehrt:
Beispiel foo.java: Inner Class Hund
Das klappt nicht:
Tier.Hund snoopy = new Tier.Hund();

Das klappt:
Tier snoopy = new Tier();
Tier.Hund snoopy2 = snoopy.new Hund();

class Tier
   {
       class Hund
           {
                void sprich()
                       {
                           System.out.println("wuff");
                       }
           }
   }

public class Foo
   {
       public static void main(String[] args)
           {
                   Tier snoopy = new Tier();
                   Tier.Hund snoopy2 = snoopy.new   Hund();      
                   snoopy2.sprich();

               //   Tier.Hund bello = new Tier.Hund();           
           }
   }

 

[Tobse]

Die Syntax ist Tier.Hund snoopy2 = new snoopy.Hund();

 

[Xyz1]

. bindet stärker als new. Ein new dazwischenzusetzen ist etwas verwirrlich, findest du nicht auch? Was ist eigentlich noch mal die Frage? Fehlendes Grundlagenverständnis?

 

[wilmaed]

Fehlendes Grundlagenverständnis?

ja.
Darum dachte ich, ich bin in der Kategorie "Java-Basics - Anfänger-Themen" richtig.

Ein new dazwischenzusetzen ist etwas verwirrlich, findest du nicht auch?

Ich habe diese Schreibweise gesehen und nicht verstanden.

Was ist eigentlich noch mal die Frage?

Frage1: was macht der Code?
bei non-static Hund gibt es keinen Compiler-Error, bei static Hund schon. Warum?

Tier snoopy = new Tier();
Tier.Hund snoopy2 = snoopy.new   Hund();

Frage2: warum erzeugt der Code bei static Hund keinen Error, bei non-static Hund schon?

Tier.Hund snoopy = new Tier.Hund();

Danke

 

[Tobse]

Innere Klassen sind im Endeffekt ganz genauso Klassen wie alle anderen auch. Eine Statische Klasse unterscheidet sich - neben der Syntax - von einer regulären Klasse in nur einem Aspekt: Der Code hat Zugriff auf die private Eigenschaften der äußeren Klasse.

Eine nicht-statische innere Klasse unterscheidet sich in einem weiteren Aspekt: Jede Instanz der inneren Klasse ist an eine Instanz der äußeren gebunden. Um eine Instanz einer nicht-statischen inneren Klasse zu erstellen braucht es zwangsläufig eine Referenz auf eine Instanz der äußeren Klasse.

Daher auch die Syntax:

// Statische innere klasse:
Tier.Hund snoopy = new Tier.Hund();
// ist nichts anderes als
Hund snoopy = new Hund();
// nur das es eben ein wenig anders notiert wird.

//-----

// nicht-statische innere Klasse:
Tier.Hund snoopy = new Tier.Hund(); // Fehler -> es wird keine Referenz auf die äußere Klasse gegeben, die ist aber zwingend erforderlich

Tier xyz= new Tier();
Tier.Hund snoopy = new xyz.Hund(); // xyz ist die Referenz auf die äußere Klasse -> alles klar

P.S.: Du kannst dir ja mal ansehen, was der Compiler ausspuckt:

class Tier { static class Hund {} }

ergibt einmal Tier.class und Tier$Hund.class

Und wenn aus der inneren Klasse auf protected oder private Eigenschaften der äußeren Klasse zugegriffen wird, braut der Compiler Methoden in die äußere Klasse, um den Zugriff zu ermöglichen. Anstatt direkt auf die Eigenschaft zuzugreiffen wird dann ein Aufruf an die generierte Methode in die innere Klasse eingebaut.
Innere Klassen sind 100% Syntax-Sugar.

P.P.S.: Eine Klasse Hund in der Klasse Tier ist ein semantisches schwerverbrechen. Ich bin mir sicher, dass class Tier {} und class Hund extends Tier {} deutlich besser (wenn auch nicht optimal) ist.

 

[wilmaed]

@Tobse
danke.

outerObject.new InnerClass(); klappt somit nur bei non-static Klassen (Inner Classes):
To instantiate an inner class, you must first instantiate the outer class. Then, create the inner object within the outer object with this syntax:
OuterClass.InnerClass innerObject = outerObject.new InnerClass();

Quelle: https://docs.oracle.com/javase/tutorial/java/javaOO/nested.html

 

[Tobse]

OuterClass.InnerClass innerObject = outerObject.new InnerClass();

Hm, das stimmt in der Tat, habs eben mal getestet. Irgendwie hatte ich das anders in Erinnerung.

Dann kannst du dir folgendes merken:

Statische innere Klasse: Outter.Inner obj = new Outer.Inner();
Innere Klasse: Outter.Innter obj = outerObj.new Inner();


---
Nebenbei: Ich arbeite jetzt seit mehreren Jahren beruflich mit Java. Wie man gemerkt hat, wusste ich den Syntax nicht einmal. Dieses Feature braucht man nicht, wenn man eine gute Anwendungsarchitektur hat.