gotowe fragmenty kodu dot. konta

src/main/java/p09_klasy/BrakSrodkow.java

+package p09_klasy;
+
+public class BrakSrodkow extends Exception {
+
+    public BrakSrodkow() {
+    }
+
+    public BrakSrodkow(String message) {
+        super(message);
+    }
+}

src/main/java/p09_klasy/Konto.java

@@ -6,6 +6,9 @@ public class Konto {
     private Osoba wlasciciel;
 
     public Konto(int numer, int saldo, Osoba wlasciciel) {
+        if(saldo < 0) {
+            throw new IllegalArgumentException("ujemne saldo w konstruktorze");
+        }
         this.numer = numer;
         this.saldo = saldo;
         this.wlasciciel = wlasciciel;
@@ -47,11 +50,30 @@ public class Konto {
     }
 
     public void wplata(int kwota) {
+        if(kwota <= 0) {
+            throw new IllegalArgumentException("niedodatnia kwota we wpłacie");
+        }
         saldo += kwota;
     }
 
-
-    public void wyplata(int kwota) {
+    public void wyplata(int kwota) throws BrakSrodkow {
+        if(kwota <= 0) {
+            throw new IllegalArgumentException("niedodatnia kwota w wypłacie");
+        }
+        if(kwota > saldo) {
+            throw new BrakSrodkow("za mało kasy na koncie nr " + numer);
+        }
         saldo -= kwota;
     }
+
+    public void przelew(int kwota, Konto kontoDocelowe) throws BrakSrodkow {
+        if(kwota <= 0) {
+            throw new IllegalArgumentException("Kwota nie jest dodatnia");
+        }
+        if(kwota > saldo) {
+            throw new BrakSrodkow("Za mało kasy podczas przelewu");
+        }
+        this.saldo -= kwota;
+        kontoDocelowe.saldo += kwota;
+    }
 }

src/main/java/p09_klasy/ProgramBankowy.java

+package p09_klasy;
+
+import java.util.Scanner;
+
+public class ProgramBankowy {
+
+    public static void main(String[] args) {
+        @SuppressWarnings("resource")
+		Scanner sc = new Scanner(System.in);
+
+        Osoba ala = new Osoba("Ala", "Kowalska", 33);
+
+        System.out.print("Podaj początkową kwotę: ");
+        int kwota = sc.nextInt();
+        sc.nextLine(); // wymuszenie przejścia do nowej linii
+
+        Konto konto = new Konto(1, kwota, ala);
+        System.out.println(konto);
+
+        petla:
+        while(true) {
+            try {
+                System.out.println("Co chcesz zrobić?  W - wpłata, Y - wypłata, K - koniec");
+                String wybor = sc.nextLine().toUpperCase();
+                switch(wybor) {
+                    case "K", "Q":
+                        break petla; // przejście do Koniec programu
+
+                    case "W":
+                        System.out.print("Podaj kwotę wpłaty: ");
+                        kwota = sc.nextInt();
+                        sc.nextLine();
+                    	konto.wplata(kwota);
+                		System.out.println("Pieniądze zostały wpłacone");
+                        break;
+                    case "Y":
+                        System.out.print("Podaj kwotę wypłaty: ");
+                        kwota = sc.nextInt();
+                        sc.nextLine();
+                        konto.wyplata(kwota);
+
+                        // ta linia wykona się tylko jeśli nie było wyjątku:
+                        System.out.println("Pieniądze zostały wypłacone");
+                        break;
+                    default:
+                        System.out.println("Nieznane polecenie");
+                        continue petla; // Przejście do Co chcesz zrobić
+                }
+            // Jeśli o różnych sytuacjach błędnych będą informować wyjątki różnych klas,
+            // to w programie możemy te sytuacje rozróżnić i obsłużyć w róznych catchach
+            } catch(IllegalArgumentException e) {
+                System.out.println("Niepoprawny argument: " + e);
+            } catch(BrakSrodkow e) {
+                System.out.println(e.getMessage());
+            } catch(Exception e) {
+                System.out.println("Inny błąd: " + e);
+            }
+            System.out.println();
+            System.out.println(konto);
+            System.out.println();
+        }
+        System.out.println("Koniec programu");
+    }
+}

src/main/java/p09_klasy/Przyklad2.java

@@ -12,8 +12,9 @@ public class Przyklad2 {
         System.out.println(kontoOli);
         System.out.println();
 
-        kontoAli.wplata(300);
+        kontoAli.wplata(-300);
         System.out.println(kontoAli);
 
+        System.out.println("Koniec programu");
     }
 }

src/test/java/p09_klasy/KontoTest.java

@@ -24,8 +24,96 @@ class KontoTest {
     }
 
     @Test
-    void testWyplata() {
+    void testWyplata() throws BrakSrodkow {
         konto.wyplata(400);
         assertEquals(600, konto.getSaldo());
     }
+
+    // obsługa wyjątków w JUnit
+
+    // wersja JUnit 5:
+    @Test
+    void testWplataUjemna() {
+        // czy na pewno takie wywołanie spowoduje wyjątek?
+        assertThrows(IllegalArgumentException.class, () -> konto.wplata(-200));
+
+        // upewniamy się jeszcze, czy saldo nie zostało w tej sytuacji zmienione
+        assertEquals(1000, konto.getSaldo());
+    }
+
+    // ↓To wklejam gotowe ↓
+    // Temat sprawdzania wyjątków w testach.
+
+    // Aby stwierdzić, że w pewnej sytuacji metoda POWINNA skończyć się wyjątkiem,
+    // możemy użyć odpowiednio try-catch (testWplataTry)
+    // albo użyć dedykowanych rozwiązań JUnit - dalsze przykłady
+
+    @Test
+    void testWplataTry() {
+        try {
+            konto.wplata(-100);
+            // Gdyby nie było wyjątku i program doszedłby do tego miejsca,
+            // test powinien skończyć się porażką
+            fail("Powinien być wyjątek, a nie ma.");
+        } catch(IllegalArgumentException e) {
+            // Jeśli wyłapiemy wyjątek, możemy sprawdzić w teście jego szczegóły,
+            // np. jaki jest message (bardzo rzadko takie rzeczy sprawdza się w testach, ale można):
+            assertEquals("Niedodatnia kwota w metodzie wplata", e.getMessage());
+        } finally {
+            // Możemy też upewnić się, że w przypadku wystąpienia wyjątku stan konta się nie zmienił.
+            assertEquals(1000, konto.getSaldo());
+        }
+    }
+
+    // Analogiczny test można też napisać wykorzystując nową funkcjonalność JUnit 5:
+    @Test
+    void testWplataUjemna_v1() {
+        // assertThrows wykonuje podany fragment kodu (w praktyce podaje się wyrażenie lambda)
+        // i sprawdza czy ten kończy się podanym rodzajem wyjątku.
+        // Jeśli jest wyjątek - dobrze
+        // Jeśli nie ma wyjątku - test failuje
+
+        assertThrows(IllegalArgumentException.class, () -> {
+            konto.wplata(-100);
+        });
+
+        // Dodatkowo po wykonaniu assertThrows możemy sprawdzić jaki jest stan końcowy,
+        // np. czy saldo się nie zmieniło.
+        assertEquals(1000, konto.getSaldo());
+    }
+
+    // Aby sprawdzić jaki jest message w wyjątku itp, możemy odebrać obiekt wyjątku i sprawdzić bezpośrednio
+    @Test
+    void testWplataUjemna_v2() {
+        IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, () -> {
+            konto.wplata(-100);
+        });
+
+        assertEquals("Niedodatnia kwota w metodzie wplata", exception.getMessage());
+        assertEquals(1000, konto.getSaldo());
+    }
+
+    @Test
+    void testWyplataUjemna() {
+        assertThrows(IllegalArgumentException.class, () -> {
+            konto.wyplata(-100);
+        });
+        assertEquals(1000, konto.getSaldo());
+    }
+
+    @Test
+    void testBrakSrodkow() {
+        assertThrows(BrakSrodkow.class, () -> {
+            konto.wyplata(1300);
+        });
+        assertEquals(1000, konto.getSaldo());
+    }
+
+    @Test
+    void testPrzelew() throws BrakSrodkow {
+        Konto konto2 = new Konto(2, 2000, null);
+        konto.przelew(400, konto2);
+        assertEquals(600, konto.getSaldo());
+        assertEquals(2400, konto2.getSaldo());
+    }
 }
\ No newline at end of file