Archief - [Java] inner class met een static member

Fraggie zei:

Okay:

- Een static var staat ergens op een vaste plaats in het geheugen, los van een object dus. Alle objecten kunnen deze raadplegen/manipuleren. We zeggen dat hij eigen is aan een klasse en niet een object.

Klik om te vergroten...

Fraggie zei:

- Een interne klasse is een instantie van een top-level klasse. Bij het aanmaken van de top-level klasse wordt er dus geheugen vrij gemaakt voor de uitwendige en inwendige klasse. Probeer dit te zien als 1 geheel.

Klik om te vergroten...

Fraggie zei:

- Als je dus een static var, in een interne klasse gedefinieerd hebt, die zelf niet static is, dan zou je per top-level object, een nieuwe static var gemaakt hebben. Nu bind je dus wel een static var aan een object, en niet aan een klasse.

De compiler kan dus onmogelijk de static modifier toepassen op jou var, omdat ze object gebonden is.

Klik om te vergroten...

forloRn_ zei:

Wat bedoel je met "een interne klasse is een instantie van een top-level klasse?" Wat bedoel je met het aanmaken van de top-level klasse? Classloading of instantiëren?

Klik om te vergroten...

forloRn_ zei:

Static staat toch sowieso los van instanties? Volgens mij spreek je hier je eerste punt tegen.

Klik om te vergroten...

Fraggie zei:

Gewoon als je een object aanmaakt van je Outer klasse, dan moet er sowieso geheugen vrij gemaakt worden binnen het object van je Outer klasse, om de Inner te kunnen gebruiken.
M.a.w. bij het initialiseren/aanmaken van je top-level klasse.

Klik om te vergroten...

public class Outer {
	
	public Outer() {
		System.out.println("Outer ctor");
	}
	
	private class Inner {
		Inner() {
			System.out.println("Inner ctor");
		}
	}
	
	public static void main(String[] args) {
		new Outer();
		new Outer();
		new Outer();
	}
}

forloRn_ zei:

Het instantiëren van Outer wilt toch niet zeggen dat er ook een Inner geïnstantieerd wordt?

Klik om te vergroten...

Fraggie zei:

De Inner class is een instantie van de Outer class.

Klik om te vergroten...

forloRn_ zei:

Dat tekeningetje wilt toch gewoon zeggen dat een inner class een referentie heeft naar haar outer class, en dat ze aan alle members van die outer class kan.

Klik om te vergroten...

forloRn_ zei:

Met permissie, maar dat slaat op niks.

Klik om te vergroten...

forloRn_ zei:

Outer en Inner behoren niet tot dezelfde klassenhiërarchie. Je kunt de ene klasse zelfs laden zonder dat de andere geladen wordt en omgekeerd.

Klik om te vergroten...

forloRn_ zei:

Code:

Deze code compileert niet. Ik zie niet in waarom Inner geen static member kan hebben die gedeeld wordt door alle instances van Inner.
[/QUOTE]

Zal gewoon een beslissing zijn van Java in hun design. (of eventueel om een historische reden, dunno)
De reden waarom het niet toegelaten is zal je volgens mij niet echt kunnen achterhalen, tenzij iemand van Java zelf er een statement over gemaakt heeft.

Klik om te vergroten...

forloRn_ zei:

Dat mag je toch niet letterlijk nemen. 't Is niet omdat wij objecten als een mooi geheel zien dat ze daarom ook netjes een continu gebied in het geheugen innemen. Hoe ze juist in het geheugen terechtkomen is interne keuken van het virtual machine en het OS en staat los van Java op zich.

Klik om te vergroten...

