Decyzje i wyjątki

1. Przegląd instrukcji sterujących

2. Operatory i wyrażenia porównania

• są operatorami dwuargumentowymi
• ich argumentami mogą być wyłącznie wyrażenia typów numerycznych (byte, char, short, int, long, float, double)
• wyrażenia relacyjne (konstruowane z pomocą tych operatorów) dają zawsze w wyniku wartości typu boolean (true lub false)
  

• mają one niższy priorytet niż operatory relacyjne
• ich argumentami mogą być wartości wszystkich typów (numerycznych, logicznych, referencyjnych), pod warunkiem jednak, że:
• jeżeli jeden z argumentów jest typu numerycznego - to drugi też musi być typu numerycznego,
• jeżeli jeden z argumentów jest typu boolean - to i drugi musi być tego typu,
• jeżeli jeden z argumentów jest typu referencyjnego, to drugi musi być typu referencyjnego dającego się przekształcić do typu pierwszego albo literałem null (o przekształceniach typów będziemy mówić później; na razie możemy przyjąć, że obowiązuje nas ograniczenie porównywania na równość - nierówność tych samych typów referencyjnych np. referencji typu String lub referencji typu Para)
  

int a = 2, b = a + 1;
if ( a == b) System.out.println("tak");
else System.out.println("nie");

if ( a != --b) System.out.println("tak");   // 2
else System.out.println("nie");

int c = 4;
if ( a < b + 1 == b  < c) System.out.println("tak");  //3
else System.out.println("tak");

1. przedrostkowa forma operatora -- zapewnia, że wartość b w przykładzie 2 będzie zmieniona przed użyciem w wyrażeniu porownania na nierówność;
2. w przykladzie 3 korzystamy z tego, że priorytet operatora == jest niższy od priorytetu operatorów relacyjnych, a te z kolei są niższe od priorytetów operatorów arytmetycznych (+); na równość porównywane są zatem dwie wartości typu boolean, a ponieważ obie są true, to wynik porównania też jest true
   

3. Operatory i wyrażenia logiczne

• jednoargumentowy operator negacji logicznej oznaczany przez ! ("nie"),
• dwuargumentowy operator koniunkcji oznaczany przez && ("i"),
• dwuargumentowy operator alternatywy oznaczany przez || ("albo").

import javax.swing.*;

public class EfUb {

  public static void main(String[] args) {

    String nazwisko;
    String imie = null;
    String txt;

    if ((nazwisko = JOptionPane.showInputDialog("Podaj nazwisko")) != null
         && (imie = JOptionPane.showInputDialog("Podaj imie")) != null
       )
       txt = nazwisko + " " + imie;
    else txt = "Niepelna informacja";
    System.out.println(txt);
    System.out.println("Imie :" + imie);
    System.out.println("Nazwisko :" + nazwisko);
    System.exit(0);
  }

}

• & koniunkcja
• | alternatywa
• ^ "wyłączające albo"
• ~ negacja

4. Podejmowanie decyzji: instrukcje if oraz if-else

char op;
double a, b, r;
...
if (op == '+') r = a + b;
else if (op == '-') r = a - b;
     else if (op == '*') r = a*b;
          else if (op == '/') r = a/b;
               else System.out.println("Błędny kod operacji");

     if (a >= 1000) System.out.println("Duża liczba")
     if (a >= 100) System.out.println("Średnia liczba")
     if (a >= 10) System.out.println("Mała liczba")

     if (a >= 10) System.out.println("Mała liczba");
     else if (a >= 100) System.out.println("Średnia liczba");
          else  if (a >= 1000) System.out.println("Duża liczba");

     if (a >= 1000) System.out.println("Duża liczba");
     else if (a >= 100) System.out.println("Średnia liczba");
          else if (a >= 10) System.out.println("Mała liczba");

     if (a >= 1000) System.out.println("Duża liczba");
     else if (a >= 100) System.out.println("Średnia liczba");
          else if (a >= 10) System.out.println("Mała liczba");
               else System.out.println("Liczba mikra, bo mniejsza od 10")

5. Wielowariantowe wybory za pomocą instrukcji switch

public class SimpleCalc {

  private double a;
  private double b;

  public SimpleCalc(double x, double y) {
    a = x;
    b = y;
  }

