# Abstraktion - Assiozation - interface / Was bedeuten diese Begriffe?



## whindu11 (17. Nov 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


----------



## Volvagia (17. Nov 2012)

Meiner Erfahrung nach hilft einen bei soetwas die Wiki nicht, die ist oft so formuliert dass sie einen nur beibringt was man sowieso schon weiß. ^^

Da in Java nur Einfachvererbungen möglich sind bieten sich Interface an falls ausschließlich abstrakte Methoden oder Konstanten gebraucht werden.

Nehmen wir mal du hast 2 Klassen: LKW und PKW. Beide machen das Selbe, können beschleunigen und bremsen. Sie tun es aber vollkommen anderst. Dann hättest du die Möglichkeit, ein Interface Auto bereitzustellen, dass die Methoden beschleunige() und bremse() enthält. Dabei können die Autos darin machen was sie wollen, solange sie im Endeffekt beschleunigen oder bremsen. (Ich glaube sonst wiedersprächen sie dem Liskovschen Substitutionsprinzip, eine Subklasse muss sich wie ihr Supertype verhalten. Wohl um Überraschungen bei Polymorphie zu vermeiden.)
So kannst du LKW und PKW beliebig austauschen, der äußere Code macht keinen Unterschied, da die Schnittstellen vom Interface implementiert werden müssen. Ist wichtig zur Entkoppelung von Programmteilen und um die Wartung durch Austauschen von Komponenten zu verringern.

Letztes stimmt glaub ich so, wobei Flugzeug <- Bugrad afaik eine Aggregation (weißer Diamant, Subobjekt des Ganzen) und Flughafen <- Landebahn eine Komposition (schwarzer Diamant, Subobjekt des Ganzen das ohne dem Ganzen nicht existieren kann) wäre. Aber bei UML habe ich nie so richtig durchgeblickt.


----------



## Fab1 (17. Nov 2012)

1. http://www.java-forum.org/einfuehrungen-erste-schritte/117297-interfaces.html

2. Abstraktion - Dinge in der Programmierung oder Informatik allgemein (abstrakt) halten. Würde ich mal sagen. 

3. Assoziation - Wenn Objekte in einer Beziehung zu einander stehen spricht man von Assoziationen. Diese Beziehungen können allerdings auch wieder aufgelöst werden und man kann neue Assoziationen zu anderen Objekten aufbauen.

Assoziation kann man noch weiter in *Aggregation *und *Komposition *unterteilen.

Aggregation - besagt, dass ein Objekt eine Menge von anderen Objekten referenziert.

Komposition - Ist eine Ganze-Teile-Beziehung, dass heißt, dass enthaltene Teilobjekt kann ohne das ganze nicht existieren. Z.B. Der Automotor existiert nicht mehr, wenn das Auto nicht mehr existiert. Da der Motor ein Teil vom Auto ist.


----------



## Spitfire777 (18. Nov 2012)

Hört sich alles komisch an, ist aber eigentlich sehr einfach, wenn mans mal verstanden hat.

1. *Ein Interface/Eine Schnittstelle* ist eine Art Regelsatz, der besagt, welche Methoden (mit welchem Rückgabewert und Parametern) in einer Klasse sein müssen. Der Regelsatz gilt dann, sobald dieser von einer anderen Klasse implementiert wird (public class Xy implements Regelsatz { ... }).

Folgende Sprechweise solltest du dir immer merken: _Klasse "Xy" implementiert ("setzt um", "vervollständigt") das Interface/die Schnittstelle "Regelsatz"._

UndWarum soll ich das machen, wenns auch ohne geht?

Wenn eine Klasse einen "Regelsatz" befolgt, so ist es einfacher Programmteile kompatibler untereinander zu machen. 

Besonders interessant wird das z.B. mit dem Provider-Entwurfsmuster, aber das ist schon viel weiter. 

2. *Abstraktion* bedeutet zu viel wie "Sachverhalt vereinfachen".
Auto ist so z.B. die abstrakte Klasse von BMW. Die abstrakte Klasse Auto enthält alles grundlegende (Methoden, Attribute), was die erbende Klasse BMW alles können und haben muss.

3. *Eine Assoziation *ist die Beziehung zwischen Objekten. z.B. Auto => Rad, Kunde => Rechnung


----------



## whindu11 (18. Nov 2012)

