# Abstraktion, Assoziation, interface?



## Googlehupf (17. November 2012)

Hallo!

Was bedeuten denn diese 3 Begriffe?

1. interface: Also interface schreibt man statt class und die jeweiligen Methoden haben keinen Funktionskörper. Was hat das für einen Sinn? Stimmts wie ich es erklärt hab, oder kann man das besser erklären.

2. Abstraktion: Hier habe ich null Ahnung.

3. Assoziation: Naja ich kenn hier nur die Bsp, also das ist einfach die Beziehung von 2 Objekten(oder?): Ein Flugzeug hat ein Bugrad, ist aber kein Bugrad. Der Flughafen hat eine Landebahn, das Flugzeug ist keine Landebahn.
Das Flugzeug benutzt eine Landebahn.

Was sollen diese Sätze jetzt aussagen? 

Trotz Google und mehrfaches durchlesen in Wikipedia und meines Docs ist es mir nicht gelungen diese Begriffe zu verstehn, darum bitte erklärt mir diese Begriffe genau und nennt vielleicht Beispiele zu den Themen.

Danke im voraus!

mfg


----------



## mike-pretzlaw (18. November 2012)

Hallo Googlehupf,

das was Du beschreibst kommt aus der Welt der OOP und dem Modellieren. Es gibt noch viele andere Konstrukte, aber zunächst mal die von dir erfragten:

Interface: Das Interface legt die Schnittstelle fest. Das heißt, dass nur die "Signatur" (Name, Anzahl und Reihenfolge der Argumente) der Funktion wichtig ist. Es ist quasi die Regel, wie alle erbenden Klassen seien müssen. In der Regel werden in einem Interface alle public und protected Methoden festgehalten. Warum? Stell dir vor Du nutzt auf deiner Seite die Klasse von jemand anderen. Er nutzt kein Interface und ändert beim nächsten Update nur einen Methodennamen. Würde deine Seite dann noch einwandfrei laufen? Nein und das hätte das Interface verhindert bzw. den Programmierer drauf aufmerksam gemacht.

Abstraktion: Dein Flugzeug. Ist es ein Fortbewegungsmittel? Jedes Fortbewegungsmittel hat eine Geschwindigkeit, eine Länge, eine Breite und Kosten. (fällt dir noch mehr ein?) In einer abstrakten Klasse kannst du also z.B. so Methoden wie getGeschwindigkeit(), getKosten(), bewege() festhalten. Steht diese Abstraktion einmal, dann kannst innerhalb von Sekunden ein Auto, ein Flugzeug, ein Fahrrad als "echte" Klassen definieren die alle von deinem abstrakten Fortbewegungsmittel erben. Diese Sachen können dann alle die Geschwindigkeit und Kosten liefern und nur noch die feinen Unterschiede müssten von dir ergänzt werden. (das war nur ein Grund der Abstraktion)

Assoziation: Genau richtig. Sieh dir einmal UML (bzw. UML2) an. Die gängigen Beziehungen wie Flugzeug-HAT-Räder, Flugzeug-NUTZT-Landebahn und Flugzeug-IST-... hast Du schon entdeckt. Das wird später interessant, wenn Du größere Projekte planst und deine ersten 5000 Zeilen Code zusammen hast. Wenn Du dann kein Diagramm hast, wo welche Klasse genutzt wird und wie der Aufbau ist, dann wird es selbst für dich schwer deinen Code zu lesen. Stell dir vor ich gebe dir nur 10 Klassen von mir und weiter nichts. Ohne Diagramm und wissen über die Beziehungen, bräuchtest lange und es wäre mühsam sich dort einzuarbeiten. Lies hierzu vllt auch etwas zu Design-Pattern.


----------



## melmager (18. November 2012)

mike-pretzlaw hat gesagt.:


> Ohne Diagramm und wissen über die Beziehungen, bräuchtest lange und es wäre mühsam sich dort einzuarbeiten. Lies hierzu vllt auch etwas zu Design-Pattern.



