Zmienne¶

Zmienne w programowaniu służą do przechowywania wartości.
Zanim będziemy mogli użyć zmiennej, musimy ją zdefiniować.
Definicja zmiennej to poinformowanie kompilatora, jaką zmienna będzie miała nazwę oraz typ.
Definicja zmiennej odbywa się poprzez podanie typu zmiennej, po którym następuje jej nazwa i średnik – możemy też zdefiniować więcej, niż jedną zmienną na raz:
```
  
int promienKola;
int x, y;
```
Zmienna może zostać zainicjalizowana wstępną wartością – pomiędzy nazwą zmiennej a średnikiem należy wtedy wpisać znak równości oraz wartość, którą chcemy nadać zmiennej:
```
int promienKola = 8;
```
Aby zmienić wartość zmiennej, piszemy jej nazwę, znak równości, oraz nową wartość:
```
double poleKola;
poleKola = 3.14 * promienKola * promienKola;
```
Wartości zmiennych możemy wypisać na ekran za pomocą instrukcji System.out.println:
```
System.out.println(poleKola);
```
Wypisując komunikaty na ekran, możemy łączyć ze sobą łańcuchy tekstowe i inne wartości:
```
System.out.println("Pole kola wynosi: " + poleKola);
```

Zanim użyjemy zmiennej, musimy jej nadać wartość – w przeciwny razie, próba kompilacji naszego programu zakończy się błędem:

public class UzycieNiezainicjalizowanejZmiennej {
  public static void main(String[] args) {
    int x;

    // blad! nie nadalismy zmiennej x jeszcze zadnej wartosci
    System.out.println("Wartosc x wynosi: " + x);
  }
}

Nazwy¶

Nazwy w języku Java muszą spełniać następujący wymagania:
- muszą zaczynać się od litery, podkreślenia _ bądź znaku dolara $
- kolejnymi znakami, poza tym wymienionymi w punkcie 1., mogą być także cyfry,
- nie mogą być takie same, jak nazwy zastrzeżone w języku Java (np. class, public, void itd.).

Przykłady poprawnych nazw zmiennych:

char jedenZnak;
double poleKola;
int liczba_pracownikow;
double _pi;
int $wynagrodzenieMiesieczne;
double wynikWRozliczeniu360;

Przykłady niepoprawnych nazw zmiennych:

// kazda z ponizszych nazw jest niepoprawna i spowoduje blad kompilacji
double 314ToLiczbaPi; // nazwa nie moze zaczynac sie od liczby
double promien kola; // spacja w nazwie jest niedozwolona
int liczba#pracownikow; // znak # nie może wystapic w nazwie
int public; // public to slowo kluczowe w jezyku Java

Małe i wielkie litery są rozróżniane w nazwach zmiennych – poniżej zdefiniowane zostały dwie różne zmienne:
```
double pi = 3.14;
double PI = 3.14;
```
Długość zmiennych może być dowolna.
Nazwy w kodach źródłowych niosą bardzo dużo informacji, o ile są one odpowiednio dobrane do obiektów, które opisują.
Przy nazywaniu zmiennych i innych obiektów należy:
- Używać dobrze dobranych, opisowych nazw, tak, aby zwiększały one czytelność kodu. Zawsze warto zastanowić się nad nazwą.
- Stosować konwencję Camel-Case – wielka litera powinna rozpoczynać każde słowo w nazwie, poczynając od drugiego słowa, np. poleKola bądź glownyTelefonKontaktowy.

Typy¶

Typ zmiennej to informacja, jakiego rodzaju wartości zmienna będzie mogła przechowywać.
Typy prymitywne to typy udostępniane przez dany język programowania. Java posiada 8 typów prymitywnych:
- boolean – typ logiczny, przyjmujący wartość true bądź false,
- byte, short, int, long – typy przechowujące liczby całkowite,
- float, double – typy przechowujące liczby rzeczywiste,
- char – typ przechowujący znaki.
Różne typy przechowujące dane tego samego rodzaju mają różne zakresy wartości, jakie mogą przyjmować kosztem większego miejsca potrzebnego na ich przechowywanie w pamięci komputera.
Typ prymitywny określa nie tylko, jakiego rodzaju wartości zmienna może przechowywać, ale także jaki jest zakres tych wartości – dla przykładu, typ byte oznacza, że zmienna będzie mogła przechowywać wartości od -128 do 127.
Język Java jest językiem typowanym, co oznacza, że zmienne mają typ określony przy ich definiowaniu przez programistę i nie może się on zmienić w trakcie wykonywania programu:
```
int liczbaOkien;

// blad! zmienna liczbaOkien moze przechowywac tylko liczby calkowite!
liczbaOkien = 3.5;
```
Liczby takie jak 10, 3.14, znaki, jak np. 'A', 'N', tekst ujęty w cudzysłowy np. "Witaj Swiecie!" oraz wartości logiczne true i false, to tzw. literały. Zapisane w kodzie źródłowym oznaczają konkretne wartości, zazwyczaj, typów prymitywnych.
Literały liczbowe zapisane w kodzie są domyślnie traktowane jako liczby typu int. Domyślnym typem wartości rzeczywistych (zmiennoprzecinkowych) jest typ double.
Jeżeli chcemy zapisać w kodzie wartość większą, niż maksymalna liczba z zakresu typu int (czyli 2147483647), to musimy na końcu liczby dodać literę L (od typu long), na przykład 10000000000L – w przeciwnym razie kompilator zaprotestuje.

