Teoria zmiennych

src/main/java/p01_zmienne/OddzielneBloki.java

+package p01_zmienne;
+
+public class OddzielneBloki {
+
+    public static void main(String[] args) {
+   	 // Blok kodu to fragment otoczony {nawiasami klamrowymi}
+   	 {
+   		 int x = 100;
+   		 System.out.println(x);
+   		 x += 5;
+   		 System.out.println(x);   		 
+   		 System.out.println(10 * x);
+   	 }
+   	 // po wyjściu z bloku zmienna x jest niedostępna
+   	 //System.out.println(x);
+   	 
+   	 // w kolejnym bloku można znowu stworzyć zmienną x, nawet innego typu
+   	 {
+   		 String x = "Alicja ma kocura";
+   		 System.out.println(x);
+   		 // System.out.println(10 * x);
+   		 System.out.println(x.toUpperCase());
+   	 }
+    }
+
+}
+
+

src/main/java/p01_zmienne/Var.java

+package p01_zmienne;
+
+import java.time.LocalTime;
+import java.util.List;
+
+public class Var {
+
+    public static void main(String[] args) {
+        // auto y = 123; // C++
+
+        // Od Java 10 można nie pisać, jakiego typu jest zmienna, tylko podczas deklaracji użyć słowa var.
+        // Ale uwaga, to działa tylko pod pewnymi warunkami.
+        var x = 1000;
+        System.out.println(x);
+        x++;
+        System.out.println(x);
+        
+        // Teraz x jest typu int. O wybranym typie decyduje wartość wpisana podczas deklaracji.
+        // Można wpisać inną wartość typu int:
+        x = 5432;
+        System.out.println(x);
+        
+        // Ale nie można wpisać wartości innego typu
+        // x = "Ala ma kota";
+        // System.out.println(x);
+        
+        // var nie można używać bez wpisania wartości, nie używa się dla deklarowania pól w klasach.
+        //ERR var niewiemco;
+        
+        // Namiastką zmiennej, do której można wpisać wszystko (jak w Pythonie lub PHP),
+        // w Javie jest typ Object
+        Object o;
+        o = "Ola ma psa";
+        System.out.println(o + " , obiekt klasy " + o.getClass().getSimpleName());
+        o = LocalTime.now();
+        System.out.println(o + " , obiekt klasy " + o.getClass().getSimpleName());
+        o = List.of("Ala", "Ola", "Ela");
+        System.out.println(o + " , obiekt klasy " + o.getClass().getSimpleName());
+        o = 1234;
+        System.out.println(o + " , obiekt klasy " + o.getClass().getSimpleName());
+        o = 3.14;
+        System.out.println(o + " , obiekt klasy " + o.getClass().getSimpleName());
+        
+        // wyjaśnienie: do tej zmiennej zawsze wpisywane będą obiekty
+        // np. zamiast int jest wpisywany obiekt Integer. Jest to mniej wydajne niż int,
+        // ale w działaniu wydaje się, że do o wpisaliśmy liczbę.
+    }
+
+}

src/main/java/p01_zmienne/Zmienne.java

+package p01_zmienne;
+
+public class Zmienne {
+
+	public static void main(String[] args) {
+		// Zmienna to jest takie miejsce w pamięci, w którym można coś zapamiętać.
+		// Inaczej, niż np. w Pythonie, w Javie zmienną trzeba zadeklarować.
+		
+		// Deklaracja zmiennych x oraz y o typie int (liczba całkowita):
+		int x, y;
+		
+		// Teraz do zmiennej można wpisać wartość:
+		x = 101;
+		// można też wartość zmiennej odczytać:
+		System.out.println(x);
+		
+		// W Javie nie można odczytywać zmiennych lokalnych, jeśli nie zostały zainicjowane:
+		//ERR System.out.println(y);
+		y = 2*x;
+		System.out.println(y);
+
+		// Bardzo często w Javie w jednej linii deklaruje się zmienną i od razu wpisuje początkową wartośc:
+		int z = x + y - 300;
+		System.out.println(z);
+		
+		// Zmienne mogą się zmieniać:
+		z = 505;
+		System.out.println(z);
+		
+		// Istnieją specjalne operatory jak += -= *= /= %= &= ......
+		// które powodują zmianę wartości zmiennej:
+		x += 20; // x = x + 20, czyli x będzie równy 101 + 20 = 121;
+		// Nie mylić z =+ , bo to by znaczyło "do x wpisz liczbę +20"
+		System.out.println(x);
+		x *= 3;  // x = x * 3, czyli x = 121 * 3 = 363
+		System.out.println(x);
+		
+		// błędem jest wpisanie wartości do zmiennej, która nie istnieje
+		//ERR liczba = 1234; // poprawne w Pythonie, niepoprawne w Javie
+		
+		// ale błędem jest także ponowna deklaracja zmiennej:
+		// int x = 999;
+		// double x = 3.14;
+		
+		// gdy chcemy tylko wpisać wartość, to nie powtarza się już typu zmiennej:
+		x = 888;
+		System.out.println(x);
+		
+		// do zmiennej jednego typu nie można wpisać wartości innego (niekompaybilnego) typu
+		//ERR x = 3.14;
+		//ERR x = "Ala ma kota";
+		//ERR x = "5432";
+		
+		// Zmiennych się nie usuwa. Po prostu wychodzimy z danego fragmentu kodu, albo z całego programu i "Java sobie posprząta".
+		
+	}
+
+}
+
+
+
+