Wobei ich immer noch nicht weiss wie so ein Diagramm erstellt wird ... Da suche ich immer noch die Passende Software zu die sowas aus vorhanden Code erstellen kann.

zu 1)
eine Schnittstelle sorgt dafür das die dort definierten Functionen auch in der Kasse definiert sind.
Sowas wird gebraucht wenn Classen zusammenarbeiten sollen.


```
interface schnittstelle {
 public int getWertBla();
}

class BenutztEs implements schnittstelle {
// dann muss hier das stattfinden:
public int getWertBla()  {
 return denwert;
}
```
damit weiss die nächste Classe (bzw der Programmierer) das "BenutztEs" auf jedenfall die Function "getWertBla()" hat weil sie die "schnittstelle" imlementiert.


----------



## saftmeister (18. November 2012)

melmager hat gesagt.:


> Wobei ich immer noch nicht weiss wie so ein Diagramm erstellt wird ... Da suche ich immer noch die Passende Software zu die sowas aus vorhanden Code erstellen kann.



Schau hier http://www.eclipse.org/modeling/mdt/?project=uml2
oder hier http://en.wikipedia.org/wiki/MagicDraw
und das: http://green.sourceforge.net/


----------



## genodeftest (18. November 2012)

Oder http://www.uml-lab.com/de/uml-lab/ (ist kostenpflichtig, gibt aber eine Schüler- und Studentenlizenz umsonst)


----------



## mike-pretzlaw (18. November 2012)

In der Theorie kommt erst das Diagramm und dann die Software  
Aber reverse engineering geht zum Glück auch http://www.softwareideas.net


----------



## Googlehupf (18. November 2012)

Danke euch!

Flugzeug hat ein Bugrad. Flugzeug benutzt eine Landebahn.

"benutzt ein", "hat ein", "ist ein" --> Wie kann man das in Java-Code darstellen?

Flugzeug benutzt Landebahn. Flugzeug ist Klasse und Landebahn die Methode?


----------



## saftmeister (18. November 2012)

Nein, Flugzeug ist eine Klasse und Landebahn ist eine Klasse. Daraus erstellt man jeweils ein Objekt z.b. Boing737 und FlughafenFrankfurtBahn26.

Zur Frage: "benutzt ein"

Boing737 bietet eine Methode landen() an. Diese Methode landen() erwartet einen Paramter vom Typ Klasse Landebahn. Dort kannst du dann das Objekt FlughafenFrankfurtBahn26 übergeben.


```
public class Landebahn
{
  private int laenge;

  public Landebahn(int laenge)
  {
    this.laenge = laenge;
  }

  public int getLaenge()
  {
    return this.laenge;
  }
}

public class Flugzeug
{
  private int minimalLaengeLandebahn;

  public Flugzeug(int minimalLL)
  {
    this.minimalLaengeLandebahn = minimalLL;
  }

  public void landen(Landebahn bahn)
  {
     if( bahn.getLaenge() < this.minimalLaengeLandebahn )
     {
       throw new LandeBahnZuKurzException();
     }
  }
}
```

Zur Frage "hat ein":


```
public class Bugrad
{
  private double bereifungsStaerke;

  public Bugrad(double bs)
  {
    this.bereifungsStaerke = bs;
  }

  public double getBereifungsStaerke()
  {
    return this.bereifungsStaerke;
  }
}

public class Flugzeug
{
  private Bugrad bugrad;

  public Flugzeug()
  {
    this.bugrad = new Bugrad(24.7);
  }
}
```

Wie man sieht, hat die Klasse Flugzeug eine Eigenschaft bugrad vom Typ Klasse Bugrad. Innerhalb der Klasse Flugzeug (also in jedem aus der Klasse Flugzeug erschaffenen Objekt) kann man dann auf bugrad zugreifen.

Zur Frage "ist ein":

Java bietet einen Operator instanceof an. Den kann man so verwenden:


