# deklaration vs definition



## noisebreath (30. Apr 2009)

macht die deklariation im vergleich zur definition einen unterschied was die speicherbelegung anbelang?

also		Typ ace = new Typ(); vs Typ ace;

will wissen ob wenn ich nur deklariere er mir weniger speicher belegt oder alloziiert er gleich volle byte für n integer zb?


----------



## Marco13 (30. Apr 2009)

Unabhängig von den Begrifflichkeiten (die IMHO eher aus der C/C++-Welt stammen)

Typ ace; // Eine Referenz (auf 'null') belegt ca. 4-8 bytes

Typ ace = new Typ(); // Eine Referenz auf ein Objekt - benötigt auch ca. 4-8 bytes, aber das Objekt ist erstellt, und belegt "beliebig viel" Speicher


----------



## noisebreath (1. Mai 2009)

was meinst du mit beliebig viel speicher? dass es beliebig viel von den 4-8 byte belegt?
das heisst es macht keinen unterschied nur zu deklarieren falls ich nicht weiss ob ich das Objekt zur Laufzeit benutze oder?


----------



## Schandro (1. Mai 2009)

Typ ace;
Hiermit erstellst du nur eine Referenz, mehr nicht. Diese kostet nur ein paar Bytes.

new Typ();
Hiermit erstellst du ein neues Object. Das kostet sehr viel mehr Speicher, je nachdem wie die Klasse Typ aussieht.

Typ ace = new Typ();
Hier erstellst du eine Referenz UND ein neues Object. Die Referenz zeigt auf das eben neu erstellte Object.


----------



## Marco13 (1. Mai 2009)

noisebreath hat gesagt.:


> was meinst du mit beliebig viel speicher? dass es beliebig viel von den 4-8 byte belegt?



Nein, beliebig viel heißt, dass wenn die Klasse z.B. so aussieht

```
class Typ
{
    private int array[] = new int[10000000];
}
```
dieses eine Objekt z.B. schonmal ca. 40 MB belegt.



noisebreath hat gesagt.:


> das heisst es macht keinen unterschied nur zu deklarieren falls ich nicht weiss ob ich das Objekt zur Laufzeit benutze oder?



Ein Unterschied besteht immer nur zwischen ZWEI Dingen. Vielleicht willst du auf sowas wie "Lazy Initialization" hinaus?

```
class Main
{
    private Typ typ;

    void foo()
    {
        if (bla)
        {
            typ.doSomething();
        }
        if (blub)
        {
            typ.doSomethingDifferent();
        }
        if (blimp)
        {
            typ.doSomethingElse();
        }
    }
}
```
in diesem Fall bräuchte man das "Typ"-Objekt ja NUR, wenn eine der drei Bedinungen erfüllt ist. Jetzt könnte man z.B. gleich am Anfang diese 3 Bedinungen überprüfen, und das Objekt ggf. erstellen, aber u.U. ist das nicht nötig oder möglich... In so einem Fall KANN es sinnvoll sein, das in dieser Form (mit "Lazy Initialization") zu lösen:


```
class Main
{
    private Typ typ;

    private Typ getTyp() // Zugriff auf "typ" NUR über diese Methode
    {
        if (typ==null) // Falls typ noch nicht erstellt wurde, 
        {
            typ = new Typ(); // wird es jetzt erstellt
        }
        return typ; // Andernfalls einfach das schon erstellte zurückgegeben
    }



    void foo()
    {
        if (bla)
        {
            getTyp().doSomething(); // Typ wird automatisch erstellt, fals nötig
        }
        if (blub)
        {
            getTyp().doSomethingDifferent(); // Typ wird automatisch erstellt, fals nötig
        }
        if (blimp)
        {
            getTyp().doSomethingElse(); // Typ wird automatisch erstellt, fals nötig
        }
    }
}
```

Aber das ist jetzt nur das, was meine Kristallkugel mir zu der Intention deiner Frage gesagt hat ... kann auch falsch sein...


----------



## noisebreath (1. Mai 2009)

es geht tatsächlich darum:

ich hab das jetzt so geschrieben:

```
public void addAlgorithms(Vector<AbstractAlgorithm> as) {
		//TODO: Combiner
		// the average combiner is the default if nothing is set. unless you want another combiner you can skip this line. */

		ComplexAlgorithm ace = null;
		ComplexAlgorithm aie = null;
		ComplexAlgorithm ccc = null;

		ContextSimilarityExtraction cse = null;
		
		for( AbstractAlgorithm a: as ){
			if (a instanceof AbstractConceptExtraction){
				if(ace.getAlgorithms().size()==0)
					ace = new ComplexAlgorithm();
				ac.addAlgorithmTo( ace, a);
			}else if(a instanceof AbstractInstanceExtraction){
				if(aie.getAlgorithms().size()==0)
					ace = new ComplexAlgorithm();
				ac.addAlgorithmTo( aie, a);
			}else if(a instanceof AbstractContextExtraction){
				if(ccc.getAlgorithms().size()==0)
					ace = new ComplexAlgorithm();
				ac.addAlgorithmTo( ccc, a);
			}else if(a instanceof AbstractContextExtraction){
				if(cse.getAlgorithms().size()==0)
					ace = new ComplexAlgorithm();
				ac.addAlgorithmTo( cse, a);
			}
		}
	}
```

das würde mir doch speicher sparen wenn zb irgendeine instance nie auftritt währen der laufzeit oder? 

lg
noise


----------



## Schandro (1. Mai 2009)

> das würde mir doch speicher sparen wenn zb irgendeine instance nie auftritt währen der laufzeit oder?


jep, dass ist besser für die Performance.


----------

