# Cannot invoke Fehler aber wo?



## newbie2009 (14. Dez 2009)

```
class Int {
	double m_wert1 ;
	double m_wert2[]= new double[1];
	double m_wert3;
	
	
	Int(double wert1 ){
		m_wert1=wert1;
		
		
		
		
	}
	
	double  add(double k ){
		
		
		m_wert1 = m_wert1+ k;
		return m_wert1;
		
	}
}


public class UE8Aufgabe1 {
	
	public static void main(String[] args) {
		
		IO.println(new Int(8).add(IO.readDouble("geben sie DOI eine zahl ein")).add(-2));
	}

}
```

Also die Variablen sind noch nich alle belegt und der Array auch nich, brauch ich noch später
hmm mein problem ist eher , wenn ich die MEthode add(-2) aufrufe dann bekomme ich folgenden Fehler : cannot invoke add(int) to the primitive  type double 

Aber wenn die MEthode das erste mal funktioniert, warum nich das zweite mal?
Außerdem sind doch alle meine Variablen double werte .

 Vielen Dank im Voraus


----------



## SlaterB (14. Dez 2009)

beim ersten Mal:
> new Int(8).add
wird add an einem Int-Objekt aufgerufen,

beim zweiten Mal

> new Int(8).add(...).add(-2)

am Rückgabewert von add, also double, double hat aber eine derartige Methode nicht, an double kann man gar nix aufrufen,
wie die Fehlermeldung zweifelsfrei sagt


----------



## Gamma (14. Dez 2009)

Wahrscheinlich fasst er -2 als int auf versuch mal

```
//...
double zwei = 2.0;
//...
....add(-zwei)
```

oder die Methode add ist mit int festgelegt
genauso wie du folgendes nicht kannst

```
int Wurzelneun = Math.sqrt(9);
//Es muss nämlich so sein:
int Wurzelneun = (int) Math.sqrt(9);
```

MfG Gamma


----------



## newbie2009 (14. Dez 2009)

> Wahrscheinlich fasst er -2 als int auf versuch mal
> Java Code: Quelltext in neuem Fenster öffnen
> 
> 1
> ...




funktioniert leider nicht aber danke @ gamma



> double hat aber eine derartige Methode nicht, an double kann man gar nix aufrufen,
> wie die Fehlermeldung zweifelsfrei sagt


  @ Slater ab hier verstehe ich deine Begründung nicht ganz könntest du es vll näher erläutern.

danke


----------



## SlaterB (14. Dez 2009)

dein Code bedeutet in etwa

```
Int x = new Int(8);
        double d = x.add(IO.readDouble("geben sie DOI eine zahl ein"));
        d.add(-2);
        IO.println(??);
```
Zeile 3 geht nicht, da willst du vielleicht x.add(-2); schreiben,
in einer Zeile ist das nicht zu machen, falls du nicht den Rückgabewert von add auf Int ändern willst


----------



## newbie2009 (14. Dez 2009)

```
IO.println(new Int(8).add(IO.readInt()).add(-2))
```

also unsere Vorgabe sah so aus, und wir müssen das jetzt realisieren.

sprich ich habe einen Wert  8 dazu addiere ich mit der Methode eine beliebige zahl , und davon subtrahiere ich die 2 , also die vorgegebene Zeile muss  sich nachher im Programm genauso später wiederfinden.


hmm vll ist das problem jetzt deutlicher geworden.


----------



## SlaterB (14. Dez 2009)

mir ist alles klar, ich wollte dir nur den Fehler erklären,

nun auch eine direkte Folgerung, eigentlich schon genannt: 
der Rückgabewert von add muss anscheinend wirklich unbedingt das Int-Objekt sein, nicht double,

das hat auch mindestens eine andere Konsequenz, aber arbeite mal etwas alleine weiter


----------



## Michael... (14. Dez 2009)

```
public static void main(String[] args) {
        IO.println(new Int(8).add(IO.readInt()).add(-2));
}
```
und weiter? Soll das noch was anderes passieren, als eine Zahl abzufragen?


----------



## newbie2009 (14. Dez 2009)

> Entwickeln Sie eine Klasse Int, so dass sich das Programm kompilieren lässt. Die Klasse Int soll dabei folgende Semantik haben:
> •
> Dem Konstruktor wird ein int-Wert übergeben, der intern gespeichert werden soll.
> •
> ...





> und weiter? Soll das noch was anderes passieren, als eine Zahl abzufragen?



habe schon überlegt, dass ich die  methode so mache  
	
	
	
	





