# Interface implementiert aber kann nicht darauf zugreifen



## Chr__Au (10. Okt 2010)

Hi ich weiß nicht ob der Titel nicht etwas in die Irre führt. Ich muss für mein Studium ein kleines Programm schreiben in dem ich eine Methode in einem Interface deklariere.

```
public interface IF_Kugel{
  void distance(IF_Kugel kugel2);
}
```


```
public class Kugel implements IF_Kugel{
  float x, y, z;
  int radius;
  kugel(float x, float y, float z, int radius){
    this.x = x;
    this.y = y;
    this.z = z;
  }
  void distance(IF_Kugel kugel2){
     float temp = kugel2 - this.x; // hier meckert der Kompiler immer dass X nicht in IF_Kugel (interface) deklariert wurde

  }
}
```
Jetzt habe ich noch in der TestKlasse ein Objekt:

```
IF_Kugel Kugel1 = new Kugel(5,6,4,2,2); // und das gleiche noch mal für Kugel2
```
erzeugt aber warum meckert der Kompiler?

Wenn ich das mit Interfaces so richtig verstanden habe dann müsste ich doch, wenn ich eine Referenz einer Superklasse also eines Interface erwarte, auch alle Objekte von Klassen die das Interface implementiert haben akzeptieren. natürlich wurde die Methode distance über kugel1.distance(kugel2) aufgerufen.

Ich hoffe ich habe jetzt hier keine Fehler geschrieben aber auf dem PC in der Hochschule war meiner Meinung alles richtig bzw. Wenn ich in der Methode distance eine Referenz von Kugel erwarte klappt alles (natürlich habe ich die anderen Referenzen angepasst).

Kann mir jemand helfen? Ich hoffe es war nicht zu kompliziert geschrieben.


----------



## Noctarius (10. Okt 2010)

X ist auch nicht in in IF_Kugel definiert, sondern in Kugel.


----------



## Chr__Au (10. Okt 2010)

ja schon das wundert mich ja weil wenn ich im Interface x deklariere dass ist X ja eine static final oder?

Ergänzend zu oben möchte ich noch sage ich habe das gefühl das irgend etwas nicht stimmt dass in distance eine Referenz von IF_Kugel erwartet wird. Aber so soll ich das Programmieren.


----------



## Gast2 (10. Okt 2010)

schreib dir für x, y, z und radius einfach getter die du dann im interface deklarierst.


----------



## Chr__Au (10. Okt 2010)

EikeB hat gesagt.:


> schreib dir für x, y, z und radius einfach getter die du dann im interface deklarierst.



Das verstehe ich jetzt nicht so ganz. Die getter sind doch dann einfach dafür mir die Instanz-Variablen zurück die kann ich doch über this. aufrufen oder macht dass dann einen unterschied. 

Ich weiß nicht ob das etwas bringt habe es mit NetBeans Programmiert.


----------



## Landei (10. Okt 2010)

```
IF_Kugel Kugel1 = new Kugel(5,6,4,2,2);
```
Dein Konstruktor hat nur 4 Parameter, hier rufst du ihn aber mit 5 auf.


----------



## Gast2 (10. Okt 2010)

Chr__Au hat gesagt.:


> Das verstehe ich jetzt nicht so ganz. Die getter sind doch dann einfach dafür mir die Instanz-Variablen zurück die kann ich doch über this. aufrufen oder macht dass dann einen unterschied.
> 
> Ich weiß nicht ob das etwas bringt habe es mit NetBeans Programmiert.



So würd ichs machen:

```
public interface IKugel {
    public double distance(IKugel kugel);

    public double getX();
    public double getY();
    public double getZ();
    public double getRadius();
}
```


```
public class Kugel implements IKugel {

    private double x;
    private double y;
    private double z;
    private double radius;

    public Kugel(double x, double y, double z, double radius) {
        this.x = x;
        this.y = y;
        this.z = z;
        this.radius = radius;
    }

    public double distance(IKugel kugel) {
        double distance = this.getX() - kugel.getX(); //<-- die Berechnung stimmt natürlich nicht
        return distance;
    }

    public double getX() {
        return x;
    }

    public double getY() {
        return y;
    }

    public double getZ() {
        return z;
    }

    public double getRadius() {
        return radius;
    }
}
```


----------



## Chr__Au (10. Okt 2010)

Ich habe mir jetzt die von mir programmierte Aufgabe gezogen und kann Sie jetzt veröffentlichen:


