Java Klassen

[JavaAnfänger (Gast)]

Hallo, ich bin gerade dabei mich weiter bei Java einzuarbeiten. Momentan 
hänge ich an Klassen fest bzw eine Klasse mit einzelnen Methoden.

Ich würde gerne einen Tank für ein Auto programmieren.



Ich erstelle eine Klasse mit Drei Attributen:
groesse, fuellstand, verbrauch

public class Autotank {
//Eigenschaften des Autotanks:
  
  double groesse;
  double fuellstand;
  double verbrauch;

Einen Konstruktor mit drei Parameter für die Anfangswerte der Attribute:

// Konstruktor mit drei Parametern für die Anfangswerte der Attribute  
  public Autotank (double a, double b, double c){
    
    a = groesse;
    b = fuellstand;
    c = verbrauch;
  }

Nun möchte ich die fünf methoden realiseren:
fuellstand() und verbrauch() (Methoden sollen zurückliefern wieviel 
Liter benzin der Tank enthält bzw. wieviel Liter pro 100 km verbraucht 
werden.

//Methoden: fuellstand, verbrauch, tanken, fahren, reichweite:
  public double fuellstand(double fuellstand){
    return fuellstand;
  }
  
  public double verbrauch (double verbrauch){
    return verbrauch;
  }

tanken(): Möchte eine Nachkommastelle als Parameter übergeben, die 
angibt wieviel Liter getankt werden soll. Wenn die Zahl negativ ist, 
soll nichts passieren, wenn der Tank "Überlaufen" würde, so soll nur 
gefüllt werden, wie groß seine "groesse" ist.

fahren(): integer wert übergeben die angibt wieviel Km ich zurücklege. 
Tankinhalt soll geändert werden. Ist die Kilometerzahl negativ so soll 
nichts passieren. Ist die Zahl höher als der Tankinhalt so soll 
Tankinhalt auf 0 gesetzt werden. Ist der Tankinhalt 0 dann false als 
Rückgabewert ansonsten true.

reichweite (): soll berechnen wieviel KM das auto zurück legen könnte 
aufgrund von Tankinhalt und Verbrauch.


Fragen:
Kann ich die ersten beiden Methoden so schreiben? Ich weiß einfach 
nicht, wie ich die anderen 3 Methoden realiseren kann. Hilfestellung 
wäre super.

Danke

[Speckbert (Gast)]

Bis wann muss die Hausaufgabe denn fertig sein?

[nicht"Gast" (Gast)]

Wozu muss ein ein Tank über den Verbrauch bescheid wissen?

[Mark B. (markbrandis)]

> double verbrauch;

Der Verbrauch ist keine Eigenschaft des Tanks. Er ist abhängig vom 
Motor, der Fahrweise, der Zuladung.

[JavaAnfänger (Gast)]

31.01

[Frank E. (Firma: Q3) (qualidat)]

1. Die Zuweisungen im Konstruktor sind falsch herum, muss z.B. 
groesse=a; heissen.

2. Die Attribute groesse, fuellstand und verbrauch sollten zusätlich 
"private" sein.

3. die Methoden zum Setzen und Auslesen ("Setter" u. "Getter") dürfen 
nicht (und sollten auch nicht) genau so heissen wie die Attribute, 
sondern z.B. GetFuellstand() ...

[Lang (Gast)]

Kleiner Tip:

Was macht bzw wie funktioniert der Zuweisungsoperator =   ?

Vor Klassen nochmal lesen, wie Funktionen/Methoden definiert werden. In 
all den unterschiedlichen Ausprägungen.

Dann kommt man auf des Rätsels Lösung.

[JavaAnfänger (Gast)]

Bin mir gerade nochmal alles von Anfang an am angucken.

public class Autotank {
  private static double groesse= 0;
  private static double fuellstand= 0;
  private double verbrauch= 0;
  
// Konstruktor mit drei Parametern für die Anfangswerte der Attribute  
  public Autotank (double a, double b, double c){
    
    groesse = a ;
    fuellstand = b;
    verbrauch = c;
  }
  //Methoden: fuellstand, verbrauch, tanken, fahren, reichweite:
//liefert den aktuellen Stand des Tankes
    public double getfuellstand(){
      return fuellstand;
    }
//liefert den Verbrauch des Autos    
    public double getverbrauch (){
      return verbrauch;
    }
//Methode zum ändern des Fuellstandes  
    public static void tanken (int liter){
      if(liter<=0 || fuellstand + liter > groesse){
      }else{
        fuellstand = fuellstand + liter;
    }
    }

Was ich nur nicht verstehe, ist warum ich die Variablen private sein 
müssen und static? Kann mir bitte jemand das bitte mit eigenen Worten 
erklären ?

[Mark B. (markbrandis)]

JavaAnfänger schrieb:
> Was ich nur nicht verstehe, ist warum ich die Variablen private sein
> müssen und static?

Sie müssen nicht private sein. Es ist aber sinnvoll, wenn sie es sind. 
Stichwort: Datenkapselung. Anderer Code von außerhalb dieser Klasse soll 
die Werte der Objekte nur auf diejenige Art und Weise manipulieren 
können, welche die Klasse selbst vorsieht.

static ist hier nicht sinnvoll. Jedes Exemplar eines Tanks hat seinen 
eigenen Füllstand. Siehe auch:

http://www.javatpoint.com/static-keyword-in-java

[Frank E. (Firma: Q3) (qualidat)]

Ein Attribut oder eine Methode macht man "static", wenn man sie benutzen 
will, ohne dass man dazu ein Objekt der Klasse instantiiert. Beispiel 
wäre eine Mathematik-Funktion aus der Math-Klasse.

Man kann z.B. a=Math.sin(b); benutzen, ohne vorher Math mit new erzeugt 
zu haben. Ist in deinem Beispiel aber nicht sinnvoll.

Ach ja - nochwas: Die Schreibweise.

Es hat sich in Java-Kreisen eine gewisse Schreibweise eingebürgert. Die 
ist zwar nicht technisch zwingend notwendig. "getfuellstand()" 
funktioniert genau so wie "GetFuellstand()" ... aber üblich wäre 
Letzters. Auch für die Benennung von Attributen und Klassen gibts solche 
Regeln. Wäre von Vorteil, wenn du dich gleich von Anfang an daran 
gewöhnst.

[foo (Gast)]

Frank E. schrieb:
> "getfuellstand()"
> funktioniert genau so wie "GetFuellstand()" ... aber üblich wäre
> Letzters.

Nein. Üblich wäre getFuellstand().
CamelCase mit Majuskel vorne ist für Klassen vorgesehen.
http://www.oracle.com/technetwork/java/codeconventions-135099.html

[Eric B. (beric)]

JavaAnfänger schrieb:
> //Methode zum ändern des Fuellstandes
>     public static void tanken (int liter){
>       if(liter<=0 || fuellstand + liter > groesse){
>       }else{
>         fuellstand = fuellstand + liter;
>     }

Die methode tanken soll nicht static sein.
Warum ist der Parameter liter ein int und kein double? Kann ich kein 
23,41 liter tanken?

[Mike (Gast)]

Die Tankroutine

  public static void tanken (int liter){
      if(liter<=0 || fuellstand + liter > groesse){
      }else{
        fuellstand = fuellstand + liter;
    }

sollte nicht static sein. Der Aufruf macht nur Sinn, wenn eine Instanz 
der Klasse existiert.

Ausserdem wird nichts in den Tank gefüllt, wenn die zu tankende Menge 
die Kapazität überschreitet. Ist das so gewollt? Sinnvoller wäre es, in 
diesem Fall den Tank komplett zu füllen

[JavaAnfänger (Gast)]

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Autotank {
  private static double groesse;
  private static double fuellstand;
  private static double verbrauch;

  // Konstruktor mit drei Parametern für die Anfangswerte der Attribute
  public Autotank(double a, double b, double c) {

    groesse = a;
    fuellstand = b;
    verbrauch = c;
  }

  // Methoden: fuellstand, verbrauch, tanken, fahren, reichweite:
  public double GetFuellstand() {
    return fuellstand;
  }

  public double GetVerbrauch() {
    return verbrauch;
  }

  public static void tanken(double liter) {
    if (liter <= 0 ) {
    } else if (fuellstand + liter > groesse){
      fuellstand = groesse;
    }
    else { 
    
      fuellstand = fuellstand + liter;
    }
    
  }

  static void fahren (int Kilometerzahl) {
    fuellstand = fuellstand -((verbrauch*Kilometerzahl)/100);
    
  }
  static double Reichweite (double kilometer){
    kilometer = (fuellstand/verbrauch)*100;
    return kilometer;
  }
  
  public static void main(String args[]) throws IOException {
      
      BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
      int choice = 0;
      Autotank a1 = new Autotank(100, 50, 5);
      do {
        
        System.out.println();
        System.out.println("Bitte waehlen:");
        System.out.println("(1) Fuellstand abfragen");
        System.out.println("(2) Verbrauch abfragen");
        System.out.println("(3) Tanken");
        System.out.println("(4) Fahren");
        System.out.println("(5) Reichweite");
        System.out.println("(0) Ende");
        choice = Integer.parseInt(in.readLine());
        System.out.println();
        
        switch (choice) {
          
          case 1: System.out.println(a1.GetFuellstand());

          break;
          
          case 2: System.out.println(a1.GetVerbrauch());

          break;
          
          case 3: tanken(in.read());

          break; 
          
          case 4: fahren(in.read());

          break;
          
          case 5: System.out.println(Reichweite(fuellstand));

          break;
          
        }
        
      
        
      } while (choice!=0);
      
    }
    
  

  }

So sieht der Code jetzt aus.
Wenn ich tanken() nicht static ist, bemängelt mir das Eclipse im 
Hauptprogramm.

Wie muss ich z.b. den Methodenaufruf in der Switchcase anweisung genau 
schreiben bei tanken() und fahren()?
Wenn ich z.b. das Programm laufen lassen und 3 für tanken drücke und 
dann die Literanzahl eingebe, nimmt er immer nur den ersten Wert. Also 
2(0)<- Nimmt er garnicht). Er nimmt also quasi nur die 2. Ruft dann aber 
auch gleichzeitig wieder die Methode für 2 auf und bricht dann ab 
aufgrund der 0.

[Achim H. (anymouse)]

Lieber JavaAnfänger (Gast),

Du solltest Dich einmal ausführlich mit dem Unterschied von 
Klassen-Methoden/Variablen/.. (static) und Instanz-Methoden/Variablen/.. 
(NICHT static) beschäftigen, und wie man diese aufruft

Beispiel: Autotank.tanken(double) vs. a1.tanken(double) ).

Du machst eine sehr seltsame Kombination, die vermutlich nicht Dein 
Wunsch ist. Daraus kommen auch so komische Effekte wie "Wenn ich 
tanken() nicht static ist, bemängelt mir das Eclipse im Hauptprogramm."

Danach kümmern wir uns mal um das mit den Bezeichnungen und den Fehlern.

[Mark B. (markbrandis)]

Achim H. schrieb:
> Lieber JavaAnfänger (Gast),
>
> Du solltest Dich einmal ausführlich mit dem Unterschied von
> Klassen-Methoden/Variablen/.. (static) und Instanz-Methoden/Variablen/..
> (NICHT static) beschäftigen, und wie man diese aufruft

Dafür müsste man halt mal nachlesen, was es damit auf sich hat. Aber das 
ist ja uncool. Lieber einfach wild drauflos hacken... :-(

[JavaAnfänger (Gast)]

Nochmal die Skripte angeguckt und werde mir nochmal alles genauer 
durchlesen und versuchen besser zu verstehen. Immerhin das mit static 
hab ich verstanden und auch warum in.read(); nicht klappt.

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Autotank {
  private double groesse;
  private double fuellstand;
  private double verbrauch;

  // Konstruktor mit drei Parametern für die Anfangswerte der Attribute
  public Autotank(double a, double b, double c) {

    groesse = a;
    fuellstand = b;
    verbrauch = c;
  }

  // Methoden: fuellstand, verbrauch, tanken, fahren, reichweite:
  public double GetFuellstand() {
    return fuellstand;
  }

  public double GetVerbrauch() {
    return verbrauch;
  }

  public void tanken(double liter) {
    if (liter <= 0 ) {
    } else if (fuellstand + liter > groesse){
      fuellstand = groesse;
    }
    else { 
    
      fuellstand = fuellstand + liter;
    }
    System.out.println("Getankt"+liter);
  }

  public boolean fahren (int Kilometerzahl) {
    fuellstand = fuellstand -((verbrauch*Kilometerzahl)/100);
    return true;
    
  }
  public double Reichweite (double kilometer){
    kilometer = (fuellstand/verbrauch)*100;
    return kilometer;
  }
  
  public static void main(String args[]) throws IOException {
      
      BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
      int choice = 0;
      boolean erfolg;
      Autotank a1 = new Autotank(80, 50, 7.5);
      
      do {
        
        System.out.println();
        System.out.println("Bitte waehlen:");
        System.out.println("(1) Fuellstand abfragen");
        System.out.println("(2) Verbrauch abfragen");
        System.out.println("(3) Tanken");
        System.out.println("(4) Fahren");
        System.out.println("(5) Reichweite");
        System.out.println("(0) Ende");
        choice = Integer.parseInt(in.readLine());
        System.out.println();
        
        switch (choice) {
          
          case 1: System.out.println(a1.GetFuellstand());

          break;
          
          case 2: System.out.println(a1.GetVerbrauch());

          break;
          
          case 3: a1.tanken(Double.parseDouble(in.readLine()));
              

          break; 
          
          case 4: a1.fahren(Integer.parseInt(in.readLine()));

          break;
          
          case 5: System.out.println(a1.Reichweite(a1.GetFuellstand()));

          break;
          
        }
        
      
        
      } while (choice!=0);
      
    }
    
  

  }

Die Methode fahren muss ich noch bearbeiten. Bitte die nicht 
berücksichtigen.

[Eric B. (beric)]

Mike schrieb:
> Ausserdem wird nichts in den Tank gefüllt, wenn die zu tankende Menge
> die Kapazität überschreitet. Ist das so gewollt? Sinnvoller wäre es, in
> diesem Fall den Tank komplett zu füllen

...und ein Overflow-Exception zu schmeissen :-)

[JavaAnfänger (Gast)]

JavaAnfänger schrieb:
> public void tanken(double liter) {
>     if (liter <= 0 ) {
>     } else if (fuellstand + liter > groesse){
>       fuellstand = groesse;
>     }
>     else {
>
>       fuellstand = fuellstand + liter;

Eric B. schrieb:
> Mike schrieb:
>> Ausserdem wird nichts in den Tank gefüllt, wenn die zu tankende Menge
>> die Kapazität überschreitet. Ist das so gewollt? Sinnvoller wäre es, in
>> diesem Fall den Tank komplett zu füllen
>
> ...und ein Overflow-Exception zu schmeissen :-)


Die Methode macht folgendes:
Wenn eine negativezahl getankt wird, passiert nichts.
Wenn übertankt wird, dann wird der tank nur bis max der Tankgröße 
befüllt.
Ansonsten wird der Fuellstand des tankes mit den getankten Litern 
addiert.

[Mladen G. (Gast)]

 public Autotank(double a, double b, double c) {

    groesse = a;
    fuellstand = b;
    verbrauch = c;
  }

.. umgekehrt wird ein Schuh draus, deklariere die Parameter des 
Konstruktors als final und der Compiler wird dir helfen ;)

[cppler (Gast)]

Sauber OO programmieren bedeutet auch OO verstanden zu haben.
Üblicherweise werden interne Variablen eines Objekts auch nur intern 
verwendet.
Stichwort "getter" und "setter" das hast Du ja halb umgesetzt.
Dann gibt es noch die Vererbung und ein Tank ist wie schon gesagt kein 
Motor geschweige denn ein Auto o.ä.
Also gehe systematisch vor und beschreibe jedes Objekt Deines Autos 
einzeln, dann bekommst Du Klassen wie Motor, Tank, Tür usw. usf.
Daraus kannst Du dann was machen.
Achja und Destruktoren sind auch immer was feines ...

[Mark B. (markbrandis)]

cppler schrieb:
> Sauber OO programmieren bedeutet auch OO verstanden zu haben.
> Üblicherweise werden interne Variablen eines Objekts auch nur intern
> verwendet.
> Stichwort "getter" und "setter" das hast Du ja halb umgesetzt.

...und wenn man es ganz ganz ganz ganz richtig macht, dann kann man auf 
Getter und Setter oftmals verzichten. Wenn man diese permanent und für 
alles benutzt, hat man eines ganz sicher nicht: Ein richtig gutes 
objektorientiertes Software-Design.

OOP bedeutet unter anderem, dass Objekte zur Laufzeit über Nachrichten 
miteinander kommunizieren. So wie es z.B. in Smalltalk üblich ist. Diese 
Nachrichten sollten aber nicht ständig trivial sein à la "gib mir Wert 
X, und ich rechne dann mit diesem".

Siehe zum Beispiel:
Why getter and setter methods are evil
http://www.javaworld.com/article/2073723/core-java/why-getter-and-setter-methods-are-evil.html
Doing it wrong: getters and setters
http://typicalprogrammer.com/doing-it-wrong-getters-and-setters/

> Achja und Destruktoren sind auch immer was feines ...

Nicht in Java, weil das dort der Garbage Collector übernimmt.