TU Wien:Einführung in die Programmierung 2 VU (Puntigam)/Fragenkatalog 1. Test

Aus VoWi
Zur Navigation springen Zur Suche springen

Beim Test bekommt man zufällig 5 Fragen mit je 5 Antwortmöglichkeiten. Um neue Fragen hinzuzufügen konvertiere sie mit dieser Website.

Datenabstraktion[Bearbeiten]

Welche der folgenden Aussagen gelten in Java für die unterschiedlichen Arten von Variablen und Parametern?
Formale Parameter und lokale Variablen können gleich heißen.
Lokale Referenzvariablen werden automatisch vorinitialisiert.
Lokale Variablen werden mit private deklariert.
Klassenvariablen werden bei der Objekterzeugung angelegt.
X
Klassenvariablen werden mit static deklariert.
X
Objektvariablen und lokale Variablen können gleich heißen.
X
Objektvariablen werden automatisch vorinitialisiert.
X
Objektvariablen werden bei der Objekterzeugung angelegt.
Welche der folgenden Aussagen treffen auf Objektmethoden bzw. Klassenmethoden zu?
Aufrufe von this(...) sind nur in Objektmethoden erlaubt.
In Klassenmethoden bezeichnet this die aktuelle Klasse.
X
In Klassenmethoden darf this nicht vorkommen.
Jede Methode f() aus einer Klasse C ist durch C.f() aufrufbar.
X
Jede nicht als static deklarierte Methode ist eine Objektmethode.
X
Klassenmethoden haben keinen Zugriff auf Objektvariablen.
Objektmethoden haben keinen Zugriff auf Klassenvariablen.
X
Objektmethoden haben Zugriff auf Objekt- und Klassenvariablen.
Welche der folgenden Aussagen stimmen in Bezug auf Datenabstraktion?
X
Das Resultat ist ein abstrakter Datentyp.
Data-Hiding behindert die Datenabstraktion.
Datenabstraktion verhindert Änderungen von Objektzuständen.
X
Datenkapselung fügt Variablen und Methoden zu einer Einheit zusammen.
Datenkapselung ist ein anderer Begriff für Data-Hiding.
X
Datenkapselung und Data-Hiding sind für Datenabstraktion nötig.
X
Klassen implementieren abstrakte Datentypen.
Kommentare sind in abstrakten Datentypen bedeutungslos.
Welche der folgenden Aussagen müssen für jede Verwendung von this(...) bzw. this in einem Konstruktor zutreffen?
X
this(...); darf nur als erste Anweisung vorkommen.
this(...); darf nur als letzte Anweisung vorkommen.
this darf in Konstruktoren nicht verwendet werden.
this ist nur in static Konstruktoren verwendbar.
this = null; darf nur als erste Anweisung vorkommen.
X
this referenziert das Objekt, das gerade initialisiert wird.
X
Wird this(...); aufgerufen, gibt es keinen Default-Konstruktor.
Zu Beginn gilt: this == null.

Datenstrukturen[Bearbeiten]

