Methoden, Listen, Boolean


RednexR

Grünschnabel
#1
Hallo! Ich habe folgende Aufgabe:

Ein App enthält folgende Klasse: App, Fitnessgerät, Trainingseinheit und Muskelgruppe.

Anforderungen and die Klasse Fitnessgerät:
Diese Klasse repräsentiert ein Fitnessgerät, z.b. Crosstrainer, Lastzug
Die Klasse muss folgende Eigenschafte besitzen:
Gerätename
Gerätetyp (Cardio oder Krafttraining)
Trainierte Muskelgruppe ( Referenz auf ein Objekt der Klasse Muskelgruppe)
Max empholene Trainigsdauer
Verbrauchte Kalorien pro Stunde (durschnittswerte)

Die klasse muss folgende methoden besitzen: 1. Ein konstruktor zum Festlegen aller Daten
int kalorienverbrauch (int minuten) -> liefert den Kkalverbrauch für eine Trainingseinheit für die angegebene Zeitspanne (in min)
int kalorienverbrauch (int minuten, Stunden) -> liefert den Kkalverbrauch für eine Trainingseinheit für die angegebene Zeitspanne (in min, Stunden)

boolean unterstützt (String Muskel) -> liefert true , wenn dieses Gerät der angegebenen muskel unterstützt
boolean unterstützt ( Muskelgruppe muskelGruppe) -> leifert true , wenn dieses Gerät eine bestimmte muskelgruppe unterstüztz
-boolean benötigtStromversorgung ( ) liefert true , wenn dieses gerät Strom braucht

Java:
public class Fintessgeraet {


    private String geraetename;
    private String geraetetyp;
    private int maxTrainingsdauer;
    public int verbrauchteKkal;
    private int stundennachmin;
    private boolean stromversorgung;
    private Muskelgruppe muskel;
    private  Muskelgruppe muskelgruppe;



    public Fintessgeraet(String geraetename, String geraetetyp, int maxTrainingsdauer, Muskelgruppe muskel, Muskelgruppe muskelgruppe, int verbrauchteKkal, boolean stromversorgung) {
        this.geraetename = geraetename;
        this.geraetetyp = geraetetyp;
        this.maxTrainingsdauer = maxTrainingsdauer;
        this.muskelgruppe= muskelgruppe;
        this.muskelgruppe = muskel;
        this.verbrauchteKkal= verbrauchteKkal;
        this.stromversorgung =stromversorgung;

    }

    public void setGeraetename(String geraetename) {
        this.geraetename = geraetename;
    }

    public void setGeraetetyp(String geraetetyp) {
        this.geraetetyp = geraetetyp;
    }

   public void setMaxTrainingsdauer(int maxTrainingsdauer) {
        this.maxTrainingsdauer = maxTrainingsdauer;
    }

    public void setMuskelgruppe(String[] Muskelgruppe) {
        this.muskelgruppe = muskelgruppe;
    }

    public String getGeraetename() {
        return geraetename;
    }

    public String getGeraetetyp() {
        return geraetetyp;
    }

    public int getMaxTrainingsdauer() {
        return maxTrainingsdauer;
    }

    public int getVerbrauchteKkal() {return this.verbrauchteKkal;}

    public Muskelgruppe getMuskelgruppe() {
        return muskelgruppe;
    }


    int kalorienverbrauch (int minuten){
        double kkalverbrauchpromin;
        kkalverbrauchpromin = ((double)verbrauchteKkal/60)*minuten;
        return  (int) kkalverbrauchpromin;
    }

    int kalorienverbrauch (int minuten , int stunden){
        return  kalorienverbrauch(minuten + 60*stunden); //berechnet stunden-> minuten

    }


         boolean benoetigtStromversorgung (){
        if  (geraetetyp == "Cardio") {
            return  true;}
        else
            {return false;}
         }


           boolean unterstützt (String muskel) {
              return this.equals(muskel);
        }

     boolean unterstützt (Muskelgruppe muskelgruppe){
         {return this.muskelgruppe.equals(Muskelgruppe);
     }

         public void fitgerAusgabe(){
          System.out.println("Verbrauchte Kalorien: " + kalorienverbrauch(verbrauchteKkal));
          System.out.println("Benötigt Stromversorgung: " + benoetigtStromversorgung());
         }




}
Anforderungen an die Klasse Trainingseinheit. Die Klasse repräsentiert eine Trainingseinheit mit einem Gerät
Muss t folgenden Eigenschaften besitzen:
Dauer des Trainings
Datum und Startzeit des Trainings
Welches Fitnessgerät verwendet wurde

-Konstruktor zum Festlegen des Fitnessgeräts
-Konstr. zum Festlegen des Fintesgeräts , Datums und Startzeit

-boolean zielErreicht (int kalorienZiel) -> liefert true, wenn das Trainig in kalprielZiel festgelegte Ziel erreicht hat. Dabei soll die Dauer des Trainings und durchnittliche Kalorienverbrauch des Fintesger. Berücksichtigt werden.

-int erforderlicheTrainingszeit (int kalorienziel)

- void trainieren() - erhöht die Trainingsdauer um 1 Min
- void trainiern (int minutem) erhäht die Trainigsdaier um 5 min
Java:
public class Trainingseinheit {
    private int trainingsdauer;
    private  String datum;
    private int trainingsZeit;
    private  int verbranntekkal;
    private int kalorienZiel;