```
public void machWasMit(Object o)
  {
    Stadt berlin = new Stadt();
    if( o instanceof Flugzeug )
    {
      Flugzeug flugzeug = (Flugzeug)o;
      flugzeug.fliegeNach(berlin); // Wenn die Klasse Flugzeug eine Methode fliegeNach() anbietet, mit Parameter vom Typ Klasse "Stadt"
    }
  }
```


----------



## Googlehupf (19. November 2012)

Danke!

kann mir einer noch die Befehle this und super() erklären?

Also super() weiß ich ca. schon, das ruft den Konstrukter der Oberklasse von der abgeleitet wurde.

Also: 


```
puplic class MainFrame extends JFrame
{
   puplic MainFrame 
   {
      super();
   }
}
```

Also wird der Konstruktor von JFrame aufgerufen. Und was für Sinn hat das?


----------



## saftmeister (19. November 2012)

this: Bezieht sich immer auf das aktuelle Objekt (also sich selbst).

super(): Wenn du eine abgeleitete Klasse erstellst, die einen eigenen Konstruktor hat, überschreibt dieser Konstruktor den der Eltern-Klasse. Wenn du den Code der Eltern-Klasse aber trotzdem ausführen lassen willst, musst du super() verwenden.


----------



## Googlehupf (19. November 2012)

Mh, das mit this ist mir noch nicht klar.

Kannst du mir vielleicht bitte 2 Bsp zeigen wo einmal mit this und einmal ohne?


----------



## saftmeister (19. November 2012)

this sollte man immer dann verwenden, wenn man mit sog. Inner Classes arbeitet. Dabei wird eine Klasse innerhalb einer Klasse implementiert.

Bsp:


```
public class A
{
  int foo;
  public class B
  {
     int foo;

     public B()
     {
        foo = 0; // Welches foo ist denn jetzt gemeint, das von B oder doch das von A?
     }
  }
}
```


----------



## Googlehupf (19. November 2012)

Ich hab hier ein Bsp zum generieren eine 7Segment-Anzeige.


```
public LED_Anzeige(int stellen) {
		super(); // ruft den konstrukter der Oberklasse auf
		anz_stellen=stellen;
		anzeige = new Led_7Segment[stellen];
		this.setLayout(new FlowLayout());
		for(int i=stellen-1; i>=0; i--) {
			anzeige[i] = new Led_7Segment(0,2); // initial-Wert: 0 --> Größe: 2
			this.add(anzeige[i]);
		}
```

Was meint den jetzt diese 2 this?

Ich meine das add und setLayout kenn ich nur von z.B.:


```
JPanel panel = new JPanel();

panel.add(anzeige[i])
panel.setLayout(new FlowLayout());
```

Ich könnte da ein neuen Panel auch anlegen oder und das so machen?

Aber was macht dieses this in diesem Fall?

Zu deinem Bsp:

Wenn ich jetzt this.foo=1 im Konstruktor B mache, welcher wird dann verändert? Und was ist wenn ich this.foo=2 in der Klasse B mache?


----------



## saftmeister (19. November 2012)

Googlehupf hat gesagt.:


> Was meint den jetzt diese 2 this?
> 
> Ich meine das add und setLayout kenn ich nur von z.B.:
> 
> Aber was macht dieses this in diesem Fall?



Die Klasse (nennen wir sie mal "Fenster"), die diese Methode LED_Anzeige() implementiert, hat entweder auch die Methoden add() und setLayout() implementiert oder aber sie erbt die Methoden von seiner Elternklasse (z.B. JFrame). Auf jeden Fall müssen die beiden Methoden innerhalb der Klasse "Fenster" auf die eine oder andere Art vorhanden sein. Denn this zeigt immer auf das eigene Objekt (sich selbst).



Googlehupf hat gesagt.:


> Wenn ich jetzt this.foo=1 im Konstruktor B mache, welcher wird dann verändert? Und was ist wenn ich this.foo=2 in der Klasse B mache?



In beiden Fällen wird die Eigenschaft "foo" der Klasse B geändert.


----------



## slowfly (19. November 2012)

