[Java] Umgang mit abstrakten Klassen, Interfaceklassen (BSP)

[IpostedIT]

Hallo,

ich versuche mich gerade in Java einzulesen. Arbeiten damit fällt mir noch imens schwer, zumal ich nicht alle Grundlagen verstanden habe.
Nun habe ich jedoch folgende Aufgabe vor mir liegen (die ich im Netz gefunden habe) und wollte mal fragen, ob mir die vielleicht jemand lösen kann (habe leider keine Musterlösung dazu im Netz gefunden. Nur, wie man von Fahrenheit nach Celsius umrechnen kann und das benötige ich hier leider nicht).

Mein Problem: Ich weiß nicht, wie ich mit abstrakten Klassen oder Interfaceklassen umgehen muss bzw wie ich auf die jeweiligen Unterklassen Celsius oder Fahrenheit verweisen kann.


Die Aufgabe:

Gegeben sei eine abstrakte Klasse ZahlMitEinheit zur Repräsentation von mit Einheiten behafteten Zahlen. Downloadlink:
http://www.xup.in/dl,26889831/ZahlMitEinheit.class/

Der Konstruktor ist gegeben durch die Signatur:
public ZahlMitEinheit(double wert);

Zusätzlich gibt es Methoden zum Zugriff auf den gespeicherten Wert:
public double getWert();
public void setWert(double wert);

Die abstrakten Methoden sind gegeben durch
public abstract String getEinheitsName();
public abstract ZahlMitEinheit konvertiereZuStandard();

welche den Namen der Einheit zurück gibt bzw. die Umwandlung in eine Standardeinheit übernimmt.


1. Entwerfen Sie ein Interface Temperatur zur Definition von Temperaturen. Teile des Interfaces sollen die Methoden erwaermen(double delta) und abkuehlen(double delta) sein zum Erhöhen bzw. Erniedrigen der aktuellen Temperatur um ein positives delta. Für unzulässige Werte von delta soll eine Exception geworfen werden.

2. Entwickeln Sie zwei Klassen Celsius und Fahrenheit, die jeweils sowohl Temperatur implementieren als auch ZahlMitEinheit erweitern. Die Standardeinheit soll Celsius sein.

Also zu 1. dachte ich mir, dass es eine "IllegalArgumentException" sein muss. (Soweit hab ich zumindest in einem Java-Tutorial gelesen). Weiß auch nicht, wie die zu implementieren ist.

Interface Temperatur erstellen:

public interface Temperatur{

public void erwaermen(double delta){
try{ wert=wert+delta };
catch{IllegalArgumentException};

public void abkuehlen(double delta);
try{ wert=wert-delta };
catch{IllegalArgumentException};

}

Ist das der einzige Inhalt? Ich habe wirklich keinen Plan.
Interface beinhaltet ja abstrakte Argumente, d. h. ich müsste z. B. Celsius folgendermaßen deklarieren:

abstract class Celsius implements Temperatur extends ZahlMitEinheit{

}

Aber das funktioniert irgendwie nicht.

Kann ich auf die Argumente der Superklasse ZahlMitEinheit irgendwie verweisen?

Wäre schon super, wenn mir das jemand vormachen/mir helfen könnte.
Ich bekomm's echt nicht gebacken.

LG

 

[mvitz]

Ein Interface darf nur den Methodenkopf beinhalten.

public void erwaermen(double delta);

Die Klasse Celsius muss dann aber nicht mehr abstract sondern konkret sein:

public class Celsius extends ZahlMitEinheit implements Temperatur {
}

in dieser musst du dann alle Methoden von Temperatur und alle abstrakten Methoden aus ZahlMitEinheit implementieren.

 

[SlaterB]

ein Interface enthält nur Methoden-Signaturen wie
public void setWert(double wert);

keinen Code und auch kein try/ catch usw
das gehört in die implementierende Klasse

-----

>abstract class Celsius implements Temperatur extends ZahlMitEinheit{

erst extends XY, dann implements XY, kein Lehrbuch für derartige Grundlagen?
(edit: ja das abstract muss auch weg, siehe Vorposting)

mit einfachen google-Suchen wie
http://www.google.de/search?hl=de&q=extends+implements&meta=
findet man auch tausende Java-Klassen als Beispiele,

man müßte vorher natürlich ungefähr ne Ahnung haben, was nicht stimmt,
wie lautet denn die Compilerfehlermeldung? danach richten

-----

> public void abkuehlen(double delta);
> try{ wert=wert-delta };
> catch{IllegalArgumentException};

sieht wie eine missglückte Implementierung einer Methode aus,
auch noch nie gemacht, von sowas wie { und } schon gehört?
-> Beispiele in Lehrbüchern anschauen,

gehört nicht ins Interface wie schon gesagt, für die Celsius-Klasse noch als Tipp:

in der Methode wird die IllegalArgumentException nicht gefangen sondern geworfen (!), wenn delta falsch ist,
fangen mit try/ catch muss sie wenn überhaupt, dann der Aufrufer der Methode

 

[ARadauer]

public interface Temperatur{ 

public void erwaermen(double delta){ 
try{ wert=wert+delta }; 
catch{IllegalArgumentException}; 

public void abkuehlen(double delta); 
try{ wert=wert-delta }; 
catch{IllegalArgumentException}; 

}

wups!! ich denke du fängst nochmal ganz von vorne an.
also ein interface definiert nur die schnettstelle, also die mehtoden. aber diese haben bei einem interface keinen inhalt, raus mit dem try{ wert=wert-delta }; das hat in einem interface nichts zu suchen!

dein interface muss so aussehen

public interface Temperatur{ 

   public void erwaermen(double delta) throws IllegalArgumentException;


   public void abkuehlen(double delta) throws IllegalArgumentException;
}

welcher code jetzt genau in abkühlen und erwärmen drinnen steht, muss in den klassen die das interface erweitern definiert werden.....

(ich finde das Beispiel schlecht, was bedeuet das erwärmen? warum muss das im interface definiert werden, ist das nicht bei beiden gleich oder hat das delta eine einheit?)

 

[ARadauer]

da war ich wohl zu langsam, ich hab kurz versucht das beispiel zu implementieren, als ich mir drauf gekommen bin, dass es überhaupt nicht schlüssig und schlecht entworfen ist....

ich zeit dir das mit meinem typischen tier beispiel...

 

[mvitz]

Wobei du das

throws IllegalArgumentException

nicht brauchst (oder sogar nicht schreiben darfst?), da es eine RuntimeException ist...
Das Beispiel ist zum Anfangen echt stellenweise doof.

 

[IpostedIT]

Ist ja unglaublich wie schnell hier geholfen wird.

Ja, ich weiß, dass mein Coding wirklich schlecht ist, aber wie gesagt, ich bin noch nicht so lange dabei und habe dieses Beispiel im Netz unter "leichte Aufgaben" gefunden. xD

 

[ARadauer]

so hier mei Tier Beispiel....

import java.util.ArrayList;

public class Test{ 

   public static void main(String[] args) {
      //er sinn des ganzen ist, dass meine Methoden die Katzen und Hunde nicht kennen müssen, sondern nur die Abstracte Klasse oder das Interface
      //das ermöglicht mir ein extrem flexibles Design meiner Software

      Test test = new Test();

      ArrayList<Tier> tiere = new ArrayList<Tier>();

      tiere.add(new Katze("Muschi"));
      tiere.add(new Katze("Murli"));
      tiere.add(new Hund("Rex"));
      tiere.add(new Hund("Wuffi"));      
      tiere.add(new Katze("Katerxx"));
      beschreibeTiere(tiere);
   }

   public static void beschreibeTiere(ArrayList<Tier> tiere){
      for(Tier t:tiere){
         System.out.print(t.getTierArt()+" "+t.getName()+" macht ");
         lassLautgeben(t);
         System.out.println();
      }
   }

   public static void lassLautgeben(KannLautGeben tier){
      System.out.print(tier.gibLaut());
   }

}
abstract class Tier implements KannLautGeben{
   String name;

   public Tier(String name){
      this.name = name;         
   }
   public String getName() {
      return name;
   }
   public void setName(String name) {
      this.name = name;
   }

   abstract public String getTierArt();
}

interface KannLautGeben {
   public String gibLaut();
}


class Katze extends Tier {

   public Katze(String name){
      super(name);                  
   }

   @Override
   public String getTierArt() {
      return "Katze";
   }

   @Override
   public String gibLaut() {
      return "miau";
   }      
}

class Hund extends Tier  {

   public Hund(String name){
      super(name);                  
   }

   @Override
   public String getTierArt() {
      return "Hund";
   }

   @Override
   public String gibLaut() {
      return "wuff wuff";
   }      
}

Wichtig um das ganze Interface und Polymorphismus Konzept zu verstehen ist, dass du den Vorteil erkennst, das die Methode beschreibeTiere die Klasse Katze und Hund gar nicht kennen muss, es muss nur die überklasse Tier kennen. Bzw die Methode lassLautgeben das Interface KannLautGeben.... damit kannst du wirklich flexible Software Bauen wo du ganze Teile die sich nur über Schnittstellen kennen, austauschen kannnst...... usw.. feierabend...

 

[IpostedIT]

Danke für das Beispiel. Werde es mal verinnerlichen ^^

 

[SvenK]

Die Sache mit den Interface ist eigentlich garnicht so schwer...

Interfaces legen nur fest, eben welche Schnittstelle (sprich welche Methoden) man von einer Klasse, die ein spezielles Interface implementiert, zu 100% erwarten kann. Implementiert diese Klasse eine der Interface-Methoden nicht, gibt es einen Compilerfehler.


An einem Beispiel wirst du den Einsatz von Interfaces auch relativ schnell verstehen (denke ich):

In Java (und in anderen OO-Programmiersprachen mit Interfaces) ist es ein Best-Practice, immer gegen Interfaces zu programmieren. Das heisst man definiert Variablen nicht vom Typ einer bestimmten Implementierung, sondern eben vom Typ des Interfaces

Beispiel

public interface TerminListe {
	public String getTermin(int id);

	public void setTermin(Termin termin);
}

Nun hast du irgendwo eine Klasse, die mit einer Terminliste arbeitet (ein Kalenderprogramm zBsp) und dort gibt es eine Methode

public void setTerminListe(TerminListe tliste){
  this.tliste = tliste;
}

Dieser Methode ist es nun egal, welche konkrete Implementierung einer Terminliste du ihr übergibst. Es kann zBsp eine TextFileTerminListe sein, bei der die Termine in eine Textdatei gespeichert werden. Oder eine DaoTerminListe, die ihre Daten in einer Datenbank ablegt. Oder XMLTerminListe, RemoteTerminListe usw .....

Der Klasse mit der setTerminListe-Methode ist es egal, wo die Daten herkommen. Hauptsache Sie kann mit tliste.getTermin( id ) einen Termin abrufen und mit tliste.setTermin( termin ) einen speichern.

Comprende?

 

[IpostedIT]

Jou, soweit hab ich das an dem Tierbeispiel schon verstanden, denke ich.


Also Interface Temperatur ist so'ne Art mittlere Superklasse, die es nicht interessiert, was in ZahlMitEinheit (Bezug Aufgabe), der Superklasse, steht. Jedoch sind die Subklassen Celsius und Fahrenheit von Temperatur abhängig, da alle "Temperaturveränderungen" (Veränderungen des double-Wertes) in diesen Subklassen von der Interfaceklasse Temperatur durchgeführt werden.


Wenn ich das so richtig verstanden habe. Wie kann ich denn abfragen, ob man lieber eine Tempertatur in Celsius oder in Fahrenheit dargestellt haben möchte?
Muss hierfür nicht irgendwo noch eine main-Klasse erstellt werden, von der aus alles geleitet wird? Oder ist diese main-Klasse in der für mich nicht einsehbaren abstrakten Superklasse und ich muss darauf eigentlich gar nicht eingehen? Dann macht die Aufgabenstellung doch irgendwie keinen Sinn, da ich Celsius als Standardklasse deklarieren sol. Wie ich das anstelle weiß ich erst, wenn ich weiß, wie man sich überhaupt zwischen Celsius und Fahrenheit entscheiden kann - müsste ja dann eine einfache IF-Abfrage sein, ala (Imaginärcode):

Bitte geben Sie a für Celsius oder b für Fahrenheit ein:

if (eingabe = a) {Celsius();
 else Fahrenheit();
 else Celsius();
}

 

[Ebenius]

Wobei du das

throws IllegalArgumentException

nicht brauchst (oder sogar nicht schreiben darfst?), da es eine RuntimeException ist...

Man darf. Mann braucht nicht. Wichtig ist, dass in der Javadoc dann steht:

/**
 * @throws IllegalArgumentException if it's raining outside
 */

 

[IpostedIT]

Jemand 'nen Tipp für den Vorvorpost?