Ich hab mit den Thread zu den Interfacs durchgelesen. Ich muss sagen das ist wirklich sehr schwer zum verstehen.


```
Ohne interface hat der gemacht: 
Car c = new Car(); //hier erzeugt man einfach ein neues Objekt Car

Mit interface:
Buyable b = new Car(); //was bedeutet diese Zeile genau? Buyable und Car sind doch vollkommen andere klassen/typen oder so?
```


Und warum funktioniert das jetzt gerade nur mit einer Methode buyable, das verstehe ich auch noch nicht.

Zur Assoziation:

Eine besondere Form der Assoziation ("hat ein", "besitzt ein") ist die Aggregation.
Dabei wird eine Klasse definiert, die als Datenfeld eine Referenz auf ein Objekt einer
bereits bekannten Klasse enthält.

Kann mir jemand bitte den Satz genau übersetzen und in einem realen und in einem java-Bsp erklären oder so bitte?


----------



## Volvagia (18. Nov 2012)

Normalerweiße stimmt das.
Falls Car aber Buyable implementiert wird Car ein Buyable (da es ja alle Methoden implementieren muss). Damit ist das kein Problem. (Polymorph)
Wie in meinen Beispiel PKW/LKW die Auto implementieren.

Das Zweite beschreibt eigendlich nur wie in einen Beispiel "Flugzeug hat ein Bugrad". (Wobei ich davon ausgehe, dass Bugräder diese ganz kleinen Reifen sind.)


----------



## whindu11 (18. Nov 2012)

Mh ok danke, ich glaube ich habs einigermaßen verstanden mit interface.

Flugzeug hat ein Bugrad. Flugzeug benutzt eine Landebahn. 

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

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

Ist "hat ein" und "besitzt ein" nicht dasselbe?


----------



## whindu11 (18. Nov 2012)

Asoo ups, statt "besitzt ein" gehört "ist ein". Ich hab 2mal dasselbe eingebaut, sorry^^.


----------



## Volvagia (18. Nov 2012)

"Ist ein" Vererbung:


```
public class Flugzeug extends Transportmittel implements Kaufbar, Fliegbar { //Buyable und Flyable klingen besser ^^

}
```

"Hat ein" Speicherung:


```
public class Flugzeug {
	public Motor motor;

	public Flugzeug() {
		motor = new Motor();
	}
}
```

"Benutzt eins" übergeben


```
public class Flugzeug {
	public void lande(Landebahn bahn) {

	}
}
```

Allerdings kommt es im Endeffekt immer auf dem Fall an. Z. B. könnte eine 3. Instanz benutzt werden um an die Daten ranzukommen. Das hilft oft beim Endkoppeln.
Anderst rum kann etwas, das benutzt wird auch gespeichert werden. Das bewirkt aber meistens das Gegenteil und schafft sehr starke Abhängigkeiten zwischen eigendlich getrennten Klassen, die nicht Teil eines Ganzen sind.

Ich würde dir raten einfach loszuprogrammieren, auch falls das eine Hausaufgabe ist. Je mehr du machst umso mehr kannst du damit assoziieren und umso eher kannst du dir darunter auch etwas vorstellen. Das habe ich auch mit meinen Satz über die Wiki gemeint.
(Der genau anderst rum als ich ihm gemeint habe vielleicht arrogant geklungen hat)


----------



## whindu11 (19. Nov 2012)

Ok 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?


----------



## Volvagia (19. Nov 2012)

Es muss immer ein Konstruktor und als erstes im Konstrukor super aufgerufen werden.
Standartmäßig passiert das automatisch.


----------



## whindu11 (19. Nov 2012)

Danke.

Kannst du mir 1 Bsp mit this und 1 Bsp ohne this aufschreiben bitte? Weil ich versteh das gar nicht irgendwie.


----------



## Volvagia (19. Nov 2012)

this zeigt nur auf die aktuelle Instanz. Das ist nur wichtig, falls es eine Instanzvariable und eine Methodenvariable den selben Namen haben. Die Methodenvariable hat Vorrang, die this zeigt dann auf die Instanzvariable.
Ansonst kann man this bei nicht-statischen Dingen schreiben, macht aber keinen Unterschied.


----------



## whindu11 (19. Nov 2012)

Ah ok danke!

Aber eins ist mir noch nciht klar, das mit den ganzen Layouts.

