Ticketautomat programmieren

nikva

Bekanntes Mitglied
Hallo Java-Forum!
Ich soll im Zuge einer Hochschulaufgabe aus vorgegebenen Klassen einen Ticketautomaten programiieren. Nun habe ich das Problem, dass die Aufgabenstellung für mich sehr kryptisch formuliert ist, was mir Probleme dabei bereitet in die Aufgabe reinzukommen.
gegeben sind folgende Klassen:
Java:
package edu.cs.hm.swe1;

import javax.swing.*;

import edu.cs.hm.swe1.ticketmachine.TicketMachine;
import edu.cs.hm.swe1.ticketmachine.TicketMachineGUI;


/**
* Simple GUI for the first version of the TicketMachine.
*
*
*
*/
public class Main extends JFrame {

     private static final long serialVersionUID = -7793153788995243551L;

    /**
     * main Method to start up the UI.
     * @param args One argument is required: ticket cost as forwarded to Constructor of class TicketMachine
     * @throws Exception
     */
    public static void main(String[] args) throws Exception {
       
        int price = HelperClass.requestUserInput("Was ist der Preis für ein Ticket?");
       
        if(price <= 0) {
            throw new RuntimeException("Error: you must provide a ticket price grater than zero!");
        }
       
        TicketMachineGUI ticketMachineGUI = new TicketMachineGUI(new TicketMachine(price));
        new TicketMachineGUI(new TicketMachine(price));
    }

}

Java:
package edu.cs.hm.swe1;

import javax.swing.JOptionPane;


/**
* Contains helper methods such as wait.
*
*
*
*/
public class HelperClass {

    /**
     * Request some user information and transform it into an int-value.
     *
     * @param question Question the user is asked
     * @return The user's reply, transformed into an int-value.
     */
    public static int requestUserInput(String question) {
        // Request user to input information about smiley
        String answer = JOptionPane.showInputDialog(question);
       
        // Transform textual answer into int-value
        int result = Integer.parseInt(answer);
       
        // Return result to caller
        return result;
    }
   
    /**
     * Print error message in separate window
     *
     * @param message Error message
     */
    public static void printErrorMessage(String message) {
        JOptionPane.showMessageDialog(null, message, "Fehlermeldung", JOptionPane.ERROR_MESSAGE);
    }
   
     /**
       * Wait for a specified number of milliseconds before finishing.
       * This provides an easy way to specify a small delay which can be
       * used when producing animations.
       * @param  milliseconds  the number
       */
      public static void wait(int milliseconds)
      {
          try
          {
              Thread.sleep(milliseconds);
          }
          catch (Exception e)
          {
              // ignoring exception at the moment
          }
      }
     
}

Java:
package edu.cs.hm.swe1.ticketmachine;

import java.awt.*;
import java.awt.event.*;

import javax.sound.sampled.*;
import javax.swing.*;


/**
* Simple GUI for the first version of the TicketMachine.
* 
*
*
*/
public class TicketMachineGUI extends JFrame {

    static final long serialVersionUID = 7571949288624872816L;
    public static final String SOUND_FILE_DROPPED_COIN = "coin.wav";
    private final TicketMachine ticketMachine;
    private JPanel mainPanel;

    /**
     * All UI-Element we use.
     */
    private final JButton insert1CtCoinButton = new JButton("Insert 1Ct Coin");
    private final JButton insert2CtCoinButton = new JButton("Insert 2Ct Coin");
    private final JButton insert5CtCoinButton = new JButton("Insert 5Ct Coin");
    private final JButton insert10CtCoinButton = new JButton("Insert 10Ct Coin");
    private final JButton refundButton = new JButton("Refund");
    private final JButton produceTicketButton = new JButton("Get Ticket");
    private final JLabel balance = new JLabel("Balance: 0");
   
    private final JLabel internalStorageArea = new JLabel("Internal Storage", SwingConstants.CENTER);
    private JLabel fill1CtArea = new JLabel("1 Ct Coins: ", SwingConstants.CENTER);
    private JLabel fill2CtArea = new JLabel("2 Ct Coins: ", SwingConstants.CENTER);
    private JLabel fill5CtArea = new JLabel("5 Ct Coins: ", SwingConstants.CENTER);
    private JLabel fill10CtArea = new JLabel("10 Ct Coins: ", SwingConstants.CENTER);
    private final JLabel emptyLabel1 = new JLabel();
    private final JLabel emptyLabel2 = new JLabel();

    public TicketMachineGUI(TicketMachine ticketMachine) {
        this.ticketMachine = ticketMachine;
        add(createPanel());
        pack();
        setVisible(true);
        setTitle("Ticket Machine");
    }

    /**
     * Creates the Master-Panel.
     * @return
     */
    private Component createPanel() {
        mainPanel = new JPanel(new GridLayout(1, 2));

        updateCoinStorageFillings();
        mainPanel.add(createControlPanel());
//       mainPanel.add(new InternalPanel());
        balance.setHorizontalAlignment(SwingConstants.CENTER);
        return mainPanel;
    }
   
