# Überladen, Interfaces und Beobachtungsmuster



## Haus00 (22. Jun 2015)

Ich bin JAVA-Anfänger und komme bei drei Teilaufgaben von ein paar Übungszetteln nicht weiter. Es gibt keine Musterlösung und auch wenig Anhaltspunkte in meinen Materialien. Ich hoffe ihr könnte mir ein paar Fragen klären.

Die *erste *geht um das *Überladen von Methoden*:






Meine Lösung:
KlasseA:

```
public class A {
 public void x() {
 System.out.println("hund");
 }
public A() {
 }
}
```

KlasseB:

```
public class B extends A {
 public void x() {
  System.out.println("katze");
}
public B() {
 super ();
}
}
```

KlasseM:

```
public class M {
public static void main (String[]args) {
 A obj1 = new A()
  obj1.x();
}
}
```

So nun zu meiner Frage: Wenn ich die Aufgabe so lösen würde, wäre dann nicht KlasseB vollkommen irrelevant? Bzw. Auf diese Weise "Überlade" ich doch nicht, sondern "Überschreibe"???

Die zweite Aufgabe bei der ich nicht weiterkomme, geht um Beobachtungsmuster. Da würde es mir helfen, wenn man mir einen Tipp geben kann wie ich da anfangen muss.





Bei der dritten Aufgabe, bin ich mir auch unsicher, ob meine Lösung so korrekt bzw. vollständig ist. 





Meine Lösung (alles in einem):

```
public class z
{
public void zMethode (String z)
{
...
}
}


public class y extends z impements x
{
pulic void xMethode (long x)
{
...
}
}


interface x
{
public void xMethode()
{ }
}


public class main
{
public static void main (String[]args) {
y object = new y();
 object.xMethode();
}
}
```


----------



## redJava99 (22. Jun 2015)

zu (1):


> So nun zu meiner Frage: Wenn ich die Aufgabe so lösen würde, wäre dann nicht KlasseB vollkommen irrelevant?


Ja. Aber welche Ausgabe bekommst du mit

```
A myA = new B();
myA.x();
```



> Bzw. Auf diese Weise "Überlade" ich doch nicht, sondern "Überschreibe"???


Ja. Überladen ist etwas anderes und hängt mit den Parametern zusammen, nicht mit Vererbung.


----------



## Haus00 (22. Jun 2015)

> Ja. Aber welche Ausgabe bekommst du mit
> 
> ```
> A myA = new B();
> ...



Dann erhalte ich die Ausgabe "Katze" und die Klasse B wäre nicht mehr irrelevant. Dankeschön. 



> Ja. Überladen ist etwas anderes und hängt mit den Parametern zusammen, nicht mit Vererbung.



Überladen wäre aber, wenn ich es z.B. so mache: (Vom Prinzip) Jedoch darf die Methode x() ja keinen Übergabeparameter haben, wie überlade ich die Methode den dann?

```
//Für Methoden
public void x() 
//überladene Methode
public void x(int xyz )
public void x(int xyz , int abc)

//Für Konstruktoren
public a() {
}
//überladene Konstruktoren
public a(String tier) {
 this.tier = tier; }

public a (String tier, String farbe) {
this.tier = tier;
this.farbe = farbe; }
```

Dankeschön. Das hilft mir schon einmal weiter


----------



## Joose (23. Jun 2015)

Haus00 hat gesagt.:


> Überladen wäre aber, wenn ich es z.B. so mache: (Vom Prinzip) Jedoch darf die Methode x() ja keinen Übergabeparameter haben, wie überlade ich die Methode den dann?



Wenn die Methode "x" keine Parameter haben darf, ist ein überladen nicht möglich.
Überladen bedeutet nichts anderes als die Methode in mehreren Varianten mit unterschiedlichen Parametern anzubieten.
Wobei sich hier die *Anzahl der Parameter, die Typen der Parameter und die Reihenfolge der Parameter unterscheiden* können


----------



## VfL_Freak (23. Jun 2015)

Moin,

hier mal schnell ein Link, der das Überladen ganz gut verdeutlicht:
Überladen von Methoden

Gruß Klaus


----------

