# Interface als Objekt



## disconnectus (22. Apr 2009)

Kann man von einem Interface ein Objekt erzeugen??


```
interface Eintrag {

  public boolean kleinerAls (Eintrag k);

}
```

Was macht diese Zeilen:

```
Eintrag[] element;
```
und 

```
Eintrag hilf;
```

Sind die Objekten? 

Kann ich hilf als Variable benutzen? Kann ich in diesem "Hilf objeckt" einen wert Speichern?

ist "Eintrag []" ein Array?


----------



## Illuvatar (22. Apr 2009)

disconnectus hat gesagt.:


> Kann man von einem Interface ein Obje*k*t erzeugen??


Nein. Nur von konkreten Implementierungen eines Interfaces.


> Was macht diese Zeilen:
> 
> ```
> Eintrag[] element;
> ...


Das sind Deklarationen von Variablen. Diese Variablen können Objekte eines beliebigen Typs enthalten, der Eintrag implementiert.


> Kann ich hilf als Variable benutzen? Kann ich in diesem "Hilf objeckt" einen wert Speichern?


Natürlich - sonst wärs ziemlich nutzlos 


> ist "Eintrag []" ein Array?


Ja. Beziehungsweise in dem Fall die Deklaration einer Variable, die ein Array von Einträgen aufnimmt.


----------



## Schandro (22. Apr 2009)

Eintrag[] ist ein Array, ja..

Du kannst von einem Interface keine Instanz erstellen. Du kannst aber eine Klasse machen die das Interface implementiert. Diese nennen wir jetzt mal EintragImpl.
Eine Instanz von EintragImpl *ist ein* Eintrag. 
Es *ist* auch ein "Object" (weil jede Klasse von Object schlussendlich erbt)
Natürlich *ist* es auch ein "EintragImpl"

Das ganze nennt sich Polymorphie. EintragImpl stellt eine Art Erweiterung zu "Eintrag" bzw. "Object" dar. Deswegen kann man sagen:

Eintrag myEintrag = new EintragImpl();

Die referenz myEintrag zeigt auf ein "Eintrag". Ob das jetzt direkt ein "Eintrag" ist (was ja nicht geht weil man interfaces nicht instanzieren kann) oder ob es eine Erweiterung von "Eintrag" ist, ist egal.

Was ist der Vorteil davon? :
du kannst 10 verschiedene Implementationen von "Eintrag" machen und davon jeweils ein paar Instanzen machen. Obwohl es alles Instanzen von verschiedenen Klassen sind, kannst du sie trotzdem alle in folgende List stecken:
List <Eintrag> meineEinträge = new ArrayList <Eintrag> ();
weil jede der instanzen eben *auch* Einträge sind.

natürlich kannst du dann nur die Methoden, die in "Eintrag" definiert wurden, aufrufen. Ansosnten müsstest du sie wieder zu einen bestimmten höheren Typ casten


----------



## disconnectus (22. Apr 2009)

Was heißt das?


Illuvatar hat gesagt.:


> Das sind Deklarationen von Variablen. Diese Variablen können Objekte eines beliebigen Typs enthalten, der Eintrag implementiert.




"Eintrag hilf;"
welche typ ist hift? Double, int, char ??? Was für ein Wert kann ich speichern?


----------



## Schandro (22. Apr 2009)

Du kannst niemals Werte in variablen speichern.
Variablen sind immer nur referenzen!

sachen wie:

```
double a = 23.6;
int b = -2;
boolean c = false;
```
Sind das auch. Sie zeigen halt nur auf unveränderliche sachen, eben auch die jeweilige Zahl/true/false/...

Ne Referenz wie
Eintrag myEintrag;
dagegen zeigt immer auf eine Instanz von Eintrag.
Du kannst z.b. schreiben:

```
Eintrag myEintrag = new EintragImpl();
myEintrag.setTitle("hallo");
System.out.println(myEintrag.getTitle());
```

Natürlich nur, wenn in Eintrag die Methoden setTitle und getTitle stehen...

Merke: In Referenzen aka Variablen stehen die Werte nicht direkt drin, sondern nur einen Pointer der beispielsweise irgendwo auf den Arbeitspeicher zeigt. Dort ist dann das richtige Object

€dit:
Wenn du also danach noch schreiben würdest

```
Eintrag myEintrag2 = myEintrag;
```
würdest du damit nicht den "Eintrag" clonen oder so. Du würdest lediglich eine weitere "Eintrag"-Referenz erschaffen, die auf dasselbe Object wie myEintrag zeigt.


----------



## tfa (22. Apr 2009)

disconnectus hat gesagt.:


> Was heißt das?
> 
> 
> 
> ...



"Eintrag hilf;"

Die Variable hilf ist vom Typ Eintrag. Ganz einfach.
Da Eintrag ein Interface ist, passen hier Objekte rein, die Eintrag implementieren (direkt oder indirekt).


----------



## andre111 (22. Apr 2009)

```
"Eintrag hilf;"
welche typ ist hift? Double, int, char ??? Was für ein Wert kann ich speichern?
```
hilf ist nur er Bezeichner für eine Variable vom Typ Eintrag.
Das ist das selbe wie mit:

```
int i;
```
i ist der Bezeichner für eine Variable vom Typ int.


----------



## disconnectus (22. Apr 2009)

okey. hilf sie typ eintrag... 

sind alle richtig??


```
hilf = 5; 
hilf= 5.3; 
hilf = " Hallo";
```

ich weiß nicht wie ich diese "hilf" benutzen kann.

Ich meine was ist typ eintrag?


----------



## Schandro (22. Apr 2009)

hast du meinen Post gelesen und nicht verstanden oder hast du ihn nicht gesehen?


----------



## SvenK (22. Apr 2009)

disconnectus hat gesagt.:


> ```
> hilf = 5;
> hilf= 5.3;
> hilf = " Hallo";
> ```


Nichts davon ist richtig, da weder 5 noch 5.3 noch "Hallo" vom Typ Eintrag sind (sondern int, double, String)

Du brauchst eine Klasse die das Interface implementiert zBsp

```
public class EintragImpl implements Eintrag {
...
}
```

Und dann kannst du folgendes machen

```
Eintrag hilf = new EintragImpl()
```

Verstanden?


----------



## Ark (22. Apr 2009)

Was machst du überhaupt schon mit Interfaces rum, wo du nicht einmal Datentypen erkennen, auseinanderhalten und zuordnen kannst?

Ark


----------



## Jango (22. Apr 2009)

Ark hat gesagt.:


> Was machst du überhaupt schon mit Interfaces rum, wo du nicht einmal Datentypen erkennen, auseinanderhalten und zuordnen kannst?
> 
> Ark



Weil die Aufgabenstellung so ist und er keinen Bock hat, sich mit dem Rest(Grundlagen) zu beschäftigen...


----------



## disconnectus (22. Apr 2009)

Die habe ich gelesen und ich weiß wie man mit einem Objekt arbeitet. 

Meine Frage ist anderes. Hier ist es wie ein Variable benutzt. 


```
public class Liste {  
	
