Gedächtnisprotokoll SE109-1: Unterschied zwischen den Versionen
Zur Navigation springen
Zur Suche springen
Keine Bearbeitungszusammenfassung |
K (Bot: Kosmetische Änderungen) |
||
(14 dazwischenliegende Versionen von 5 Benutzern werden nicht angezeigt) | |||
Zeile 2: | Zeile 2: | ||
Was trifft für folgenden Programmtext zu? | Was trifft für folgenden Programmtext zu? | ||
int[] intArray = new int[5]; | |||
for (int i : intArray) | |||
{ | { | ||
i = 42; | |||
} | } | ||
int j = intArray[0]; | |||
Antwortmöglichkeiten (ungenau): | Antwortmöglichkeiten (ungenau): | ||
Zeile 17: | Zeile 14: | ||
* intArray[1] ist 0 | * intArray[1] ist 0 | ||
* Die erste Zeile des Methodenrumpfs erzeugt ein Array mit Platz für fünf int-Werte | * Die erste Zeile des Methodenrumpfs erzeugt ein Array mit Platz für fünf int-Werte | ||
== Frage == | |||
Welche Aussagen bezüglich Variablen sind korrekt? | |||
* Bei einem Methodenaufruf werden die Werte der formalen Parameter an die aktuellen Parameter gebunden | |||
* Die Lebensdauer einer lokalen Variable entspricht maximal der Lebensdauer der Methode, in der sie deklariert wurde | |||
* Eine Variable in Java ist die Abstraktion eines physischen Speicherplatzes | |||
* Die Deklaration von Exemplarvariablen und lokalen Variablen ist ''immer'' gleich | |||
* [...] | |||
Zeile 30: | Zeile 37: | ||
* Wenn bei ArrayList ''niemals'' die Kapazität verringert wird, kann bei einer sehr dynamischen Liste viel Speicher unnötig verbraucht werden | * Wenn bei ArrayList ''niemals'' die Kapazität verringert wird, kann bei einer sehr dynamischen Liste viel Speicher unnötig verbraucht werden | ||
* Bei schlechter Wahl des Pivot-Elements hat QuickSort die gleiche Komplexität wie BubbleSort | * Bei schlechter Wahl des Pivot-Elements hat QuickSort die gleiche Komplexität wie BubbleSort | ||
== Frage == | |||
Welche Aussagen stimmen? | |||
* [...] | |||
* Sind bei einem Graphen jeder Kante Gewichte zugeordnet, so spricht man von einem gerichteten Graphen | |||
* Die Implementation eines Graphen mittles Adjazenzlisten ist im Allgemeinen speichereffizienter als eine Implementation durch eine Adjazenzmatrix | |||
* Der kürzeste Weg lässt sich nur in einem gerichteten Graphen bestimmen | |||
* Wenn in einem Graphen mindestens ein Weg existiert, auf dem ein Knoten mehrfach durchlaufen wird, so ist der Graph zyklisch | |||
== Frage == | |||
Welchen Wert hat die Variable g nach Ausführung dieser Anweisungen? | |||
{ | |||
int g = 4; | |||
int h = g + 3; | |||
h = g - h; | |||
} | |||
Antwortmöglichkeiten: | |||
* -3 | |||
* 4 | |||
* 3 | |||
* 0 | |||
== Frage == | |||
Welchen Wert hat h nach Ausführung dieses Programmtextes? | |||
int g = 4; | |||
int h = g + 3; | |||
g = h - 2; | |||
h = g + 2; | |||
Antwortmöglichkeiten (ungenau): | |||
* [...] | |||
* 7 | |||
== Frage == | |||
Welchen Wert hat result nach Ausführung der folgenden Zeilen, wenn sum den Wert 0 und count den Wert 1 hat?: | |||
int result = 2; | |||
if( sum == 0 ) | |||
if( count == 0) | |||
result = 1; | |||
else | |||
result = 0; | |||
* 0 | |||
* 1 | |||
* 2 | |||
* Der Code wirft eine Exception | |||
[[Kategorie:Gedaechtnisprotokoll|SE1]] | [[Kategorie:Gedaechtnisprotokoll|SE1]] |
Aktuelle Version vom 8. Juni 2012, 17:08 Uhr
Frage[Bearbeiten]
Was trifft für folgenden Programmtext zu?
int[] intArray = new int[5]; for (int i : intArray) { i = 42; } int j = intArray[0];
Antwortmöglichkeiten (ungenau):
- intArray[1] ist 42
- j ist 42
- intArray[1] ist 0
- Die erste Zeile des Methodenrumpfs erzeugt ein Array mit Platz für fünf int-Werte
Frage[Bearbeiten]
Welche Aussagen bezüglich Variablen sind korrekt?
- Bei einem Methodenaufruf werden die Werte der formalen Parameter an die aktuellen Parameter gebunden
- Die Lebensdauer einer lokalen Variable entspricht maximal der Lebensdauer der Methode, in der sie deklariert wurde
- Eine Variable in Java ist die Abstraktion eines physischen Speicherplatzes
- Die Deklaration von Exemplarvariablen und lokalen Variablen ist immer gleich
- [...]
Frage[Bearbeiten]
Welche Aussagen stimmen?
- Das Einfügen am Anfang einer Liste ist bei einer LinkedList schneller als bei einer ArrayList
- Das Einfügen am Ende einer Liste ist für ArrayList und LinkedList immer gleich schnell
- Das Lesen eines Elements in der Mitte einer Liste geht schneller bei einer ArrayList
- Die Suche nach einem Element in einer unsortieren Liste hat den Aufwand O(n)
- In einem balancierten, binären Baum hat die Suche nach einem Element die Komplexität O(n log n)
- Wenn bei ArrayList niemals die Kapazität verringert wird, kann bei einer sehr dynamischen Liste viel Speicher unnötig verbraucht werden
- Bei schlechter Wahl des Pivot-Elements hat QuickSort die gleiche Komplexität wie BubbleSort
Frage[Bearbeiten]
Welche Aussagen stimmen?
- [...]
- Sind bei einem Graphen jeder Kante Gewichte zugeordnet, so spricht man von einem gerichteten Graphen
- Die Implementation eines Graphen mittles Adjazenzlisten ist im Allgemeinen speichereffizienter als eine Implementation durch eine Adjazenzmatrix
- Der kürzeste Weg lässt sich nur in einem gerichteten Graphen bestimmen
- Wenn in einem Graphen mindestens ein Weg existiert, auf dem ein Knoten mehrfach durchlaufen wird, so ist der Graph zyklisch
Frage[Bearbeiten]
Welchen Wert hat die Variable g nach Ausführung dieser Anweisungen?
{ int g = 4; int h = g + 3; h = g - h; }
Antwortmöglichkeiten:
- -3
- 4
- 3
- 0
Frage[Bearbeiten]
Welchen Wert hat h nach Ausführung dieses Programmtextes?
int g = 4; int h = g + 3; g = h - 2; h = g + 2;
Antwortmöglichkeiten (ungenau):
- [...]
- 7
Frage[Bearbeiten]
Welchen Wert hat result nach Ausführung der folgenden Zeilen, wenn sum den Wert 0 und count den Wert 1 hat?:
int result = 2; if( sum == 0 ) if( count == 0) result = 1; else result = 0;
- 0
- 1
- 2
- Der Code wirft eine Exception