Hilfe

[uta]

Hilfe, bin ganz neu in Java und habe keine AHnung. Lese mich aber schon ein. Nun hat mein Prof. so eine Aufgabe gestellt und man soll die Fehler finden. Ich finde keine mehr. Könnt ihr mir helfen?
Danke

public class Beet {
 public static void main(String[] args) {       
  int steineProM;
  int rosenProQm;
  double steineGesamt, rosenGesamt;
   // Anzahl der Steine pro Meter
  // Anzahl der Rosen pro Quadratmeter
  8 = steineProM;
  10 = rosenProQm;
  // Konstante Pi definieren
  final double PI = 3.141592;
  // Durchmesser setzen
  int durchmesser = 4;
  // Berechnung durchhfuehren
  steineGesamt = (durchmesser*PI)*steineProM;
  rosenGesamt = (PI*(durchmesser*durchmesser/4))*rosenProQm;
  // Ausgabe der Werte
  System.out.println("rosenGesamt");
  System.out.println("steineGesamt");
 }
 }

 

[Robat]

Welche Fehler hast du denn schon gefunden?

 

[Javinner]

@uta
Primitive Data Types
The Java® Language Specification
Datentypen, Typisierung, Variablen und Zuweisungen

 

[uta]

Dies ist das was noch übrig ist. Aber ich glaube da sind noch mind. Zwei Fehler drin. Bin totale Anfängerin

 

[Robat]

Kleiner Hinweis: Überleg mal "was" zu "was" zugewiesen werden soll. Es wird immer der Wert hinter dem "=" dem Wert vor dem "=" zugewiesen

 

[uta]

Also steineProM = 8
rosenProQm = 10

 

[Robat]

Sieht besser aus, ja

 

[uta]

Ansonsten wäre alles richtig

 

[Robat]

Ansonsten wäre alles richtig

Ist das eine Frage oder eine Aussage?

 

[uta]

Beim Ergebnis zeigt er mir (regex):125\663[0-9]* an. Ergebnis soll 125.66368 sein

 

[uta]

Weiss nicht was falsch ist

 

[Robat]

Beim Ergebnis zeigt er mir (regex):125\663[0-9]* an

Das passt nicht zu deinem Code den du gepostet hast.

 

[uta]

public class Beet {
public static void main(String[] args) {
int steineProM;
int rosenProQm;
double steineGesamt, rosenGesamt;

// Anzahl der Steine pro Meter
// Anzahl der Rosen pro Quadratmeter
steineProM = 8;
rosenProQm = 10;
// Konstante Pi definieren
final double PI = 3.141592;
// Durchmesser setzen
int durchmesser = 4;
// Berechnung durchhfuehren
steineGesamt = (durchmesser*PI)*steineProM;
rosenGesamt = (PI*(durchmesser*durchmesser/4))*rosenProQm;
// Ausgabe der Werte
System.out.println("rosenGesamt");
System.out.println("steineGesamt");
}
}
doch und als Ergebnis
rosenGesamt
(regex):125\.663[0-9]*
steineGesamt
(regex):100\.530[0-9]*

Danke für deine Hilfe.

 

[Robat]

Okay ich denke wir reden aneinander vorbei. Was bezeichnest du als "Ergebnis"? Lädst du das Programm irgendwo hoch und du bekommst eine Ausgabe oder testest du es selber in einer Entwicklungsumgebung (Eclipse, Intellij, Netbeans, .. )?
Kleiner Tipp noch: Überleg mal wie man Werte auf der Konsole ausgibt.

 

[uta]

Ja genau und der Prof will das Ergebnis so haben.
Ich hab keine Ahnung wie man Werte auf der Konsole ausgibt. Bin neu

 

[Robat]

Bin neu

Darauf kann man sich aber nicht ausruhen. Euer Prof wird euch sicherlich gezeigt haben, wie man Variablen auf der Konsole ausgibt. Ansonsten einfach mal danach googeln. Gibt genug Einträge dazu

 

[uta]

Hab ich und mach ich schon den ganzen Tag. Könntest du mir helfen bitte

 

[Robat]

int x = 5;
System.out.println(x);

Jetzt schau mal genau hin, wie die Ausgaben bei dir im Code aussehen

 

[uta]

Die stehen mit " Zeichen. Müssen die weck

 