BorderLayout reiht die Elemente nicht der Reihe an sondern passt sie an die Fensterbreite, Länge etc. an(south, north, east, west center).

FlowLyout setzt die Elemente einfach in eine Reihe.

Im folgenden Bsp will ich mein Label ganz unten am Fenster haben(BorderLayout.SOUTH), aber das label ist genau rechts neben den 2 Buttons.

Was ist da los, warum funktioniert das nicht?


```
package uebung001_farbwechseln;
     
    import java.awt.*;
    import javax.swing.*;
    import java.awt.event.*;
     
    public class MainFrame extends JFrame {
      private JPanel contentPane;
      private JPanel panel1;
      private JButton button_green;
      private JButton button_red;
      private JLabel label1;
     
      public MainFrame() {
        try {
          setDefaultCloseOperation(EXIT_ON_CLOSE);
          FrameInit();
        }
        catch (Exception exception) {
          exception.printStackTrace();
        }
      }
     
      /**
       * Component initialization.
       *
       * @throws java.lang.Exception
       */
      private void FrameInit() throws Exception {
        contentPane = (JPanel) getContentPane();
        contentPane.setLayout(new BorderLayout());
        setSize(new Dimension(400, 300));
        setTitle("Frame Title");
       
        panel1 = new JPanel();
        label1 = new JLabel();
        panel1.setLayout(new FlowLayout());
        button_green = new JButton("green");
        button_red = new JButton("red");
        panel1.add(button_green);
        panel1.add(button_red);
        button_green.setFont(new Font("Arial",Font.BOLD,20));
       
        Button_ActionListener bal = new Button_ActionListener();
       
        label1.setText("blub");
       
        panel1.add(label1,BorderLayout.SOUTH);
       
        button_green.addActionListener(bal);
        button_red.addActionListener(bal);
       
        contentPane.add(panel1, BorderLayout.CENTER);
      }
     
      /*private void changeColor {
              if(panel1.getBackground() == Color.red)
              {
                     
              }
              else
              {
                      panel1.setBackground(Color.red);
              }
      }*/
     
      private void buttonHandler(ActionEvent ae) {
              button_red.setEnabled(true);
              button_green.setEnabled(true);
             
              if(ae.getSource() == button_red)
              {
                      button_red.setEnabled(false);
                      panel1.setBackground(Color.red);
              }
              else
              {
                      button_green.setEnabled(false);
                      panel1.setBackground(Color.green);
              }
      }
     
      private class Button_ActionListener implements ActionListener {
              public void actionPerformed(ActionEvent ae) {
                     buttonHandler(ae);
              }
      }
    }
```


----------



## Volvagia (19. Nov 2012)

panel1 hat nun mal das Flow- und nicht das BorderLayout.


----------



## whindu11 (19. Nov 2012)

Danke.

Es existieren da auch noch die Begriffen final und static. final ist klar, hier wird eine Konstante festgelegt(ähnlich #define in C).

Das static ist so halbwegs klar: 


```
private static int x = 0;
privat int x = 0;
```

Bei static kann man diese Variable gleich verwenden ohne das man diese instanzziert hat. Aber in meine Beispiel oben kann man ja beide gleich verwenden, also bringt das static in diesem Fall nichts oder?


```
private JButton button1;
private static JButton button1;
```

Hier ohne static muss man button1 instanzieren und mit static nicht, dies kann man aber nur machen, wenn man einen Button braucht oder?

Gibt es noch mehr Gründe und Erklären für static?


----------



## whindu11 (20. Nov 2012)

Bitte Leute, sagt mir ob ich das richtig erklärt habe .


----------



## Volvagia (20. Nov 2012)

Stimmt nicht.
Keine der Variablen musst du initialisieren, da es Instanz und Klassenvariablen sind. Die sind von Natur aus false bei boolean, 0 bei Zahlenwerten oder null bei Objektreferencen.
Nur Methodenvariablen müssen intialisiert werden.

Static bedeutet, dass die Variablen von der Klasse abhängen. Das bedeutet, besitzt die Klasse Flugzeug das statische double geschwindigkeit und du dir 5 Flugzeuge daraus erzeugst hat jedes dieser Flugzeuge die selbe Geschwindigkeit, da sie alle aus der selben Klasse erzeugt werden.
Statische Attribute werden vor häufig aber nicht immer für Konstante benutzt, statische Methoden vor allem für kleine Hilfsmethoden.


----------