Stałe¶

Stałe mają za zadanie przechowywać raz im nadaną, niezmienną wartość.
Stałe definiujemy tak jak zmienne, z dodatkiem słowa kluczowego final przed typem stałej.
Zgodnie z konwencją, nazwy stałych powinny być zapisane wielkimi literami, a kolejne słowa, z których ich nazwa się składa, powinny być oddzielone od siebie znakiem podkreślenia ( _ ), np. LICZBA_DNI_W_TYGODNIU.
Próba zmiany wartości stałej powoduje błąd na etapie kompilacji:
```
final double PI = 3.14;

// blad kompilacji!
PI = 5;
```

Operatory¶

Operatory służą do wykonywania pewnych operacji. Do dyspozycji mamy m. in. operatory arytmetyczne i przypisania.
Argumenty operatorów, czyli wartości, na których operują, nazywamy operandami.
Operatory mają różne priorytety – nawiasy mogą zostać użyte do zmiany kolejności działania operatorów.
Podstawowe operatory arytmetyczne to:
- + dodawanie
- - odejmowanie
- * mnożenie
- / dzielenie całkowite,
- % modulo – reszta z dzielenia.
Operator dzielenia wykonuje dzielenie całkowite, jeżeli oba jego operandy są typu całkowitego, tzn. zwraca zaokrągloną w dół wartość całkowitą. Jeżeli któryś z operandów jest typu rzeczywistego, wynik także będzie wartością rzeczywistą.
Rzutowanie typów, czyli konwersję wartości jednego typu na inny, wykonuje się za pomocą składni (typ)wartosc, np. (double)zmiennaTypuCalkowitego:
```
System.out.println(10 / 4); // wypisze 2 – dzielenie calkowite
System.out.println((double)10 / 4); // wypisze 2.5
```

Operator przypisania nadaje zmiennym wartość:

  
int bokKwadratu = 5;
int poleKwadratu = bokKwadratu *  bokKwadratu;

Dostępne są też skrótowe operatory += *= -= i inne, które wykonują operację na zmiennej i przypisują jej wartość:
```
// rownoznaczne z bokKwadratu = bokKwadratu + 10
bokKwadratu += 10; // zwieksza bokKwadratu o 10
```
Do dyspozycji mamy także jednoargumentowe operatory inkrementacji i dekrementacji:
- ++ prefixowy i postfixowy – zwiększa wartość zmiennej o 1,
- --prefixowy i postfixowy – zmniejsza wartość zmiennej o 1,

Operatory prefixowe różnią się tym od postfixowych, że wartość zmiennej jest zwracana przed lub po zmianie wartości:

x = 0;
y = x++;
System.out.println("x = " + x + ", y = " + y); // wypisze x = 1, y = 0

x = 0;
y = ++x;
System.out.println("x = " + x + ", y = " + y); // wypisze x = 1, y = 1

Operatory przypisania oraz operatory inkrementacji i dekrementacji zawsze wymagają zmiennej. Próba zapisu 5 = 10 lub 20++ spowoduje błąd kompilacji.

Typ String i wczytywanie danych od użytkownika¶

String to typ złożony, który służy do przechowywania ciągu znaków.

Stringi można łączyć za pomocą operatora +

String imie = "Jan";
String nazwisko = "Nowak";

String osoba = imie + " " + nazwisko;

int wiek = 25;
String komunikat = osoba + " ma " + wiek + " lat.";

String udostępnia wiele przydatnych metod, które operują na łańcuchach znaków, na przykład toUpperCase, która zamienia małe litery na wielkie:
```
String powitanie = "Witajcie!";
powitanie = powitanie.toUpperCase();

System.out.println(powitanie); // wypisze WITAJCIE!
```

Poznaliśmy sposób na wczytywanie od użytkownika liczb oraz słów:

import java.util.Scanner;

public class PobieranieDanychOdUzytkownika {
  public static void main(String[] args) {
    // przyklad wczytywania boku kwadratu
    System.out.println("Prosze podac bok kwadratu:");

    int bokKwadratu = getInt();
    System.out.println(
      "Pole tego kwadratu wynosi " + (bokKwadratu * bokKwadratu));
  }

  public static int getInt() {
    return new Scanner(System.in).nextInt();
  }

  public static String getString() {
    return new Scanner(System.in).next();
  }
}

Aby wykorzystać wczytywanie danych od użytkownika, należy skopiować do swojego programu kod podświetlony na niebiesko powyżej.
Aby pobrać od użytkownika wartość, zdefiniuj zmienną, a następnie skorzystaj ze składni:
- jeżeli chcesz pobrać liczbę: zmiennaLiczbowa = getInt();
- jeżeli chcesz pobrać słowo: zmiennaString = getString();
Zdefiniowana powyżej metoda getString pobiera pierwsze słowo wpisane przez użytkownika.

Rozdział 3 - Zmienne - Podsumowanie