[Robat]

Schau dir mein Beispiel an, schau dir dein Code an und überleg selbst. Alles was in Anführungszeichen steht wird als String interpretiert.

 

[uta]

Ich komm wirklich nicht drauf

 

[Robat]

public static void main( String[] args ) {
    ...
    // Ausgabe der Werte
    System.out.println(rosenGesamt); // <-- keine Anführungszeichen
    System.out.println(steineGesamt);
}

 

[uta]

Danke danke

 

[Xyz1]

Also liest man nur diese Seite, fragt man sich schon um was es geht....
Die zu ändernden Änderungen vor Deiner Änderung wären interessant!!!!

/**
 * @author DW
 */
public class Beet {
    public static void main(String[] args) {
        int steineProM;
        int rosenProQm;
        double steineGesamt, rosenGesamt;
// Anzahl der Steine pro Meter
        steineProM = 8;
// Anzahl der Rosen pro Quadratmeter
        rosenProQm = 10;

// Konstante Pi definieren
        final double PI = Math.PI;

// Durchmesser setzen
        int durchmesser = 4;

// Berechnung durchhfuehren
        steineGesamt = (durchmesser * PI) * steineProM;
        rosenGesamt = (PI * (durchmesser * durchmesser / 4.0)) * rosenProQm;

// Ausgabe der Werte
        System.out.println("rosenGesamt" + " = " + rosenGesamt);
        System.out.println("steineGesamt" + " = " + steineGesamt);
    }
}

Mehr als 100 (rote) Rosen hat Dein Beet

 

[uta]

Hab ich gesehen. Ich Danke dir. Ungefähr 10 Fehler waren drin.
Danke nochmals

 

[mihe7]

Mich würde ja nur mal interessieren, wie man 0,66 Rosen pflanzt.

 

[Xyz1]

@mihe7 hat recht....
@uta wenn Du möchtest kannst du es abrunden...

 

[Xyz1]

@mihe7
Ist das richtig

(PI * (durchmesser * durchmesser / 4.0)) *

oder das

(durchmesser * PI) *

oder beides?
Das eine müsste doch die Kreisfläche für Rosen sein - und das andere der Kreisumfang für Steine sein - stimmts?

 

[Xyz1]

Ich denke das könnte richtig sein:

import java.util.Scanner;

/**
 * @author DW (das bin ich)
 * @date 28-10-2018
 * @version 1
 */
public class Beet {
    final static int STEINE_PRO_M = 8;
    final static int ROSEN_PRO_M = 10;

    public static void main(String[] args) {
        System.out.println("Welchen Durchmesser hat Dein kreisförmiges Beet in cm?");
        int zwischenvar = new Scanner(System.in).nextInt();
        Kreis kreisbeet = new Kreis(zwischenvar);

        int steineGesamt = (int) Math.ceil(kreisbeet.gibUmfangInCm() * STEINE_PRO_M / 100f);
        int rosenGesamt = (int) (kreisbeet.gibFlaecheInCm() / ROSEN_PRO_M / 100f);

        System.out.println("Du brauchst (mind.) " + steineGesamt + " Steine außendrumherum.");
        System.out.println("Du kannst (höchst.) " + rosenGesamt + " Rosen pflanzen.");
    }
}

class Kreis {
    final int durchmesserInCm;

    Kreis(int durchmesserInCm) {
        this.durchmesserInCm = durchmesserInCm;
    }

    float gibUmfangInCm() {
        return (float) (durchmesserInCm * Math.PI);
    }

    float gibFlaecheInCm() {
        return (float) (durchmesserInCm * durchmesserInCm * Math.PI / 4.0);
    }
}

--- exec-maven-plugin:1.2.1:exec (default-cli) @ KPTest ---
Welchen Durchmesser hat Dein kreisförmiges Beet in cm?
400
Du brauchst (mind.) 101 Steine außendrumherum.
Du kannst (höchst.) 125 Rosen pflanzen.
------------------------------------------------------------------------
BUILD SUCCESS

LOGISCHEN FEHLER GEMACHT????

 

[mihe7]

Das eine müsste doch die Kreisfläche für Rosen sein - und das andere der Kreisumfang für Steine sein - stimmts?

Ja, der Umfang ist Pi mal D(aumen)urchmesser, also Pi*(r+r), die Fläche dagegen PI*(r*r).

 

