Java Applet |
tigerbine
Grünschnabel
Dabei seit: 03.06.2007
Beiträge: 2
|
|
code: |
1:
2:
3:
|
//Nimmt beliebige Objekte entgegen, die ein Schloss haben
static void schliesseAuf(ISchloss ding){
ding.aufschliessen(); |
|
Da hänge ich wieder. Was bedeutet
Dachte hier wird was übergeben von Typ Ischloss. Also ding typisiert Ischloss. Und das geht für mich nicht. Haus oder Tresor wäre für mich gegangen.
|
|
29.01.2014 20:14 |
|
|
Karlito
Kaiser
Dabei seit: 11.04.2011
Beiträge: 1.461
|
|
Naja, ganz einfach gesprochen ist es vom Typ Schloss. Eben ein Schloss mit einem haufen Beton oder einem Metallkasten hinten dran. Es ist einfach eine Art der Abstraktion. In dem Fall beschränken wir uns eben nur auf die Sicht, dass es ein Schloss hat oder ist.... M;an schränkt also die Perspektive auf ein Objekt auf nur die Funktionalität, was das Interface bietet ein.
Jede Klasse, die ein Interface implementiert, kann eben bei Bedarf auf eben nur dieses Interface "reduziert" werden. Das ist immer dann nützlich, wenn Du noch nicht weißt, welche Objekte diese Schnittstelle bereit stellen werden. Man garantiert aber, dass alle diese Objekte in gleicher Art und Weise behandelt werden können, halt nur eingeschränkt auf das Interface.
Sollte das
Wenn das immernoch unverständlich ist, muss ich mal versuchen mir ein Beispiel auszudenken. Das wird dann aber bestimmt erst frühestens morgen. (Soweit nicht noch jemand anderes eine bessere Erklärung hat)
Edit: Folgendes kann man auch machen:
code: |
1:
2:
3:
4:
|
ISchloss haus = new Haus():
ISchloss tresor = new Tresor();
|
|
Wenn jetzt die Klassen Haus und Tresor noch viele andere Funktionen bereit stellen würden, könnte man diese bei den Variablen haus und tresor nicht mehr benutzen. Man schränkt also die Sicht auf nur einen Teilaspekt ein, den die beiden Objekte gemeinsam haben.
VG,
Karlito
|
|
29.01.2014 20:52 |
|
|
ed209
Routinier
Dabei seit: 07.09.2006
Beiträge: 324
|
|
code: |
1:
2:
3:
|
public interface SchokoRiegel {
boolean istLecker();
} |
|
Hier definierst du SchokoRiegel als etwas, das lecker ist oder halt nicht.
D.h. für jede Klasse die das Interface SchokoRiegel implementiert musst du eine methode istLecker implementieren, die true oder false zurückgibt.
code: |
1:
2:
3:
4:
5:
|
public class SchokoLadenKeksGemisch implements SchokoRiegel {
@Override
public boolean istLecker(){
return true;
} |
|
Hier erfindest du einen spezielle Form des SchokoRiegels mit dem Namen SchokoLadenKeksGemisch.
"SchokoLadenKeksGemisch implements SchokoRiegel" bedeutet in diesem Fall "SchokoLadenKeksGemisch ist eine spezielle Form von SchokoRiegel".
code: |
1:
2:
3:
4:
5:
|
public class SchokoladenSuechtiger {
public void essen (SchokoRiegel schokoriegel) {
if(schokoriegel.istLecker()) {
System.out.println("Boah, lecker");
} |
|
Und warum das ganze? Damit Du jetzt deinem SchokoladenSuechtigen eine beliebige SchokoRiegel-Klasse übergeben kannst, ohne dass dabei im Vorfeld klar sein muss um welche Form von SchokoRiegel es sich handelt.
Ich kann jetzt zum Beispiel eine weitere SchokoRiegel-Implementierung schreiben und sie funktioniert mit dem Rest des Programms, ohne dass du sie vorher gekannt hast als Du deinen SchokoladenSuechtiger geschrieben hast.
code: |
1:
2:
3:
4:
5:
6:
|
public class KnoblauchFischRiegel implements SchokoRiegel
@Override
public boolean isLecker() {
return false;
}
|
|
Anstatt dass du eine Instanz von SchokoRiegel direkt machst, machst du dann Instanzen von Klassen die das Interface implementieren. Zum Beispiel:
code: |
1:
2:
3:
4:
5:
6:
7:
8:
|
public static void main(String args[]) {
SchokoladenSuechtiger tigerbine = new SchokoladenSuechtiger();
SchokoRiegel einRiegel = new KnoblauchFischRiegel();
SchokoRiegel nochEinRiegel = new SchokoLadenKeksGemisch();
tigerbine.essen(einRiegel);
tigerbine.essen(nochEinRiegel);
} |
|
Für Tippfehler übernehme ich keine Haftung
Auch wenn es sich um zwei konkrete Arten von Riegeln handelt, kannst Du im Code dann davon abstrahieren und mit generischen Schokoriegeln rumhantieren.
Gruss,
ED
|
|
29.01.2014 23:23 |
|
|
tigerbine
Grünschnabel
Dabei seit: 03.06.2007
Beiträge: 2
|
|
Zitat: |
Original von ed209
code: |
1:
2:
3:
|
public interface SchokoRiegel {
boolean istLecker();
} |
|
Hier definierst du SchokoRiegel als etwas, das lecker ist oder halt nicht.
D.h. für jede Klasse die das Interface SchokoRiegel implementiert musst du eine methode istLecker implementieren, die true oder false zurückgibt.
--> check
code: |
1:
2:
3:
4:
5:
|
public class SchokoLadenKeksGemisch implements SchokoRiegel {
@Override
public boolean istLecker(){
return true;
} |
|
Hier erfindest du einen spezielle Form des SchokoRiegels mit dem Namen SchokoLadenKeksGemisch.
"SchokoLadenKeksGemisch implements SchokoRiegel" bedeutet in diesem Fall "SchokoLadenKeksGemisch ist eine spezielle Form von SchokoRiegel".
--> Spezielle Form? Wie würdest du dann "extends" beschreiben? Sagen wir allgemeine Klasse Keks und SchokoLadenKeksGemisch extends Keks. Kann nun wortklauberei sein, sorry. Ich denke du verstehst scho, wie ich das meine.
code: |
1:
2:
3:
4:
5:
|
public class SchokoladenSuechtiger {
public void essen (SchokoRiegel schokoriegel) {
if(schokoriegel.istLecker()) {
System.out.println("Boah, lecker");
} |
|
Und warum das ganze? Damit Du jetzt deinem SchokoladenSuechtigen eine beliebige SchokoRiegel-Klasse übergeben kannst, ohne dass dabei im Vorfeld klar sein muss um welche Form von SchokoRiegel es sich handelt.
Ich kann jetzt zum Beispiel eine weitere SchokoRiegel-Implementierung schreiben und sie funktioniert mit dem Rest des Programms, ohne dass du sie vorher gekannt hast als Du deinen SchokoladenSuechtiger geschrieben hast.
code: |
1:
2:
3:
4:
5:
6:
|
public class KnoblauchFischRiegel implements SchokoRiegel
@Override
public boolean isLecker() {
return false;
}
|
|
Anstatt dass du eine Instanz von SchokoRiegel direkt machst, machst du dann Instanzen von Klassen die das Interface implementieren. Zum Beispiel:
--> so hätte ich es eher erwartet. Vielleicht ist das Buchbeispiel dann nicht so... doll? ich muss mir aber auf jeden Fall wohl einfach merken, dass es auch Instanzen von Interfaces gibt, oder?
code: |
1:
2:
3:
4:
5:
6:
7:
8:
|
public static void main(String args[]) {
SchokoladenSuechtiger tigerbine = new SchokoladenSuechtiger();
SchokoRiegel einRiegel = new KnoblauchFischRiegel();
SchokoRiegel nochEinRiegel = new SchokoLadenKeksGemisch();
tigerbine.essen(einRiegel);
tigerbine.essen(nochEinRiegel);
} |
|
Für Tippfehler übernehme ich keine Haftung
Auch wenn es sich um zwei konkrete Arten von Riegeln handelt, kannst Du im Code dann davon abstrahieren und mit generischen Schokoriegeln rumhantieren.
Gruss,
ED |
Gruß,
tigerbine
eine weitere Frage, aber neues Java Problem
code: |
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
|
package de.galileocomputing.schroedinger.java.kapitel08;
public class SchuhTesterMitArray implements SolcheSchuheHastDuSchon{
private SchuhPaar[] schuhe;
private int schuhZaehler = 0;
public SchuhTesterMitArray() {
this.schuhe = new SchuhPaar[20];
}
@Override
public void addSchuhPaar(SchuhPaar schuhe){
if(this.schuhZaehler < this.schuhe.length){
this.schuhe[this.schuhZaehler] = schuhe;
this.schuhZaehler++;
}
}
@Override
public boolean hastDuSchon(SchuhPaar neuesSchuhPaar){
boolean hastDuSchon = false;
for (SchuhPaar schuhPaar : this.schuhe);
//....
return hastDuSchon;
}
} |
|
code: |
1:
|
for (SchuhPaar schuhPaar : this.schuhe); |
|
Wird hier über den Array iterriert? Schreibt man dann die aktuelle Position in schuhPaar und kann somit damit "arbeiten" in dem //... Bereich?
Dieser Beitrag wurde 1 mal editiert, zum letzten Mal von tigerbine: 30.01.2014 15:21.
|
|
30.01.2014 15:17 |
|
|
Karlito
Kaiser
Dabei seit: 11.04.2011
Beiträge: 1.461
|
|
Zitat: |
Original von tigerbine
--> Spezielle Form? Wie würdest du dann "extends" beschreiben? Sagen wir allgemeine Klasse Keks und SchokoLadenKeksGemisch extends Keks. Kann nun wortklauberei sein, sorry. Ich denke du verstehst scho, wie ich das meine.
|
Der Unterschied zwischen extends und implements ist, dass extends eine vorhandene Klasse spezialisiert. Ein SchokoLadenKeksGemisch ist ein spezieller Keks, da es alles was der Keks ist erbt und weitere Eigenschaften dazu kommen.
Implements beschränkt sich, wie ich schon versucht habe zu beschreiben, auf nur einen Teilaspekt des Objekts.
Zitat: |
Original von tigerbine
--> so hätte ich es eher erwartet. Vielleicht ist das Buchbeispiel dann nicht so... doll? ich muss mir aber auf jeden Fall wohl einfach merken, dass es auch Instanzen von Interfaces gibt, oder?
|
Es gibt keine Instanzen von Interfaces. Es gibt nur Instanzen von Klassen, die Interfaces implementieren. Ein Objekt einer Klasse, die ein Interface implementiert, ist nur immer auch gleichzeitig vom Typ des Interfaces.
Was dir vielleicht noch nicht klar ist, ist das prinzip der Polymorphie. Wenn eine Klasse eine andere erweitert (extends) oder ein Interface implementiert, dann hat sie zusätzlich zu ihrem eigenen Typ noch die Typen der geerbten Klasse und des Interfaces.
VG,
Karlito
|
|
30.01.2014 15:32 |
|
|
tigerbine
Grünschnabel
Dabei seit: 03.06.2007
Beiträge: 2
|
|
Danke. So langsam brauche ich wirklich mal nen Keks.
Kann mir noch jemand bei der Frage zur Iteration helfen?
|
|
30.01.2014 15:59 |
|
|
|
code: |
1:
2:
|
for (SchuhPaar schuhPaar : this.schuhe)
//tue etwas mit schuhPaar |
|
Ist eine Schleife, mit der das Array schuhe durchlaufen werden kann. (Das Semikolon danach habe ich entfernt, sonst wird in der Schleife genau nichts getan und der Befehl danach nur einmal ausgeführt. In anderen Sprachen heißt die Schleife foreach.
Der Schleife ist sehr ähnlich zu der hier:
code: |
1:
2:
|
(for int i = 0; i < this.schuhe.length; i++)
//tue etwas mit this.schuhe[i] |
|
Es gibt aber einen Unterschied: mit der ersten Variante kannst du nur lesend zugreifen, also nicht schreiben schuhPaar = <wasAuchImmer>;
Bei der zweiten Schleife ist das möglich.
__________________ Syntax Highlighting fürs Board (Link)
|
|
30.01.2014 16:43 |
|
|
tigerbine
Grünschnabel
Dabei seit: 03.06.2007
Beiträge: 2
|
|
|
30.01.2014 16:49 |
|
|
tigerbine
Grünschnabel
Dabei seit: 03.06.2007
Beiträge: 2
|
|
Ich muss nochmal an den Anfang zurückkehren. Datentypen. Denn in den Kurzschreibweisen scheine ich mich ein wenig zu verlieren.
Bei einfachen Datentypen gibt es doch im Grunde 2 Schritte, Deklaration und Wertzuweisung.
code: |
1:
2:
|
int height;
height = 5; |
|
Bei erweiterten Datentypen sind dann 3 Schritte nötig: Deklaration, Erzeugung und Wertzuweisung
code: |
1:
2:
3:
4:
|
char yesKey[];
yesKey = new char[2];
yesKey[0] = 'J';
yesKey[1] = 'A'; |
|
Ist das soweit korrekt? Und das kann man dann auch verkürzt schreiben?
Danke
|
|
31.01.2014 20:32 |
|
|
|
Ja, das ist richtig.
in kurz:
code: |
1:
2:
|
int height = 5;
char yesKey[] = ("JA").toCharArray(); |
|
bzw. nur die ersten beiden Zeilen von yesKey:
code: |
1:
|
char yesKey[] = new char[2]; |
|
__________________ Syntax Highlighting fürs Board (Link)
|
|
01.02.2014 07:38 |
|
|
|
Ob du gleich Werte übergeben kannst, hängt vom Kopf des zugehörigen Konstruktors ab:
code: |
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
|
public class Rectangle {
private double width, height;
//Konstruktor für Rectangle()
public Rectangle(){
this.width = 0;
this.height = 0;
}
//Konstruktor für Rectangle(2,3)
public Rectangle(double width, double height){
this.width = width;
this.height = height;
}
@Override
public String toString(){
return this.width + " * " + this.height;
}
}
public class Main {
public static void main(String[] args) {
Rectangle rect1 = new Rectangle();
Rectangle rect2 = new Rectangle(2,3);
System.out.println("rect1 = " + rect1);
System.out.println("rect2 = " + rect2);
}
} |
|
Ausgabe:
code: |
1:
2:
|
rect1 = 0.0 * 0.0
rect2 = 2.0 * 3.0 |
|
__________________ Syntax Highlighting fürs Board (Link)
|
|
01.02.2014 11:36 |
|
|
tigerbine
Grünschnabel
Dabei seit: 03.06.2007
Beiträge: 2
|
|
Danke.
|
|
01.02.2014 12:00 |
|
|
tigerbine
Grünschnabel
Dabei seit: 03.06.2007
Beiträge: 2
|
|
Nochmal zu den Konstruktoren. Kann eine Klasse auch mehrere haben? Oder wie ist folgender Codebzgl. public Rectangle(){} zu verstehen?
code: |
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
|
public class Rectangle{
private int height =1;
private int width = 1;
public Rectangle(){}
public Rectangle(int height, int width){
this.height = height;
this.width = width;
}
} |
|
|
|
02.02.2014 21:25 |
|
|
Karlito
Kaiser
Dabei seit: 11.04.2011
Beiträge: 1.461
|
|
Hallo tigerbine,
das Prinzip, dass es eine Methode mit dem selben Namen geben kann, welche verschiedene kombinationen von Parametern entgegen nimmt, nennt sich Überladung. Konstruktoren können auch überladen werden. Somit lautet die Antwort ja, es kann mehrere Konstruktoren für eine Klasse geben.
Edit: Der Code ist so zu verstehen, dass es einen Konstruktor gibt, welcher Höhe und Breite initialisiert und einen der dies nicht tut und somit die vorgegebenen Standardwerte übernimmt.
VG,
Karlito
|
|
03.02.2014 00:25 |
|
|
|