Rozdział 3 - Zmienne - Podsumowanie

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łą 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 potrzebowanego 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 ikrementacji 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.

Dodaj komentarz

Twój adres email nie zostanie opublikowany. Nie musisz podawać swojego imienia, e-mailu, ani strony www, aby opublikować komentarz. Komentarze muszą zostać zatwierdzone, aby były widoczne na stronie.