  public double makeOp(char op) {

    double r = 0;

    switch(op) {
       case '+' : r = a + b; break;
       case '-' : r = a - b; break;
       case '*' : r = a * b; break;
       case '/' : r = a / b; break;
       default  : System.out.println("Nieznany kod operacji");
    }

    return r;
  }

}

class SimplecalcTest {

  public static void main(String[] args) {

    SimpleCalc sc = new SimpleCalc(1.2, 3.7);
    System.out.println( sc.makeOp('+'));
    System.out.println( sc.makeOp('-'));
    System.out.println( sc.makeOp('*'));
    System.out.println( sc.makeOp('/'));

  }
}

public class SimpleCalc {
  
  private static enum Op { PLUS, MINUS, MULT, DIV };

  private double a;
  private double b;

  public SimpleCalc(double x, double y) {
    a = x;
    b = y;
  }

  public double makeOp(Op op) {

    double r = 0;

    switch(op) {
       case PLUS : r = a + b; break;
       case MINUS : r = a - b; break;
       case MULT : r = a * b; break;
       case DIV : r = a / b; break;
       default  : System.out.println("Nieznany kod operacji");
    }

    return r;
  }
  
  public static void main(String[] args) {

    SimpleCalc sc = new SimpleCalc(1.2, 3.7);
    System.out.println( sc.makeOp(Op.PLUS));
    System.out.println( sc.makeOp(Op.MINUS));
    System.out.println( sc.makeOp(Op.MULT));
    System.out.println( sc.makeOp(Op.DIV));
  }

}

import javax.swing.*;

public class Test {

  public static void main(String[] args) {
    int i = Integer.parseInt(JOptionPane.showInputDialog("Liczba"));
    switch(i)    {
      case 1 : switch(testNum(i)) {
                    case 1 : System.out.println("same one"); break;
                    case 2 : System.out.println("double one"); break;
                    default: System.out.println("other one"); break;
                }
                break;
      case 2 :  System.out.println("two"); break;
      default:  System.out.println("other two"); break;
    }
    System.out.println("Koniec");
  }

 static int testNum(int n) {
   return n*2;
 }

}

    switch(i)    {
      case 1 : switch(testNum(i)) {
                 case 1 : System.out.println("same one"); break;
                 case 2 : System.out.println("double one"); break;
                 default: System.out.println("other one"); break;
               }
              // pominięte break
      case 2 :  System.out.println("two"); break;
      default:  System.out.println("other two"); break;
    }
    System.out.println("Koniec");

    outerSwitch:
    switch(i)    {
      case 1 : switch(testNum(i)) {
                 case 1 : System.out.println("same one"); break;
                 case 2 : System.out.println("double one");
                          break outerSwitch;
                 default: System.out.println("other one"); break;
               }

      case 2 :  System.out.println("two"); break;
      default:  System.out.println("other two"); break;
    }
    System.out.println("Koniec");

6. Operator warunkowy ?:

7. Wyjątki

7.1. Obsługa wyjątków

public class NoCatch {

  public static void main(String[] args) {
    int a = 1, b = 0, c = 0;
    c = a/b;
    System.out.println(c);
  }

}

public class Catch1 {

  public static void main(String[] args) {
    int a = 1, b = 0, c = 0;
    String wynik;
    try {
      c = a/b;
      wynik = "" + c;
    } catch (ArithmeticException exc) {
        wynik = "***";
    }
    System.out.println(wynik);
  }

}

  public static void main(String[] args) {

    String s1 = JOptionPane.showInputDialog("Podaj pierwszą liczbę");
    if (s1 != null) {
      String s2 = JOptionPane.showInputDialog("Podaj drugą liczbę");
      if (s2 != null) {
        int n1;
        int n2;
        try {
          n1 = Integer.parseInt(s1);
          n2 = Integer.parseInt(s2);
        } catch (NumberFormatException exc) {
            System.out.println("Błędne dane - kończę działanie");
            return;
        }
        JOptionPane.showMessageDialog(null, "Suma: " + (n1 + n2));
      }
    }
  }

import java.util.*;

class ReportExc {

  public ReportExc() {
    wykonaj();
  }

  public void wykonaj() {
    try {
      int num = Integer.parseInt("1aaa");
    } catch (NumberFormatException exc) {
        System.out.println("Co podaje getMessage()");
        System.out.println( exc.getMessage());
        System.out.println("Co podaje toString()");
        System.out.println(exc);
        System.out.println("Wydruk śladu stosu (kolejność wywołań metod)");
        exc.printStackTrace();
        System.exit(1);
    }
  }