```
// Kugel.java
public class Kugel implements KugelIF{
    public float x, y, z, radius;



    Kugel(float x, float y, float z, float radius){
        this.x = x;
        this.y = y;
        this.z = z;
        this.radius = radius;
    }
    public void getDistance(KugelIF kugel2){
        float tem = kugel2.
        float a = (this.y);
        float b = (this.y);
        float c = (float)Math.pow((a*a+b* b), 0.5);

        
    }

// KugelIF.java
public class Kugel implements KugelIF{
    public float x, y, z, radius;



    Kugel(float x, float y, float z, float radius){
        this.x = x;
        this.y = y;
        this.z = z;
        this.radius = radius;
    }
    public void getDistance(KugelIF kugel2){
        
        float a = (kugel2.x - this.x);
        float b = (kugel2.y - this.y);
        float c = (float)Math.pow((a*a+b* b), 0.5);

        
    }

// TestKugel.java
public class TestKugel {
    public static void main(String[] args){

        KugelIF kugel1 = new Kugel(1.0f, 0.0f, 0.5f, 2.0f);
        KugelIF kugel2 = new Kugel(2.0f, 3.0f, -1.0f, 2.0f);

        kugel1.getDistance(kugel2);


    }
}
```

So meine frage ist jetzt warum NetBeans ein Fehler bei Zeile 26 und 27 anzeigt. 
Fehlermeldung:



> cannot find symbol
> symbol: variable x
> location: interface KugelIF
> --



Ich hoffe Ihr könnt mir jetzt besser weiterhelfen. Ist halt schon gleich viel deutlicher.

PS: Danke EikeB ich werde mal das mit getter versuchen Danke.


----------



## Chr__Au (10. Okt 2010)

WOW danke es geht! Aber warum muss ich x,y,z über getter abrufen? Das verstehe ich jetzt noch nicht so ganz da ich ja eigentlich nichts geändert habe. Oder kann ich wenn ich ich einer Referenz welche vom Typ eines Interfaces ist und auf ein Objekt einer implementierten Klasse zeigt, nicht auf die Variablen und Methoden zugreifen kann die nur in der "Subklasse" initialisiert wurden?


----------



## Gast2 (10. Okt 2010)

> float a = (kugel2.x - this.x);
> float b = (kugel2.y - this.y);


Das Interface kann ja gar nicht wissen welche Variablen die implementierende Klasse hat, deswegen kannst du auf diese auch nicht über das Interface zugreifen.
Bei den Gettern ist das anders. Du deklarierst diese Methoden im Interface, daher weiß java dass jede Klasse die das Interface implementiert mindestens diese Methoden zur verfügung stellt.


----------



## Chr__Au (10. Okt 2010)

Ok dann bringst du mich auf eine neue frage. Wenn ich jetzt noch eine Methode schreiben möchte die irgend etwas macht aber nur in meiner Klasse Kugel auftraten soll. Wie mach ich das nun dass ich über meine Interface ref. darauf zugreifen kann? sagen wir die Methode soll die die Hypotenuse berechnen. 

Also ich meine die Methode distance(...) ruft die mehtode hypotenuse() auf, hypotenuse() ist nicht im interface enthalten.

Ich hoffe ihr versteht was ich mein.


----------



## Gast2 (10. Okt 2010)

Je nachdem auf welchem Objekt du die Methode aufrufen willst.

1. Auf dem aktuellen(this) Objekt:
Da kannst du hypothenuse() ohne Probleme einfach in der distance() aufrufen.

2. Auf dem Objekt kugel2 (vom Typ IFKugel):
Hier musst du zuerst prüfen ob kugel2 wirklich vom Typ Kugel ist (instanceof). Danach castest du auf Kugel und kannst darauf dann hypothenuse() aufrufen.


----------



## Chr__Au (10. Okt 2010)

Ok danke. Dann schließe ich das Thema. Ich hab schon gedacht ich bin zu blöd so eine einfache Aufgabe zu lösen. Aber danke nochmal. Ich finde hier im Forum die Reaktionszeiten einfach genial.


----------



## Landei (10. Okt 2010)

Für die Quadratwurzel gibt es die Funktion Math.sqrt(x). Ist schneller und hübscher zu lesen als Math.pow(x, 0.5).


----------



## Chr__Au (10. Okt 2010)

Landei hat gesagt.:


> Für die Quadratwurzel gibt es die Funktion Math.sqrt(x). Ist schneller und hübscher zu lesen als Math.pow(x, 0.5).


Danke weiß ich nur in der letzten Klausur habe ich die Wurzelfunktion genommen und habe dafür Null punkte bekommen, da nur die Math.pow ... angegeben war. Und jetzt soll es einfach eine gedankenstütze für mich sein.


----------



## Landei (10. Okt 2010)

Was ist denn das für ein pseudopädagogischer Schleimscheißer, der null Punkte dafür gibt, dass man die Wurzelfunktion zum Wurzelziehen nimmt? Aber vielleicht ist Math.pow() ja irgendwie didaktisch wertvoller. Warum dann nicht gleich Math.exp(0.5*Math.log(x))?


----------