    /**
     * Creates the Panel with buttons and the display.
     * @return
     */
    private Component createControlPanel() {
        JPanel controlPanel = new JPanel(new GridLayout(7, 2));
        controlPanel.add(balance);
        controlPanel.add(internalStorageArea);
       
        controlPanel.add(insert1CtCoinButton);
        controlPanel.add(fill1CtArea);
       
        controlPanel.add(insert2CtCoinButton);
        controlPanel.add(fill2CtArea);
       
        controlPanel.add(insert5CtCoinButton);
        controlPanel.add(fill5CtArea);
       
        controlPanel.add(insert10CtCoinButton);
        controlPanel.add(fill10CtArea);
       
        controlPanel.add(refundButton);
        controlPanel.add(emptyLabel1);
        controlPanel.add(produceTicketButton);
        controlPanel.add(emptyLabel2);

        insert1CtCoinButton.addActionListener(new ActionListener() {
            public void actionPerformed(final ActionEvent e) {
                if(!ticketMachine.insert1Ct()) {
                    playSound();
                }
                else {
                    fill1CtArea.setText("1 Ct Coins: " + ticketMachine.getFill1Ct());
                    balance.setText("Balance: " + ticketMachine.getBalance() + "");
                    mainPanel.repaint();
                }
            }});
        insert2CtCoinButton.addActionListener(new ActionListener() {
            public void actionPerformed(final ActionEvent e) {
                if(!ticketMachine.insert2Ct()) {
                    playSound();
                }
                else {
                    fill2CtArea.setText("2 Ct Coins: " + ticketMachine.getFill2Ct());
                    balance.setText("Balance: " + ticketMachine.getBalance() + "");
                    mainPanel.repaint();
                }
            }});
        insert5CtCoinButton.addActionListener(new ActionListener() {
            public void actionPerformed(final ActionEvent e) {
                if(!ticketMachine.insert5Ct()) {
                    playSound();
                }
                else {
                    fill5CtArea.setText("5 Ct Coins: " + ticketMachine.getFill5Ct());
                    balance.setText("Balance: " + ticketMachine.getBalance() + "");
                    mainPanel.repaint();
                }
            }});
        insert10CtCoinButton.addActionListener(new ActionListener() {
            public void actionPerformed(final ActionEvent e) {
                if(!ticketMachine.insert10Ct()) {
                    playSound();
                }
                else {
                    fill10CtArea.setText("10 Ct Coins: " + ticketMachine.getFill10Ct());
                    balance.setText("Balance: " + ticketMachine.getBalance() + "");
                    mainPanel.repaint();
                }
            }});
        refundButton.addActionListener(new ActionListener() {
            public void actionPerformed(final ActionEvent e) {
                if(ticketMachine.refundBalance() > 0 ) {
                    playSound();
                    updateCoinStorageFillings();
                    balance.setText("Balance: " + ticketMachine.getBalance() + "");
                    mainPanel.repaint();
                }
            }});
        produceTicketButton.addActionListener(new ActionListener() {
            public void actionPerformed(final ActionEvent e) {
                showTicket(ticketMachine.printTicket());
                updateCoinStorageFillings();
                balance.setText("Balance: " + ticketMachine.getBalance() + "");
                mainPanel.repaint();
            }});

        return controlPanel;
    }
   
    private void updateCoinStorageFillings() {
        fill1CtArea.setText("1 Ct Coins: " + ticketMachine.getFill1Ct());
        fill2CtArea.setText("2 Ct Coins: " + ticketMachine.getFill2Ct());
        fill5CtArea.setText("5 Ct Coins:: " + ticketMachine.getFill5Ct());
        fill10CtArea.setText("10 Ct Coins: " + ticketMachine.getFill10Ct());
    }
   
    /**
     * Displays a ticket in its own JFrame. That frame can be closed by clicking Escape.
     * @param ticket The text to show on the ticket (i.e. on the frame).
     */
    private void showTicket(String ticket) {
        final JFrame ticketFrame = new JFrame("Ticket");
        JLabel ticketText = new JLabel("<html><body>" + ticket.replaceAll("\n", "<br>") + "</body></html>");
        ticketFrame.add(ticketText);
        ticketFrame.addKeyListener(new KeyAdapter() {
            public void keyPressed(KeyEvent ke) {
                if(ke.getKeyCode() == KeyEvent.VK_ESCAPE) {
                    ticketFrame.setVisible(false);
                    ticketFrame.dispose();
                }
            }
        });
        ticketFrame.pack();
        ticketFrame.setVisible(true);
    }

    /*
     * Play the coin-dropped-sound
     */
    private synchronized void playSound() {
        try {
            Clip clip = AudioSystem.getClip();
            AudioInputStream inputStream = AudioSystem.getAudioInputStream(
                    this.getClass().getResourceAsStream(SOUND_FILE_DROPPED_COIN));
            clip.open(inputStream);
            clip.start();
        } catch (Exception e) {
            //silently catch all exceptions to avoid confusion.
            //throw new RuntimeException(e);
        }
    }

}

hab dann über die debug hilfe in eclipse diese Methoden in der klasse Ticketmachine erstellt wie es in der Aufgabenstellung vorgegeben wird.

Java:
package edu.cs.hm.swe1.ticketmachine;

public class TicketMachine {
   
    private int ticketprice;
    private int balance;
    private int fill1ct;
    private int fill2ct;
    private int fill5ct;
    private int fill10ct;

    public TicketMachine(int price) {
      ticketprice = price;
    }

    public boolean insert1Ct() {
        // TODO Auto-generated method stub
        return false;
    }

    public String getFill1Ct() {
        // TODO Auto-generated method stub
        return null;
    }

    public String getBalance() {
        // TODO Auto-generated method stub
        return null;
    }

    public boolean insert2Ct() {
        // TODO Auto-generated method stub
        return false;
    }

    public String getFill2Ct() {
        // TODO Auto-generated method stub
        return null;
    }

    public boolean insert5Ct() {
        // TODO Auto-generated method stub
        return false;
    }

    public String getFill5Ct() {
        // TODO Auto-generated method stub
        return null;
    }

    public boolean insert10Ct() {
        // TODO Auto-generated method stub
        return false;
    }

    public String getFill10Ct() {
        // TODO Auto-generated method stub
        return null;
    }

    public int refundBalance() {
        // TODO Auto-generated method stub
        return 0;
    }

    public String printTicket() {
        // TODO Auto-generated method stub
        return null;
    }

}




Hoffe hier gibt es jemanden der mir etwas Starthilfe geben kann
 

Anhänge

  • 08-Aufgabe-Fallunterscheidung.pdf
    373,6 KB · Aufrufe: 20

nikva

Bekanntes Mitglied
Java:
    public TicketMachine(int price) {
      this.balance=price;
      fill1ct=0;
      fill2ct=0;
      fill5ct=0;
      fill10ct=0;
    }
