Typy danych. Operatory i wyrażenia

1. Literały i zmienne

111

System.out.println(1000 + 100);
System.out.println(1000 + 100 - 50);
System.out.println(1000 + 100 - 50 + 200);

// ...
skonta = 1000; // zmienna skonta reprezentuje aktualny stan konta; poczatkowo 1000

skonta = skonta + 100; // po wpłacie stan konta ulega zmianie; teraz zmienna skonta ma wartość 1100
// ...
skonta = skonta - 50; // a teraz 1050 (po wypłacie)
// ...
skonta = skonta + 200; // po ostatniej wpłacie stan konta wynosi 1250
// ...
System.out.println(konto); // możemy go wypisać na konsoli, wyprowadzając wartość zmiennej skonta

2. Pojęcie typu. Typy proste

• dodawanie (operator +),
• mnożenie (operator *),
• odejmowanie (operator -),
• dzielenie (/),
• reszta z dzielenia (operator %)
• zwiększanie o 1 (operator ++)
• oraz zmniejszanie o 1 (--).

3. Typy i użycie literałów

a = b;

a = 'b';

x = if;

• każda liczba całkowita zapisana literalnie (np. 100) traktowana jest jako liczba typu int.
• każda liczba rzeczywista zapisana literalnie (z kropką dziesiętną - np. 1.2, albo w notacji naukowej np. 1e+9) traktowana jest jako liczba typu double,
• każdy literał znakowy (znak w apostrofach) jest typu char
• każdy napis true lub false jest literałem logicznym (typ boolean); słowa true i false są słowami zarezerwowanymi języka.
  

• użycie litery L lub l jako przyrostka liczby całkowitej sprawia, że liczba ta będzie traktowana jako typu long (np. 3L - będzie literałem typu long)
• użycie f lub F spowoduje, że liczba rzeczywista będzie traktowana jako typu float (np. 0.3f)
  

• w systemie dziesiętnym - w naturalny sposób (np. 3 lub 121),
• w systemie ósemkowym - poprzez poprzedzenie liczby znakiem 0 (np. 03),
• w systemie szesnastkowym - poprzez poprzedzenie liczby znakami 0x lub 0X (np. 0x1a, 0X11, 0xFF - zwróćmy uwagę, że cyfry szesnastkowe powyżej 9 mogą być zapisywane dużymi lub małymi literami)

public class LitLicz {

 public static void main(String[] args) {

 System.out.println( 10 + 0x10 );
 System.out.println( 10/3 );
 System.out.println( 10./3 );
 System.out.println( 10d/3);
 System.out.println( 2147483648L );
 System.out.println( 2147483647 + 1 );
 System.out.println( 2147483647L + 1 );

 }
}

• Operacje na liczbach rzeczywistych są niedokładne.
• W wyrażeniach podanych w programie wystarczyło zmodyfikować tylko jeden z literałów biorących udział w operacji, by otrzymać pożądany wynik(nie pisaliśmy 10d/3d, wystarczyło napisac 10d/3). Intuicyjnie możemy to rozumieć w ten sposób, że typ wyniku operacji określany jest przez "większy" (określający większe możliwe wartości) z typów biorących w niej udział argumentów (w tym przypadku literałów).

• literał znakowy - w apostrofach - to zawsze jeden znak,
• literał łańcuchowy - w cudzysłowie - to zero lub dowolna liczba znaków; jeśli w cudzysłowie nie podamy żadnego znaku - to mamy pusty łańcuch znakowy

public class LitZn {

 public static void main(String[] args) {
 System.out.print("\u03b1\u03b2\u03b3 ");
 System.out.print('\\');
 System.out.print('\'');
 System.out.print(" alfa beta gamma '");
 System.out.println("\nalfa\nbeta\ngamma");
 System.out.println("c:\\util\\bak");
 }
}

• '\u03b1' oznacza (heksadecymalnie) kod znaku 'α' (alfa - z alfabetu greckiego), inne kody w tym wierszu programu odpowiadają literom beta i gamma,
• znak apostrofu i lewy ukośnik w literale znakowym oznaczamy \' i \\
• znaki specjalne zupełnie naturalnie wstawiamy do łańcuchów znakowych: w napise "\nalfa\nbeta\ngamma" \n oznacza znak nowego wiersza, wobec tego napisy zostaną wyprowadzone w kolejnych wierszach,
• aby wyprowadzić napis zawierający ukośniki musieliśmy je w tym napisie powtarzać .

4. Typy zmiennych. Deklaracje

public class CompPrice {

