# missing return statement



## tentigo (17. Jan 2011)

hallo, ich bin dabei einen Tarifrechner zu programmieren, der dann übergebene Stromtarife von verschiedenen Anbietern vergleicht.. beim Compilen.. ergibt sich jedoch folgender Fehler... 

```
.\TarifRechner.java:50: missing return statement
        }
        ^
1 error
```

Der Fehler aus Zeile 50 entspricht hier der Zeile mit dem else... Da ich mehrere Klassen in verschiedenen Dateien programmiert haben, habe ich nur den Ausschnit hier gepostet...

Ich habe mich natürlich auch über den Fehler informiert, aber.. hier sind doch alle möglichkeiten abgedeckt und es gibt immer nen Return... wo liegt denn der Fehler...?

```
public boolean istKleiner(Vergleichbar other){

		if(other instanceof Tarif){
			if(tarif<((Tarif)other).getTarif()){
				return true;
			}
			else{
				return false;
			}
		}
	
		return false;


	}
```

Vielen Dank für Hinweise, 

MfG
N.


----------



## Haave (17. Jan 2011)

Du weißt aber schon, dass 
	
	
	
	





```
return
```
 in Kleinbuchstaben zu schreiben ist? (Das ist btw das Syntaxhighlighting für SQL-Code )


----------



## darekkay (17. Jan 2011)

pack noch ein else für das erste if dazu. also if-(if-else)-else, und bei jedem muss ein return stehen.

EDIT: oh ja, mach erstmal die returns klein ^^


----------



## tentigo (17. Jan 2011)

ja klar^^

hat er hier automatisch gemacht... liegt wohl am SQL code...


----------



## Haave (17. Jan 2011)

darekkay hat gesagt.:


> pack noch ein else für das erste if dazu. also if-(if-else)-else, und bei jedem muss ein return stehen.


Kann man machen, muss man aber nicht. Bei Eclipse z.B. kann man sich eine Warnung ausgeben lassen, wenn ein return unnötigerweise in einem else-Block ist, obwohl es ohne else auch gereicht hätte. Das 
	
	
	
	





```
return false
```
 hier in Zeile 12 müsste eigentlich ausreichen, so dass, auch wenn kein if-Block beschritten wurde, auf jeden Fall etwas zurückgegeben wird.


----------



## tentigo (18. Jan 2011)

hm gut.. jetzt kommt ein else without if fehler...

ich machs mal so wie ichs von anfing an machen würde.. (wurde erst so verkettet beim suchen nach einer Lösung...)


```
public boolean istKleiner(Vergleichbar other){

		if(other instanceof Tarif && tarif<((Tarif)other).getTarif()){
			return true;
		}	
		else{
			return false;
		}

	}
```

beim else verlangt er ein return statement.. nun las ich aber auch.. dass es ja sein "könnte", dass weder if noch else erfüllt werden.. und am ende vor der letzten bracket ein return stehen muss... in dem fall würde aber ein unreachable fehler kommen...

Bitte bitte helft mir das zu verstehen^^

MfG
N.


----------



## darekkay (18. Jan 2011)

Haave hat gesagt.:


> Kann man machen, muss man aber nicht. Bei Eclipse z.B. kann man sich eine Warnung ausgeben lassen, wenn ein return unnötigerweise in einem else-Block ist, obwohl es ohne else auch gereicht hätte. Das
> 
> 
> 
> ...



Ja, eigentlich mach ich das auch immer so. Ich wüsste aber nicht, woran es sonst liegen könnte.. (außer, das return ist wirklich groß geschrieben (was aber nach dem letzten post nicht der fall zu sein scheint))


----------



## Haave (18. Jan 2011)

Ich hab deinen Code gerade mal genommen und ein wenig verändert. Die Struktur mit den ifs und elses wurde beibehalten, ich hab nur mal die Abfragen entsprechend zu irgendwas anderem geändert, um zu gucken, ob es sich kompilieren lässt (Code ergibt also keinen Sinn, ich habe ja keine Klasse Tarif etc., soll nur verdeutlichen, dass es geht).


```
public class KleinerAls {
	public boolean istKleiner(int other){
		if(other<10){
			if(other<5){
				return true;
			}
			else{
				return false;
			}
		}
		return false;
	}
}
```

Das lässt sich bei mir anstandslos kompilieren.


Edit:
Zu deinem zweiten Beispiel: Mit dem unreachable statement hattest du ein Konstrukt wie dieses hier, oder?

```
public boolean istKleiner_Unsinn(int other){
	if(other<10 && other<5){
		return true;
	}
	else {
		return false;
	}
	return false;
}
```

Das letzte return false kann niemals erreicht werden, weil immer das return false aus dem else-Block genommen wird, wenn die if-Bedingung nicht erfüllt ist. Es ist toter Code und das streicht dir der Compiler an.


----------



## tentigo (18. Jan 2011)

