# 2 weitere kurze Fragen



## Sabrina-Berlin (10. Jan 2020)

Hi,
ich benötige erneut eure Hilfe und wäre euch sehr verbunden, wenn ihr mir weiterhelfen könnt.

*Frage 1: Welche Aussage trifft zu?*
public class Lebewesen {
    private String name;
    public String toString() {
        return (name);
    }
}

public class Mensch extends Lebewesen { 
    private char geschlecht;
    public String toString() {
        return (super.toString() + " Geschlecht: " + geschlecht);
    }
}

a) toString() wird überladen
b) toString() liefert einen Compilerfehler, weil super falsch verwendet wird
c) toString() liefert einen Compilerfehler, weil die Attribute name und geschlecht private sind
d) toString() wird überschrieben


Ich denke, dass es entweder a) oder d) sein müssen. Jedoch kenne ich mich mit den Java Thermen nicht so gut aus


*Frage 2: Welche Aussage ist falsch?*
a) Eine Klasse kann mehrere Interfaces implementieren
b) Ein Interface kann als Datentyp einer Variablen verwendet werden
c) In einem Interface darf es implementierte Methoden geben
d) Eine Klasse kann ein Interface implementieren und zusätzlich von einer anderen Klasse erben



Ich danke euch wieder mal 1000 mal im Voraus.


----------



## thecain (10. Jan 2020)

Wieso probierst du es nicht einfach aus? Dann siehst du ja ob deine Annahmen stimmen


----------



## Sabrina-Berlin (10. Jan 2020)

thecain hat gesagt.:


> Wieso probierst du es nicht einfach aus? Dann siehst du ja ob deine Annahmen stimmen


Ich verstehe ehrlich gesagt den Unterschied zwischen toStirng wird überladen und toString wird überschrieben nicht. Ich glaube, eines von beides ist richtig. Jedoch weiß ich nicht welches davon.


----------



## mihe7 (10. Jan 2020)

Sabrina-Berlin hat gesagt.:


> Ich denke, dass es entweder a) oder d) sein müssen. Jedoch kenne ich mich mit den Java Thermen nicht so gut aus


Überladen = mehrere Methoden mit gleichem Namen aber unterschiedlicher Parameterliste
Überschreiben = neue Implementierung einer nicht-statische Methode, die in einer Basisklasse definiert wurde.


----------



## Sabrina-Berlin (10. Jan 2020)

mihe7 hat gesagt.:


> Überladen = mehrere Methoden mit gleichem Namen aber unterschiedlicher Parameterliste
> Überschreiben = neue Implementierung einer nicht-statische Methode, die in einer Basisklasse definiert wurde.


Ah, ok, verstehe. Also wird toString hier überschrieben, richtig? Das heißt Antwort d) ist richtig. Vielen Dank


----------



## mihe7 (10. Jan 2020)

Sabrina-Berlin hat gesagt.:


> Also wird toString hier überschrieben, richtig?


Richtig.

Beim Überladen gibt es in anderen Sprachen mehr Möglichkeiten, z. B. können in C++ auch Operatoren (wie + oder <<) überladen werden.


----------



## kneitzel (10. Jan 2020)

Bei der zweiten Frage muss man aber etwas drauf eingehen denke ich mal, denn die Aussagen sind ja (aktuell) alle richtig:

a) Eine Klasse kann mehrere Interfaces implementieren
Dass dies geht, sollte klar sein. 

b) Ein Interface kann als Datentyp einer Variablen verwendet werden
Auch klar - einfaches Beispiel: `List<String> myList = new ArrayList<>();`
=> List<T> ist ein Interface und das ist hier der Datentyp der Variable myList.

c) In einem Interface darf es implementierte Methoden geben
Geht auch - Änderung kam mit Java 8 und nennt sich default method: https://dzone.com/articles/interface-default-methods-java

d) Eine Klasse kann ein Interface implementieren und zusätzlich von einer anderen Klasse erben
Das ist auch möglich.

Ein Beispiel, das die Punkte A, C und D enthält (B hatte ich ja schon ein Beispiel):
A.java (Interface mit Implementation einer Methode)

```
interface A {
  default void defaultMethod() { System.out.println("default Method"); }
}
```

SuperClass.java:

```
public class SuperClass {
}
```

ExampleClass.java

```
public class ExampleClass extends SuperClass implements A {
}
```

Und lässt sich problemlos übersetzen mit
javac A.java SuperClass.java ExampleClass.java


----------



## kneitzel (10. Jan 2020)

Ach - mehrere Interfaces hatte ich vergessen ... daher noch:
B.java

```
interface B {
  void doB();
}
```

Und ExampleClass dann halt:

```
public class ExampleClass extends SuperClass implements A,B {
  public void doB() {}
}
```


----------



## Sabrina-Berlin (10. Jan 2020)

JustNobody hat gesagt.:


> Bei der zweiten Frage muss man aber etwas drauf eingehen denke ich mal, denn die Aussagen sind ja (aktuell) alle richtig:
> 
> a) Eine Klasse kann mehrere Interfaces implementieren
> Dass dies geht, sollte klar sein.
> ...


Cool, danke für die Antwort. Aber eines davon muss falsch sein, dass heißt ich muss eines auswählen. Welches macht daher am meisten Sinn auszuwählen?


----------



## kneitzel (10. Jan 2020)

C, denn bis Java 8 ging das nicht. Default Methoden sind mit Java 8 eingeführt worden.


----------



## Sabrina-Berlin (10. Jan 2020)

Danke an alle


JustNobody hat gesagt.:


> C, denn bis Java 8 ging das nicht. Default Methoden sind mit Java 8 eingeführt worden.


----------