  private Eintrag[] element;  // speichert die Listenelemente

  private int anzahl;         // aktuelle Anzahl der enthaltenen Elemente

  public Liste (int maxAnzahl) {             
    // Konstruktor. Erzeugt leere Liste der Laenge maxAnzahl
    element = new Eintrag[maxAnzahl];     
    anzahl = 0;                              
  }

  public void aufnehmen (Eintrag k) {  
    // nimmt das Element k in das aufrufende Listen-Objekt auf
    element[anzahl] = k;
    anzahl = anzahl + 1;
  }
  
  public void sortiere () {
    // sortiert die Elemente des aufrufenden Listen-Objekts aufsteigend
    int m;
    Eintrag hilf;

    for (int i = 0; i < anzahl-1; i++) {
      m = i;
      for (int j = i+1; j < anzahl; j++)
        if (element[j].kleinerAls(element[m]))
          m = j;
      if (m != i) { // Vertauschen
        hilf       = element[i];
        element[i] = element[m];
        element[m] = hilf;
      } 
    } 
  }
  
  public String toString() {
    // liefert eine Kommaaufzählung der Elemente als String zurück
    String s = "(";
    for (int i = 0; i < anzahl-1; i++) {
      s = s + element[i] + ", ";
    }
    s = s + element[anzahl-1] + ")";
    return s;
  }
}
```

In Zeile 22 Es ist wie ein int benutzt. 
In Zeile 3 Es ist wie ein Array deklariert.


----------



## disconnectus (22. Apr 2009)

Schandro hat gesagt.:


> hast du meinen Post gelesen und nicht verstanden oder hast du ihn nicht gesehen?



Alle deine Posts habe ist gelesen. Die sind aber keine Antwort für meine Frage.


----------



## Schandro (22. Apr 2009)

in Zeile 22 ist es wie eine Referenz auf ein "Eintrag" benutzt
in Zeile 3 wird ein Array mit dem Typ "Eintrag" deklariert

Les die Kapitel vllt. nochmal durch


----------



## disconnectus (22. Apr 2009)

was ist vllt?


----------



## SvenK (22. Apr 2009)

Alles schön und gut und auch richtig. Nur was willst du hier übergeben?

```
public void aufnehmen (Eintrag k)
```

Spätestens da brauchst du eine konkrete Implementierung von Eintrag (siehe oben)


----------



## Schandro (22. Apr 2009)

> was ist vllt?


Meine (anscheinend nicht so gebräuchliche) Abkürzung für "vielleicht"^^


----------



## disconnectus (22. Apr 2009)

Kennst du einen guten Stoff?


----------



## faetzminator (23. Apr 2009)

> Meine (anscheinend nicht so gebräuchliche) Abkürzung für "vielleicht"^^


vllt. denkst du das nun auch nur wegen disconnectus' Post 


> Kennst du einen guten Stoff?


Ich würde dir empfehlen (zumindest die ersten Kapitel von) Galileo Computing :: Java ist auch eine Insel (8. Auflage) zu lesen.


----------



## disconnectus (23. Apr 2009)

Danke sehr.... Das Buch habe ich heute gekauft.

Das ist Genau was ich gesucht habe.  Es hat 300 aufgaben mit ihrer Lösungen.


----------

