Lokale Klassen

[ohmp2007]

Hallo Leute, habe gelesen dass lokale Klassen ein anderer Begriff für innere Klassen sind!

Habe das hier dazu gefunden:

Lokale Klassen sind auch innere Klassen, die jedoch nicht als Eigenschaft direkt in einer Klasse eingesetzt werden. Diese Form der inneren Klasse befindet sich in Anweisungsblöcken von Methoden oder Initialisierungsblöcken. Lokale Schnittstellen sind nicht möglich...

Kann mir es bitte einer mit anderen Worten erklären 🙂

public class DrinnenMachtSpass
{
  public static void main( String[] args )
  {
    int i = 2;
      final int j   = 3;
    class In
    {
      In() {
        System.out.println( j );
//        System.out.println( i );    // Fehler, da i nicht final
      }
    }
    new In();
  }
}

 

[tfa]

Grob gesagt: Eine lokale Klasse ist eine Inner Class, die in einer Methode definiert wird. Siehe dein Beispielcode.

Mich würde interessieren, ob jemand hier lokale Klassen praktisch einsetzt. Der Nutzen scheint mir sehr beschränkt zu sein.

 

[XHelp]

Mich würde interessieren, ob jemand hier lokale Klassen praktisch einsetzt. Der Nutzen scheint mir sehr beschränkt zu sein.

Ich habe es noch nie benutzt, aber der einzige Nutzen, den ich erkennen kann ist die Möglichkeit Konstruktoren zu nutzen, welche man bei anonymen Klassen nicht hat.

 

[Marco13]

Ein Beispiel könnte sein, wenn man irgendwelche Objekte kurz zusammenfassen will, z.B um einen Array von ints zu sortieren, aber danach noch die "permutation" für den Originalarray zu erhalten - dann könnte man sowas machen wie

class IntPair implements Comparable...
{
    int a, b;
}

Aber es stimmt: Alltäglich sind sie eher nicht...

 

[patrick81]

ein typisches Beispiel für Klassen in Methoden findet man häufig bei Threads und Listeners

z.B wenn ein neuer Thread gestartet wird

public static void main(String[] args) throws Exception {
		
		new Thread(new Runnable() {
			
			public void run() {
				//do something
			}
		}).start();
		
}

kann man auch so definieren

public static void main(String[] args) throws Exception {
		
		class MyRunnable implements Runnable {

			public void run() {
				//do something
			}
			
		}
		
		Runnable runnable = new MyRunnable();
		
		new Thread(runnable).start();
		
	}

 

[tfa]

@patrick81
Das erste Beispiel ist eine normale anonyme Inner Class. Die ist sehr häufig.
Sie durch eine lokale Klasse zu ersetzen wie im zweiten Beispiel ist überflüssig.

 

[Noctarius]

Ich habe es noch nie benutzt, aber der einzige Nutzen, den ich erkennen kann ist die Möglichkeit Konstruktoren zu nutzen, welche man bei anonymen Klassen nicht hat.

Naja fast:

public void foo(final Bar bar) {

  new Thread(new Runnable() {
    privat final String name;

    {
      this.name = bar.getName();
    }

    public void run() {
      doSomething();
    }
  });

}

Man hat also schon eine Art Konstruktor 🙂 Sieht man daran, dass das final-Konstrukt sauber aufgelöst wird.


PS: Auf die Frage nach Benutzung von lokalen Klassen - noch nie gebraucht, anonyme Klassen reichen mir.

 

[Marco13]

Ja, @tfa, sowas ähnliches wollte ich auch @patrick81 schreiben... habe dann aber überlegt, wie man die beiden Fälle voneinander abgrenzen kann. Man könnte GROB sagen, dass man eine Lokale Klasse braucht, wenn man mehrere Instanzen einer Klasse braucht, die anonym sein könnte, wenn ... man nicht mehrere Instanzen brauchen würde ... :roll: (mehr Koffein... 😳 )

 