  public static void main(String[] args) {
    new ReportExc();
  }

}

• albo ujęcie instrukcji, która może go spowodować w blok try-catch,
• albo przesunięcie obsługi do kodu, który wywołuje ten blok, w którym zawarta jest ta instrukcja.

public class ControlledExc {
  
  public void printWaitAndPrint() {
    System.out.println("Za 2 sekundy wypiszę następny tekst");
    Thread.sleep(2000);
    System.out.println("Następny tekst");
  }
  
  public static void main(String[] args) {
    new ControlledExc().printWaitAndPrint();
  }

}

  public void printWaitAndPrint() throws InterruptedException {
    System.out.println("Za 2 sekundy wypiszę następny tekst");
    Thread.sleep(2000);
    System.out.println("Następny tekst");
  }

  public static void main(String[] args) {
    new ControlledExc().printWaitAndPrint();
  }

public class ControlledExc {
  
  public void printWaitAndPrint() throws InterruptedException {
    System.out.println("Za 2 sekundy wypiszę następny tekst");
    Thread.sleep(2000);
    System.out.println("Następny tekst");
  }
  
  public static void main(String[] args) {
    try {
      new ControlledExc().printWaitAndPrint();
    } catch (InterruptedException exc) {
        exc.printStackTrace();
    }
  }

}

  try {
    // instrukcje wykonywane w bloku try
  } catch (TypWyj1 exc) {
    // obsluga wyjątku typu TypWyj1
  } catch (TypWyj2 exc) {
    // obsluga wyjątku typu TypWyj2
  }
  // ...
  } catch (TypWyjN exc) {
    // obsluga wyjatku typu TypWyjN
  } [ finally {                       
    // kod wykonywany niezaleznie do tego czy wyjatek powstał czy nie
  } ]

Uwaga: nawiasy kwadratowe wskazuję na opcjonalność klauzuli finally

import javax.swing.*;

public class StringCalc {
  
  public String sum(String s1, String s2) {
    int sum = 0,
        sumLen = 0;
    try {
      sum = Integer.parseInt(s1) + Integer.parseInt(s2);
      sumLen = s1.length() + s2.length();
    } catch(NullPointerException exc) {
        return "Któryś z napisów jest null";
    } catch (NumberFormatException exc) {
        return "Któryś z napisów nie jest liczbą";
    } catch (Exception exc) {
        return "Wystąpił jakis błąd";
    } finally {
        JOptionPane.showMessageDialog(null, "Jestem finally!");
    }
    return "Suma: " + sum + '\n' + "Suma długości: " + sumLen;
  }

  public static void main(String[] args) {
    String s1 = JOptionPane.showInputDialog("Podaj pierwszą liczbę");
    String s2 = JOptionPane.showInputDialog("Podaj drugą liczbę");
    StringCalc calc = new StringCalc();
    JOptionPane.showMessageDialog(null, calc.sum(s1, s2));
  }
  
}

7.2. Zgłaszanie wyjątków

public class Account {
 // ...
 private double balance;
 // ... 
 
 public void withdraw(double d) {
    if (d <= 0) throw new IllegalArgumentException("Withdrawal should be > 0");
    if (balance - d < 0)
      throw new IllegalArgumentException("Withdrawal exceeding balance not allowed");
    balance -= d;
  }

• gdy jakaś nasza metoda może zgłosić kontrolowany wyjątek klasy NaszWyj -- musi podać w deklaracji, w klauzuli throws klasę zgłaszanego wyjątku lub dowolną jej nadklasę 
• void naszaMetoda() throws NaszWyj
• nasza metoda sprawdza warunki powstania błędu
• jeśli jest błąd - tworzy wyjątek (new NaszWyj(...)) i sygnalizuje go za pomocą instrukcji throw :
• throw new NaszWyj(ew_param_konstruktora_z_info_o_błędzie)

public class AccountException extends Exception {

  public AccountException() {
  }

  public AccountException(String msg) {
    super(msg);
  }

}

  public void withdraw(double d) throws AccountException  {
    if (d < 0) throw new AccountException("Withdrawal should be >= 0");
    if (balance - d < 0)
      throw new AccountException(
                "Withdrawal exceeding balance not allowed");
    balance -= d;
  }

8. Podsumowanie