# Zkouška-12.01. 2026

**Co tento kód vypíše?**

```java
public class Test {
    public static void update(StringBuilder sb) {
        sb.append("!");
        sb = new StringBuilder("Hi");
    }

    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder("Hello");
        update(sb);
        System.out.println(sb);
    }
}
```

Odpověď: Hello!

Vysvětlení: V Javě se všechny parametry předávají hodnotou. Reference na nový `StringBuilder` se tedy nepropaguje do `sb` v `main`.

**Máme definovány následující tři interface:**

```java
interface Callable<T> {
    void get(T t);
}

interface Function<T, R> {
    R func(T t);
}

interface UnnaryOperation<T> extends Function<T, T> {
}
```

Které lambda výrazy se správně zkompilují?

1. `Callable<Integer> ca = b -> -b;`
2. `Function<Integer, Integer> fu = b -> -b;`
3. `UnnaryOperation<Integer> uo = b -> -b;`
4. Ani jeden, protože `b -> -b` není zkompilovatelný výraz.

Odpověď: 2., 3.

**Co kód vypíše?**

```java
class A {
    void foo() {
        System.out.println("A");
    }

    void bar() {
        foo();
    }
}

class B extends A {
    @Override
    void foo() {
        System.out.println("B");
    }
}

public class Test {
    public static void main(String[] args) {
        A a = new B();
        a.bar();
    }
}
```

Odpověď: B

**Co udělá tento kód?**

```java
public record Person(String name) {
    public static void main(String[] args) {
        Person p1 = new Person("Peter");
        Person p2 = new Person("Peter");

        System.out.println(p1 == p2);
        System.out.println(p1.equals(p2));
    }
}
```

1. Přeloží se a vypíše false true
2. Přeloží se a vypíše false false
3. Přeloží se a vypíše true true
4. Přeloží se a vypíše true false
5. Nepřeloží se, protože vstupní funkce main nesmí být v record
6. Nepřeloží se, protože funkce equals není na Person definovaná

Odpověď: 1.

**Konstruktory můžeme:**

1. přetěžovat
2. předefinovávat
3. ani jedno

Odpověď: 1.

**Doplňte co možná nejkratší implementaci třídy Resource, aby šel kód přeložit a spustit bez chyb**

```java
class Resource ...

public class Test {
    public static void main(String[] args) {
        try (Resource r = new Resource()) {

        } catch (Exception e) {}
    }
}
```

Možná odpověď:

```java
class Resource implements AutoCloseable {
    public void close() {}
}
```

Triková, ale kratší odpověď:

```java
class Resource extends StringWriter {}
```

Vysvětlení: StringWriter také implementuje AutoCloseable a má bezparametrický konstruktor. Například s FileReader bychom museli v Resource definovat explicitní konstruktor volající jeden z konstruktorů FileReader.

Uznal mi ale i první řešení s nějakým balastem navíc, takže o délku doopravdy nejde.

**Implementace funkce s generiky**

Napište funkci `mergeLists`, která dostane dva kompatibilní objekty implementující interface `List` a vrátí nový `List`, který obsahuje prvky z obou vstupních parametrů. `List` implementuje interface `Iterable` a funkce `T get(int i)` a `void add(T a)`. 

Možná odpověď:

```java
public static <T> List<T> mergeLists(List<? extends T> list1, List<? extends T> list2) {
    List<T> newList = new ArrayList<>();
    
    for (T a : list1) newList.add(a);
    for (T a : list2) newList.add(a);

    return newList;
}
```

Uznával také

```java
public static <T> List<T> mergeLists(List<T> list1, List<T> list2) {
    List<T> newList = new ArrayList<>();
    
    for (T a : list1) newList.add(a);
    for (T a : list2) newList.add(a);

    return newList;
}
```

a

```java
public static <T> List<? super T> mergeLists(List<? extends T> list1, List<? extends T> list2) {
    List<T> newList = new ArrayList<>();
    
    for (T a : list1) newList.add(a);
    for (T a : list2) newList.add(a);

    return newList;
}
```

**Předefinujte ve třídě B funkci void printFields() tak, aby vypsala obsah a i b:**

```java
class A {
    private int a;

    public void printFields() {
        System.out.println(a);
    }
}

class B extends A {
    private int b;

    ...
}
```

Možná odpověď:

```java
    @Override
    public void printFields() {
        super.printFields();
        System.out.println(b);
    }
```

Vysvětlení: Pozor, `a` je private. 

**Doplňte do volání metody sort lambda výraz, který setřídí řetězce podle délky**

```java
List<String> list = new ArrayList<>();
...
list.sort(...);
```

Možná odpověď:

```java
(s1, s2) -> s1.length() - s2.length()
```

**Doplňte implementaci funkce validate, aby true vracela pouze pro knihy, jejichž autor není null a je v kolekci allowedAuthors**

```java
class Book {
    String name;
    String author;
}

public class Library {
    private List<String> allowedAuthors = loadAuthors();

    public boolean validate(Book book) {
        ...
    }
}
```

Možná odpověď:

```java
    public boolean validate(Book book) {
        if (book.author == null) return false;

        for (String allowedAuthor : allowedAuthors) {
            if (book.author.equals(allowedAuthor)) return true;
        }

        return false;
    }
```

Elegantněji třeba:

```java
public boolean validate(Book book) {
    return book.author != null && allowedAuthors.contains(book.author);
}
```