Mai 31

Eine weitere Möglichkeit, dass ein Objekt zur Garbage Collection herangezogen werden kann, ist der Verweis auf eine andere Referenzvariable:

class Angestellter {

public static void main(String[] args) {

String a = “Test1″;

String b = “Test2″;

a=b; // Beide Referenzvariablen zeigen auf b; a ist daher nicht mehr erreichbar und geeignet zur Garbage Collection

}

}

Tagged with:
Mai 29

So, heute wollen wir uns mal anschauen, wie ein Objekt überhaupt zur Garbage Collection herangezogen werden kann,  nämlich indem die Referenzvariable auf null zeigt:

class Angestellter {

public static void main(String[] args) {

String s = “Test”; // nicht geeignet zur Garbage Collection

s=null; // geeignet zur Garbage Collection

}

}

Tagged with:
Mai 27

Garbage Collection (eigentlich englisch für Müllabfuhr; Abkürzung: GC) steht für die Automatische Speicherbereinigung bzw Freispeichersammlung .

Typischerweise ist dies ein sich periodisch wiederholender Vorgang, während dessen die normale Ausführung von Programmen unterbrochen wird, um Objekt-Referenzen zu analysieren und Speicher freizugeben, der zugwiesen, aber noch nicht referenziert wurde.

Es werden nicht länger benötige Speicherbereiche freigegeben oder wiederverwendet, noch nicht benötigte Speicherbereiche zusammengelegt, um ineffiziente Nutzung des bereits zugeteilten Speichers zu vermeiden.

Vorteil der Garbage Collection ist die nicht mehr benötigte explizite Freigabe von Speicher wie z.B. in C++. Die beiden größten Fehlerquellen (zu frühe Freigabe noch referenzierter Objekte oder gar keine Freigabe) werden beseitigt.

Als Nachteil muss angesehen werden, dass das automatische Einsammeln des “Mülls” zur Laufzeit geschieht.  Es entsteht ein sogenannter Overhead, welcher in Echtzeitsystemen zu einem Problem werden kann.

Tagged with:
Mai 24

die letzten Tage haben wir uns recht viele Beispiele angeschaut; was geht, was geht nicht, was geht unter welchen Umständen, etc.

Zum Abschluss dieses Themas (naja, fast, ich habe noch ein paar Übungen für einen späteren Zeitpunkt geplant) will ich die wichtigsten Infos nochmal zusammenfassen:

  • Gib es bei Methodenaufrufen keine exakte übereinstimmung, wird der nächstgrößere Typ “gezogen”.
  • Es wird immer nur der nächstgrößere, aber nie ein kleinerer Wert gezogen, auch wenn dieser theoretisch passen würde, da Datentypen zwar erweitert, aber nicht verkleinert werden können
  • Für den Falle, dass sich der Compiler zwischen Autoboxing und dem größerem Wert entscheiden muss, wird immer der nächstgrößere Wert und nicht der Autoboxing-Wert gezogen.
  • Bei Wahlmöglichkeit immer die genaue Anzahl von Werten gezogen wird und nicht eine variable Anzahl von Werten
  • Diese Wahlmöglichkeitist unabhängig von Autoboxing
  • Referenzvariablen können auch im Zuge des Polymorphismus erweitert werden, da ja jede Subklasse auch eine Überklasse ist.
  • Wrapper können nicht andere Werte (außer ihrem eigenen primitven Wert) aufnehmen. Abhilfe schafft hier die Aufnahme per Object-Klasse und anschließenden expliziten Cast
Mai 23

Wie ich ja vor ein paar Tagen erklährt habe, funktioniert der folgende Code nicht, da Long-Objekte keine Integer-Objekte aufnehmen können:

class Angestellter {

void getPosition(Long a){

System.out.println(“Long-Übernahme”);

}

public static void main(String[] args) {

Integer b = 2;

Angestellter a = new Angestellter();

a.getPosition(b);

}

}

Hier, die Abänderung, mit der dieser Code compiliert werden kann:

public class Angestellter {

void getPosition(Object a){

long b = (Long) a;

}

public static void main (String args[]){

Angestellter a = new Angestellter();
Integer b = 2;
a.getPosition(b);

}

}