.. bei mir nicht... hä? (bezieht sich aufs compilieren, das mit dem toten code.. ja das macht sinn.. wollt nur zeigen, dasss ich alles probiert hab 

das hängt doch aber auch nicht von den anderen sourcecodes ab.. oder?


```
public boolean istKleiner(Vergleichbar other){

	if(other instanceof Tarif){
            if(tarif<((Tarif)other).getTarif()){
                return true;
            }     <---------------------------hier erwartet der compiler ein return statement
            else{
                return false;
            }
        }
        return false;
    }
```


genauso steht die Methode bei mir im Editor...
zur Info.. ich arbeite mit abstrakten Klassen usw.. verebung, interface .. joa aber das dürfte sich ja nicht auswirken..

also ich stehe echt auf dem Schlauch...

MfG
N.


----------



## Haave (18. Jan 2011)

Ich weiß nicht, ob es nicht doch von irgendwas anderem im Rest deines Codes abhängen könnte, deshalb hab ich die oben gepostete Klasse KleinerAls mit der Methode istKleiner() geschrieben, weil sie unabhängig von deinem Code ist. Hast du mal probiert, die zu kompilieren?


----------



## tentigo (18. Jan 2011)

Hm, seltsam, das klappt dann, hängt also wohl doch vom Rest des Codes ab.. ich bin mal so frei zumindest die Datei in dem die Methode steht zu posten.. vllt findet sich ja wer, der es überfliegt^^


```
public abstract class Tarif implements Vergleichbar{

	private double grundpreis;
	private double kwh;
	private double tarif;
	private String name;

	public double getGrundpreis(){
		return grundpreis;
	}
	public double getKwh(){
		return kwh;
	}
	public double getTarif(){
		return tarif;
	}
	public String getName(){
		return name;
	}

	public void setGrundpreis(double grundpreis){
		this.grundpreis =grundpreis;
	}
	public void setKwh(double kwh){
		this.kwh=kwh;
	}
	public void setTarif(double tarif){
		this.tarif=tarif;
	}
	public void setName(String name){
		this.name=name;
	}

	public Tarif(String name, double grundpreis){
		this.kwh=0.0;
		this.tarif=grundpreis;
		this.name=name;
		this.grundpreis=grundpreis;
	}
	
	
	public abstract void berechneTarif(double kwh);


	public boolean istKleiner(Vergleichbar other){

	if(other instanceof Tarif){
            if(tarif<((Tarif)other).getTarif()){
                return true;
            }
            else{
                return false;
            }
        }
        return false;
    }

}
```

UND dies ist die Klasse, mit der ich meine Programmierung testen soll.. beim compilieren dieses programms gibt es die fehlermeldung..


```
public class DemoTarifRechner {


	public static void main(String[] args) {


		
// Tarife 

	Tarif[] tarife = {
 
	
	new EPrimo("EPrimo", 500.0),

	new Nuon("Nuon", 529.0), 
			
	new Vattenfall("Vattenfall", 499.0) 

		};

		
// Tarifrechner
		
	TarifRechner tr = new TarifRechner(tarife);

		
// Einlesen des monatlichen Verbrauchs von der Kommandozeile
	
	double verbrauch = Double.parseDouble(args[0]);
		
		
// Ermittlung des konstenguenstigten Tarifs
	
	Tarif bestTarif = tr.getBestTarif(verbrauch);

		
// Ausgabe
	
	System.out.print("Guenstigter Tarif bei einem Verbrauch von ");

		System.out.println(verbrauch + " kwh:");

		System.out.println("Anbieter: " + bestTarif.getName());

		System.out.println("Tarif   : " + bestTarif.getTarif() + " Cent");
	}
}
```

dann gibt es natürlich noch die Stromanbieter, 3 an der Zahl.. alle in dieser Form..


```
public EPrimo(String name, double grundpreis) {

		super(name, grundpreis);
	}

	
	public void berechneTarif(double kwh) {


		setKwh(kwh);

		setTarif(getGrundpreis() + 20.0*kwh);
	}
}
```

das interface, welches der Tarif implementiert.. ist folgendes

```
interface Vergleichbar {
	abstract boolean istKleiner(Vergleichbar other);
	}
```
MfG
N.


----------



## L-ectron-X (18. Jan 2011)

Das hier ist doch umständlich und überflüssig:


> ```
> public boolean istKleiner_Unsinn(int other){
> if(other<10 && other<5){
> return true;
> ...




Diese Variante macht genau das gleiche und ist zudem besser zu lesen/verstehen.

```
public boolean istKleinerUnsinn(int other){
	if(other<10 && other<5){
		return true;
	}

	return false;
}
```


----------



## turing (18. Jan 2011)

Also dann fänd ich das hier eleganter. Aber so manch einer findet natürlich die if-else-Blöcke sprechender.


```
public boolean istKleiner_Unsinn(int other){
  return other<10 && other<5;
}
```


----------



## ARadauer (18. Jan 2011)

turing hat gesagt.:


> Also dann fänd ich das hier eleganter. Aber so manch einer findet natürlich die if-else-Blöcke sprechender.
> 
> 
> ```
> ...



Ein _ in einer Methode ist alles andere als elegant in JAVA



> ```
> }     <---------------------------hier erwartet der compiler ein return statement
> else{
> ```


nein... erwartete er nicht...


----------



## turing (18. Jan 2011)

Ich bezog mich nur auf die Fom des Rückgabewertes. Underscores sind tatsächlich nicht elegenat (in Java). Mir persönlich graut es auch vor "Denglish" im Quellcode.


----------



## nrg (18. Jan 2011)

ARadauer hat gesagt.:


> Ein _ in einer Methode ist alles andere als elegant in JAVA



darum ging es auch nicht . also ich hab hier grad durchgescrollt und eigentlich nur auf die Lösung gewartet. Finde sowas mit if/else zu lösen ist mehr als hässlich. Wenn es kein boolean ist nimmt man eben den ternären operator.


----------



## Haave (18. Jan 2011)

Hey hey, nun beruhigt euch mal. Ich hab die Methode doch nur istKleiner_Unsinn() genannt, um sie von der istKleiner()-Methode abzugrenzen. "Unsinn" deshalb, weil sie in der von mir beschriebenenen Form zu einem "unreachable statement" führt, und der Unterstrich diente dazu, damit es nicht aussieht wie "kleiner Unsinn"  Das Denglish hab ich halt einfach mitübernommen 

Aber ich glaube, dem Threadersteller ist es keine große Hilfe, wenn darüber diskutiert wird, ob jetzt ein Einzeiler oder if-Blöcke schöner sind.


----------



## tentigo (18. Jan 2011)

so.. es ist mir ja ein bisschen peinlich aber es lag daran, dass ich in der falschen Datei gesucht habe...

mea culpa...

aber ich habe eure diskussion überlesen.. und joa.. verinnerlicht.

Nun hat sich jedoch ein neues Problem ergeben:

```
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 0
```

und zwar im rahmen dieser sourcecodes (ich poste mal zwei da die zusammenhängen


```
public class TarifRechner {

	

// Array von Tarifen verschiedener Stromanbieter


	private Tarif[] tarife;

	
/*
	 
* Konstruktor zur Initialisierung der Tarife.
	 
* 
	 * Parameter: Tarife[] tarife - Array von Tarifen
	 */


	public TarifRechner(Tarif[] tarife) {

		this.tarife = tarife;
	
	}

	
public Tarif getBestTarif(double verbrauch){
	
		tarife[0].berechneTarif(tarife[0].getKwh());
		tarife[1].berechneTarif(tarife[1].getKwh());
		tarife[2].berechneTarif(tarife[2].getKwh());
		
	if(tarife[0].getTarif()<tarife[1].getTarif() && tarife[0].getTarif()<tarife[2].getTarif()){
		return tarife[0];
	}
	else if(tarife[1].getTarif()<tarife[0].getTarif() && tarife[1].getTarif()<tarife[2].getTarif()){
		return tarife[1];
	}

	else{
		return tarife[2];
	}	
	}
}
```
und hier die Testklasse.. bei der dann der Fehler auftritt... laut zeilenanzeige würde das hier zeile 37 entsprechen, da wo der Kommentar Ausgabe steht


```
public class DemoTarifRechner {


	public static void main(String[] args) {


		
// Tarife 

	Tarif[] tarife = {
 
	
	new EPrimo("EPrimo", 500.0),

	new Nuon("Nuon", 529.0), 
			
	new Vattenfall("Vattenfall", 499.0) 

		};

		
// Tarifrechner
		
	TarifRechner tr = new TarifRechner(tarife);

		
// Einlesen des monatlichen Verbrauchs von der Kommandozeile
	
	double verbrauch = Double.parseDouble(args[0]);
		
		
// Ermittlung des konstenguenstigten Tarifs
	
	Tarif bestTarif = tr.getBestTarif(verbrauch);

		
// Ausgabe
	
	System.out.print("Guenstigter Tarif bei einem Verbrauch von ");

		System.out.println(verbrauch + " kwh:");

		System.out.println("Anbieter: " + bestTarif.getName());

		System.out.println("Tarif   : " + bestTarif.getTarif() + " Cent");
	}
}
```


weshalb fliegt er denn aus dem Array... vorallem bei 0 ?
es wird doch am anfang der Testklasse ein Array mit 3 "Stromanbietern" gefüllt.. also müssten doch 0 1 und 2 im array existieren?

MfG
N.


----------



## Haave (18. Jan 2011)

Ich blicke nicht ganz durch. Du schreibst, der Fehler würde hier bei Zeile 37 angezeigt, wo der Kommentar "Ausgabe" steht. Wenn da aber nur der Kommentar steht, kann da ja nicht der Fehler liegen 
Ich vermute, du meinst Zeile 34, wo auf die Methode getBestTarif() zugegriffen wird, die mit dem Array rummacht. Wo genau gibt's denn da jetzt die ArrayIndexOutOfBoundsException?

Spricht was dagegen, die Array-Initialisierung testweise mal so zu machen?

```
Tarif[] tarife = new Tarif[3];
tarife[0] = new EPrimo("EPrimo", 500.0);
tarife[1] = new Nuon("Nuon", 529.0);
tarife[2] = new Vattenfall("Vattenfall", 499.0);
```

Vielleicht geht auch was bei der Referenzweitergabe beim Konstruktor von TarifRechner schief… keine Ahnung :rtfm:


----------



## tentigo (18. Jan 2011)

laut console  (in meinen fall zeile 19) ist das beim Kommentar.. is mir auch.. ein rätsel.. aber vllt weiß java es nur nicht genauer...

und ja ich denke auch, dass es irgendwo da passieren muss wo sie, wie du sagst "rummachen" 

naja ich hab die fehlermeldung ja gepostet.. also  laut console gibt es den Fehler schon beim Index 0

testweise könnte ich deine Arrayerzeugung ma probieren, aber an und für sich "darf" ich die Testklasse nicht verändern. müsste also irgendwie auch so gehen

EDIT

auch wenn ich das Array nach deinem Vorschlag erzeuge gibts den selben Fehler... allerdings steht der fehler dann in einer Zeile (laut konsole) in der schon längst nix mehr steht...???:L


----------



## tentigo (18. Jan 2011)

Hm, was mich auch wundert, ist... dass ich gar nicht erst dazu komme Werte für den Verbrauch (Stromverbrauch) einzugeben..
ich kann compilieren, aber dann beim java ... kommt der fehlr.. also muss der fehler doch schon vorher auftreten


```
public class DemoTarifRechner {

	
	public static void main(String[] args) {

		

// Tarife 
	
	Tarif[] tarife = { 

			new EPrimo("EPrimo", 500.0),
				
			new Nuon("Nuon", 529.0),
 
			new Vattenfall("Vattenfall", 499.0) 

		};

		

// Tarifrechner
	
	TarifRechner tr = new TarifRechner(tarife);

		
// Einlesen des monatlichen Verbrauchs von der Kommandozeile
	
	double verbrauch = Double.parseDouble(args[0]);
		
		
// Ermittlung des konstenguenstigten Tarifs
	
	Tarif bestTarif = tr.getBestTarif(verbrauch);

		
// Ausgabe
	
	System.out.print("Guenstigter Tarif bei einem Verbrauch von ");
	
	System.out.println(verbrauch + " kwh:");
	
	System.out.println("Anbieter: " + bestTarif.getName());
	
	System.out.println("Tarif   : " + bestTarif.getTarif() + " Cent");
	}
}
```

Da ich ja gar nicht bis zum Einlesen komme muss  es wohl hier irgendwas.. geben..


```
// Tarife 
	
	Tarif[] tarife = { 

			new EPrimo("EPrimo", 500.0),
				
			new Nuon("Nuon", 529.0),
 
			new Vattenfall("Vattenfall", 499.0) 

		};

		

// Tarifrechner
	
	TarifRechner tr = new TarifRechner(tarife);
```

aber kann man aus dem Arrray fliegen wenn man ein Array füllt?
bzw wenn einen neuen TarifRechner initialisiert?? 
hier nochmal der TarifRechner 

```
public class TarifRechner {

	

// Array von Tarifen verschiedener Stromanbieter


	private Tarif[] tarife;

	
/*
	 
* Konstruktor zur Initialisierung der Tarife.
	 
* 
	 * Parameter: Tarife[] tarife - Array von Tarifen
	 */


	public TarifRechner(Tarif[] tarife) {

		this.tarife = tarife;
	
	}

	
public Tarif getBestTarif(double verbrauch){
	
		tarife[0].berechneTarif(tarife[0].getKwh());
		tarife[1].berechneTarif(tarife[1].getKwh());
		tarife[2].berechneTarif(tarife[2].getKwh());
		
	if(tarife[0].getTarif()<tarife[1].getTarif() && tarife[0].getTarif()<tarife[2].getTarif()){
		return tarife[0];
	}
	else if(tarife[1].getTarif()<tarife[0].getTarif() && tarife[1].getTarif()<tarife[2].getTarif()){
		return tarife[1];
	}

	else{
		return tarife[2];
	}	
	}
}
```
MfG
N.


----------



## SlaterB (18. Jan 2011)

was ist denn das hier für eine Ansammlung von undurchsichten Posts und Codes?
wie lautet die aktuelle Fehlermeldung/ das Problem? auf die Schnelle gar nicht zu finden, 

Code von 10 Postings zusammenzukopieren ist auch nicht grad schön, mach es bitte wie folgt, alles zusammen,
das ganze kann dann jeder kopieren, in eine Klasse Test einfügen, Run, läuft,
nur bei dir vielleicht bisschen komplizierter, weil alle Klassen schon vorhanden sind, in einem separaten Projekt aber bestimmt auch möglich,

Klassen vielleicht nicht alle die aktuellesten, von erste Seite des Threads zusammenkopiert,
fehlende Klassen wie Vattenfall selber kopiert


```
public class Test
{

    public static void main(String[] args)
    {
        DemoTarifRechner.main(new String[] {"4"});
    }
}


class DemoTarifRechner
{


    public static void main(String[] args)
    {


        // Tarife

        Tarif[] tarife =
            {

            new EPrimo("EPrimo", 500.0),

            new Nuon("Nuon", 529.0),

            new Vattenfall("Vattenfall", 499.0)

            };


        // Tarifrechner

        TarifRechner tr = new TarifRechner(tarife);


        // Einlesen des monatlichen Verbrauchs von der Kommandozeile

        double verbrauch = Double.parseDouble(args[0]);


        // Ermittlung des konstenguenstigten Tarifs

        Tarif bestTarif = tr.getBestTarif(verbrauch);


        // Ausgabe

        System.out.print("Guenstigter Tarif bei einem Verbrauch von ");

        System.out.println(verbrauch + " kwh:");

        System.out.println("Anbieter: " + bestTarif.getName());

        System.out.println("Tarif   : " + bestTarif.getTarif() + " Cent");
    }
}


class EPrimo
    extends Tarif
{
    public EPrimo(String name, double grundpreis)
    {
        super(name, grundpreis);
    }


    public void berechneTarif(double kwh)
    {
        setKwh(kwh);
        setTarif(getGrundpreis() + 20.0 * kwh);
    }
}


class Nuon
    extends Tarif
{
    public Nuon(String name, double grundpreis)
    {
        super(name, grundpreis);
    }


    public void berechneTarif(double kwh)
    {
        setKwh(kwh);
        setTarif(getGrundpreis() + 20.0 * kwh);
    }
}


class Vattenfall
    extends Tarif
{
    public Vattenfall(String name, double grundpreis)
    {
        super(name, grundpreis);
    }

    public void berechneTarif(double kwh)
    {
        setKwh(kwh);
        setTarif(getGrundpreis() + 20.0 * kwh);
    }
}


interface Vergleichbar
{
    abstract boolean istKleiner(Vergleichbar other);
}


abstract class Tarif
    implements Vergleichbar
{

    private double grundpreis;
    private double kwh;
    private double tarif;
    private String name;

    public double getGrundpreis()
    {
        return grundpreis;
    }

    public double getKwh()
    {
        return kwh;
    }

    public double getTarif()
    {
        return tarif;
    }

    public String getName()
    {
        return name;
    }

    public void setGrundpreis(double grundpreis)
    {
        this.grundpreis = grundpreis;
    }

    public void setKwh(double kwh)
    {
        this.kwh = kwh;
    }

    public void setTarif(double tarif)
    {
        this.tarif = tarif;
    }

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

    public Tarif(String name, double grundpreis)
    {
        this.kwh = 0.0;
        this.tarif = grundpreis;
        this.name = name;
        this.grundpreis = grundpreis;
    }


    public abstract void berechneTarif(double kwh);


    public boolean istKleiner(Vergleichbar other)
    {

        if (other instanceof Tarif)
        {
            if (tarif < ((Tarif)other).getTarif())
            {
                return true;
            }
            else
            {
                return false;
            }
        }
        return false;
    }

}


class TarifRechner
{


    // Array von Tarifen verschiedener Stromanbieter


    private Tarif[] tarife;


    /*
     * 
     * Konstruktor zur Initialisierung der Tarife.
     * 
     * 
     * Parameter: Tarife[] tarife - Array von Tarifen
     */


    public TarifRechner(Tarif[] tarife)
    {

        this.tarife = tarife;

    }


    public Tarif getBestTarif(double verbrauch)
    {

        tarife[0].berechneTarif(tarife[0].getKwh());
        tarife[1].berechneTarif(tarife[1].getKwh());
        tarife[2].berechneTarif(tarife[2].getKwh());

        if (tarife[0].getTarif() < tarife[1].getTarif() && tarife[0].getTarif() < tarife[2].getTarif())
        {
            return tarife[0];
        }
        else if (tarife[1].getTarif() < tarife[0].getTarif() && tarife[1].getTarif() < tarife[2].getTarif())
        {
            return tarife[1];
        }

        else
        {
            return tarife[2];
        }
    }
}
```
Ausgabe

```
Guenstigter Tarif bei einem Verbrauch von 4.0 kwh:
Anbieter: Vattenfall
Tarif   : 499.0 Cent
```
Programm erwartet einen args-Parameter, wenn der fehlt gibts eine Exception, die Anzahl Parameter wird vorher nicht geprüft


----------



## jgh (18. Jan 2011)

gibst du deinem Programm denn auch einen Wert mit?

[c]    double verbrauch = Double.parseDouble(args[0]);[/c] denn ansonsten fliegt er hier ja schon raus?


edit: to late


----------



## tentigo (18. Jan 2011)

oh das könnte es sein.. vergessenden wert beim befehl mitzu übergeben..
sry, wegen des durcheinanders...

ich hab deinen code mal kopiert und ja es klappt, allerdings soll ich ja mit einer eingabeaufforderung arbeiten bzw darf ich die Dateien nicht einfach zusammenpacken...

es müsste doch auch funktionieren wenn ich einzelne dateien von klassen ahbe, oder?


----------



## tentigo (18. Jan 2011)

ok.. nachdem ich nun schon auf dem richtigen weg bin... vielen dank zuerst einmal..

ich muss natürlich das programm so ausführen 
java DemoTarifRechner <zahl>, wobei zahl ein double ist

jedoch kommt nun als Antwort

"Syntaxfehler"

sry wegen der Unannehmlichkeiten... aber naja.. so sind die Javaanfänger...

MfG
N.


----------



## SlaterB (18. Jan 2011)

"Syntaxfehler" ist keine aktzeptable Antwort, weder von einem Programm an dich, noch von dir ans Forum 

ist da nichts längeres mit Zeilenangabe? in einer Entwicklungsumgebung irgendwas rot unterstrichen?
ist es überhaupt ein Compilerfehler oder eine Ausgabe bei Ausführung? irgendwelche Infos muss es doch geben,
poste notfalls einen Screenshot, kann man hier in Postings direkt anhängen

wenn du meinen Code verwendest, dann funktioniert
> java DemoTarifRechner <zahl>
nicht, bleib lieber bei deinen


----------



## tentigo (18. Jan 2011)

Danke für die rasche antwort

```
C:\Users\Studium\Desktop\Uni\Info\HA 11>java DemoTarifRechner <400.0>
Syntaxfehler.
```

ich weiß.. nicht akzeptabel aber vorhanden...

Ist ein Fehler bei der Ausführung

rot unterstrichen? nutze kein Eclipse falls du darauf hinauswillst.. ich soll ja lernen usw 

MfG
N.


----------



## xehpuk (18. Jan 2011)

Wenn da wirklich "Syntaxfehler." steht, hast du uns aber etwas vorenthalten. Irgendwo ein try-catch?
Wie wärs, wenn du die spitzen Klammern weglässt?



tentigo hat gesagt.:


> rot unterstrichen? nutze kein Eclipse falls du darauf hinauswillst.. ich soll ja lernen usw


Fragt sich nur, was ihr dann lernen sollt. :bae:


----------



## SlaterB (18. Jan 2011)

das habe ich in der Tat noch nicht gesehen, oder kann mich nicht erinnern,
du hast nicht zufällig selber im Programm irgendwelche Prüfungen/ try/catch, die Syntaxfehler ausgeben?

<400.0> ist natürlich Käse, die Klammern müssen weg


----------



## tentigo (18. Jan 2011)

in der Tat.. ohne Klammern

vielen Dank, ich muss jetzt nur nochmal die Tarifevergleichsfunktion bearbeiten, denn es kommt immer Vattenfall als anbieter heraus und das .. geht ja nich 

vielen vielen Dank

MfG
N.


----------



## bone2 (18. Jan 2011)

erst:

```
public abstract void berechneTarif(double kwh);
```
dann

```
tarife[2].berechneTarif(tarife[2].getKwh());
```
wundert mich das es überhaupt startet


----------



## SlaterB (18. Jan 2011)

nicht zurecht, sobald man erstmal ein reales Objekt hat kann man auch immer alle Methoden aufrufen,
es gibt eben Subklassen die die Methode implementieren oder notfalls anonyme innere Klassen, bei der Deklaration wird alles abgesichert

bei ActionListener a = ..; wunder man sich ja auch nicht, warum der Aufruf der actionPerformed()-Methode geht


----------



## tentigo (18. Jan 2011)

also.. das problem bei folgendem ist ..einmal brauch ich euch noch. ist allerdings gradnen logisches Problem...

und zwar beim vergleichen der Anbiter.. erhalte ich immer vattenfall... er rechnet immer den Tarif von Nuon aber zum Grundpreis von Vattenfall ... ???:L
so werden die Anbieter eingegeben

```
Tarif[] tarife = { 
			new EPrimo("EPrimo", 500.0),	
			new Nuon("Nuon", 529.0),
			new Vattenfall("Vattenfall", 499.0) 
		};
```

es hat mit der Form zu tun, wie die Anbieter programmiert sind...


```
public class EPrimo extends Tarif {

	public EPrimo(String name, double grundpreis) {

		super(name, grundpreis);
	}

	public void berechneTarif(double kwh) {


		setKwh(kwh);

		setTarif(getGrundpreis() + 20.0*kwh);
	}
}
```

Dadurch dass sie ja auf die Superklasse zugreifen ist also als letztes der Grundwert des zuletzt eingetragenen Anbieters drin... aber müsste nicht jeder ne eigene superklasse haben..?

wie kann ich es machen, dass für jeden Anbieter ein einzelner Grundpreis da ist.. ( mit vererbung)

so ist der Konstruktor in der Superklasse programmiert

```
public Tarif(String name, double grundpreis){
		this.kwh=0.0;
		this.tarif=grundpreis;
		this.name=name;
		this.grundpreis=grundpreis;
	}
```


----------



## SlaterB (18. Jan 2011)

das funktioniert schon, bei mir zumindest wenn ich es mit 400 rechne, nur sind die anderen alle teurer, teils phänomenal, 
400*20 bei EPrimo sind allein 8000, da spielt ein Grundpreis von paar Hundert keine Rolle,
logge überall mit System.out.println, was gerechnet wird, und erkläre mit Worten was du eigentlich erwartest


(5 * kwh + kwh) ist übrigens == (6 * kwh)


----------



## tentigo (18. Jan 2011)

habs nochmal geändert, bzw das + hätte ein * sein müssen...

naja aber wenn ich 1kwh berechne müsste vattenfall mir nur 499 berechnen...tuts aber nicht sondern es rechnet 499+1*20=519

also schließe ich darauf, dass irgendwo was spinnt..
denn .. naja es passt nicht...
tarif Nuon

```
public void berechneTarif(double kwh){	
		setTarif(getGrundpreis()+(5*kwh*kwh)/1000);	
	}
```
tarif Vattenfall

```
public void berechneTarif(double kwh){
		if(kwh<1000){
			setTarif(getGrundpreis());
		}
		if(kwh>=1000 && kwh < 4000){
			setTarif(getGrundpreis()+(15* kwh));
		}			
		if(kwh>=4000){
			setTarif(getGrundpreis()+(25* kwh));
		}
	}
```
tarif Eprimo

```
public void berechneTarif(double kwh) {
		setKwh(kwh);
		setTarif(getGrundpreis() + 20.0*kwh);
	}
```

mein TarifRechner.. (mit else, da ich mal 3 if bedingungen hatte aber dann ja ein return fehlte...)

```
public Tarif getBestTarif(double verbrauch){
	
		tarife[0].berechneTarif(verbrauch);
		tarife[1].berechneTarif(verbrauch);
		tarife[2].berechneTarif(verbrauch);
		
	if(tarife[0].getTarif()<tarife[1].getTarif() && tarife[0].getTarif()<tarife[2].getTarif()){
		return tarife[0];
	}
	else if(tarife[1].getTarif()<tarife[0].getTarif() && tarife[1].getTarif()<tarife[2].getTarif()){
		return tarife[1];
	}

	else{
		return tarife[2];
	}	
	}
```

mag ich nun den besten Tarif ermitteln.. wird mir wie gesagt immer Vattenfall empfohlen.. und immer gerechnet grundpreis=499 +20*verbrauch...

hier der Aufruf zum vergleichen..

```
public static void main(String[] args) {

		

// Tarife 
	
	Tarif[] tarife = { 
			new EPrimo("EPrimo", 500.0),	
			new Nuon("Nuon", 529.0),
			new Vattenfall("Vattenfall", 499.0) 

		};

// Tarifrechner
	
	TarifRechner tr = new TarifRechner(tarife);
		
// Einlesen des monatlichen Verbrauchs von der Kommandozeile
	
	double verbrauch = Double.parseDouble(args[0]);
			
// Ermittlung des konstenguenstigten Tarifs
	
	Tarif bestTarif = tr.getBestTarif(verbrauch);
		
// Ausgabe
	
	System.out.print("Guenstigter Tarif bei einem Verbrauch von ");
	
	System.out.println(verbrauch + " kwh:");
	
	System.out.println("Anbieter: " + bestTarif.getName());
	
	System.out.println("Tarif   : " + bestTarif.getTarif() + " Cent");
	}
}
```

Hä?
könnte sich wer bzgl. dieses Problems mir anschließen bisher .. wunder ich mich nur?
ich befürchte ja.. dass einfach alle drei Anbieter irgendwie auf dieselben Attribute zugreifen....
MfG
N.


----------



## SlaterB (18. Jan 2011)

mit vollständigen Programmen posten ist es bei dir noch nicht weit her, was?
dass für Vattenfall 519 gerechnet ist sehe ich in keiner Form, vielleicht hast du in irgendwelchen Klassen noch irgendwas anders..

mein Test mit aktualisierten Code deines letzten Postings:

```
public class Test
{

    public static void main(String[] args)
    {
        DemoTarifRechner.main(new String[]
            {"1"});
        DemoTarifRechner.main(new String[]
            {"100"});
        DemoTarifRechner.main(new String[]
            {"400"});
        DemoTarifRechner.main(new String[]
            {"1400"});
    }
}


class DemoTarifRechner
{


    public static void main(String[] args)
    {

        // Tarife

        Tarif[] tarife =
            {new EPrimo("EPrimo", 500.0), new Nuon("Nuon", 529.0), new Vattenfall("Vattenfall", 499.0)

            };

        // Tarifrechner

        TarifRechner tr = new TarifRechner(tarife);

        // Einlesen des monatlichen Verbrauchs von der Kommandozeile

        double verbrauch = Double.parseDouble(args[0]);

        // Ermittlung des konstenguenstigten Tarifs

        Tarif bestTarif = tr.getBestTarif(verbrauch);

        // Ausgabe

        System.out.print("Guenstigter Tarif bei einem Verbrauch von ");

        System.out.println(verbrauch + " kwh:");

        System.out.println("Anbieter: " + bestTarif.getName());

        System.out.println("Tarif   : " + bestTarif.getTarif() + " Cent");

    }
}


class EPrimo
    extends Tarif
{
    public EPrimo(String name, double grundpreis)
    {
        super(name, grundpreis);
    }

    public void berechneTarif(double kwh)
    {
        setKwh(kwh);
        setTarif(getGrundpreis() + 20.0 * kwh);
    }
}


class Nuon
    extends Tarif
{
    public Nuon(String name, double grundpreis)
    {
        super(name, grundpreis);
    }


    public void berechneTarif(double kwh)
    {
        setTarif(getGrundpreis() + (5 * kwh * kwh) / 1000);
    }
}


class Vattenfall
    extends Tarif
{
    public Vattenfall(String name, double grundpreis)
    {
        super(name, grundpreis);
    }

    public void berechneTarif(double kwh)
    {
        if (kwh < 1000)
        {
            setTarif(getGrundpreis());
        }
        if (kwh >= 1000 && kwh < 4000)
        {
            setTarif(getGrundpreis() + (15 * kwh));
        }
        if (kwh >= 4000)
        {
            setTarif(getGrundpreis() + (25 * kwh));
        }
    }
}


interface Vergleichbar
{
    abstract boolean istKleiner(Vergleichbar other);
}


abstract class Tarif
    implements Vergleichbar
{

    private double grundpreis;
    private double kwh;
    private double tarif;
    private String name;

    public double getGrundpreis()
    {
        return grundpreis;
    }

    public double getKwh()
    {
        return kwh;
    }

    public double getTarif()
    {
        return tarif;
    }

    public String getName()
    {
        return name;
    }

    public void setGrundpreis(double grundpreis)
    {
        this.grundpreis = grundpreis;
    }

    public void setKwh(double kwh)
    {
        this.kwh = kwh;
    }

    public void setTarif(double tarif)
    {
        this.tarif = tarif;
    }

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

    public Tarif(String name, double grundpreis)
    {
        this.kwh = 0.0;
        this.tarif = grundpreis;
        this.name = name;
        this.grundpreis = grundpreis;
    }


    public abstract void berechneTarif(double kwh);


    public boolean istKleiner(Vergleichbar other)
    {

        if (other instanceof Tarif)
        {
            if (tarif < ((Tarif)other).getTarif())
            {
                return true;
            }
            else
            {
                return false;
            }
        }
        return false;
    }

}


class TarifRechner
{


    // Array von Tarifen verschiedener Stromanbieter


    private Tarif[] tarife;


    /*
     * 
     * Konstruktor zur Initialisierung der Tarife.
     * 
     * 
     * Parameter: Tarife[] tarife - Array von Tarifen
     */


    public TarifRechner(Tarif[] tarife)
    {

        this.tarife = tarife;

    }


    public Tarif getBestTarif(double verbrauch)
    {

        tarife[0].berechneTarif(verbrauch);
        tarife[1].berechneTarif(verbrauch);
        tarife[2].berechneTarif(verbrauch);

        System.out.println("0: " + tarife[0].getTarif());
        System.out.println("1: " + tarife[1].getTarif());
        System.out.println("2: " + tarife[2].getTarif());


        if (tarife[0].getTarif() < tarife[1].getTarif() && tarife[0].getTarif() < tarife[2].getTarif())
        {
            return tarife[0];
        }
        else if (tarife[1].getTarif() < tarife[0].getTarif() && tarife[1].getTarif() < tarife[2].getTarif())
        {
            return tarife[1];
        }

        else
        {
            return tarife[2];
        }

    }
}
```
Ausgabe:

```
0: 520.0
1: 529.005
2: 499.0
Guenstigter Tarif bei einem Verbrauch von 1.0 kwh:
Anbieter: Vattenfall
Tarif   : 499.0 Cent
0: 2500.0
1: 579.0
2: 499.0
Guenstigter Tarif bei einem Verbrauch von 100.0 kwh:
Anbieter: Vattenfall
Tarif   : 499.0 Cent
0: 8500.0
1: 1329.0
2: 499.0
Guenstigter Tarif bei einem Verbrauch von 400.0 kwh:
Anbieter: Vattenfall
Tarif   : 499.0 Cent
0: 28500.0
1: 10329.0
2: 21499.0
Guenstigter Tarif bei einem Verbrauch von 1400.0 kwh:
Anbieter: Nuon
Tarif   : 10329.0 Cent
```

> ich befürchte ja.. dass einfach alle drei Anbieter irgendwie auf dieselben Attribute zugreifen....
denkbar wäre es wenn du Fehler eingebaut hast, z.B. die Attribute static..


----------



## tentigo (18. Jan 2011)

mysteriös... ne habe kein static verwendet..naja ich werds erstmal so stehen lassen...
vielen dank für die hilfe

ich werde mich bessern, was das posten angeht  versprochen

MfG
N.


----------