[Andi_CH]

@patrick81
Das erste Beispiel ist eine normale anonyme Inner Class. Die ist sehr häufig.
Sie durch eine lokale Klasse zu ersetzen wie im zweiten Beispiel ist überflüssig.

... ausser du brauchst sie mehr als einmal

Ein weiteres Beispiel:
Enums haben wir hier einige lokale - in der Regel beschreiben die den Status eines Objektes und sind public. Es kann schon hinterfragt werden ob eine innere Klasse richtig ist, aber einerseits reduziert es die Anzahl Files und, IMHO wesentlich wichtiger, es signalisiert die Zusammengehörigkeit.

Viele heissen "Status" - die Notation

Abc.Status.xyz

ist durchaus elegant zu lesen.

 

[Tomate_Salat]

@Andi_CH: Ich glaube du verwechselst hier nested-class mit locale-class. Eine Nested-Class oder static-nested-class ist ganz nett (wird ja auch sehr gerne von Google eingesetzt 🙂 ). Aber eine lokale klasse, ja ich wusste das es sie gibt. Aber verwendet habe ich sie noch nie. Sehe jetzt keinen Vorteil zur anonymen inneren Klasse.

 

[tfa]

Man könnte GROB sagen, dass man eine Lokale Klasse braucht, wenn man mehrere Instanzen einer Klasse braucht, die anonym sein könnte, wenn ... man nicht mehrere Instanzen brauchen würde

Ja, das wäre der einzige Vorteil.
Vielleicht für Testdaten in einem Unit-Test, wenn man viele Objekte einer Klasse haben möchte. (Man könnte natürlich auch eine normale Nested Class nehmen.)

 

[Noctarius]

Wo braucht man da denn eine lokale Klasse? Ich benötige nur eine Instanz der anonymen Klasse - oder habe ich den Sinn der Aussage "mehrere" falsch verstanden?

public void foo() {
    final Runnable runnable = new Runnable() {
        public void run() {
        }
    }
}

 

[Beni]

Ein weiterer Vorteil von lokalen gegenüber anonymen Klassen ist, dass lokale Klassen mehrere Interfaces implementieren können.

public void foo(){
  class Irgendwas implements Comparable<Irgendwas>, Runnable{
    ...
  }

  List<Irgendwas> list = new ArrayList<Irgendwas>();
  list.add( new Irgendwas( 123 ));
}

P.S. Das letzte mal, dass ich eine lokale Klasse benutzte war ein kleiner, unbedeutender Algorithmus bei dem Objekte auf mehrere Listen und Maps verteilt werden mussten.

 

[Andi_CH]

Schon wieder etwas gelernt ...

Da sieht man, dass an Schulen doch nicht immer alles richtig doziert wird ;-)

Klassen in Klassen drin wurden uns als lokal verkauft und die hier als lokal bezeichneten wurden uns verschwiegen - zugegebenermassen sehe ich allerdings dafür auch keine weitverbreitete Anwendung, denn ...

Ein weiterer Vorteil von lokalen gegenüber anonymen Klassen ist, dass lokale Klassen mehrere Interfaces implementieren können.

... das können nested Classes auch ;-)

 

[Tomate_Salat]

... das können nested Classes auch ;-)

und haben Zugriff auf private:

public class Readable 
{
	public static void main(String[] args) 
	{
		Readable readable=new Readable();
		Readable.Writable writAble=readable.new Writable(); // <-- ist ein wenig ungewohnt zu lesen
		
		writAble.setName("Peter");
		System.out.println(readable.getName());
	}
	
	private String name;
	
	public String getName() {
		return name;
	}
			
	public class Writable 
	{		
		public void setName(String name)
		{
			Readable.this.name=name;
		}		
	}
}

wobei man hier aufpassen muss, dass man wirklich eine nested und keine static-nested verwendet. Letzteres kann gehandhabt werden, wie eine normale top-level-class.

 

[ohmp2007]

Herzlichen Dank