So würde ich aufgabe 1d machen, aber wie implementiere ich die maximale anzahl an Münzen?
 

mihe7

Top Contributor
Java:
private final int maxCoinsPerValue;

public TicketMachine(int price) {
    ...
    maxCoinsPerValue = 10;
}
 

nikva

Bekanntes Mitglied
c) Schreiben Sie einen Konstruktor, der für den Preis, die maximale Anzahl der Münzen sowie die Startbelegungen der einzelnen Münzfächer (vom 1Ct-Fach aufsteigend bis zum 10CtFach) als Parameter geeignete Werte empfängt und diese an die zugehörigen Attribute zuweist. Initialisieren Sie dabei auch das Guthaben des Automaten-Nutzers auf einen geeigneten Wert.

Verstehe ich das richtig,dass ich mir hier die werte selbst aussuchen kann? Aber was ist dann mit den maximalen Münzen für den Preis gemeint? Die maximale anzahl der jeweiligen Münze die Teil des Preises sein können?
 

mihe7

Top Contributor
ach, das ist dann quasi schon in java vordefiniert?
Was ist vordefiniert?

Verstehe ich das richtig,dass ich mir hier die werte selbst aussuchen kann?
Werte? Es geht hier um Parameter, die der Aufrufer setzt, wenn er ein neue Instanz (Objekt) der Klasse erstellt. So wie Du oben price als Parameter festgelegt hast, erzeugst Du nochmal einen Konstruktor mit den benötigten Parametern (s. Aufgabe).
 

nikva

Bekanntes Mitglied
ich meine die startbelegungen der einzelnen Münzfächer. Da muss ich doch selbst wählen wie viele jeweils vorhanden sind, oder sollen die einfach 0 sein?
 

mihe7

Top Contributor
"Schreiben Sie einen Konstruktor, der für den Preis, die maximale Anzahl der Münzen sowie die Startbelegungen der einzelnen Münzfächer (vom 1Ct-Fach aufsteigend bis zum 10CtFach) als Parameter geeignete Werte empfängt und diese an die zugehörigen Attribute zuweist."
 

nikva

Bekanntes Mitglied
ist das dann nicht das was ich hier schon gemacht hab?
Java:
      fill1ct=0;
      fill2ct=0;
      fill5ct=0;
      fill10ct=0;
 

mihe7

Top Contributor
Nein. Dieser Konstruktor hat keine Parameter für die Münzfächer und weist auch nur 0 zu. Du brauchst einen weiteren Konstruktor, der die Werte als Parameter entgegennimmt.
 

mihe7

Top Contributor
Nein. Getter und Setter sind dafür da, Attributwerte eines Objekt zu erhalten bzw. zu ändern. Der Konstruktor dagegen ist dazu da, das Objekt (-> seine Attribute) während seiner Erzeugung zu initialisieren.

In Aufgabe c) und d) sollst Du Konstruktoren schreiben, in Aufgabe e) Getter und in f) entsprechende Setter.
 

nikva

Bekanntes Mitglied
in etwa so?
Java:
package edu.cs.hm.swe1.ticketmachine;

public class TicketMachine {

    private int ticketPrice;
    private int internalStorage;
    private int balance;
    private int fill1ct;
    private int fill2ct;
    private int fill5ct;
    private int fill10ct;

    private final int maxCoinsPerValue;

    public TicketMachine(int price) {
        ticketPrice = price;
        balance = 0;
        internalStorage = 0;
        fill1ct = 0;
        fill2ct = 0;
        fill5ct = 0;
        fill10ct = 0;
        maxCoinsPerValue = 10;
    }

    public void insert1Ct() {
        balance = balance + 1;
    }
 

mihe7

Top Contributor
OK, da müssen wir mal ganz anders anfangen.

Stell Dir mal einen Ticketautomaten vor. Den machen wir ganz einfach: er kann nur Tickets zu einem einzigen Preis verkaufen.

Jetzt kann man in so einen Automaten Geld einwerfen und das wird gesammelt. In Automaten, die nicht wechseln können, reicht es aus, das Geld einfach in einer gemeinsamen Box zu sammeln. Unser Automat soll aber wechseln können, d. h. er muss intern mehrere Münzfächer haben und in jedes Münzfach dürfen nur Münzen eines Wertes aufgenommen werden. Es gibt also ein Fach für 1 Ct-Münzen, ein Fach für 2 Ct-Münzen usw.

Diese Münzfächer bilden den internen (Münz-)Speicher, d. h. "interner Speicher" ist einfach nur eine Bezeichnung für die Gesamtheit aller Münzfächer. Der interne Speicher ist aber kein eigenständiges Teil, das real im Automaten existieren würde.

Natürlich kann so ein Münzfach nicht beliebig viele Münzen aufnehmen - irgendwann reicht der Platz halt einfach nicht mehr. Unsere Automaten seien immer so gebaut, dass von jedem Münzwert gleich viele Münzen aufgenommen werden können. Wie viele genau in jedes Münzfach passen ist vom jeweiligen Automat abhängig.

Alle Automaten sind also gleich aufgebaut, können aber unterschiedlich konfiguriert werden. In der Luxusvariante ist alles konfigurierbar: der Preis, die Größe der Münzfächer und sogar die Bestückung der Münzfächer kann "bestellt" weden.
Java:
public class TicketMachine {
    // Preis pro Ticket
    private int ticketPrice;

    // Anzahl der Münzen in den Münzfächern
    private int fill1ct;
    private int fill2ct;
    private int fill5ct;
    private int fill10ct;
    
    // Maximale Anzahl an Münzen je Münzfach
    private int maxCoinsPerValue;