Welche der folgenden Aussagen stimmen in Bezug auf die unterschiedlichen Arten linearer und assoziativer Datenstrukturen?
X
Assoziative Datenstrukturen erlauben wahlfreie Zugriffe.
Assoziative Datenstrukturen haben wie Arrays eine fixe Größe.
X
Assoziative Datenstrukturen verwenden Schlüssel zur Adressierung.
Einträge in Queues sind nach Schlüsseln sortiert.
put(k,v) gibt null zurück wenn der Schlüssel k schon existiert.
X
Die Methodennamen push und pop weisen auf LIFO-Verhalten hin.
X
Double-Ended-Queues können auch wie Stacks verwendet werden.
Assoziative Datenstrukturen haben LIFO- oder FIFO-Verhalten.
Welche der folgenden Aussagen stimmen in Bezug auf rekursive Datenstrukturen?
X
Doppelt verkettete Listen sind in beide Richtungen traversierbar.
X
Fortschritt erfolgt durch induktiven Aufbau und Dereferenzierung.
X
Auch zyklische Datenstrukturen müssen fundiert sein.
X
Zur Fundierung können spezielle Knoten verwendet werden.
X
Zur Fundierung wird meist null verwendet.
Jeder Knoten, der mehrere Knoten referenziert, ist Teil eines Baums.
Schleifen erlauben kein vollständiges Traversieren.
Welche der folgenden Aussagen stimmen in Bezug auf die Unterscheidung zwischen Datenstrukturen und abstrakten Datentypen?
X
Abstrakte Datentypen beschreiben vorwiegend Schnittstellen.
Abstrakte Datentypen implementieren Algorithmen.
X
Abstrakte Datentypen lassen verwendete Algorithmen meist offen.
Abstrakte Datentypen müssen bestimmte Datenstrukturen festlegen.
X
Abstrakte Datentypen spezifizieren Typen von Methoden-Parametern.
X
Datenstrukturen beschreiben, wie Operationen auf Daten zugreifen.
Datenstrukturen lassen offen, wie Daten zusammenhängen.
Datenstrukturen legen die Typen ihrer Einträge fest.
X
Datenstrukturen sind unabhängig von bestimmten Programmiersprachen.
Jede Datenstruktur hat eine festgelegte Maximalgröße.
a sei eine Variable mit einer leeren assoziativen Datenstruktur, wobei Schlüssel und Werte vom Typ String sind (und null sein können). X und Y seien zwei voneinander verschiedene String-Konstanten (static final). Nach welchen der folgenden Aufruf-Sequenzen liefert a.get(X) den String in Y als Ergebnis?
a.put(a.get(X), a.get(Y)); a.put(X, X); a.put(Y, Y);
a.put(X, X); a.put(a.get(X), a.get(Y)); a.put(Y, Y);
X
a.put(X, X); a.put(Y, Y); a.put(a.get(X), a.get(Y));
a.put(X, X); a.put(Y, Y); a.put(a.get(Y), a.get(X));
X
a.put(X, Y); a.put(a.get(Y), a.get(X)); a.put(Y, X);
a.put(X, Y); a.put(X, X); a.put(a.get(X), a.get(Y));
X
a.put(X, Y); a.put(Y, X); a.put(a.get(X), a.get(Y));
X
a.put(Y, X); a.put(a.get(Y), a.get(X)); a.put(X, Y);
X
a.put(Y, X); a.put(X, Y); a.put(a.get(Y), a.get(X));
x, y und z seien Objektreferenzen ungleich null. Welche der folgenden Bedingungen müssen für jede Implementierung der Methoden boolean equals(Object obj) und int hashCode() in Java gelten?
X
Aus x.equals(y) folgt x.hashCode() == y.hashCode().
Aus !x.equals(y) folgt x.hashCode() != y.hashCode().
X
Aus x.equals(y) folgt y.equals(x).
X
Aus !x.equals(y) folgt !y.equals(x).
Aus x.equals(y) folgt !y.equals(x).
null.equals(null) gibt true zurück.
X
x.equals(null) gibt false zurück.
x.hashCode() >= 0 gibt true zurück.
Aus x.hashCode() == y.hashCode() folgt x.equals(y).
null.equals(x) gibt false zurück.
t sei eine Variable mit einem einfachen (unbalancierten) binären Suchbaum ganzer Zahlen, der durch diese Anweisungen aufgebaut wurde: STree t = new STree(); t.add(4); t.add(9); t.add(7); Welche der folgenden Aussagen treffen auf t zu?
Der Baum hat eine Tiefe von 2.
X
Der Baum hat eine Tiefe von 3.
Der Knoten mit Wert 7 hat zumindest ein Kind.
Der Knoten mit Wert 7 ist die Wurzel.
X
Der Knoten mit Wert 7 ist ein Blattknoten.
X
Der Knoten mit Wert 9 hat zumindest ein Kind.
Der Knoten mit Wert 9 ist ein Blattknoten.
t sei eine Variable mit einem einfachen (unbalancierten) binären Suchbaum ganzer Zahlen, der durch diese Anweisungen aufgebaut wurde: STree t = new STree(); t.add(7); t.add(9); t.add(4); Welche der folgenden Aussagen treffen auf t zu?
X
Der Baum hat eine Tiefe von 2.
Der Baum hat eine Tiefe von 3.
X
Der Knoten mit Wert 7 ist die Wurzel.
Der Knoten mit Wert 7 ist ein Blattknoten.
X
Der Knoten mit Wert 9 ist ein Blattknoten.
x sei eine Referenz auf einen Knoten (Typ Node) in einer einfach verketteten Liste mit mindestens einem existierenden Nachfolger (in der Objektvariablen next). Welche der folgenden Anweisungs-Sequenzen entfernen den direkten Nachfolger von x aus einer Liste, ändern sonst aber nichts?
x.next.next.next = x.next.next;
Node n = x.next.next; n.next = x;
Node d = x.next; d = d.next;
X
Node d = x.next; x.next = d.next;
X
Node n = x.next.next; x.next = n;

