# Problem mit Vererbung



## Lordy (25. Okt 2008)

Ich bastel mir hier gerade etwas und hab mir für verschiedenen Daten eine Oberklasse Data angelegt. Von der Klasse bilde ich nun verschiedene Unterklassen für speziella Daten.

DataA, DataB, DataC erben von Data.

Nun muss ich Daten prüfen und habe mir dafür die Oberklasse DataCheck geschrieben. Von dieser bilde ich nun entsprechende Unterklassen.

DataCheckA, DataCheckB, DataCheckC von DataCheck.

DataCheck prüft die Daten von Data, bei den anderen Klassen erfolgt das ganze analog. Da die Überprüfung erstmal gleich sein soll, dachte ich mir, kann ich das ganze in den Oberklassen implementieren und vererbe das ganze einfach und es läuft dann, ist aber leider nicht der Fall.

Hier mal ein Beispiel:
Die Oberklasse Data

```
public class Data {
    
    private String _id;
    private String _value;
    
    public Data(String id, String value){
        _id = id;
        _value = value;
    }
    
    public String getId(){
        return _id;
    }
    
    public String getValue(){
        return _value;
    }
}
```

Nun die geerbte Klasse DataA

```
public class DataA extends Data {
    
    public Data(String id, String value){
       super(id, value);
    }
}
```

Nun meine DataCheck

```
public class DataCheck {
    
    public boolean checkId(Data data, String id){
        if(data.getId().equals(id){
          return true;
        }
        else{
          return false;
        }
    }
}
```

DataCheck klappt für Data, nun will ich da draus DataCheckA erzeugen.


```
public class DataCheckA extends DataCheck {
    
    public boolean checkId(DataA data, String id){
        super.checkId(data, id);
    }
}
```

So könnte ich mir ne Menge Arbeit sparen, weil das ganze eigentlich wesentlich komplexer ist. Mir ist schon klar, dass DataCheck Data als Datentyp erwartet aber da DataA ja von Data erbt, müsste das doch eigentlich gehen oder? Es kommt nämlich der Typenfehler, also DataA ist nicht Data.
Kennt da jemand eine Lösung für? Wäre echt klasse, weil ich will eigentlich nicht 20 mal das gleiche schreiben und wenn ich nur ne Kleinigkeit ändere, muss ich das alles kopieren und in den anderen Klassen auch ergänzen. Sollte man ja eigentlich bei OOP vermeiden können.

Ich hoffe mal, dass das ganze verständlich geschrieben ist und mir jemand helfen kann.

Viele Grüße aus Hamburg!


----------



## Murray (25. Okt 2008)

Wenn die check-Methode in den abgeleiteten Klassen ohnehin nichts anderes tut als in den Basisklasse: warum sollte sie dann in den abgeleiteten Klassen überhaupt überschrieben werden?


----------



## Marco13 (26. Okt 2008)

Wie lautet den die Fehlermeldung?


----------



## Lordy (26. Okt 2008)

Ich hab mir gedacht, ich könnte so dann den anderen Typ übergeben aber da lag ich ein bisschen falsch.

Es ist immer ein Typfehler, DataCheck erwartet Data und nicht DataA. Irgendwo hab ich mal gelesen, dass man bei Vererbung den abgeleiteten Klassen so wie oben beschrieben verwenden kann, da sie ja den gleichen Ursprung haben.

Hat irgendwer noch ne Idee, wie ich das Problem lösen kann?


----------



## Landei (27. Okt 2008)

Geht das?

```
public class DataCheck<D extends Data> { 
    
    public boolean checkId(D data, String id){ 
        if(data.getId().equals(id){ 
          return true; 
        } 
        else{ 
          return false; 
        } 
    } 
}
```


```
public class DataCheckA extends DataCheck<DataA> { 
    
    public boolean checkId(DataA data, String id){ 
        super.checkId(data, id); 
    } 
}
```


----------



## Lordy (28. Okt 2008)

Super, vielen Dank! Jetzt klappt es. Wieder was dazu gelernt, wusste gar nicht, dass ich da noch expliziet nen Datentyp angeben kann.
Das D im ersten Code Bereich in Zeile 2 ist doch als Variable zu verstehen oder?


----------



## diel2001 (1. Nov 2008)

```
public class DataA extends Data {
   
    public Data(String id, String value){ // public Data muss public DataA heißen
       super(id, value);
    }
```

den Konstruktoten werden nicht vererbt


----------