    // Luxusvariante: alles konfigurierbar
    public TicketMachine(int price, int initialMaxCoinsPerValue, 
            int initialFill1Ct, int initialFill2Ct, int initialFill5Ct, int initialFill10Ct) {
        ticketPrice = price;
        maxCoinsPerValue = initialMaxCoinsPerValue;
        fill1Ct = initialFill1Ct;
        // usw.
    }
}

Daneben bieten wir noch eine Standardvariante an, bei der nur der Preis konfigurierbar ist. Die Münzfächer sollen dabei leer bleiben und jeweils maximal 10 Münzen aufnehmen können:
Java:
    // Standardvariante: nur Preis ist konfigurierbar
    public TicketMachine(int price) {
        ticketPrice = price;
        maxCoinsPerValue = 10;
        // die restlichen int-Instanzvariablen werden automatisch mit 0 initialisiert
    }

Eine Alternativ dazu ist, im Konstruktor für die Standardvariante den Konstruktor der Luxusvariante aufzurufen, um die Konfiguration vorzunehmen:
Java:
    // Standardvariante: nur Preis ist konfigurierbar
    public TicketMachine(int price) {
        this(price, 10, 0, 0, 0, 0, 0); // verwendet den Luxuskonstruktor
    }

Alles klar jetzt?
 

mihe7

Top Contributor
und balance wird dann über getter der jeweiligen münzfächer berechnet?
Nein, wie sollte das funktionieren? Das Münzfach hat ja nur eine Anzahl an Münzen. Wenn ich jetzt eine entsprechende Münze einwerfe, erhöht sich die Anzahl. Dann weißt Du hinterher doch nicht mehr, wie viel Geld ich mittlerweile eingeworfen habe. Kurz: balance brauchst Du schon als Attribut (s. Aufgabe b) - das habe ich nur der Einfachheit halber weggelassen, um die Beschreibung nicht unnötig zu verkomplizieren).
 

nikva

Bekanntes Mitglied
und da in der main methode der konstruktor nur nach dem int price fragt ist wohl die "standardvariante" am sinnvollsten. Man gibt den Ticketpreis über die GUI und der konstruktor gibt das an die variable ticketPrice weiter. die fill variablen(die münzfächer) werden auf 0 gesetzt und balance setze ich auch über den konstruktor auf 0. nun geht es dann also darum über die setter für jeden münzeinwurfsbutton zu definieren wie sich das münzfach ändert aber eben auch der wert von balance. Es muss also jeder Vorgang 2 setter aufrufen?
 

mihe7

Top Contributor
und da in der main methode der konstruktor nur nach dem int price fragt ist wohl die "standardvariante" am sinnvollsten.
Äh, nein. Die Standardvariante ist einfach nur eine Kurzschreibweise für die Luxusvariante. Statt
Java:
new TicketMachine(price, 10, 0, 0, 0, 0, 0)
kann man halt - für genau diesen Fall - einfach
Java:
new TicketMachine(price)
schreiben.

Will man aber einen Ticketautomaten in einer anderen Konfiguration, muss man die Luxusvariante verwenden. Die Konstruktoren existieren ja beide in der Klasse, d. h. einmal kannst Du einen Ticketautomaten in der Standardkonfiguration erstellen und einmal in einer anderen.

nun geht es dann also darum über die setter für jeden münzeinwurfsbutton zu definieren wie sich das münzfach ändert aber eben auch der wert von balance. Es muss also jeder Vorgang 2 setter aufrufen?
Langsam, langsam. Eine Aufgabe nach der anderen!

Du hast bis jetzt (wenn Du alles soweit umgesetzt hast) die Aufgaben a bis d erledigt. Bei Aufgabe e) brauchst Du für jedes Attribut einen Getter (die kannst Du von der IDE erzeugen lassen). Falls Du das schon hast, kommt Aufgabe f) dran.

Bei f) geht es dann darum, einen Setter für jedes Münzfach zu schreiben. Der Setter muss dafür sorgen, dass das Münzfach nicht unterfüllt (negative Anzahl an Münzen gibt es nun mal nicht) und nicht überfüllt (der Platz ist beschränkt) wird.

Wenn Du das soweit hast, poste mal Dein Ergebnis.
 

nikva

Bekanntes Mitglied
ich meinte nur weil es ja in main.java nur mit einer variablen(price) aufgerufen wird
Java:
        new TicketMachineGUI(new TicketMachine(price));
 

nikva

Bekanntes Mitglied
Java:
public class TicketMachine {

    private int ticketPrice;
    private int fill1ct;
    private int fill2ct;
    private int fill5ct;
    private int fill10ct;
    private int balance;

    private int maxCoinsPerValue;

    public TicketMachine(int price, int initialMaxCoinsPerValue, int initialFill1ct, int initialFill2ct,
            int initialFill5ct, int initialFill10ct) {
        ticketPrice = price;
        fill1ct = initialFill1ct;
        fill2ct = initialFill2ct;
        fill5ct = initialFill5ct;
        fill10ct = initialFill10ct;
        maxCoinsPerValue = 10;
    }

    // Konstruktor für den Ticketautomaten
    public TicketMachine(int price) {
        ticketPrice = price; // Ticketpreis wird bestimmt
        balance = 0; // anfangsguthaben ist 0
        fill1ct = 0; // Münzfächer haben Füllstand 0
        fill2ct = 0;
        fill5ct = 0;
        fill10ct = 0;
        maxCoinsPerValue = 10; // maximale Füllmenge 10
    }

    public void setFill1ct(int amount) {
        if (fill1ct > 10)
            fill1ct = fill1ct + amount;
    }

    public void setFill2ct(int amount) {
        if (fill2ct > 10)
            fill2ct = fill2ct + amount;
    }

    public void setFill5ct(int amount) {
        if (fill5ct > 10)
            fill5ct = fill5ct + amount;
    }

    public void setFill10ct(int amount) {
        if (fill10ct > 10)
            fill10ct = fill10ct + amount;
    }
 

nikva

Bekanntes Mitglied
und die getter

Java:
    public int getFill1Ct() {

        return fill1ct;
    }

    public int getFill2Ct() {

        return fill2ct;
    }

    public int getFill5Ct() {

        return fill5ct;
    }