    private  Fintessgeraet fintessgeraet; // nochmal prüfen
    private int erforderlicheTrainigsZeit;


    public Trainingseinheit(Fintessgeraet fintessgeraet, int trainingsdauer, String datum) {
        this.fintessgeraet = fintessgeraet;
        this.trainingsdauer = trainingsdauer;
        this.datum = datum;
    }

    public Trainingseinheit(int trainingsdauer,String datum, Fintessgeraet fintessgeraet){
        setDatum(datum);
        setTrainingsdauer(trainingsdauer);
        setFintessgeraet(fintessgeraet);
    }
    public String getDatum() {
        return datum;
    }

    public int getTrainingsdauer(){
        return trainingsdauer;}

    public Fintessgeraet getFintessgeraet() {
        return fintessgeraet;
    }

    public void setDatum(String datum) {

        this.datum = datum;
    }

    public void setFintessgeraet(Fintessgeraet fintessgeraet) {

        this.fintessgeraet = fintessgeraet;
    }

    public void setTrainingsdauer(int trainingsdauer) {
        this.trainingsdauer = trainingsdauer;
    }

    public void setTrainingsZeit(int trainingsZeit) {
        this.trainingsZeit = trainingsZeit;
    }

    public void setVerbranntekkal(int verbranntekkal) {
        this.verbranntekkal = verbranntekkal;
    }

    public int getTrainingsZeit() {
        return trainingsZeit;
    }

    public int getVerbranntekkal() {
        return verbranntekkal;
    }
    public void setKalorienZiel(int kalorienZiel){
        this.kalorienZiel= kalorienZiel;
    }

    public int getKalorienZiel() {
        return kalorienZiel;
    }

    boolean zielErreicht(int kalorienziel, int kalorienverbrauch){
        if (kalorienverbrauch > kalorienziel){
            return true;}
            else {
            return  false;}
        }



       public int erforderlicheTrainigsZeit(int kalorienziel, int kalorienverbrauch){
             verbranntekkal= kalorienziel/kalorienverbrauch;
            trainingsZeit= verbranntekkal*60;
            return erforderlicheTrainigsZeit;
        }

        void trainieren(){
            trainingsdauer =+1;
        }

    void trainieren(int minuten){
        trainingsdauer =+5;
    }


    public void trainingseinheitausgabe() {
        System.out.println( "Diese Trainingseinheit dauert " + this.trainingsdauer +
                " Minuten. Datum und Startzeit: " + this.datum +
                " Vervendetes Fitnessgerät: " + this.fintessgeraet+
                " Verbrannte Kalorien: " + getVerbranntekkal()+
                " Trainingsdauer; " +getTrainingsZeit()+
                 " Erforderliche Zeit um Ziel zu erreichen :" + this.trainingsZeit);
    }

}
Anforderungen an die Klasse Muskelgruppe:
Die Klasse repräsentiert eine Muskelgruppe, zB, "Brust" besteht aus "großer Brustmuskel" usw
Die Klasse muss folgende Eigenschaften besitzen:

- Bezeichnung der Muskelgrupp
-die Liste mit allen Muskeln der Muskelgruppe. Ein einzelner Muskel kann als Zeichenkette gespeichert werden, die LIste dieser Strings könnte in einem Array gespeichert werden.

Die Klasse muss folgende Methode besitzen:
boolean enthält ( String Muskel) - true , wenn diesse Muskelgruppe den angegebenen muskel enthält
Code:
java[/I]] 
public class Muskelgruppe {

    private String[] muskel;

    private String muskelgruppe;

    public Muskelgruppe(String muskelgruppe, String muskel[]) {
        this.muskelgruppe = muskelgruppe;
        this.muskel = muskel;
    }


    public boolean enthält(String muskel) {
        for (String m : muskel) {
               if(m. equals(muskel);
               return true;
    }return false;

    }





  public final static String LOWERCHEST = "Lower chest";
  public final static String MIDDLECHEST = "Middle chest";
  public final static String UPPERCHEST = "Upper chest";
  public final static String QUADS = "Quadriceps";
  public final static String HAMSTRINGS = "Harmstrings";
  public final static String HIPS = "Hips";
  public final static String CALVES = "Calves";
  public final static String BICEPS = "Biceps";
  public final static String TRICEPS = "Triceps";
  public final static String FOREARMS = "Forearms";
  public final static String LOWERBACK = "Lower back";
  public final static String MIDDLEBACK = "Middle back";
  public final static String TRAPS = "Traps";
  public final static String DELTS = "Delts";
  public final static String LOWERABS = "Lower abs";
  public final static String UPPERABS = "Upper abs";
}
Anforderungen an die Main Methode APP


Erzeugen Sie Zwei Fitnessgeräte und legen Sie für diese Alle erforderlichen Daten fest. Rufen Sie alle Methoden der Klassen Fitnessgerät, Trainingseinheit und Muskelgruppe beispielhaft für Objektinstanzen dieser Klassen auf.

Erzeugen Sie weiteres Objekt der Klasse Trainingseinheit . Rufen Sie dieses Objekt in einer while- Schleife solange die Methode trainienen (5) auf, bis ein gewünschtes Trainingsziel von 800 Kkal erreicht wird.
Es wird Also immer in 5 -Min- Intervallen trainiert bis mind 800 KKal erreicht sind. Geben Sie danach die tatsächlich verbrauchten Kalorien aus.
Code:
import java.util.ArrayList;
import java.util.Arrays;

public class App {


