MPK

/////////////////////////////////////// BILETOMAT //////////////////////////////////////////////////////

//////////////////////////////////////// MAIN ///////////////////////////////////////////////

public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        String rodzaje[] ={"Jednoprzejazdowy", "20minutowy", "40miutowy", "60minutowy"};
        double ceny[] = {1.80, 1.40, 2.50, 4.00};

        /*
         * (Zapisy te widoczne sa rowniez w klasach ktorych dotycza)
         * W projekcie wystepuja nastepujace przypadki kompozycji i dziedziczeni:
         * W klasie Biletomat wystepuje kompozycja : utworzono obiekt klasy Bilet oraz obiekt klasy Transakcja w klasie Biletomat
         * W klasach: USA, EUR, PLN wystepuje dziedziczenie: wszystkie dziedzicza po plasie pieniadz
         */


        Biletomat MPK = new Biletomat(rodzaje, ceny, "Kraków", 13);

        MPK.pokazDostepneBilety();
        System.out.println(" ");


        MPK.sprzedajBilet("60minutowy", 5, new EUR(4));         // Dla sprawdzenia czy wykrywa brak pieniedzy
        MPK.sprzedajBilet("Inny", 1, new PLN(4));               // Dla sprawdzenia czy niewlasciwy rodzaj
        MPK.sprzedajBilet("20minutowy", 15, new USD(10));
        MPK.sprzedajBilet("40miutowy", 4, new EUR(20));
        MPK.sprzedajBilet("Jednoprzejazdowy", 2, new EUR(3));
        MPK.sprzedajBilet("60minutowy", 4, new PLN(11));        // Dla sprawdzenia czy wykrywa brak pieniedzy
        MPK.sprzedajBilet("20minutowy", 4, new PLN(50));
        MPK.sprzedajBilet("20minutowy", 4, new USD(210));

        System.out.println(" ");
        System.out.println(MPK);

    }

}

//////////////////////////////////////// PIENIADZ ///////////////////////////////////////////////

public class Pieniadz {
    private double kwota;

    /**
     * Konstruktor pieniadza
     * @param kwota kwota
     */
    public Pieniadz(double kwota){
        this.kwota = kwota;
    }

    /**
     * Pozyskuje kwote
     * @return kwota
     */
    public double getKwota() {
        return kwota;
    }

    /**
     * Ustawia kwote
     * @param kwota kwota
     */
    public void setKwota(double kwota) {
        this.kwota = kwota;
    }
}

//////////////////////////////////////// TRANSAKCJA ///////////////////////////////////////////////

import java.time.LocalDate;

public class Transakcja {

    private LocalDate data;
    private String rodzaj;
    private double dochod;
    private int ilosc;

    /**
     * Konstruktor klasy transakcja
     * @param rodzaj rodzaj transakcji
     * @param ilosc ilosc biletow do kupienia
     */
    public Transakcja(String rodzaj, int ilosc)
    {
        this.rodzaj = rodzaj;
        this.ilosc = ilosc;
        data = LocalDate.now();
    }

    /**
     * toString
     */
    public String toString() {
        return "Transakcja: rodzaj - " + rodzaj + ", ilosc - " + ilosc + ", dochod - " + dochod;
    }

    /**
     * Pozyskuje dochod transakcji
     * @return dochod
     */
    public double getDochod() {
        return dochod;
    }

    /**
     * Ustawia dochod z transakcji
     * @param dochod dochod
     */
    public void setDochod(double dochod) {
        this.dochod = dochod;
    }

    /**
     * Pozyskuje date
     * @return data
     */
    public LocalDate getData() {
        return data;
    }

    /**
     * Ustawia date
     * @param data data
     */
    public void setData(LocalDate data) {
        this.data = data;
    }

    /**
     * Pozyskuje rodzaj
     * @return rodzaj
     */
    public String getRodzaj() {
        return rodzaj;
    }

    /**
     * Ustawia rodzaj
     * @param rodzaj rodzaj
     */
    public void setRodzaj(String rodzaj) {
        this.rodzaj = rodzaj;
    }

    /**
     * Pozyskuje ilosc
     * @return ilosc
     */
    public int getIlosc() {
        return ilosc;
    }

    /**
     * Ustawia ilosc
     * @param ilosc ilosc
     */
    public void setIlosc(int ilosc) {
        this.ilosc = ilosc;
    }

}
//////////////////////////////////////// BILETOMAT ///////////////////////////////////////////////

public class Biletomat
{
    private String lokalizacja;
    private double saldo = 100.00;
    private Transakcja[] zapisTransakcji;               // Przypadek kompozycji - utworzono obiekt klasy Transakcja w klasie Biletomat
    private Bilet[] rodzajeBiletow;                     // Przypadek kompozycji - utworzono obiekt klasy Bilet w klasie Biletomat
    private int index = -1;

    /**
     * Konstruktor klasy Biletomat
     * @param rodzaje rodzaje
     * @param ceny ceny
     * @param lokalizacja lokalizacja
     * @param maksymalnaLiczbaTransakcji maksymalnaLiczbaTransakcji
     */
    public Biletomat(String rodzaje[], double ceny[], String lokalizacja, int maksymalnaLiczbaTransakcji)
    {
        this.lokalizacja = lokalizacja;
        this.zapisTransakcji = new Transakcja[maksymalnaLiczbaTransakcji];
        this.rodzajeBiletow = new Bilet[rodzaje.length];

        for(int i=0;i<rodzaje.length;i++)
        {
            rodzajeBiletow[i] = new Bilet(rodzaje[i], ceny[i]);
        }
    }