    public int getFill10Ct() {
        return fill10ct;
    }
 

nikva

Bekanntes Mitglied
habs nochmal wie folgt überarbeitet:
Java:
package edu.cs.hm.swe1.ticketmachine;

public class TicketMachine {

    private int ticketPrice;
    private int fill1ct;
    private int fill2ct;
    private int fill5ct;
    private int fill10ct;
    private int balance;

    private int maxCoinsPerValue;

    public TicketMachine(int price, int initialMaxCoinsPerValue, int initialFill1ct, int initialFill2ct,
            int initialFill5ct, int initialFill10ct) {
        ticketPrice = price;
        fill1ct = initialFill1ct;
        fill2ct = initialFill2ct;
        fill5ct = initialFill5ct;
        fill10ct = initialFill10ct;
        maxCoinsPerValue = initialMaxCoinsPerValue;
    }

    // Konstruktor für den Ticketautomaten
    public TicketMachine(int price) {
        ticketPrice = price; // Ticketpreis wird bestimmt
        balance = 0; // anfangsguthaben ist 0
        fill1ct = 0; // Münzfächer haben Füllstand 0
        fill2ct = 0;
        fill5ct = 0;
        fill10ct = 0;
        maxCoinsPerValue = 10; // maximale Füllmenge 10
    }

public void setFill1ct(int amount) {
        if (fill1ct + amount > 10)
            fill1ct = 10;
        if (fill1ct + amount < 0)
            fill1ct = 0;
        else
            fill1ct = fill1ct + amount;
    }

    public void setFill2ct(int amount) {
        if (fill2ct + amount > 10)
            fill2ct = 10;
        if (fill2ct + amount < 0)
            fill2ct = 0;
        else
            fill2ct = fill2ct + amount;
    }

    public void setFill5ct(int amount) {
        if (fill5ct + amount > 10)
            fill5ct = 10;
        if (fill5ct + amount < 0)
            fill5ct = 0;
        else
            fill5ct = fill5ct + amount;
    }

    public void setFill10ct(int amount) {
        if (fill10ct + amount > 10)
            fill10ct = 10;
        if (fill10ct + amount < 0)
            fill10ct = 0;
        else
            fill10ct = fill10ct + amount;
    }

    public int getFill1Ct() {

        return fill1ct;
    }

    public int getFill2Ct() {

        return fill2ct;
    }

    public int getFill5Ct() {

        return fill5ct;
    }

    public int getFill10Ct() {
        return fill10ct;
    }
 

mihe7

Top Contributor
Nein, setFill soll einfach nur den Wert setzen - nix rechnen. Was Du gemacht hast, geht eher in Richtung insertXXX. Lies die Aufgabenstellung nochmal durch.
 

nikva

Bekanntes Mitglied
also eher so?
Java:
package edu.cs.hm.swe1.ticketmachine;

public class TicketMachine {

    private int ticketPrice;
    private int fill1ct;
    private int fill2ct;
    private int fill5ct;
    private int fill10ct;
    private int balance;

    private int maxCoinsPerValue;

    public TicketMachine(int price, int initialMaxCoinsPerValue, int initialFill1ct, int initialFill2ct,
            int initialFill5ct, int initialFill10ct) {
        ticketPrice = price;
        fill1ct = initialFill1ct;
        fill2ct = initialFill2ct;
        fill5ct = initialFill5ct;
        fill10ct = initialFill10ct;
        maxCoinsPerValue = initialMaxCoinsPerValue;
    }

    // Konstruktor für den Ticketautomaten
    public TicketMachine(int price) {
        ticketPrice = price; // Ticketpreis wird bestimmt
        balance = 0; // anfangsguthaben ist 0
        fill1ct = 0; // Münzfächer haben Füllstand 0
        fill2ct = 0;
        fill5ct = 0;
        fill10ct = 0;
        maxCoinsPerValue = 10; // maximale Füllmenge 10
    }

  
  
    public void setFill1ct(int amount) {
        fill1ct = amount;
    }
    public void setFill2ct(int amount) {
        fill2ct = amount;
    }
    public void setFill5ct(int amount) {
        fill5ct = amount;
    }
    public void setFill5ct(int amount) {
        fill5ct = amount;
    }
  
    public void insert1ct() {
        if (fill1ct > 10)
            fill1ct = 10;
        if (fill1ct < 0)
            fill1ct = 0;
        else
            fill1ct = fill1ct + 1;
    }
    public void insert2ct() {
        if (fill2ct > 10)
            fill2ct = 10;
        if (fill2ct < 0)
            fill2ct = 0;
        else
            fill2ct = fill2ct + 1;
    }
    public void insert5ct() {
        if (fill5ct > 10)
            fill5ct = 10;
        if (fill5ct < 0)
            fill5ct = 0;
        else
            fill5ct = fill5ct + 1;
    }
    public void insert10ct() {
        if (fill10ct > 10)
            fill10ct = 10;
        if (fill10ct < 0)
            fill10ct = 0;
        else
            fill10ct = fill10ct + 1;
    }


    public int getFill1Ct() {

        return fill1ct;
    }

    public int getFill2Ct() {

        return fill2ct;
    }

    public int getFill5Ct() {

        return fill5ct;
    }