Der Typ Objekt kann also jedes andere Objekt aufnehmen, da er Über-Objekt jedes Objektes ist.

Nochmal zur Rekapitulation was genau passiert ist:

  1. die Integer-Referenz wird in eine Objekt-Referenz erweitert
  2. die getPosition-Methode, bekommt eine Objekt-Referenz, die eigentlich eine Integer-Referenz ist
  3. die Methode casted das Objekt  in eine Long-Referenz
Mai 21

Nochmal zur Erinnerung, dass man int-Werte mit Methoden, die einen long-wert aufnehmen aufrufen kann:

class Angestellter {

void getPosition(long a){

System.out.println(“Long-Übernahme”);

}

public static void main(String[] args) {

int b = 2;

Angestellter a = new Angestellter();

a.getPosition(b);

}

}

Dies funktioniert aber nicht bei Wrappern:

class Angestellter {

void getPosition(Long a){

System.out.println(“Long-Übernahme”);

}

public static void main(String[] args) {

int b = 2;

Angestellter a = new Angestellter();

a.getPosition(b);

}

}

Hier wird ein Compilerfehler (The method getPosition(Long) in the type Angestellter is not applicable for the arguments (Integer)) ausgegeben.

Mai 19

Referenzvariablen können auch im Zuge des Polymorphismus erweitert werden, da ja jede Subklasse auch eine Überklasse ist.

class Angestellter {

}

class Buchhalter extends Angestellter {

public static void main(String[] args) {

Buchhalter a = new Buchhalter();

a.getPosition(a);

}

void getPosition(Angestellter a) {

System.out.println(“Angestellter”);

}

}

Für unser Beispiel bedeutet dies, dass ja jeder Buchhalter auch ein Angestellter ist und deswegen diese Erweiterung funktioniert. Der Code wird fehler- und warnungsfrei compiliert

Mai 17

Vor ein paar Tagen haben wir gelernt, das bei einer Wahlmöglichkeit immer der genaue Wert gezogen wird. Dies ändert sich auch nicht, wenn Autoboxing ins Spiel kommt:
class Angestellter {

public void getPosition(int … a) {

System.out.println(“int …. a”);

}

public void getPosition(Integer a, Integer b) {

System.out.println(“Integer a, Integer b”);

}

public static void main(String[] args) {

int a = 1;

int b = 2;

Angestellter angestellter = new Angestellter();

angestellter.getPosition(a,b);

}

}

Ausgabe ist hier logischerweise Integer a, Integer b.

Mai 15

Ihr merkt schon, Überladung ist doch nicht ganz so einfach, wie gedacht.
Heute wollen wir uns mal ansehen, wie der Compiler reagiert, wenn 2 mögliche Aufnahmemethoden zur Verfügung stehen; einmal mit einer variablen Anzahl von Werten und einmal mit der genauen Anzahl der übergebenenen Werte:
class Angestellter {

public void getPosition(int … a) {

System.out.println(“int …. a”);

}

public void getPosition(int a, int b) {

System.out.println(“int a, int b”);

}

public static void main(String[] args) {

int a = 1;

int b = 2;

Angestellter angestellter = new Angestellter();

angestellter.getPosition(a,b);

}

}
Die Ausgabe ist int a, int b; da bei einer Wahlmöglichkeit immer der genaue Wert gezogen wird

Mai 13

Für den Falle, dass sich der Compiler zwischen Autoboxing und dem größerem Wert entscheiden muss, wird immer der nächstgrößere Wert und nicht der Autoboxing-Wert gezogen.
Hier mal wieder ein Beispiel:

class Angestellter {

public void getPosition(long a) {

System.out.println(“long-Methode”);

}

public void getPosition(Integer a) {

System.out.println(“Integer-Methode”);

}

public static void main(String[] args) {

int a = 1;

Angestellter angestellter = new Angestellter();

angestellter.getPosition(a);

}

}

Die Ausgabe ist wie erwartet “long-Methode”, da ja immer der nächstgrößere Wert gezogen wird.

preload preload preload
http://www.wikio.de Blog Top Liste - by TopBlogs.de Blogverzeichnis - Blog Verzeichnis bloggerei.de Bloggeramt.de Software
Webbhotell Top Blogs