Kleiner Tipp meinerseits:
Zum Tool: Ich muss Visual Paradigm empfehlen. Ist zwar kostenpflichtig, es gibt aber eine Studentenlizenz.


----------



## Googlehupf (19. November 2012)

Ok, danke das mit foo verstehe ich jetzt.

Ich seh grad das die klasse LED_Anzeige wirklich von JPanel ableitet, was ja heißt das LED_Anzeige setLayout und add von JPanel vererbt hat:


```
public class LED_Anzeige extends JPanel{
	private Led_7Segment anzeige[];
	private int anz_stellen;
	
	public LED_Anzeige(int stellen) {
		super(); // ruft den konstrukter der Oberklasse auf
		anz_stellen=stellen;
		anzeige = new Led_7Segment[stellen];
		this.setLayout(new FlowLayout());
		for(int i=stellen-1; i>=0; i--) {
			anzeige[i] = new Led_7Segment(8,2); // initial-Wert: 0 --> Größe: 2
			this.add(anzeige[i]);
		}	
	}
	
	public void setValue(long value) {
		for(int i=0; i<anz_stellen; i++){
			short rest = (short)(value % 10);
			value = (long)(value / 10);
			anzeige[i].setValue(rest);
		}
	}
}
```

Das eigene Objekt wäre jetzt ein Objekt von LED_Anzeige? Wird das jetzt hier bei "this" instanziert? Und in einer anderen java-datei rufe ich den Konstruktor der klasse LED_Anzeige auf: 
	
	
	



```
LED_Anzeige anzeige = new LED_Anzeige(5);
```

"Methoden müssen auf eine anderen Art vorhanden sein" <--- Was ist damit gemeint?

Erklär mit bitte dieses this mit Hilfe das Programmcodes(oben), ich glaube ich brauch einen Code nebenbei und eine Erklärung und dann kann ich nachvollziehen wie das alles funktioniert. Bitte .

Andere Frage:

ohne this.setLayout(new FlowLayout()); funktioniert das Programm auch, kannst du dir vorstellen warum?

Wie würde das ohne den ganzen this aussehn bzw. wie würde der Code aussehn ohne this und das Programm funktioniert, also am Ende hat man die 7Segment-Anzeigen.

Gruß


----------



## sheel (19. November 2012)

Googlehupf hat gesagt.:


> ohne this.setLayout(new FlowLayout()); funktioniert das Programm auch, kannst du dir vorstellen warum?


Die ganzen Layouts haben nur eine Auswirkung darauf,
wo am Panel und wie groß Buttons/Textfelder etc. sind, wenn man sie einfach so add´et.
Wenn sonst nichts mit dem Flowlayout passiert (außer dieser Zeile)
wird das Programm auch weiterhin problemlos funktionieren,
nur die Sachen am Fenster könnten durcheinander sein.
Buttons unter einem Textfeld statt daneben usw.



Googlehupf hat gesagt.:


> Wie würde das ohne den ganzen this aussehn bzw. wie würde der Code aussehn ohne this und das Programm funktioniert, also am Ende hat man die 7Segment-Anzeigen.


...
this tut nichts sichtbares, das hat keine Auswirkung auf die Programmausführung.

Ich versuch mal selbst eine Erklärung, ohne auf die ganzen verstreuten Beispiele und Hinweise
einzugehen (@Saftmeister&Co: Das soll _nicht_ heißen, dass eure Erklärungen schlecht wären).


Beispielfall:
Eine Klasse Person

```
class Person
{
    public String name;

    public void printName() {
        System.out.println(name);
    }

    public void tuIrgendwas() {
    }
}
```
(Die public-Variable name statt getName/setName ist nur zur Beispielverkürzung).
Irgendwo anders (zB.im main) wird ein Objekt von Person gemacht:

```
Person p;
p = new Person();
p.name = "sheel";
```
Wenn es jetzt irgendeine Methode in irgendeiner Klasse gibt,
der man eine Person übergeben muss

```
class AndereKlasse {
    public void tuWasMitPerson(Peron x) {
        x.printName();
    }
}
```
könnte man im main sowas anlegen und dann die Person daran übergeben:

