OOP 2 Quizes 2019

public void start(javafx.stage.Stage stage) { ... }

Wir haben die Begriffe Bühne (Stage) und Szene (Scene) kennen gelernt

Im Unterricht haben wir die Klasse javafx.scene.Node besprochen.

Im Zusammenhang mit der Klasse javafx.scene.layout.Region haben wir den
Begriff Margin kennengelernt.

Button button = new Button("Click");
button.setOnAction(this::addLabel);
Der Parameter der Methode setOnAction ist vom Typ EventHandler<ActionEvent>.
Dieses Funktional Interface EventHandler enthält die Methode:
void handle(T event)

Im Unterricht haben wir JavaFX Properties kennengelernt

Invalidation Listener sind eine Möglichkeit um ungültige Zustände in
Properties mitzukriegen.

Design Pattern wurden das erste Mal in der Gebäude-Architektur entwickelt
und eingesetzt - Siehe: A Pattern Language, 1977.
Seit dem Buch 'Design Patterns: Elements of Reusable Object-Oriented Software'
aus dem Jahre
1994 werden Muster auch in der Software-Produktion aktiv eingesetzt.

Das Presentation Model (PM) ist ein Design Pattern.

public class LastLaugh {
public static void main(String[] args) {
System.out.print("H" + "a");
System.out.print('H' + 'a');
}
}

Welche Aussage ist korrekt?

Stream<String> echos = Stream.generate(() -> "Echo");
echos.forEach(System.out::println);

List<String> words = List.of("Programmieren", "sie", "viel.");
Stream<String> stream = words.stream().filter(w -> w.length() > 5);
stream.forEach(System.out::println);

Stream<String> longestFirst =
words.stream().sorted(Comparator.comparing(String::length).reversed());

Stream.of("a", "b", "c").noneMatch(e -> "d".equals(e))

List<Optional<String>> optionals = List.of(Optional.ofNullable(null),
Optional.ofNullable("a"));
Stream<String> s = optionals.stream().flatMap(Optional::stream);
s.forEach(System.out::println);

List<String> words = List.of("a", "aa", "aaa", "a");
Map<Integer, List<String>> groups =
words.stream().collect(Collectors.groupingBy(String::length));
Was enthält die Map nach der Ausführung des Codes? Eine Map wird mit {} und eine
List mit [] dargestellt.

Stream.iterate(1, i -> i + 1).limit(100).reduce(0, (x, y) -> x + y)

List<String> wordList = new ArrayList<>();
wordList.add("aaaa");
wordList.add("a");
Stream<String> words = wordList.stream();
words.forEach(s -> { if(s.length() < 3) wordList.remove(s); });

class Dog {
public static void bark() {
System.out.print("woof");
}
}
class Besenji extends Dog {
public static void bark() {
// Besenji dont bark.
}
}
public class Bark {
public static void main(String[] args) {
Dog woofer = new Dog();
Dog nipper = new Besenji();
woofer.bark();
nipper.bark();
}
}

Wir betrachten das UML Diagramm der Interfaces und Klassen, welche das
Collections API bilden. Welche Aussage trifft zu?

Betrachten wir die Interfaces Queue und Deque. Welche Aussage ist korrekt?

Collection<String> coll = ....;
Iterator<String> iter = coll.iterator();
while(iter.hasNext()) {
  String e = iter.next();
  if(e fulfills the condition) {
    iter.remove();
    }
 }

Welche Aussage zum Thema Set ist korrekt?

Map<String, Integer> m = new HashMap<>();
int result = m.get("some-key");

Map<String, Integer> counts = new HashMap<>();
counts.merge("Hans", 1, Integer::sum);

Map<String, Integer> map = new HashMap<>();
map.put("1", 1);
map.put("2", 2);
Set set = map.keySet();
set.remove("1");
Welche Aussage ist nach dem Ausführen des Codes korrekt?

public class Person {
private List<Person> friends;
...
public List<Person> getFriends() {
return Collections.unmodifiableList(friends);
}
}
Welche Aussage ist korrekt?

import java.util.*;
public class MoreNames {
private Map<String, String> m = new HashMap<>();
public void MoreNames() {
m.put("Mickey", "Mouse");
m.put("Mickey", "Mantle");
}
public int size() {
return m.size();
}
public static void main(String[] args) {
MoreNames moreNames = new MoreNames();
System.out.println(moreNames.size());
}
}

Sei

public class Entry<K, V> { ... }

eine generische Klasse.

Wir wollen mit

Entry<String, int> entry = new Entry<>();

eine Instanz dieser Klassen erzeugen.
Welche Aussage ist korrekt?

Unser Typ T soll das Interface Runnable implementieren.
Wir schreiben: T extends Runnable
Welche Aussage ist richtig?

T extends Runnable & AutoClosable

class A {}
class B extends A {}
Nun erzeugen wir Arrays aus diesen Typen:
A[] arr = new A[1];
B[] brr = new B[1];
Dann weisen wir wie folgt zu:
arr = brr;
Schliesslich fügen wir eine neue Instanz vom Typ A hinzu:
arr[0] = new A();

public static void printNamesAndAddMax(List<? extends Employee> staff) {
for(int i = 0; i < staff.size(); i++) {
Employee employee = staff.get(i);
System.out.println(employee.getName());
}
staff.add(new Employee("Max"));
}
Welche Aussage ist richtig?

public static boolean hasNulls(List<?> elements) {
for (Object element : elements) {
if(element == null) {
return true;
}
}
return false;
}
Welche Aussage ist richtig?

ArrayList<String> strings = new ArrayList<>();
System.out.println(strings.getClass());
Welche Aussage ist richtig?

Sei T eine Typ Variable. Betrachten wir den folgenden Code:
T[] result = new T[42];
Welche Aussage ist richtig?

pubic class TheClass<T> {
public boolean equals(T t) {
return true;
}
}

import java.util.*;
public class Name {
private final String first, last;
public Name(String first, String last) {
this.first = first;
this.last = last;
}
public boolean equals(Name n) {
return n.first.equals(first) && n.last.equals(last);
}
public int hashCode() {
return 31 * first.hashCode() + last.hashCode();
}
public static void main(String[] args) {
Set<Name> s = new HashSet<>();
s.add(new Name("Donald", "Duck"));
System.out.println(s.contains(new Name("Donald", "Duck")));
}
}