 public static void main(String[] args) {

 int cProc = 700; // cena procesora
 int cPly = 500; // ... płyty
 int cPam = 300; // innych składnikow ...
 int cDysk = 400;
 int cInn = 500;

 final double VAT = 1.22; // narzut podatku VAT

 // Liczymy cenę komputera bez monitora
 // wyrażenie sumujące składniki zapisując
 // jako wyrażenie inicjującę zmienną cKomp

 double cKomp = (cProc + cPly + cPam + cDysk + cInn) * VAT;

 System.out.println("Cena komputera bez monitora wynosi :");
 System.out.println(cKomp);

 int cMon = 1100; // cena monitora netto
 cKomp = cKomp + cMon * VAT; // i nowa cena komputera z monitorem

 System.out.println("Cena komputera z monitorem wynosi :");
 System.out.println(cKomp);

 }
}

 cMon = 1100; // cena monitora netto
 cKomp = cKomp + cMon * VAT; // i nowa cena komoutera z monitorem

5. Operatory i wyrażenia

5.1. Przegląd

5.2. Operatory przypisania

5.3. Zwiększanie i zmniejszanie

• przyrostkowej (operator po argumencie - zmiennej)
• przedrostkowej (operator przed argumentem - zmienną)
  

• ++ zwiększa, a -- zmniejsza o jeden wartość argumentu (zmiennej),
• przyrostkowa forma operatorów (znak operatora po argumencie) modyfikuje wartość argumentu po jej wykorzystaniu w wyrażeniu, przedrostkowa (znak operatora przed argumentem) - przed wykorzystaniem tej wartości.

public class Express1 {

 public static void main(String[] args) {

 int a = 1, b = 2, c = 3;
 a = b = c * 1 + 2;
 System.out.println("a=" + a + " b=" + b + " c=" + c);
 a = b = c * (1 + 2);
 System.out.println("a=" + a + " b=" + b + " c=" + c);
 a = b++;
 System.out.println("a=" + a + " b=" + b + " c=" + c);
 c = --b;
 System.out.println("a=" + a + " b=" + b + " c=" + c);
 a++;
 b++;
 c++;
 System.out.println("a=" + a + " b=" + b + " c=" + c);

 a = b++*++c;
 System.out.println("a=" + a + " b=" + b + " c=" + c);

 int DlugaNazwaZmiennej = 20;
 DlugaNazwaZmiennej = DlugaNazwaZmiennej * 10;
 DlugaNazwaZmiennej *= 10;
 System.out.println( DlugaNazwaZmiennej );

 }
}

5.4. Dzielenie całkowite i reszta

public class Klocki {
 
  public static void main(String[] args) {

    int n = 41;         // liczba klocków

    int s = 7;          // ile klocków mieści się w pojemniku
                        // jezeli wszystkie pojemniki sa pelne pokazuje 
                        // również ile jest klockow w ostatnim z nich
                        // wykorzystamy te zmienną do pokazania
                        // ile jest klocków w ostatnim pojemniku
                         
    int poj  = n/s;     // liczba pojemników; inicjalnie - pełnych
    int rest = n%s;     // reszta z dzielenia pokazuje 
                        // czy mamy dodatkowy pojemnik 
                        // i ile jest w nim klocków

    if (rest != 0) {    // jeżeli jest dodatkowy pojemnik
       poj++;           // liczba pojemników zwiekszona o dodatkowy
       s = rest;        // zmieniamy wartosc s - ostatni pojemnik niepelny!
    }
    
    System.out.println("Liczba pojemnikow        : " + poj); 
    System.out.println("Liczba klockow w ostatnim: " + s);
  }

}

• instrukcja if służy do sprawdzania warunków, jeśli warunek w nawiasach okrągłych jest prawdziwy, to jest wykonywana instrukcja zapisana po zamykającym nawiasie okrągłym,
• instrukcja grupująca { ... } służy do grupowania instrukcji - ujęte w nawiasy klamrowe traktowane są jako jedna instrukcja, co wykorzystujemy w if 
  
• operator "czy nie równe" zapisujemy w Javie jako !=
• operator "czy równe" zapisujemy jako ==
• zauważmy, że priorytet operatora % jest wyższy niż operatorów == i !=, dlatego w if nie musieliśmy stosować dodatkowych nawiasów.

6. Konwersje arytmetyczne

public class Char {

 public static void main(String[] args) {

 char c = 'a';
 int kod = c;
 System.out.println("Kod znaku " + c + " = " + kod);
 kod = 77;
 c = (char) kod;
 System.out.println("Kod znaku " + c + " = " + kod);

 // Czasem trzeba użyć jawnej konwersji rozszerzającej
 System.out.println("Kod znaku " + '*' + " = " + (int) '*');

 // Oczywiście - zawężające zawsze trzeba podawać jawnie
 System.out.println("Kod znaku " + (char) 66 + " = " + 66);

 }

}

7. Podsumowanie

• pojęcie literału i zmiennej,
  
• pojęcie typu danych,
• rodzaje typów danych w Javie (w tym szczegółowo tzw. typy proste),
• literały,
• deklaracje zmiennych,
• pojęcie identyfikatora i konwencje nazewnicze Javy,
  
• podstawowe operatory (w tym szczegółowo operatory arytmetyczne),
• pojęcie wyrażenia oraz priorytety i wiązania operatorów,
• konwersje arytmetyczne.