Wykład 2

Wykład 3: Sterowanie
1.wprowadzenie
8.obsługa błędów
2.podstawy języka
9.kolekcje obiektów
3.sterowanie
10.wejście i wyjście
4.inicjacja i sprzątanie
11.równoległość
5.kontrola dostępu
12.interfejs graficzny
6.dziedziczenie
13.programy sieciowe
7.polimorfizm
14.obsługa baz danych
15.obsługa serwerów
Wykład 3: Zagadnienia
Manipulacja danych i kontrola sterowania:
operatory w Javie
● instrukcje sterowania wykonaniem
●
Konstrukcje wzorowane na C++.
Operatory
1.przypisania
7.bitowe
2.matematyczne
8.przesunięcia
3.zwiększania
9.if-else
4.zmniejszania
10.przecinek
5.relacji
11.łańcuchowy plus
6.logiczne
12.rzutowania
Operatory: Obliczenie
Operator pobiera jeden lub więcej argumentów i
zwraca wynik obliczony na ich podstawie.
Obliczenie przez operator:
s + “ i spolka”
Obliczenie przez wywołanie metody:
s.concat(“ i spolka”)
Operatory: Efekt Uboczny
Operator może zmienić wartość swych argumentów.
s = new String(“test”);
Nazywane to jest efektem ubocznym.
Operatory: Stosowanie
Typy podstawowe
i + 2
Wszystkie obiekty
o1=o2, o1==o2, o1!=o2
String
s+” i spolka”, s+=” i spolka”
Operatory Przypisania
Przypisanie
zmienna = wartosc;
Weź wartość i skopiuj ją do zmiennej.
Wartość może być:
stałą
– zmienną
– wyrażeniem
–
Przypisanie: Typy Podstawowe
Przypisanie typów podstawowych:
int a;
int b;
a = b;
Następuje proste kopiowanie zawartości.
Przypisanie Obiektów
Powoduje kopiowanie odwołań:
class Number { int i; }
Number n1 = new Number();
Number n2 = new Number();
n1.i = 9; // n1.i==9
n1 = n2;
n2.i = 10; // n1.i==10
Wywołanie Metod
Podobny efekt daje wywołanie metody:
class Number { int i; }
static void f(Number n) { n.i = 1; }
Number m = new Number();
m.i = 2; //m.i==2
f(m);
//m.i==1
Operatory Matematyczne
Działania arytmetyczne: dodawanie,
odejmowanie, dzielenie, mnożenie,
modulo.
Zapis skrócony, operatory unarne:
x = x + 2;
x += 2;
x = -2;
x = x – 2;
x -= 2;
x = +2;
x = x / 2;
x /= 2;
x = x * 2;
x *= 2;
x = x % 2;
x %= 2;
Operatory Zwiększania
pre-incrementacja: operacja potem wynik
int i = 2;
j = ++i;
// i==3 && j==3
post-incrementacja: wynik potem operacja
int i = 2;
j = i++;
// i==3 && j==2
Operatory Zmniejszania
pre-decrementacja: operacja potem wynik
int i = 2;
j = --i;
// i==1 && j==1
post-decrementacja: wynik potem operacja
int i = 2;
j = i--;
// i==1 && j==2
Operatory Relacji
Operatory relacji służą porównaniu
wartości operandów. Zwracają boolean.
x < 2
x > 2
x <= 2
x >= 2
x == 2
x != 2
Równość Obiektów: Odwołania
Porównanie dwóch obiektów to
porównanie odwołań do nich.
Integer n1 = new Integer(2);
Integer n2 = new Integer(2);
System.out.println(n1 == n2);//false
System.out.println(n1 != n2);//true
Równość Obiektów: Wartość
Porównanie wartości dwóch obiektów:
Integer n1 = new Integer(2);
Integer n2 = new Integer(2);
System.out.println(n1.equals(n2));
equals() zdefiniowana jest dla
wszystkich obiektów, ale nie dla typów
podstawowych.
Równość Obiektów: Wartość
Porównanie wartości dwóch obiektów:
class Value {
int i;
public boolean equals(Value v) {
i == v.i
}
}
Value n1 = new Value(2);
Value n2 = new Value(2);
System.out.println(n1.equals(n2));
Operatory Logiczne
Koniunkcja, alternatywa, negacja.
boolean b = true;
int i = 2;
b && (i > 2) //false
b || (i > 2) //true
!(i >= 2)
//false
Tylko do argumentów typu logicznego.
Skracanie Obliczenia
Ustalenie wartości operacji logicznej tylko
na podstawie pierwszego argumentu.
boolean b1 = false;
int i = 2;
b && ((i = 1) > 0) //false, i == 2
!b || ((i = 1) > 0)//true, i == 2
Operatory Bitowe
Manipulowanie pojedynczymi bitami
argumentów całkowitych.
int i = 1;
i & 5 // 0001 & 0101 == 0001 == 1
i | 6 // 0001 | 0110 == 0111 == 7
i ^ 3 // 0001 ^ 0011 == 0010 == 2
~i
// ~0001 == 11...10
Operatory Przesunięcia
Przesunięcie operatora po lewej stronie przez liczbę
bitów daną przez operator po prawej.
int i = 2;
i << 2
// 0010 << 2 == 1000 == 8
i >> 1
// 0010 >> 1 == 0001 == 1
-i >> 1 // 0010 >> 1 == 1...1
Przesunięcie w prawo używa rozszerzania znaku:
0 wstawiane dla dodatniej liczby, 1 dla ujemnej.
Operator if-else
Operator 3-argumentowy:
test? wartosc0 : wartosc1
Co łatwiejsze?
static int ternary(int i) {
return i < 10 ? i*100 : i*10;
}
static int ternary(int i) {
if (i < 10) return *100
else return i*10
}
Operator Przecinek
Operator do przetwarzania sekwencyjnego.
Używany tylko w instrukcji for:
for (i=1, j=i+10; j<5; i++, j=i*2) {
System.out.println(i + j);
}
Operator Łańcuchowy Plus
Wyłamuje się z ogólnej zasady że
operatory nie możne w Javie przeciążać.
int x = 0, y = 1, z = 2;
String s = “x, y, z”;
System.out.println(s + x + y + z);
System.out.println(x + y + z + s);
Jeśli wyrażenie zaczyna się łańcuchem, to
pozostałe też muszą być łańcuchami.
Operatory Rzutowania
Automatyczna zamiana typu na inny:
int i = 1;
float v = i;
Rzutowanie to wymuszenie takiej
konwersji:
int i = 1;
long l1 = (long)i;
long l2 = (long)200;
Rzutowanie: Konwersja
Konwersja zawężająca: utrata informacji,
bezpośrednie rzutowanie niezbędne.
float v = 1.5;
int i = (int)v;
Konwersja rozszerzająca: więcej
informacji, rzutowanie nie jest konieczne.
int i = 1;
float v = i;
Rzutowanie: Ograniczenia
Można rzutować każdy typ podstawowy na
inny, oprócz boolean.
Typów klas rzutować nie można, oprócz
String.
Literały
Jakie są typy stałych?
char c = 0xfff;
//szestnastkowo
int i = 0177;
//ósemkowo
long n = 200l
//long
float v = 1.5f
//float
double d = 47e47d //double
Domyślnie stałe zmienno-pozycyjne są
double, wiec f może być niezbędne.
Promocja Typu
Operacja na danych mniejszych niż int:
–
promocja argumentów to typu int
–
wynik typu int
Największy typ danych w wyrażeniu
określa rozmiar wyniku wyrażenia.
Należy rzutować jak to nie odpowiada.
Kolejności Operatorów
jedno-argumentowe
+ - ++ --
arytmetyczne
* / % + - << >>
relacyjne
> < <= >= == !=
logiczne i bitowe
&& || & | ^
warunkowy
A > B ? X : Y
przypisania
= += -= *= /= %=
Przegląd Metod Sterowania
1.if-else
2.return
3.iteracja
4.do-while
5.for
6.break i continue
7.switch
Sterowanie: If-else
Postać z jednym wyborem:
if (wyrażenie-logiczne) instrukcja
Postać z dwoma wyborami:
if (wyrażenie-logiczne) instrukcja
else instrukcja
Sterowanie: If-else
wyrażenie-logiczne
zwraca wartość logiczną
instrukcja
prosta instrukcja zakończona
średnikiem
złożona instrukcja w nawiasach {...}
Sterowanie: If-else
static int test(int val, int zakres); {
int wynik = 0;
if (val > zakres) wynik = 1;
else if (val < zakres) wynik = -1;
else wynik = 0;
return wynik;
}
Sterowanie: Return
Dwie funkcje:
ustala jaka wartość jest zwracana
przez metodę
– powoduje że wartość jest zwracana
natychmiast
–
Sterowanie: Return
static int test(int val, int zakres); {
if (val > zakres) return 1;
else if (val < zakres) return -1;
else return 0;
}
Sterowanie: Iteracja
Instrukcje iteracji:
– while
– do-while
– for
Sterowanie: While
Instrukcja jest powtarzana dopóki
wyrażenie logiczne jest prawdziwe:
while (wyrażenie-logiczne)
instrukcja
Wyrażenie logiczne jest obliczane przed
rozpoczęciem pętli, i przed każda iteracją.
Sterowanie: While
public static void main(String[] args) {
double r = 0;
while (r < 0.99d) {
r = Math.random();
System.out.println(r);
}
}
Math.random() generuje liczbę losową
double pomiędzy 0 i 1 (wyłącznie).
Sterowanie: Do-While
Wyrażenie jest obliczane po pętli:
instrukcja wykonuje się co najmniej raz.
do
instrukcja
while (wyrażenie-logiczne);
Sterowanie: For
Inicjacja na początek, test warunku przed
iteracją, wykonanie kroku po iteracji.
for (inicjacja; test; krok)
instrukcja
Możliwość deklaracji zmiennych w
instrukcji.
Sterowanie: For
public static void main(String[] args) {
for (int i = 0; i < 128; i++)
if (Character.isLowerCase((char)i))
System.out.println((char)i);
}
Sterowanie: Break i Continue
Wewnątrz każdej instrukcji iteracji:
break wychodzi z pętli, pomijając
resztę instrukcji
– continue przerywa wykonanie
aktualnej iteracji i zaczyna następną
–
Sterowanie: Break i Continue
public static void main(String[] args) {
for (int i = 0; i < 100; i++) {
if (i == 74) break;
if (i % 9 != 0) continue;
System.out.println(i);
}
}
Sterowanie: Etykiety
Java nie posiada instrukcji goto.
Posiada etykiety przed instrukcjami
iteracji, oraz etykietowane wersje break i
continue.
Sterowanie: Etykiety
public static void main(String[] args) {
int i = 0;
zewnetrzny: for (; true; )
wewnetrzny: for (; i<10 ; i++) {
if (i==5) break zewnetrzny;
if (i==2) continue wewnetrzny;
}
}
Sterowanie: Switch
Instrukcja wielokrotnego wyboru:
switch(wybor) {
case wartosc1: instrukcja;break;
case wartosc2: instrukcja;break;
case wartosc3: instrukcja;break;
...
default: instrukcja;
}
Sterowanie: Switch
Instrukcja porównuje wynik wyrażenia
wybór z każdą ze stałych wartość:
jeśli jest przypadek zgodny z
wartością, wykonuje się odpowiednia
instrukcja
– jeżeli nie istnieje taki przypadek,
wykonuje się instrukcja default.
–
Switch: Ograniczenia
Jeśli instrukcja nie kończy się przez
break, to wykonują się kolejne przypadki.
Wyrażenie wyboru w switch musi być
typu int lub char.
Instrukcje: Switch
public static void main(String[] args) {
char c = (char)(Math.random()*26+'a');
System.out.print(c + “: “);
switch(c) {
case 'a':
case 'e':
case 'i':
case 'o':
Instrukcje: Switch
case 'u':
System.out.println(“samogloska”);
break;
default:
System.out.println(“spolgloska”);
}
}