    /**
     * toString
     */
    public String toString()
    {
        String wynik="";
        System.out.println("Wszystkie transakcje: ");

        for(int i=0;i<=index;i++) {
            wynik += zapisTransakcji[i]+"  \n";
        }

        return wynik;
    }

    /**
     * Metoda wyswietlajaca bilety
     */
    public void pokazDostepneBilety()
    {
        System.out.println("Dostepne bilety: ");

        for(int i =0; i<rodzajeBiletow.length;i++)
        {
            System.out.println(rodzajeBiletow[i]);
        }
    }

    /**
     * Dodaje transakcje
     * @param transakcja transakcja
     * @param dochod dochod
     */
    private void dodajTransakcje(Transakcja transakcja, double dochod)
    {
        if(index + 1 < zapisTransakcji.length)
        {
            zapisTransakcji[++index] = transakcja;
            zapisTransakcji[index].setDochod(dochod);
        }
    }

    /**
     * Wsywietla transakcje
     */
    public void wyswietlTransakcje()
    {
        System.out.println("Wszystkie transakcje:");

        for(int i=0;i<=index;i++)
        {
            System.out.println(zapisTransakcji[index]);
        }
    }

    /**
     * Wyswietla transakcje z danego dnia
     * @param data
     */
    public void wydrukujTransakcje(String data)
    {
        System.out.println("Transakcje na dzien "+ data);

        for(int i=0;i<=index;i++)
        {
            if(zapisTransakcji[index].getData().equals(data))
            {
                System.out.println(zapisTransakcji[index]);
            }
        }

        System.out.println(" ");
    }

    /**
     * Funkcja sprzedajaca bilety
     * @param rodzaj rodzaj
     * @param ilosc ilsoc
     * @param kwota wybrany typ platnosci oraz ilosc, np USD(10)
     */
    public void sprzedajBilet(String rodzaj, int ilosc, Pieniadz kwota)
    {
        boolean czyTakiIstnieje = false;

        for(int i=0;i<rodzajeBiletow.length;i++)
        {
            if(rodzajeBiletow[i].getRodzaj() == rodzaj)
            {
                czyTakiIstnieje = true;

                if(kwota.getKwota()==ilosc*rodzajeBiletow[i].getCena())
                {
                    saldo += ilosc*rodzajeBiletow[i].getCena();
                    System.out.println("Zaplacono równą kwotą, bilet zostal sprzedany");
                    dodajTransakcje(new Transakcja(rodzaj,ilosc),ilosc*rodzajeBiletow[i].getCena() );
                }
                else if(kwota.getKwota()>ilosc*rodzajeBiletow[i].getCena())
                {
                    saldo+=ilosc*rodzajeBiletow[i].getCena();
                    System.out.println("Sprzedano bilet, wydaje reszte " + (kwota.getKwota() - ilosc*rodzajeBiletow[i].getCena()));
                    dodajTransakcje(new Transakcja(rodzaj, ilosc), ilosc*rodzajeBiletow[i].getCena() );
                }
                else {
                    System.out.println("Nie mozna sprzedac biletu, za malo pieniedzy");
                    break;
                }
            }

            if(czyTakiIstnieje == true)
            {
                break;
            }
        }
        if(czyTakiIstnieje == false)
        {
            System.out.println("Brak tego rodzaju biletu");
        }
    }

}
//////////////////////////////////////// BILET ///////////////////////////////////////////////

public class Bilet {
    private String rodzaj;
    private double cena;

    /**
     * Konstruktor Biletu
     * @param rodzaj rodzaj biletu
     * @param cena cena biletu
     */
    public Bilet(String rodzaj, double cena) {
        this.cena = cena;
        this.rodzaj = rodzaj;
    }

    /**
     * toString
     */
    public String toString() {
        return "Bilet "+ rodzaj + " kosztuje " + cena + " zlotych";
    }

    /**
     * Pozyskuje rodzaj biletu
     * @return rodzaj biletu
     */
    public String getRodzaj() {
        return rodzaj;
    }

    /**
     * Ustawia rodzaj biletu
     * @param rodzaj rodzaj biletu
     */
    public void setRodzaj(String rodzaj) {
        this.rodzaj = rodzaj;
    }

    /**
     * Pozyskuje cene biletu
     * @return cena biletu
     */
    public double getCena() {
        return cena;
    }

    /**
     * Ustawia cene biletu
     * @param cena cena biletu
     */
    public void setCena(double cena) {
        this.cena = cena;
    }

}

//////////////////////////////////////// PLN ///////////////////////////////////////////////
// PLN dziedziczy z klasy Pieniadz, rozszerzajac go o typ jakim jest
public class PLN extends Pieniadz{
    private String typ;

    /**
     * Konstruktor PLN
     * @param rodzaj nominal
     */
    public PLN(int rodzaj) {
        super(rodzaj);
        this.typ = "PLN";
    }
}

//////////////////////////////////////// USD ///////////////////////////////////////////////
// USD dziedziczy z klasy Pieniadz, rozszerzajac go o typ jakim jest
public class USD extends Pieniadz{
    private String typ;

    /**
     * Konstruktor USD
     * @param rodzaj nominal
     */
    public USD(int rodzaj) {
        super(rodzaj*3.5);                  // Przyjmuje ze 1USD = 3.5PLN
        this.typ = "USD";
    }
}

//////////////////////////////////////// EUR ///////////////////////////////////////////////
// EUR dziedziczy z klasy Pieniadz, rozszerzajac go o typ jakim jest
public class EUR extends Pieniadz{
    private String typ;

    /**
     * Konstruktor EUR
     * @param rodzaj nominal
     */
    public EUR(int rodzaj) {
        super(rodzaj*4);                // Przyjmuje ze 1EUR = 4PLN
        this.typ = "EUR";
    }
}