[Xyz1]

Ich will das nicht ad absurdum führen aber das ginge doch auch:

import java.util.Scanner;

/**
 * @author DW (das bin ich)
 * @date 28-10-2018
 * @version 2
 */
public class Beet {
    public static void main(String[] args) {
        System.out.println("Welchen Durchmesser hat Dein kreisförmiges Beet in cm?");
        Kreisbeet<IPflanze, DSteinrand> k = new Kreisbeet<>(new Kreis(new Scanner(System.in).nextInt()));
        System.out.println("Du brauchst (mind.) " + k.gibRandgrundbestandteileGesamt(new DSteinrand()) + " Steine außendrumherum.");
        System.out.println("Du kannst (höchst.) " + k.gibPflanzenGesamt(() -> 10) + " Rosen pflanzen.");
    }
}

class Kreis {
    final int durchmesserInCm;

    Kreis(int durchmesserInCm) {
        this.durchmesserInCm = durchmesserInCm;
    }

    float gibUmfangInCm() {
        return (float) (durchmesserInCm * Math.PI);
    }

    float gibFlaecheInCm() {
        return (float) (durchmesserInCm * durchmesserInCm * Math.PI / 4.0);
    }
}

interface IPflanze {
    int gibProM();
}

interface IRose extends IPflanze {
    int ROSEN_PRO_M = 10;
}

class DRose implements IRose {
    public int gibProM() {
        return ROSEN_PRO_M;
    }
}

interface IRandgrundbestandteil {
    int gibProM();
}

interface ISteinrand extends IRandgrundbestandteil {
    int STEINE_PRO_M = 8;
}

class DSteinrand implements ISteinrand {
    public int gibProM() {
        return STEINE_PRO_M;
    }
}

class Kreisbeet<P extends IPflanze, R extends IRandgrundbestandteil> {
    Kreis kreis;

    <P, R> Kreisbeet(Kreis k) {
        kreis = k;
    }

    int gibPflanzenGesamt(P p) {
        return (int) (kreis.gibFlaecheInCm() / p.gibProM() / 100f);
    }

    int gibRandgrundbestandteileGesamt(R r) {
        return (int) Math.ceil(kreis.gibUmfangInCm() / r.gibProM() / 100f);
    }
}

Gefällt Dir k.gibRandgrundbestandteileGesamt(new DSteinrand()) oder k.gibPflanzenGesamt(() -> 10) besser - und wo sind dort die Vorteile?

 

[mihe7]

int gibProM();

gibFlaecheInCm

Qm bzw. Qcm.

kreis.gibFlaecheInCm() / p.gibProM() / 100f

1 m = 100 cm
1 m² = 1 m * 1 m = 100 cm * 100 cm = 10000 cm²

 

[Xyz1]

JA IRGENDWO habe ich nun bei Kreisbeet ein / mit einem * verwechselt.... Danke @mihe7 .
----
So blööööde Frage, aber wie kann man eigentlich den Durchmesser eines Kreisblumenbeets mit einem Maßband messen?
Man kann doch schlecht den μ-Winkel sowie den Sehnentangentenwinkel durch blosses Hinsehen bestimmen.

Bin gerade beim Peripheriewinkelsatz....

 

[Xyz1]

Ich weiß was ich gesucht hatte, pure built-in functional interfaces with default methods....
Also:

import java.util.Scanner;

/**
 * @author DW (das bin ich)
 * @date 28-10-2018
 * @version 3
 */
public class Beet {
    public static void main(String[] args) {
        System.out.println("Welchen Durchmesser hat Dein kreisförmiges Beet in cm?");
        Kreisbeet<IPflanze, IRandgrundbestandteil> k = new Kreisbeet<>(new Kreis(new Scanner(System.in).nextInt()));
        // Das (1):
        System.out.println("Du brauchst (mind.) " + k.gibRandgrundbestandteileGesamt(new DIRandgrundbestandteil() {}) + " Steine außendrumherum.");
        // oder Das (2):
        System.out.println("Du brauchst (mind.) " + k.gibRandgrundbestandteileGesamt(() -> 8) + " Steine außendrumherum.");
        System.out.println("Du kannst (höchst.) " + k.gibPflanzenGesamt(new DIPflanze() {}) + " Rosen pflanzen.");
    }
}