```
Person p;
p = new Person();
p.name = "sheel";

AndereKlasse anderes = new AndereKlasse();
anderes.tuWasMitPerson(p);
```
Alles kein Problem.

Aber was, wenn eine Person sich selbst irgendwohin übergeben will?
zB. die Person p vom main, wenn Person sowas wäre (tuIrgendwas ist anders)

```
class Person
{
    public String name;

    public void printName() {
        System.out.println(name);
    }

    public void tuIrgendwas() {
        AndereKlasse a = new AndereKlasse();
        a.tuWasMitPerson(?);
    }
}
```
Was übergibt man beim Fragezeichen?
Die Person hat keine Ahnung, wie "ihre" Variable im main draußen heißt (p in dem Fall).
Die Person weiß auch überhaupt nicht, ob ihre Variable im main oder sonst irgendwo ist.
->Sie kommt an ihre Variable einfach nicht dran.

Natürlich kann man einzelne Variablen übergeben, zB. name, indem man einfach name hinschreibt. Aber das komplette Personenobjekt?

Dafür gibt es jetzt this. Das ist eben das komplette Objekt,
ohne dass man den Namen/Ort der Variablen draußen kennen muss.


```
class Person
{
    public String name;

    public void printName() {
        System.out.println(name);
    }

    public void tuIrgendwas() {
        AndereKlasse a = new AndereKlasse();
        a.tuWasMitPerson(this);
    }
}
```
this ist innerhalb der Klasse komplett gleich zu verwenden wie p draußen im main.
zB. könnte man im main ein

```
System.out.println(p.name);
```
machen, das kann dann innerhalb der Klasse so ausschauen:

```
System.out.println(this.name);
```
Wenn man einfach nur schreibt:

```
System.out.println(name);
```
ist das in dem Fall das Selbe wie mit this.name (wann es nicht das Selbe ist siehe unten).

Also, das wäre Anwendungsfall 1: Sich als Komplettobjekt selbst verwenden,
ohne die echte Variable außen zu kennen.


Anwendungsfall 2:
Wenn die Person jetzt ein setName hat (hetName von mir aus auch, ist unwichtig)
(und tuIrgendwas ist jetzt auch unwichtig, weg damit)

```
class Person
{
    public String name;

    public void setName(String neuerName) {
       name = neuerName;
    }

    public void printName() {
        System.out.println(name);
    }
}
```
Kein Problem.
Man könnte auch schreiben

```
this.name = neuerName;
```
wäre auch kein Problem. Vorerst aber mal ohne this.

Würde man den Parameter von setName auch name nennen

```
public void setName(String name) {
    name = name;
}
```
gibts ein Problem.
In Java ist es so, das bei der {}-Klammerung alles weiter innen
wichtiger ist als die äußeren Sachen. Betreffend setName
hat das String name direkt bei der Methode also Vorrang
zum String name der ganzen Klasse.
Jedes name bei setName meint also die selbe Variable, den Parameter.

name=name ist damit ziemlich sinnlos und das Klassen-name bekommt den Wert nicht.
Jetzt kann man mit this sagen, dass man das Klassen-name meint.

```
public void setName(String name) {
    this.name = name;
}
```
That´s all, mehr ist da nicht dahinter.

Diese Variablenüberschneidungen können, wie von den Vorpostern schon gesagt,
auch bei ineinander verschachtelten Klassen vorkommen, statt Methode-in-Klasse.


Etwas noch, wieder bezogen auf das Person p im main:
Man könnte ja die angelegte Person wegschmeißen/überschreiben mit einer neuen Person:

```
Person p;
p = new Person();
p.name = "sheel";

p = new Person();
p.name = "saftmeister";
```
Das geht mit this innerhalb der Klasse nicht, die kann sich nciht selbst wegschmeißen.
Also kein

```
this = new Person();
```
in Person und dann denken, p in main hat das auch übernommen.

So.


----------



## Googlehupf (19. November 2012)

Mh danke, klingt logisch^^.

