OOP if Anweisungen

[coldstone]

Hallo liebe freunde;

was sit syntaktisch hier falsch???
Wenn ich kompilieren will bekomme ich folgende fehlermeldugen??

Messwert.java:14: illegal start of type
if (messwert = sollwert) {
^
Messwert.java:14: <identifier> expected
if (messwert = sollwert) {
^
Messwert.java:14: ';' expected
if (messwert = sollwert) {
^
Messwert.java:14: illegal start of type
if (messwert = sollwert) {
^
Messwert.java:14: <identifier> expected
if (messwert = sollwert) {
^
Messwert.java:14: ';' expected
if (messwert = sollwert) {
^
Messwert.java:15: illegal start of type
System.out.println("Messwert ist exakt sollwert!");
^
Messwert.java:15: ';' expected
System.out.println("Messwert ist exakt sollwert!");
^
Messwert.java:15: invalid method declaration; return type required
System.out.println("Messwert ist exakt sollwert!");
^
Messwert.java:15: illegal start of type
System.out.println("Messwert ist exakt sollwert!");
^
Messwert.java:16: class, interface, or enum expected
} else if (wert <= 0,1){
^
Messwert.java:18: class, interface, or enum expected
} else if (wert <= 0,5) {
^
Messwert.java:20: class, interface, or enum expected
} else if (wert > 0,5) {
^
Messwert.java:22: class, interface, or enum expected
}
^
Messwert.java:24: class, interface, or enum expected
public double messwert {
^
Messwert.java:27: class, interface, or enum expected
}
^
Messwert.java:29: class, interface, or enum expected
public double sollwert {
^
Messwert.java:32: class, interface, or enum expected
}
^
18 errors

import vfh.prog1.bib;

 /** Messwert.java
  *  Klasse zur Beschreibung eines Autos.
  *   @ author Name, mail
  *   Datum
  **/
 public class Messwert {
     // Attribute
      double messwert;
      double sollwert;
      double wert;
   
      if (messwert = sollwert) {
    	   System.out.println("Messwert ist exakt sollwert!");
    	} else if (wert <= 0,1){
    	    System.out.println("Messwert liegt innerhalb der Toleranz!");
    	} else if (wert <= 0,5) {
    	    System.out.println("Messwert ist brauchbar!");
    	} else if (wert > 0,5) {
    	    System.out.println("Ausschuss");
    	} 
}
  public double messwert {
 
     double messwert = Konsole.getInputDouble("Wert:");
  }
  
  public double sollwert {
	  
	 double sollwert = Konsole.getInputDouble("Wert:");
  }

 

[gman]

Hi,

dein ganzer If-Block steht einfach so in der Klasse rum. Der muss schon in einer Methode drin stehen.

 

[eRaaaa]

Oha...

a) du kannst die Abfragen nicht einfach so mitten in die Klasse schreiben, die müssen in einen Block ala Konsturktor/Methode/etc.

b) Methoden immer mit Klammern public double messwert() { und natürlich dann auch ein double zurückgeben!

 

[wired_]

Hallo.

Mir ist noch etwas aufgefallen. Werte werden mit == verglichen.
Also folgendermaßen

if (messwert == sollwert)

 

[Runtime]

  public double sollwert {
	  
	 double sollwert = Konsole.getInputDouble("Wert:");
  }

Das sollte so aussehen:

  public void sollwert() {
	  
	 double sollwert = Konsole.getInputDouble("Wert:");
  }

Edit: Hab eRaaaa übersehen

 

[coldstone]

Erstmal vielen dank für eure Antworten.


muss den die if-Anweisung in der Klasse bleiben oder auserhalb der klasse Messwert erzeugt werden?

Nur mal zum Verständniss des aufbaues eines Java Programms.
Hier erzeuge ich doch eine Klasse Messwert und lege fest, welche Attribute ich brauche mit der zuweisung der Datentypen. Lieg ich da richtig?

import vfh.prog1.bib;

 /** Messwert.java
  *  Klasse zur Beschreibung eines .
  *   @ author Name, mail
  *   Datum
  **/
 public class Messwert {
     // Attribute
      double messwert;
      double sollwert;
      double wert;
}

Hier lege ich doch fest, was gemacht werden soll. Also sozusagen, was getan werden soll. Lieg ich da richtig?

 public static main(String[] args) {

 if (messwert == sollwert) {
	   System.out.println("Messwert ist exakt sollwert!");
	} else if (wert <= 0,1){
	    System.out.println("Messwert liegt innerhalb der Toleranz!");
	} else if (wert <= 0,5) {
	    System.out.println("Messwert ist brauchbar!");
	} else if (wert > 0,5) {
	    System.out.println("Ausschuss");
	}
 }

Und hierdurch werden die Daten eingegeben.
Wird denn Automatisch der eingegeben Wert in "messwert" oder "sollwert" an die Methode zurückgegeben oder muss mann in Java dafür eine anweisung schreiben?

 public double messwert() {
 
     double messwert = Konsole.getInputDouble("Wert:");
     
 }
  
  public double sollwert() {
	  
	 double sollwert = Konsole.getInputDouble("Wert:");
     
  }

Eine erklärung für Java Lehrlinge wie mich bitte. :rtfm:

 

[gman]

Zum zweiten Code-Abschnitt: Ja, jetzt befindet sich der If-Block auch in einer Methode ("main") und steht
nicht irgendwo in der Klasse rum.

Wird denn Automatisch der eingegeben Wert in "messwert" oder "sollwert" an die Methode zurückgegeben oder muss mann in Java dafür eine anweisung schreiben?

Wie eRaaa schon sagte musst du ein double zurück geben:

    public double sollwert() {
        double sollwert = Konsole.getInputDouble("Wert:");

        return double;
    }

Der Codeschnipsel enthält einen Fehler! Es muss natürlich [c]return sollwert;[/c] heissen! Aber
ich lasse es mal drin, damit die folgenden Beiträge noch ihren Sinn behalten.

 

[coldstone]

So habe denn Quellcode so verändert

import vfh.prog1.bib;

 /** Messwert.java
  *  Klasse zur Beschreibung eines .
  *   @ author Name, mail
  *   Datum
  **/
 public class Messwert {
     // Attribute
      double messwert;
      double sollwert;
      double wert;
}
 
 public static main(String[] args) {

 if (messwert == sollwert) {
	   System.out.println("Messwert ist exakt sollwert!");
	} else if (wert <= 0,1){
	    System.out.println("Messwert liegt innerhalb der Toleranz!");
	} else if (wert <= 0,5) {
	    System.out.println("Messwert ist brauchbar!");
	} else if (wert > 0,5) {
	    System.out.println("Ausschuss");
	}
 }
 
 
 public double messwert() {
 
     double messwert = Konsole.getInputDouble("Wert:");
     return double;
 }
  
  public double sollwert() {
	  
	 double sollwert = Konsole.getInputDouble("Wert:");
     return double;
  }

Bekomme aber beim kompilieren aber immer noch Fehler angezeigt.

Messwert.java:15: class, interface, or enum expected
public static main(String[] args) {
^
Messwert.java:19: class, interface, or enum expected
} else if (wert <= 0,1){
^
Messwert.java:21: class, interface, or enum expected
} else if (wert <= 0,5) {
^
Messwert.java:23: class, interface, or enum expected
} else if (wert > 0,5) {
^
Messwert.java:25: class, interface, or enum expected
}
^
Messwert.java:29: class, interface, or enum expected
public double messwert() {
^
Messwert.java:32: class, interface, or enum expected
return double;
^
Messwert.java:33: class, interface, or enum expected
}
^
Messwert.java:35: class, interface, or enum expected
public double sollwert() {
^
Messwert.java:38: class, interface, or enum expected
return double;
^
Messwert.java:39: class, interface, or enum expected
}
^
11 errors

Wieso gibt er eigentlich die geschweiften kammern als fehler an? Und ist die Wahl der main Methode denn falsch?

 

[eRaaaa]

Du solltest vllt nochmal ein wenig lesen, hier fehlen Grundlagen!

 public class Messwert {
     // Attribute
      double messwert;
      double sollwert;
      double wert;
}

die zweite Klammer schließt die Klasse ! Methoden usw. müssen da aber mit rein

 public static main(String[] args) {

 if (messwert == sollwert) {
	   System.out.println("Messwert ist exakt sollwert!");
	} else if (wert <= 0,1){
	    System.out.println("Messwert liegt innerhalb der Toleranz!");
	} else if (wert <= 0,5) {
	    System.out.println("Messwert ist brauchbar!");
	} else if (wert > 0,5) {
	    System.out.println("Ausschuss");
	}
 }

-Es heißt public static void main(String[] args) {
-Du kannst von der main-Methode nicht einfach so auf diese Variablen zugreifen, außer sie wären static. Du brauchst ein Objekt!

 public double messwert() {
 
     double messwert = Konsole.getInputDouble("Wert:");
     return double;
 }

Das war gman`s Fehler

return double;

ist natürlich falsch --> return messwert, oder eben void und das return weglassen!

--> :rtfm: (ganz viel)

 

[gman]

UUUUUUUPS, Sch****!

Das ist ja mal peinlich. Sorry, Coldstone. Und danke eRaaa. Ich schliesse mich ihm übrigens an,
dir fehlen noch deutlich die Grundlagen, dazu ein hier beliebter Link:

Galileo Computing :: Java ist auch eine Insel (8. Auflage)

 

[coldstone]

Ich merke schon ich muss wirklich noch viel nachlesen. :rtfm: Muss aber leider auch diese Aufgabe bis Morgen Abend erledigen. Währe euch wirklich dankbar wen Ihr mir bschen auf die sprünge helfen könntet.
Nun was bedeutet denn diese Aussage:

public static void main(String[] args)

Public bedutet soweit ich weis, das der Wert von überall gesehen werden kann.
Static ----> das der Rückgabewert unveränderbar ist.
void???
main ----> ist die Methode
String????
args?????

Verstehe ich das richtig das in jedem Java Programm eine Methode vorhanden sein muss und die Methode der eigentliche Programmteilist?

Zum if-Block:

if (messwert == sollwert) {
       System.out.println("Messwert ist exakt sollwert!");
    } else if (wert <= 0,1){
        System.out.println("Messwert liegt innerhalb der Toleranz!");
    } else if (wert <= 0,5) {
        System.out.println("Messwert ist brauchbar!");
    } else if (wert > 0,5) {
        System.out.println("Ausschuss");
    }
 }

Darf denn "wert" dort stehen ist das richtig? Denn ich bin davon ausgegangen, das wenn ich ein Objekt "wert" erstelle und den wert mit return zurückgebe wäre das doch korrekt???

 

[gman]

Static ----> das der Rückgabewert unveränderbar ist.

Nein. Static bedeutet das eine Variable/Methode nicht an eine Instanz eines Objektes gebunden ist, sondern
an die Klasse. Zum Beispiel kann mann eine statische Methode aufrufen ohne ein Objekt der Klasse zu haben:

//hier ist "random" eine statische Methode der Klasse "Math"
double rand = Math.random();

Verstehe ich das richtig das in jedem Java Programm eine Methode vorhanden sein muss und die Methode der eigentliche Programmteilist?

Fast. Die "main"-Methode dient nur als "Startpunkt" der Anwendung.

Darf denn "wert" dort stehen ist das richtig?

In deinem bisherigen Code werden den Variablen noch keine Werte zugewiesen! Du musst mit den
Methoden noch "messwert" und "sollwert" einen Wert zuweisen. Und wenn ich den Code richtig
verstehe, soll "wert" die Differenz von "mess-" und "sollwert" sein.

 

[vanny]

Ein paar Sachen hab ich auch schon begriffen ^^, die teile ich gerne mit dir

"void" sind Methoden, die keinen Wert zurück geben
"String" ist ein Datentyp ...ein String halt^^ und mit [] wird es ein String-Array
des "args" hab ich auch nich kapiert in der mainMethode, vieleicht mag da mal einer der "pros was zu sagen"
und
public, private und die anderen Sichtbarkeiten solltest du dir auch anschauen

also wenn du das schnell fertig bekommen musst, dann häng dich nicht an der mainMethode auf, sondern erstell dir ne Klasse mit nem Konstruktor und erzeuge dir in der main einfach ein neues Objekt.

 

[JavaN3rd]

Ein weiterer Fehler ist das es 0.5 bzw 0.1 usw. heissen soll und nicht 0,1. Java verwendet das Komma als Separator (einfach ausgedrückt), Dezimalzahlen hingegen müssen mit . (Punkt) geschrieben werden.

 

[coldstone]

In deinem bisherigen Code werden den Variablen noch keine Werte zugewiesen! Du musst mit den
Methoden noch "messwert" und "sollwert" einen Wert zuweisen. Und wenn ich den Code richtig
verstehe, soll "wert" die Differenz von "mess-" und "sollwert" sein.

Aber wird denn nicht damit messwert und sollwert ein Wert zugewiesen den der Nutzer selber eingibt??

public double messwert() {
 
     double messwert = Konsole.getInputDouble("Wert:");
     return messwert;
 }
  
 public double sollwert() {
	  
	 double sollwert = Konsole.getInputDouble("Wert:");
     return sollwert;
  }

ICh müsste doch jetzt irgendwie eine rechenmethode erstellen, damit "wert" in dem if-Block einen Wert zugewiesen bekommt oder?

 

[gman]

Die Abfrage an den Nutzer ("Wert:") wird aber auch nur angezeigt, wenn die Methode aufgerufen wird.
Und auch nur dann kannst du den Rückgabewert der Methode verwenden. Oder du machst "messwert"
und "sollwert" zusätzlich static und dann:

  public void messwert() {
 
     messwert = Konsole.getInputDouble("Wert:");
 }

Im übrigen musst du die Variablen sowieso static machen, wenn du sie in der "main"-Methode
verwenden willst.

 

[coldstone]

Ok, du meinst es müsste so aussehen wenn ich dich richtig verstanden habe!!

 public static double messwert() {
 
     double messwert = Konsole.getInputDouble("Wert:");
     
 }
  
 public static double sollwert() {
	  
	 double sollwert = Konsole.getInputDouble("Wert:");
   
  }

Und um den Wert "wert" berechnen zu lassen, muss ich da eine neue klasse erzeugen und in der klasse eine methode oder wie berechne ich den Wert "wert"?

Meine Überlegung wäre:

 public class wert {
	      public static void main(String[] args) {
	          double a = messwert(); 
	          double b = sollwert();
	          double c = wert();
	          
	        	  c=a-b;	        	  	          
	      }
	  }

Nur wie gebe ich den wert "wert" an die Klasse Messwert zurück? ???:L
Und wie kann man den wert "wert" als Betrag zurückgeben? ???:L

 

[bone2]

du musst deine messwert und sollwert methoden auch aufrufen in der main methode.
auf die static attribute kann man von überall im programm einfach zugreifen:

public class Test {
    // Attribute
    private static double messwert;
    private static double sollwert;
    private static double wert;

    public static void main(String[] args) {
        getMesswert();
        getSollwert();
        getWert();

        if (messwert == sollwert) {
            System.out.println("Messwert ist exakt sollwert!");
        } else if (wert <= 0.1){
            System.out.println("Messwert liegt innerhalb der Toleranz!");
        } else if (wert <= 0.5) {
            System.out.println("Messwert ist brauchbar!");
        } else if (wert > 0.5) {
            System.out.println("Ausschuss");
        } 
    }

    private static void getMesswert() {
        messwert = Konsole.getInputDouble("Wert:");
    }

    private static void getSollwert() {
        sollwert = Konsole.getInputDouble("Wert:");
    }

    private static void getWert() {
        wert = messwert - sollwert;
    }

}

vfl hat natürlich recht, habs mal angepasst

 

[VfL_Freak]

Moin,

und dann gleich noch ein ganz wichtiger Tipp:

es ist auf Dauer absolut tödlich, wenn Variablennamen und Methodenbezeichner gleich lauten (Bsp.: messwert)

Das mag bei einem Programm mit 10 Zeilen vlt. noch so eben überschaubar sein.
Wenn Du aber mal ein Projekt mit nur 100 oder aber 1000 oder 10000 Zeilen Code hast, bekommst Du schneller Probleme, als Du "Java" sagen kannst

Gewöhn' Dir von Anfang an die richtige Syntax an ...
Java-Syntax ? Wikipedia

Gruß
Klaus

 

[bygones]

es ist auf Dauer absolut tödlich, wenn Variablennamen und Methodenbezeichner gleich lauten (Bsp.: messwert)
Das mag bei einem Programm mit 10 Zeilen vlt. noch so eben überschaubar sein.
Wenn Du aber mal ein Projekt mit nur 100 oder aber 1000 oder 10000 Zeilen Code hast, bekommst Du schneller Probleme, als Du "Java" sagen kannst

stimme ich nicht ganz zu. Die API kommuniziert nur die Methode und nach innen sollte deine Klasse so und so nicht mehrere hundert Zeilen sein (v.a nicht bei stupiden Datenhaltern). Ich seh kein Problem darin dies gemeinsam zu haben.

des "args" hab ich auch nich kapiert in der mainMethode, vieleicht mag da mal einer der "pros was zu sagen"

falls noch nicht beantwortet. "args" ist einfach der Bezeichner des Parameters, so dass man in der Methode damit arbeiten kann. Bei der Main Methode hat sich eben für den String[] der Bezeichner "args" etabliert... man koennte es aber auch nenn wie man will

 

[Andi_CH]

Steht auch irgendwo dass eine Prozedur < 100 Zeilen und eine Klasse (File) < 1000 Zeilen sein sollte?

Was mich aber zum Posting verleitet ist die Tatsache, dass mir hier vor Kurzem wehement etwas viel gefährlicheres empfohlen wurde.
Gleiche Namen für Parameter und Variablen Das ist der Horror!
(Für den Menschen ist es sehr schnell unklar was z.B. messwert = 5.0; bewirkt, wenn der Parameter und die Variable messwert heissen!)

Ernst gemeinte Frage: Was soll am Codeschnippsel unten gefährlich sein? Da ist doch alles sogar für den Menschen unverwechselbar?

(Ich selbst würde es allerdings NIE ohne "get" und "set" vor den Methoden schreiben. Bei mir wird JEDER Bezeichner nur ein einziges Mal verwendet.)

private double messwert;
public double messwert(){return messwert;}
public void messwert(int neuerMesswert){messwert = neuerMesswert;}

public void demo (int pNeuerWert){
  double tmp = messwert();
  messwert(pNeuerWert);
  messwert = 7;
  // zwar sinnlos, aber sind auch eindeutig
  messwert(messwert);
  messwert(messwert());
  ....
}

 

[VfL_Freak]

Moin,

stimme ich nicht ganz zu. Die API kommuniziert nur die Methode und nach innen sollte deine Klasse so und so nicht mehrere hundert Zeilen sein (v.a nicht bei stupiden Datenhaltern). Ich seh kein Problem darin dies gemeinsam zu haben.

ich hatte ja auch nicht Klasse, sondern Projekt geschrieben ....

Aber nicht desto trotz gibt es (aus guten Gründen) gewisse Konventionen, an die man sich halten sollte!
Und wenn man sich erst mal was "Falsches" angewöhnt hat, wird man es nur schwer wieder los ....

In meiner letzten Firma wurde irgendwann Programmierrichtlinien entwickelt und regelmäßige Code-Reviews durchgeführt. Habe mich selbst immer wieder erschrocken, was man dann alles so nicht beachtet, weil man es anders gewohnt ist !

Gruß
Klaus

 

[bygones]

Aber nicht desto trotz gibt es (aus guten Gründen) gewisse Konventionen, an die man sich halten sollte!
Und wenn man sich erst mal was "Falsches" angewöhnt hat, wird man es nur schwer wieder los ....

wie du unten sagst, die definition von "falschem" ist hin und wieder unterschiedlich

In meiner letzten Firma wurde irgendwann Programmierrichtlinien entwickelt und regelmäßige Code-Reviews durchgeführt. Habe mich selbst immer wieder erschrocken, was man dann alles so nicht beachtet, weil man es anders gewohnt ist !

ich entwickler hier in der Firma u.a. die Richtlinien und führe täglich Reviews durch... die Reaktionen sind mir bekannt ;-)

 

[coldstone]

du musst deine messwert und sollwert methoden auch aufrufen in der main methode.
auf die static attribute kann man von überall im programm einfach zugreifen:

public class Test {
    // Attribute
    private static double messwert;
    private static double sollwert;
    private static double wert;

    public static void main(String[] args) {
        getMesswert();
        getSollwert();
        getWert();

        if (messwert == sollwert) {
            System.out.println("Messwert ist exakt sollwert!");
        } else if (wert <= 0.1){
            System.out.println("Messwert liegt innerhalb der Toleranz!");
        } else if (wert <= 0.5) {
            System.out.println("Messwert ist brauchbar!");
        } else if (wert > 0.5) {
            System.out.println("Ausschuss");
        } 
    }

    private static void getMesswert() {
        messwert = Konsole.getInputDouble("Wert:");
    }

    private static void getSollwert() {
        sollwert = Konsole.getInputDouble("Wert:");
    }

    private static void getWert() {
        wert = messwert - sollwert;
    }

}

vfl hat natürlich recht, habs mal angepasst

Vielen dank für die Antworten. Sorry wenn ich einigen auf die Nerven gehe. Aber ich muss es irgendwie lernen und werde es auch irgendwie lernen.
Ist dies jetzt die finale version? Wenn ich kompiliere bekomme ich immer noch fehler meldungen. Undzwar das die Import Anweisung fehlerhaft ist.

import vfh.prog1.bib;

 

[bone2]

der import fehlt bei mir, wie dir vielleicht auffallen sollte und ich glaub den class name hab auch verändert, hab in eclipse ein testprofil, wo ich solche spielerreien immer einfach reinkopiere