class Kreis {
    final int durchmesserInCm;

    Kreis(int durchmesserInCm) {
        this.durchmesserInCm = durchmesserInCm;
    }

    float gibUmfangInCm() {
        return (float) (durchmesserInCm * Math.PI);
    }

    float gibFlaecheInCm() {
        return (float) (durchmesserInCm * durchmesserInCm * Math.PI / 4.0);
    }
}

interface IPflanze {
    int ROSEN_PRO_M = 10;
    int gibProM();
}

interface DIPflanze extends IPflanze {
    default int gibProM() {
        return ROSEN_PRO_M;
    }
}

interface IRandgrundbestandteil {
    int STEINE_PRO_M = 8;
    int gibProM();
}

interface DIRandgrundbestandteil extends IRandgrundbestandteil {
    default int gibProM() {
        return STEINE_PRO_M;
    }
}

class Kreisbeet<P extends IPflanze, R extends IRandgrundbestandteil> {
    Kreis kreis;

    <P, R> Kreisbeet(Kreis k) {
        kreis = k;
    }

    int gibPflanzenGesamt(P p) {
        return (int) (kreis.gibFlaecheInCm() / p.gibProM() / 100f);
    }

    int gibRandgrundbestandteileGesamt(R r) {
        return (int) Math.ceil(kreis.gibUmfangInCm() * r.gibProM() / 100f);
    }
}

Nur noch einen Wissenslücke offenbar bei (1): oder (2): ....

@mihe7 : Gefällt Dir Variante (1) oder (2) besser?

BEARBEITUNG: Fehler war nebenbeibemerkt hier: kreis.gibUmfangInCm() * r.gibProM() / 100f vorher stand da nämlich / anstelle des *s.

 

[mihe7]

Gefällt Dir Variante (1) oder (2) besser?

Die Frage stellt sich für mich nicht, weil das alles Overkill ist Ansonsten Variante (2), dann würde ich allerdings die default-Method gleich in das originäre Interface klatschen und mir die Erweiterung davon sparen.

Bzgl. der Berechnung: schau mal, was rauskommt, wenn Du 15 Rosen/m² verwendest...

 

[Xyz1]

Ich verstehe das net mehr. Beitrag # 24 war noch richtig....

    public static void main(String[] args) {
        System.out.println("Welchen Durchmesser hat Dein kreisförmiges Beet in cm?");
        Kreisbeet<IPflanze, IRandgrundbestandteil> k = new Kreisbeet<>(new Kreis(new Scanner(System.in).nextInt()));
        System.out.println("Du brauchst (mind.) " + k.gibRandgrundbestandteileGesamt(() -> 8) + " Steine außendrumherum.");
        System.out.println("Du kannst (höchst.) " + k.gibPflanzenGesamt(() -> 15) + " Rosen pflanzen.");
    }

=>

Welchen Durchmesser hat Dein kreisförmiges Beet in cm?
400
Du brauchst (mind.) 101 Steine außendrumherum.
Du kannst (höchst.) 83 Rosen pflanzen.

=>
Wenn auf einen qm 15 anstatt 10 Rosen passen dann sollten nicht insgesamt weniger Rosen auf das Beet passen - oder?

 

[mihe7]

Wenn auf einen qm 15 anstatt 10 Rosen passen dann sollten nicht insgesamt weniger Rosen auf das Beet passen - oder?

Richtig. Fläche (in qm) x Rosen/qm = Anzahl Rosen. Schau nochmal in Kommentar #32

 

[Xyz1]

Mit dem Builder pattern passt es.

import java.util.Scanner;

/**
 * @author DW (das bin ich)
 * @date 29-10-2018
 * @version 4
 */
public class Beet {
    IGrundform gf;
    IPflanze pf;
    IRandgrundbestandteil rg;

    Beet(IGrundform g) {
        gf = g;
        pf = new IRosen() {
        };
        rg = new ISteine() {
        };
    }

    Beet setPflanze(IPflanze p) {
        pf = p;
        return this;
    }

    Beet setRandbestandteil(IRandgrundbestandteil r) {
        rg = r;
        return this;
    }

    Beet doPflanzenGesamt(String art) {
        System.out.println("Du kannst (höchst.) " + (int) (gf.gibFlaecheInQCm() / (100 * 100) * pf.gibProM()) + " " + art + " pflanzen.");
        return this;
    }