Schau mal bitte in Zeile 12 bei meinem letzten geposteten Code, da steht ja: "this.add(anzeige[i]);".

In diesem Fall handelt es sich, wegen "this" um die Klasse "LED_Anzeige", die in einem anderen File instanziert wurde(ein Objekt davon wurde erschaffen) und wie verwenden jetzt "this", weil dies Klasse dias Objekt vom anderen File nicht kennt bzw. darauf einfach nicht zugreifen kann.

Richtig?

Wir adden eine 7segmentanzeige auf die Klasse LED_Anzeige, das bedeutet für mich diese Zeile.

Normalerweise kenne ich:


```
panel1 = new JPannel();
panel1.add(anzeige); // also das wir die anzeige, button oder was für ein Element auch immer auf das Panel(Fenster...) adden, ich verstehe nicht ganz warum Zeile 12 oben funktioniert.
```


----------



## sheel (19. November 2012)

Zum Code:
Das ist ja, wenn es außerhalb von der Klasse gemacht wird.

Innerhalb der Klasse wäre es eben
this.add(anzeige);
oder, falls nur diese Methode add existiert, kann man auch einfach schreiben
add(anzeige);

Das eine Klasse ihr Objekt draußen nicht kennt ist ja eigentlich der Regelfall.


----------



## Googlehupf (19. November 2012)

Mh ja ok, aber ich verstehe einfach nicht, wo die 7Segment-Anzeige geaddet wird. Wenn ich in den Code schaue sehe ich nirgends, das diese 7Segment-Anzeige auf das Panel bzw. Fenster geadded wurde.

Wenn jetzt z.B. folgendes stehen würde dann kenn ich mich aus: panel.add(button);

Hier weiß ich, dass der Button auf dem Panel drauf ist.

Und bei this.add(anzeige[ i ]), kann ich nirgends erkennen, das die ledanzeige auf ein Panel geadded wird.

Sieht man das irgendwo, oder wie soll man das erklären?


----------



## sheel (19. November 2012)

Der Code steht in der Klasse LED_Anzeige,
also meint this ein LED_Anzeige-Objekt.
LED_Anzeige extends JPanel.
Also erbt this (und alle andern LED_Anzeigen) von JPanel, und ist damit ein JPanel.
this=panel

anzeige[ i ] ist ein LED_7segment. Keine Ahnung,
was das ist (Button wohl nicht, von was erbt es?),
aber irgendwas addbares wirds wohl sein.


----------



## Googlehupf (19. November 2012)

```
public class Led_7Segment extends java.awt.Canvas
```

Also wir haben da so eine fertige Bibliothek davon bekommen. Die hat irgendwer von der Schule geschrieben und beinhalten halt Methoden(setValue, getValue, keine add-Methode laut Skriptum etc.)


----------



## saftmeister (20. November 2012)

Googlehupf hat gesagt.:


> ```
> public class Led_7Segment extends java.awt.Canvas
> ```
> beinhalten halt Methoden(setValue, getValue, keine add-Methode laut Skriptum etc.)



Schau mal:

Deine Led_7Segment Klasse leite ab von
java.awt.Canvas leitet ab von java.awt.Component.

Eine add()-Methode muss diese Led_7Segment Klasse auch gar nicht anbieten. Denn die Led_7Segment Klasse ist selbst eine Komponente, die man einem Container hinzufügen kann. Da sie selbst kein Container ist, sondern zum darauf Zeichnen benutzt wird, muss sie auch keine Methode zum hinzufügen weiterer Komponenten oder die Möglichkeit des Verwendens eines Layout-Managers anbieten.

Ein Container wäre z.B. javax.swing.JFrame (landläufig bekannt als "Fenster") oder auch das verwendete und dir bekannte javax.swing.Panel. Beide erweitern java.awt.Container und bieten damit unter anderem die Methoden 

- add(Component comp)
- setLayout(LayoutManager mgr) 

an.

Was du hier siehst, ist die Klassen-Hierarchie und du solltest dich damit anfreunden ;-)


----------