Dynamische und statische Bindung[Bearbeiten]

Welche der folgenden Aussagen stimmen in Bezug auf dynamisches und statisches Binden?
X
Bei statischem Binden kennt der Compiler die auszuführende Methode.
X
Dynamisches Binden ist zusammen mit Untertypbeziehungen nötig.
X
Ein dynamischer Typ ist stets eine Klasse, kein Interface.
Ein statischer Typ ist stets ein Interface, keine Klasse.
Klassenmethoden werden immer dynamisch gebunden.
Objektmethoden werden immer dynamisch gebunden.
Objektmethoden werden in deklarierten Typen von Objekten ausgeführt.
X
Private Methoden werden immer statisch gebunden.
X
Objektmethoden werden in dynamischen Typen von Objekten ausgeführt.
Ein statischer Typ ist stets ein Interface, keine Klasse.
R, S und T seien Referenztypen. Welche der folgenden Aussagen treffen zu?
X
Aus R Untertyp von S und S Untertyp von T folgt: R Untertyp von T.
Aus S ist Klasse und T ist Interface folgt: S ist Untertyp von T.
Aus S Untertyp von T folgt: Kommentare in S und T sind gleich.
X
Aus S Untertyp von T und T Untertyp von S folgt: S.class==T.class.
X
T ist Untertyp von T.
S und T seien Referenztypen, sodass der Compiler folgenden Programmtext fehlerfrei compiliert: T x = new S(); x.foo(); Welche der folgenden Aussagen treffen für alle passenden S, T, x und foo() zu?
Die Methode foo() muss in S vorkommen, in T aber nicht.
X
Durch x.foo() wird die Methode in S ausgeführt.
Es gilt: x.getClass() == T.class
X
Kommentare zu foo() in T müssen auch auf foo() in S zutreffen.
X
S ist Untertyp von T.
T sei ein Referenztyp (Klasse oder Interface), und x sei eine durch R x = new S(); deklarierte Variable, wobei der Compiler keinen Fehler meldet. Welche der folgenden Aussagen treffen für alle passenden R, S, T und x zu?
Mit S ist Untertyp von T gilt: ((T)x).getClass() == R.class
X
Mit S ist Untertyp von T gilt: ((T)x).getClass() == S.class
Mit S ist Untertyp von T gilt: ((T)x).getClass() == T.class
X
(T)null liefert zur Laufzeit keinen Fehler.
X
(T)x ändert den deklarierten Typ von x auf T.
X
(T)x liefert keinen Laufzeitfehler wenn R Untertyp von T ist.
(T)x liefert Laufzeitfehler wenn T nicht Untertyp von R ist.
X
(T)x liefert Laufzeitfehler wenn S nicht Untertyp von T ist.
(T)x ändert den dynamischen Typ von x auf T.
T sei ein Referenztyp (Klasse oder Interface), und x sei eine Variable eines Referenztyps mit x != null. Welche der folgenden Aussagen treffen für alle T und x zu?
Aus x instanceof T folgt x.getClass() == T.class.
X
Aus x.getClass() == T.class folgt x instanceof T.
X
Gilt x.getClass() == T.class, dann ist T eine Klasse.
Gilt x instanceof T, dann ist T der deklarierte Typ von x.
Gilt x instanceof T, dann ist T der dynamische Typ von x.
Gilt x instanceof T, dann ist T eine Klasse.
x.getClass() liefert (interne Repr. vom) deklarierten Typ von x.
X
x.getClass() liefert (interne Repr. vom) dynamischen Typ von x.