    Beet doRandgrundbestandteileGesamt(String art) {
        System.out.println("Du brauchst (mind.) " + (int) Math.ceil(gf.gibUmfangInCm() / 100f * rg.gibProM()) + " " + art + " außendrumherum.");
        return this;
    }

    public static void main(String[] args) {
        System.out.println("Welchen Durchmesser hat Dein kreisförmiges Beet in cm?");
        new Beet(new Kreis(new Scanner(System.in).nextInt()))
                .setPflanze(() -> 5)
                .setRandbestandteil(() -> 8)
                .doRandgrundbestandteileGesamt("Steine")
                .doPflanzenGesamt("Rosen");
    }
}

interface IGrundform {
    float gibUmfangInCm();
    float gibFlaecheInQCm();
}

class Kreis implements IGrundform {
    final int durchmesserInCm;

    Kreis(int durchmesserInCm) {
        this.durchmesserInCm = durchmesserInCm;
    }

    @Override
    public float gibUmfangInCm() {
        return (float) (durchmesserInCm * Math.PI);
    }

    @Override
    public float gibFlaecheInQCm() {
        return (float) (durchmesserInCm * durchmesserInCm * Math.PI / 4.0);
    }
}

@FunctionalInterface
interface IPflanze {
    int gibProM();
}

interface IRosen extends IPflanze {
    int ROSEN_PRO_M = 10;
    @Override
    default int gibProM() {
        return ROSEN_PRO_M;
    }
}

@FunctionalInterface
interface IRandgrundbestandteil {
    int gibProM();
}

interface ISteine extends IRandgrundbestandteil {
    int STEINE_PRO_M = 8;
    @Override
    default int gibProM() {
        return STEINE_PRO_M;
    }
}

Welchen Durchmesser hat Dein kreisförmiges Beet in cm?
400
Du brauchst (mind.) 101 Steine außendrumherum.
Du kannst (höchst.) 62 Rosen pflanzen.

=> Physik => Einheiten => Ich => Unschlau.

Ich will Default Parameter haben!!!!

 

[mihe7]

Ich will Default Parameter haben!!!!

Wozu?

 

[mrBrown]

Ich will Namen ohne Prefix haben!!!

 

[tommysenf]

 

[Xyz1]

Es soll doch nicht Hello World ausgeben,
es ging schon um etwas berechnen.

Würde das wohl wie in der Junior High machen.... Ihr auch?

 

[Xyz1]

Wenn ein kreisförmiges Blumenbeet einen Durchmesser von 4 anstatt 1 Metern hat und in ein einmetriges Blumenbeet passen 5 Rosen dann passen da doch ungefähr 12,56mal so viele Rosen rein wie vorher..... ODER nich?
Weil wenn nich dann ist # 38 auch falsch....
Ich habe irgendwie die Vermutung dass das noch nich richtig iss......
Weiß ich, als einstiger Mathe-lk'er sollte ich mich schämen.

 

[mihe7]

Jetzt stell Dich nicht so an ;-)

Die Einheit, in der die "Rosendichte" gegeben ist, ist [1/qm]. Wenn Du von einer Fläche in Quadratmetern ausgehst, ist ihre Einheit [qm]. Sei die Rosendichte gleich 15/qm und die Fläche 10 qm, dann ergibt sich eine Zahl n = 15/qm * 10 qm = 150 qm/qm = 150.

Es folgt: pf.gibProM() * gf.gibFlaecheInQCm() / 10000f wobei ich immer noch nicht weiß, warum die Methode gibProM heißt und nicht gibProQM...

 

[Xyz1]

Ein Kreis mit der Fläche 10qm hat den Durchmesser: http://www.mathepower.com/kreis.php?r=&durch=&umf=&flinh=10&submit=berechnen
3.568m
=>

Welchen Durchmesser hat Dein kreisförmiges Beet in cm?
356
Du brauchst (mind.) 90 Steine außendrumherum.
Du kannst (höchst.) 149 Rosen pflanzen.

=>

(und

Welchen Durchmesser hat Dein kreisförmiges Beet in cm?
357
Du brauchst (mind.) 90 Steine außendrumherum.
Du kannst (höchst.) 150 Rosen pflanzen.

)