1. Een inner class is geen top-level class, net als in VHDL en µC. Je mag er dus ook niet van uit gaan dat ze beide dezelfde eigenschappen hebben.
   
   
2. Je mag zeggen dat in C de voorloper van een class een struct was. En een struct houd alle variabelen in 1 stuk geheugen (we spreken hier over de primitieve datatypes van in Java).
   
   
3. Ik heb een vriend die als afstudeer richting compilers doet, en daar beginnen ze met uitleg te geven over bestaande compilers/technieken. Ook hij zegt dat dat bij het aanmaken van een object de attributen samen gehouden worden.
   
   Het komt er altijd op neer dat, je de hoeveelheid geheugen van je attributen, moet kunnen bezetten in RAM. Hoewel een String nu in Java toch beter is dan een string in C++, zou ik ze nu beschouwen als een plain char array (char = primitief). Nu is het gemakkelijk te begrijpen dat elke klasse een vaste grootte heeft.
   
   Wanneer je objecten van je klassen maakt, en er mee begint te werken ga je alleen maar pointers bij maken en locale variabelen. De Java compilers kan dus onmogelijk weten hoeveel je er zal bij maken (vergelijk dit een beetje met de stack and heap van C++).
   
   
4. Als je in je top-level klasse een static attribuut hebt, dan weet de JVM waar deze staat, tot je alle referenties naar het object verliest.
   
   
   Nu komt het:
5. Bij het aanmaken van een object, van de Outer klasse, MOET er geheugen gemaakt worden voor op zijn minst de attributen, van de Inner klasse. Want de Inner klasse is geprogrammeerd IN de Outer klasse. Dus nog vóór er een object gemaakt wordt van de Inner klasse, zou er reeds nu een stukje “shared memory” moeten bestaan, voor die static attribuut. Waar zou de VM dit moeten schrijven? In de geheugen ruimte van het Outer object? Dan behoord het toch tot het Outer object en niet tot het Inner object?
   
   
6. Stel nu dat jij gelijkt hebt, en er alleen referenties naar Inner objecten in een Outer object staan. Dan vind ik dat als je 1 Outer object en 20 Inner objecten aanmaakt, en je het Outer object vrij geeft de Inner objecten moeten blijven bestaan. Want ze bestaan op hen eentje zonder link/klassenhiërarchie naar het Outer object, zoals jij hier zegt:
   
   

   Outer en Inner behoren niet tot dezelfde klassenhiërarchie. Je kunt de ene klasse zelfs laden zonder dat de andere geladen wordt en omgekeerd.

   Klik om te vergroten...

   
   Dan heb je toch een huge memory leak gemaakt? 20 objecten die blijven bestaan zonder pointers en shared memory gebruiken die nooit meer zal vrij gegeven worden.
   
   Met dit puntje kan ik dus geen vrede sluiten want dit kan gewoon niet in Java. memory leaks zouden verleden tijd moeten zijn in Java, maar daar hebben we totaal geen zicht over.
   
   
7. Moest je echter wel 2 aparte top-level klassen schrijven, die gewoon gebruik maken van elkaar, dan is er geen probleem. Elk object wordt op zijn tijd aangemaakt.
   
   Het verschil zit hem hier in:
   Inner.java
   
   Code:

    public class Inner 
   {
        private static Object member;
   }

   
   Outer.java
   
   Code:

   public class Outer 
   {
       int x;
       Inner innerObject;
       public Outer(int x)
       {
           this.x = x;
           innerObject = new Inner();
       }
   }

   
   Nu beschik je over 2 top-level klassen. Hoewel een object van de klasse Outer nu ook ooit wel eens gebruik zal maken van een object uit de klasse Inner. Daarom kies ik bewust niet voor de default constructor. Dan is de grootte van de klasse Outer bij het aanmaken, echter perfect gekend. Want de regel Inner innerObject; is gewoon een pointer (precies zoals jij al meerdere keren gezegd hebt) naar null en neemt een pointer is altijd even groot (int? long? ala primitief data type).
   
   
   Om het nu volledig over de schreef te gaan (staat los van de jou klassen):
8. Ik denk dat het logisch is dat je geen static attributen kan gebruiken, die van globaal belang zijn in en naamloze instantie van een anonieme (interne) klasse.

Fraggie zei:

[*] Stel nu dat jij gelijkt hebt, en er alleen referenties naar Inner objecten in een Outer object staan. Dan vind ik dat als je 1 Outer object en 20 Inner objecten aanmaakt, en je het Outer object vrij geeft de Inner objecten moeten blijven bestaan. Want ze bestaan op hen eentje zonder link/klassenhiërarchie naar het Outer object, zoals jij hier zegt:

Klik om te vergroten...