Informatiker Board (http://www.informatikerboard.de/board/index.php)
- Sonstiges (http://www.informatikerboard.de/board/board.php?boardid=2)
-- Off-Topic (http://www.informatikerboard.de/board/board.php?boardid=3)
--- Java Applet (http://www.informatikerboard.de/board/thread.php?threadid=1785)

Geschrieben von tigerbine am 29.01.2014 um 20:14:

 

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

code: 
1:

(ISchloss ding)


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. verwirrt


Geschrieben von Karlito am 29.01.2014 um 20:52:

 

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


Geschrieben von ed209 am 29.01.2014 um 23:23:

 

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 Augenzwinkern

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


Geschrieben von tigerbine am 30.01.2014 um 15:17:

 

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 Augenzwinkern

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?


Geschrieben von Karlito am 30.01.2014 um 15:32:

 

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


Geschrieben von tigerbine am 30.01.2014 um 15:59:

 

Danke. So langsam brauche ich wirklich mal nen Keks.

Kann mir noch jemand bei der Frage zur Iteration helfen?


Geschrieben von eulerscheZahl am 30.01.2014 um 16:43:

 

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.


Geschrieben von tigerbine am 30.01.2014 um 16:49:

 

Ja, der ; war falsch. Hab ich ewig gesucht. Danke. smile

Prima, Variante 2 hätte ich "geschrieben", aber du hast ja auch schon den Unterschied erklärt. Daumen hoch

Dann kann ich im Buch weitermachen.

Bis zur nächsten Frage Wink


Geschrieben von tigerbine am 31.01.2014 um 20:32:

  Deklaration

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


Geschrieben von eulerscheZahl am 01.02.2014 um 07:38:

 

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];


Geschrieben von tigerbine am 01.02.2014 um 11:05:

 

Ok, wenn man viel schreibt ist einem sicher das Kurze lieber. Am Anfang muss ich mir die einzelnen Schritte immer wieder ins Gedächtnis rufen. Kommen wir noch zu den benutzerdefinierten Datentypen,

Wir haben eine Klasse rectangle. Nun sind wir in einer anderen Klasse. Dort muss das Deklariert und Erzeugt werden.

code: 
1:
2:

Rectangle rect;
rect = new Rectangle();


Gibt es hier auch so was wie eine Wertzuweisung? Wäre das dann, wenn man dem Konstruktor Werte mitgibt/mitgeben könnte? Ich denke da z.B. an konkrete Abmessungen eines Rechtecks. Dann musste man aber erst gucken, ob der Konstruktor das macht? Also sehr salopp von mir formuliert.

Und in kurz dann

code: 
1:

Rectangle rect  = new Rectangle();


Geschrieben von eulerscheZahl am 01.02.2014 um 11:36:

 

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


Geschrieben von tigerbine am 01.02.2014 um 12:00:

 

Danke. Wink


Geschrieben von tigerbine am 02.02.2014 um 21:25:

 

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;
  }
}


Geschrieben von Karlito am 03.02.2014 um 00:25:

 

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


Forensoftware: Burning Board, entwickelt von WoltLab GmbH