    public static void main(String[] args) {
        System.out.println("Fitness App ist gestartet!");
        ArrayList<String> Muscle =new ArrayList<>();
        Muscle.add ("Lower chest");
        Muscle.add ("Middle chest");
        Muscle.add("Upper chest");

        String [] muskelgruppeChest = {Muskelgruppe.LOWERCHEST, Muskelgruppe.MIDDLECHEST, Muskelgruppe.UPPERCHEST};
      String [] muskelgruppeLegs = {Muskelgruppe.QUADS, Muskelgruppe.HAMSTRINGS, Muskelgruppe.CALVES, Muskelgruppe.HIPS};
      String []  muskelgruppeArms = {Muskelgruppe.BICEPS, Muskelgruppe.TRICEPS, Muskelgruppe.FOREARMS};
      String [] muskelgruppeBack =  {Muskelgruppe.LOWERBACK, Muskelgruppe.MIDDLEBACK, Muskelgruppe.TRAPS};
      String [] muskelgruppeShoulders =  {Muskelgruppe.DELTS};
      String [] muskelgruppeAbs ={Muskelgruppe.LOWERABS, Muskelgruppe.UPPERABS};


        Fintessgeraet ellipse = new Fintessgeraet("Leg press", "Krafttraining", 60, muskelgruppeLegs ,7, true);
        Fintessgeraet legpress = new Fintessgeraet("Ellipse", "Cardio", 500, 45, "");






        Trainingseinheit t1 = new Trainingseinheit(50 , "13.04.2018", ellipse);

//        t1.setDatum("21.04.2018");
//        t1.setFintessgeraet(ellipse);
//        t1.setTrainingsdauer(40);

        Trainingseinheit t2 = new Trainingseinheit(5, "18.04.2018", legpress); // 2 Möglichkeiten Konstruktor zu definieren
        t1.setTrainingsZeit(20);
        t1.setVerbranntekkal(233);
        t1.setKalorienZiel (800);
        t1.setFintessgeraet(legpress);


        t2.setTrainingsZeit(3);
        t2.setVerbranntekkal(20);

         boolean zielErreicht;


        System.out.println("Erster Fitnessgeraet: " + ellipse.getGeraetename() +
                           " Gerätetyp: " + ellipse.getGeraetetyp() +
                           " Maximale Trainingsdauer: " + ellipse.getMaxTrainingsdauer() +
                           " Kalorien pro Stunde: " + ellipse.getVerbrauchteKkal());
        System.out.println("Trainierte Muskelgruppe: " + Arrays.toString(muskelgruppeLegs) + " , "
                           + Arrays.toString(muskelgruppeBack) + " , " + Arrays.toString(muskelgruppeChest));

        System.out.println("Zweiter  Fitnessgeraet: " + legpress.getGeraetename() +
                           " Gerätetyp: "   + legpress.getGeraetetyp() +
                            " Maximale Trainingsdauer: " + legpress.getMaxTrainingsdauer() +
                            " Kalorien pro Stunde: " + legpress.getVerbrauchteKkal());
        System.out.println(" Trainierte Muskelgruppe: " + Arrays.toString(muskelgruppeLegs));

        t1.trainingseinheitausgabe();
        t2.trainingseinheitausgabe();
             do {
            t1.trainieren(5);
        } while (t1.getKalorienZiel() == t1.getVerbranntekkal());
         System.out.println();

    }
}
Meine Fragen: Wie kann man diese Liste von Muskeln und Muskelgruppen richtig realisieren?
Wie kann man auch die While-Schleife richtig realisieren?

Überprüfen Sie die Code, bitte(
Ich wäre sehr, sehr dankbar für all Ihre Hilfe.
 

RednexR

Grünschnabel
#3
Hi! Mein Problem besteht darin, dass ich noch nicht genau verstehen kann, wie man die Klasse Muskelgruppe + Listen realisieren kann. Zuerst habe ich versucht es als ArrayListe zu machen, hab aber schon gelöscht.

Ich kann noch nicht verstehen, wie man diese Liste realisieren und verbinden/ bool prüfen und wie man noch die While-Schleife in diesem Fall richtig realisieren kann.
 

Neue Beiträge