    public int getFill10Ct() {
        return fill10ct;
    }

oder bei den insermethoden eher mit setter und getter arbeiten?
 

nikva

Bekanntes Mitglied
zurückliefert, ob der Benutzer
des Automaten erfolgreich eine 1Ct-Münze in den Automaten einwerfen konnte.
- Welchen Rückgabetyp braucht die Methode?

ok, ich glaub es muss eher ein boolean sein, so wie sich das hier liest und darüber dann über einen setter den wert für balance erhöhen
 

mihe7

Top Contributor
Neiiiin.
Java:
    public void setFill1ct(int amount) {
        if (amount < 0) {
            fill1Ct = 0; 
        } else if (amount > maxCoinsPerValue) {
            fill1Ct = maxCoinsPerValue;
        } else {
            fill1Ct = amount; 
        }

        // oder kürzer:
        // fill1Ct = amount < 0 ? 0 : (amount > maxCoinsPerValue ? maxCoinsPerValue : amount);
        // oder kürzer und schöner:
        // fill1Ct = Math.max(Math.min(amount, maxCoinsPerValue), 0);
    }
 

nikva

Bekanntes Mitglied
Java:
    public void insert1ct() {
     getFill1Ct();
     setFill1ct(fill1ct+1);
     balance = balance+1;
    }
ist das so auch syntaktisch korrekt? Das problem wäre doch, dass balance immer um 1 erhöht wird auch wenn der speicher voll wäre. Deswegen müsste ja eine art zwischentest erfolgen über einen boolean oder nicht?
 

mihe7

Top Contributor
Syntaktisch ist das korrekt. Aber getFill1Ct() ist überflüssig, weil Du den Rückgabewert nirgends verwendest und - weil ich es gerade sehe - der Setter müsste setFill1Ct und nicht setFill1ct heißen. Ebenso muss bei den Feldbezeichner der fillX-Variablen das Ct mit großem C geschrieben werden - zumindest nach Aufgabenstellung.

Du könntest z. B. statt setFill1Ct(fill1Ct+1); auch setFill1Ct(getFill1Ct() + 1); schreiben.
 

nikva

Bekanntes Mitglied
Dann hab ich aber immer noch das Problem, dass balance immer erhöht wird, auch wenn ich bereits 10 münzen im speicher hatte.Jetzt müsste ich ja iwie über einen boolean regeln ob die münze wirklich im speicher landen konnte oder nicht. Aber wie implementiere ich das in der insert methode? Ich kann den return type zu boolean ändern und dann die bedingungen für false und true bestimmen aber die methode weiß ja nicht wann die münze gespeichert wird und wann nicht. Oder mache ich das über die setter methode?
 

mihe7

Top Contributor
Also könntest Du Dir doch vor dem Aufruf des Setters die aktuelle Zahl merken und nach dem Aufruf des Setters mit dieser Zahl vergleichen.
 

nikva

Bekanntes Mitglied
Code:
    public boolean insert1Ct() {
        getFill1Ct();
        if (fill1Ct>=10) {
            return false;
        }
        else
        setFill1Ct(getFill1Ct() + 1);
        balance = balance + 1;
        return true;
    }
 

nikva

Bekanntes Mitglied
zuerst holt er sich den wert von fill1Ct
dann überprüft er ob der wert größer gleich 10 ist
wenn ja dann gibt er false zurück und tut nichts weiter

wenn nein dann addiert er 1 und erhöht balance auch um 1 und gibt true zurück

ok, ich merks grad selbst: der methode ist egal ob der wert negativ ist
 

mihe7

Top Contributor
ok, ich merks grad selbst: der methode ist egal ob der wert negativ ist
Das meinte ich noch nicht mal.

zuerst holt er sich den wert von fill1Ct
Du rufst getFill1Ct() auf. An der Stelle passiert aber rein gar nichts, da Du den Rückgabewert nicht verwendest (s. Kommentar #32). Um den Rückgabewert zu verwenden, könntest Du ihn in einer Variablen speichern, z. B.
Java:
int fill1CtBefore;
fill1CtBefore = getFill1Ct();
Jetzt könntest Du mit fill1CtBefore weiterarbeiten, wenn Du den Ansatz umsetzen wolltest, hinterher nachzuschauen, ob sich im Münzfach etwas geändert hat.

Das lassen wir jetzt aber mal, da Du einen anderen Ansatz gewählt hast, der grundsätzlich auch funktioniert: vorab prüfen, ob die Münze überhaupt noch Platz hat.

dann überprüft er ob der wert größer gleich 10 ist
Warum 10?
 

nikva

Bekanntes Mitglied
weil 10 doch der maximale platz im fach ist
Java:
    public boolean insert1Ct() {
        int fill1Ctbefore;
        fill1Ctbefore = getFill1Ct();
        setFill1Ct(getFill1Ct() + 1);
        if (fill1Ct > fill1Ctbefore) {
            balance = balance + 1;
            return true;
        } else
            return false;

    }
    }

ist es so besser?
 
Zuletzt bearbeitet:

mihe7

Top Contributor
Nein, der maximale Platz im Fach steht in einer Instanzvariablen und kann bei der Erzeugung des Ticketautomaten über den Konstruktor eingestellt werden.
 

mihe7

Top Contributor
aber das ist ja mit dem ansatz egal, weil es bereits im setter vergleicht ob es geht
Bei dem Ansatz aus #41 ja (den hast Du aber drei Minuten nach meinem Beitrag eingefügt). Dort kommt auch keine 10 mehr vor :)

Wenn Du mit Getter arbeiten willst, dann bitte konsistent:
Java:
    public boolean insert1Ct() {
        int fill1Ctbefore;
        fill1Ctbefore = getFill1Ct();
        setFill1Ct(fill1CtBefore + 1); 
        if (getFill1Ct() > fill1Ctbefore) {
            balance = balance + 1;
            return true;
        } else
            return false;
        }
    }
 

nikva

Bekanntes Mitglied
ich versuche grade aufgabe h zu lösen aber sobald ich mathematische operationen durchführen will kommt die meldung "invalid assignement operator"
Java:
    public int returnChange() {
        int change10CtCoins;
        balance - ticketPrice = change;
        change/10 = change10CtCoins;
    }
 

mihe7

Top Contributor
Das "=" wird nicht für Gleichungen verwendet, sondern für Zuweisungen. Einer Berechnung kann man nichts zuweisen.

Was willst Du denn genau machen?
 

nikva

Bekanntes Mitglied
ich will jetzt den ticketpreis von wert balance abziehen um das restgeld zu ermitteln.
diesen wert teile ich durch 10 um zu ermitteln wie viele 10 cent münzen ich rausgebe
den rest davon durch 5 um die 5 cent münzen zu ermitteln etc
 

mihe7

Top Contributor
Ok, dann dreh die "Gleichungen" um :)
Java:
int change = balance - ticketPrice;
int change10CtCoins = change/10;
 

nikva

Bekanntes Mitglied
Code:
    public int returnChange() {
        int change = balance - ticketPrice;
        int change10CtCoins = change/10;
        int change5CtCoins = change%10/5;
        int change2CtCoins = (balance - change10CtCoins*10 - change5CtCoins*5)/2;
        int change1CtCoins = balance - change10CtCoins - change5CtCoins - change2CtCoins;
        
        setFill1Ct(getFill1Ct()-change1CtCoins);
        setFill2Ct(getFill2Ct()-change2CtCoins);
        setFill5Ct(getFill5Ct()-change5CtCoins);
        setFill10Ct(getFill10Ct()-change10CtCoins);
        
        
    }

In der Aufgabe steht jetzt, dass erst noch überprüft werden soll ob überhaupt ein Rückgeld gegeben werden soll oder ob nur gecheckt werden soll wie viel zurückgegeben werden könnte. Ich verstehe nicht was genau damit gemeint ist.
 

nikva

Bekanntes Mitglied
es sieht mittlerweile so aus, aber ich bin mir noch nicht sicher wie genau ich das jetzt mit refundBalance vereinbaren soll

Java:
    public boolean returnChange() {
        int change = getBalance() - ticketPrice;
        if (change > 0) {
            int change10CtCoins = change / 10;
            int change5CtCoins = change % 10 / 5;
            int change2CtCoins = (getBalance() - change10CtCoins * 10 - change5CtCoins * 5) / 2;
            int change1CtCoins = getBalance() - change10CtCoins - change5CtCoins - change2CtCoins;

            setFill1Ct(getFill1Ct() - change1CtCoins);
            setFill2Ct(getFill2Ct() - change2CtCoins);
            setFill5Ct(getFill5Ct() - change5CtCoins);
            setFill10Ct(getFill10Ct() - change10CtCoins);
            if (change1CtCoins + change2CtCoins + change5CtCoins + change10CtCoins == change) {

            }
            return true;

        } else
            return false;

    }
 
Ähnliche Java Themen
  Titel Forum Antworten Datum
G Ticketautomat strukturierter hinbekommen Java Basics - Anfänger-Themen 55
S Ticketautomat Java Basics - Anfänger-Themen 17
I Ticketautomat in Java umprogrammieren Java Basics - Anfänger-Themen 8
A GUI bequemer programmieren? Java Basics - Anfänger-Themen 6
N Hey Leute und zwar versuche ich gerade ein 2D Spiel zu Programmieren aber die Figur will sich nicht nach links oder rechts bewegen :( Java Basics - Anfänger-Themen 12
B OOP was heißt objektorientiertes Programmieren (fragt ein absoluter Anfänger) Java Basics - Anfänger-Themen 17
laxla123 Rechteck programmieren Java Basics - Anfänger-Themen 4
A Erste Schritte Dynamische Stempel im PDF Exchange programmieren Java Basics - Anfänger-Themen 0
D Programmieren nach UML Java Basics - Anfänger-Themen 2
Y Taschenrechner programmieren Java Basics - Anfänger-Themen 3
B Überweisung programmieren Java Basics - Anfänger-Themen 7
bluetrix Programmieren eines Bots für Zahlen-Brettspiel Java Basics - Anfänger-Themen 9
D Ampel Programmieren die jede 10 sekunden ihre farbe wechselt Java Basics - Anfänger-Themen 6
J ArrayList add methode selbst programmieren Java Basics - Anfänger-Themen 10
00111010101 Objektorientiertes Programmieren mit Vererbung (Zahlen in Array verschwinden) Java Basics - Anfänger-Themen 3
thor_norsk Fernseher programmieren mit Java Java Basics - Anfänger-Themen 4
M Jenga Regeln Java Programmieren Java Basics - Anfänger-Themen 1
M Ressourcensparend programmieren Java Basics - Anfänger-Themen 3
brypa Wie Programmieren lernen? Java Basics - Anfänger-Themen 15
G Spielerwechsel programmieren Java Basics - Anfänger-Themen 1
J Solitär (Brettspiel) programmieren Java Basics - Anfänger-Themen 3
H Objektorientiertes Programmieren Java Basics - Anfänger-Themen 4
K 12- Stunden Konverter Programmieren Java Basics - Anfänger-Themen 1
WAB9703-04 Programm zum automatischen Ausfüllen von Formularen programmieren Java Basics - Anfänger-Themen 3
L Zahlenspiel programmieren Java Basics - Anfänger-Themen 1
TimoN11 Automat programmieren Java Basics - Anfänger-Themen 4
G Erste Schritte Array Mittelwert Methode Programmieren Java Basics - Anfänger-Themen 5
ehmo würfelspiel programmieren anfänger Java Basics - Anfänger-Themen 1
N Ufospiel programmieren Java Basics - Anfänger-Themen 13
KogoroMori21 Vorbereitung auf die Programmieren Klausur vom ersten Semester Java Basics - Anfänger-Themen 4
Drinkerbell Erste Schritte Zu blöd zum Programmieren? Java Basics - Anfänger-Themen 9
G Stack programmieren Java Basics - Anfänger-Themen 6
I Brauche Hilfe bei Objektorientiertem programmieren Java Basics - Anfänger-Themen 23
T Auf einem Schachbrett bewegen programmieren Java Basics - Anfänger-Themen 2
G Bruchrechner programmieren Java Basics - Anfänger-Themen 6
G Ufo Spiel programmieren Java Basics - Anfänger-Themen 13
D Schachbrett (8x8) programmieren Java Basics - Anfänger-Themen 3
J Spiel programmieren Java Basics - Anfänger-Themen 16
J Hilfe beim Programmieren Java Basics - Anfänger-Themen 5
S Kreisberechnung3 Buch: Programmieren lernen mit Java von Hans-Peter Habelitz Java Basics - Anfänger-Themen 39
M Quiz in Java programmieren mit Array Java Basics - Anfänger-Themen 8
S Spiel-Programmieren. Wenn ein Objekt den anderen berührt. Java Basics - Anfänger-Themen 6
K Java programmieren Java Basics - Anfänger-Themen 6
V_Fynn03 Kontrolle des Quelltextes (Bank programmieren)(GUI) Java Basics - Anfänger-Themen 6
D Was tun gegen zu komplzierten Denken beim Programmieren Java Basics - Anfänger-Themen 27
V_Fynn03 Bruchrechner programmieren (2 Klassen) Java Basics - Anfänger-Themen 9
M Rechner programmieren Java Basics - Anfänger-Themen 3
V_Fynn03 Java Bruchrechner programmieren Java Basics - Anfänger-Themen 13
J Java Suchfunktion Programmieren Java Basics - Anfänger-Themen 1
L Erste Schritte Bin ich "zu dumm" oder nicht geeignet zum Programmieren? Java Basics - Anfänger-Themen 3
U Ist jemad gut in programmieren (JAVA) und kann mir helfen? Java Basics - Anfänger-Themen 1
H Uhr programmieren Java Basics - Anfänger-Themen 10
T Schalter programmieren Java Basics - Anfänger-Themen 17
S Ampel Programmieren Java Basics - Anfänger-Themen 5
P Erste Schritte Probleme mit dem Programmieren Java Basics - Anfänger-Themen 12
D Richtig für Programmieren an der UNI lernen Java Basics - Anfänger-Themen 8
B Folgende Abfrage dynamisch programmieren? Java Basics - Anfänger-Themen 8
D Beim Programmieren auf die Logisch einfache Lösung kommen. Java Basics - Anfänger-Themen 17
B UML Klassen Diagramm zu Java Code Programmieren und ausführen Java Basics - Anfänger-Themen 21
steven789hjk543 Kann man mit Java und Eclipse einen Virus programmieren? Java Basics - Anfänger-Themen 13
S Spiel programmieren mit Java Java Basics - Anfänger-Themen 11
A Kalender programmieren, ich finde meinen Fehler nicht. Java Basics - Anfänger-Themen 9
S Erste Schritte Hilfe beim lernen von Programmieren Java Basics - Anfänger-Themen 2
V Zeichenkette programmieren Java Basics - Anfänger-Themen 20
O Fenster programmieren Java Basics - Anfänger-Themen 2
R Uebersichtlicher bzw. besser Programmieren Java Basics - Anfänger-Themen 13
N Dynamisches Programmieren/Fibonacci Java Basics - Anfänger-Themen 1
B Spielfiguren für ein Beute-Jägerspiel programmieren Java Basics - Anfänger-Themen 12
A Programmieren lernen Java Basics - Anfänger-Themen 28
F ArrayListe manuell programmieren? Java Basics - Anfänger-Themen 24
X Erste Schritte Einstieg ins Programmieren Java Java Basics - Anfänger-Themen 2
O Erste Schritte ln(1+x) Reihe Programmieren Java Basics - Anfänger-Themen 6
Ellachen55 Weihnachtsbaum in Eclipse programmieren Java Basics - Anfänger-Themen 6
L Klassen Geldrückgabe - Aufgabe Programmieren Java Basics - Anfänger-Themen 23
H Stern Dreieck (Buch: Grundkurs Programmieren) Java Basics - Anfänger-Themen 2
V Variablen Vorkommen programmieren Java Basics - Anfänger-Themen 18
S Dreieckssignal programmieren Java Basics - Anfänger-Themen 5
K Fehler beim Programmieren von TicTacToe Java Basics - Anfänger-Themen 12
M Spiel programmieren Java Basics - Anfänger-Themen 16
A Fenster programmieren Java Basics - Anfänger-Themen 1
V OOP Kassensystem objektorientiert programmieren Java Basics - Anfänger-Themen 15
A Erste Schritte DoodleJump programmieren: Kollisionsabfrage Java Basics - Anfänger-Themen 4
CT9288 Kleine Simulation programmieren, denkanstöße erbeten Java Basics - Anfänger-Themen 19
H Welche IDE zum Buch "Programmieren mit Java" von Reinhard Schiedermeier des Verlags Pearson Studium Java Basics - Anfänger-Themen 19
D Könnt ihr mir helfen beim Programmieren eines Ping Pong Spieles? Java Basics - Anfänger-Themen 9
M Rekursive Methode Programmieren Java Basics - Anfänger-Themen 3
I Spielbrett programmieren: Datenstruktur Java Basics - Anfänger-Themen 3
G Rekursives Programmieren --> harmonische Reihe Java Basics - Anfänger-Themen 3
A Endlich anfangen mit Programmieren ! Java Basics - Anfänger-Themen 8
L Karawane programmieren Java Basics - Anfänger-Themen 0
kokojamboo92 Spiel programmieren Java Basics - Anfänger-Themen 1
E Mastermind programmieren, wie den falschen Platz aber richtige Farbe schecken? Java Basics - Anfänger-Themen 23
steven789hjk543 Erste Schritte java programmieren/ Schritt für Schritt Java Basics - Anfänger-Themen 14
I Spiel programmieren. Java Basics - Anfänger-Themen 16
H [Studium] Mäxchenspiel programmieren Java Basics - Anfänger-Themen 10
C BlueJ Zahlenschloss programmieren Java Basics - Anfänger-Themen 5
steven789hjk543 mit dem Smartphone java programmieren Java Basics - Anfänger-Themen 44
F Okjektorientiert programmieren Java Basics - Anfänger-Themen 2
S OOP Ticketsystem programmieren Java Basics - Anfänger-Themen 6
P Selber Programmieren lernen oder Uni? Java Basics - Anfänger-Themen 12

Ähnliche Java Themen

Neue Themen


Oben