```
Int  add(Int k ){
		
		
		m_wert1= m_wert1 +k ;
		m_wert2[0]=m_wert1;
		return m_wert1;
		
	}
```
 aber klappt auch nicht, weil er dann einen wert vom neuen Typ Int zurückliefert  und die double Werte nich konvertieren kann ...


----------



## SlaterB (14. Dez 2009)

return this;


----------



## Michael... (14. Dez 2009)

newbie2009 hat gesagt.:


> ```
> Int  add(Int k ){
> ...
> m_wert1= m_wert1 +k ;
> ...


bei k handelt es sich um ein Objekt vom Typ Int und ich glaube nicht, dass man den '+' Operator darauf anwenden kann. Ich würde sagen, Du brauchst eher eine Methode

```
public void add(int k) {
```
oder

```
public Int add(int k) {
```


----------



## newbie2009 (14. Dez 2009)

Michael... hat gesagt.:


> bei k handelt es sich um ein Objekt vom Typ Int und ich glaube nicht, dass man den '+' Operator darauf anwenden kann. Ich würde sagen, Du brauchst eher eine Methode
> 
> ```
> public void add(int k) {
> ...





da hast du recht, hat der compiler auch rumgemeckert.

nun habe ich den tipp von slater noch mit eingebaut und habe folgendes programm nun :
	
	
	
	





```
class Int {
	double  m_wert1 ;
	
	
	
	
	Int(double wert1 ){
		m_wert1=wert1;
		
		
		
		
	}
	
	  public  Int  add(double  k ){
	        
	        
	        m_wert1= m_wert1 +k ;
	        
	        return this;
	        
	    }
		
	}



public class UE8Aufgabe1 {
	
	public static void main(String[] args) {
		
		
		
		IO.println(new Int(8).add(IO.readInt("geben sie DOI eine zahl ein")).add(2));
		
	}

}
```

Gebe ich jedoch eine Zahl ein, so bekomme ich werte wie Int@addbf1 , ich tippe der gibt jetzt einfach den Int wert  von der 8 aus und so oder?


----------



## SlaterB (14. Dez 2009)

das war die Konsequenz von der ich sprach, das ist die Standard-Ausgabe zum Int-Objekt,

siehe
Galileo Computing :: Java ist auch eine Insel (8. Auflage) – 10.2 Object ist die Mutter aller Klassen
10.2.2 Objektidentifikation mit toString()


----------



## newbie2009 (15. Dez 2009)

ok ich glaube ich  habe das problem begriffen  
ich müsste erst den wert von Int in eine zahl konvetieren, mit der man wieder rechnen kann odeR?


----------



## SlaterB (15. Dez 2009)

Int ist ein Objekt und wird es immer bleiben, da ist nix zu konvertieren, 
du könntest entweder einen Wert abfragen, getMwert() aufrufen,
oder die toString() Methode überschreiben, dann wird genau das ausgegeben, was die Methode ansagt, wie im Lehrbuch zu lesen


----------



## newbie2009 (15. Dez 2009)

erstmal danke für deine geduld  
Aber ich programmier noch nich so lange objektorintiert .

nun ja ich komme aber glaube ich der sache langsam näher .

habe es jetzt mit der toString() methode versucht aber klappt immer noch nicht, liefert immer noch einen komiscschen wert sprich den Int@wert.



```
public class skript {
    
    public static void main(String[] args) {
    	
    	Int x= new Int(8);
    	    	Int obj = x;
    	        String s = obj.toString();
    	        System.out.println("String value is: = " + s);
    
    }
 
}
```


----------



## SlaterB (15. Dez 2009)

nicht aufrufen, aufgerufen wird sie sowieso, 
implementieren/ überschreiben


----------



## newbie2009 (15. Dez 2009)

Vielen Dank slater 

also ich war kurz vorm aufgeben 
habe es aber dann doch noch geschafft .

```
class Int {
    static int m_wert1 ;				// eine static variable damit alle methoden, damit arbeiten können 
 
   
    Int(int wert1 ){					
        m_wert1=wert1;
    }
    
    

        
        

    
    Int  add(int k ){
        
    	m_wert1 = m_wert1+ k;
       return  this;
       
        
    }

    
    
 
    
    
    public String makeString( ){
  	  
  	  return Integer.toString(m_wert1) ;
  	}

   
  
}

 
 
public class skript {
    
    public static void main(String[] args) {
    
    	
    	
    	
    System.out.println(new Int(8).add(IO.readInt("geben sie einen Wert ein")).add(-2).makeString());
    }
 
}
```

vielen dank


----------



## SlaterB (15. Dez 2009)

das static unbedingt entfernen, läuft auch so 
und sonst können nicht zwei verschiedene Int-Objekte ihren eigenen Zustand verwalten


----------

