Podstawowe kwestie - typy, zmienne

src/hello/Rozmowa.java

+package hello;
+
+import java.time.LocalTime;
+import javax.swing.JOptionPane;
+
+public class Rozmowa {
+
+	public static void main(String[] args) {
+		String jezyk = JOptionPane.showInputDialog("Jaki język programowania lubisz?");
+		JOptionPane.showMessageDialog(null, "Super, bo " + jezyk + " jest bardzo dobrym językiem.");
+		JOptionPane.showMessageDialog(null, LocalTime.now());
+		
+		JOptionPane.showMessageDialog(null, "Pozdrawiamy", jezyk, JOptionPane.WARNING_MESSAGE);
+	}
+
+}

src/p01_zmienne/Paliwo.java

+package p01_zmienne;
+
+import java.util.Scanner;
+
+/*
+Użytkownik podaje:
+ - cena paliwa
+ - spalanie l / 100 km
+ - odległość w km
+Program oblicza koszt podróży
+*/
+public class Paliwo {
+
+	public static void main(String[] args) {
+		Scanner scanner = new Scanner(System.in);
+		
+		System.out.print("Podaj cenę paliwa: ");
+		double cena = scanner.nextDouble();
+		System.out.print("Podaj spalanie na 100 km: ");
+		double spalanie = scanner.nextDouble();
+		System.out.print("Podaj odległość w km: ");
+		double dystans = scanner.nextDouble();
+		
+		double koszt = cena * spalanie * dystans / 100;
+		System.out.println("Koszt podróży: " + koszt);
+	}
+
+}

src/p01_zmienne/Paliwo2.java

+package p01_zmienne;
+
+import java.util.Scanner;
+
+public class Paliwo2 {
+	// W tej wersji do wczytywania używam Scannera, a do wypisywania używam printf
+	// Pozostaję przy domyślnych ustawieniach regionalnych - dla polskich używany będzie przecinek.
+
+	public static void main(String[] args) {
+		Scanner scanner = new Scanner(System.in);
+		
+		System.out.print("Podaj cenę paliwa: ");
+		double cena = scanner.nextDouble();
+		System.out.print("Podaj spalanie na 100 km: ");
+		double spalanie = scanner.nextDouble();
+		System.out.print("Podaj odległość w km: ");
+		double dystans = scanner.nextDouble();
+		
+		double koszt = cena * spalanie * dystans / 100;
+		System.out.printf("Koszt przejazdu %.0f km wyniesie %.2f\n", dystans, koszt);
+		
+		// Akurat w przypadku Scannera czytającego dane z System.in,
+		// nie stanie się nic złego, jeśli go nie zamkniemy.
+		// Ale Eclipse przypomina, aby obiekt Scanner zamknąć - więc to tutaj robię, aby nie było ostrzeżnia.
+		scanner.close();
+		
+		// Gdy będziemy mówić o plikach, dowiemy się więcej o zamykaniu/zwalnianiu zasobów.
+	}
+
+}

src/p01_zmienne/Paliwo3.java

+package p01_zmienne;
+
+import java.util.Locale;
+import java.util.Scanner;
+
+public class Paliwo3 {
+	// W tej wersji do wczytywania używam Scannera, a do wypisywania używam printf
+	// Ustawienia regionalne skanera od prinf zmieniam na Locale.US - ułamki dziesiętne za kropką
+
+	public static void main(String[] args) {
+		Scanner scanner = new Scanner(System.in);
+		scanner.useLocale(Locale.US);
+		
+		System.out.print("Podaj cenę paliwa: ");
+		double cena = scanner.nextDouble();
+		System.out.print("Podaj spalanie na 100 km: ");
+		double spalanie = scanner.nextDouble();
+		System.out.print("Podaj odległość w km: ");
+		double dystans = scanner.nextDouble();
+		
+		double koszt = cena * spalanie * dystans / 100;
+		System.out.printf(Locale.US, "Koszt przejazdu %.0f km wyniesie %.2f zł\n", dystans, koszt);
+	}
+
+}

src/p01_zmienne/Paliwo4.java

+package p01_zmienne;
+
+import java.util.Locale;
+import java.util.Scanner;
+
+public class Paliwo4 {
+	// W tej wwersji ustawienia regionalne zmieniam na samym początku programu, i nie muszę już ich przestawiać za każdym razem. 
+
+	public static void main(String[] args) {
+		Locale.setDefault(Locale.US);
+		Scanner scanner = new Scanner(System.in);
+		
+		System.out.print("Podaj cenę paliwa: ");
+		double cena = scanner.nextDouble();
+		System.out.print("Podaj spalanie na 100 km: ");
+		double spalanie = scanner.nextDouble();
+		System.out.print("Podaj odległość w km: ");
+		double dystans = scanner.nextDouble();
+		
+		double koszt = cena * spalanie * dystans / 100;
+		System.out.printf("Koszt przejazdu %.0f km wyniesie %.2f zł\n", dystans, koszt);
+	}
+
+}

src/p01_zmienne/Prostokat.java

+package p01_zmienne;
+
+import java.util.Scanner;
+
+/* Program za pomocą Scannera wczytuje dwie liczby - długości boków prostokąta -
+ * i oblicza pole powierzchni oraz obwód tego prostokąta i wypisuje te informacje.
+ */
+public class Prostokat {
+
+	public static void main(String[] args) {
+		Scanner scanner = new Scanner(System.in);
+		System.out.println("Podaj dwie liczby - długości boków prostokąta:");
+		double a = scanner.nextDouble();
+		double b = scanner.nextDouble();
+		double pole = a*b;
+		double obwod = 2*a + 2*b;
+		System.out.println("Pole powierzchni wynosi " + pole + " a obwód " + obwod);
+	}
+
+}

src/p01_zmienne/Skaner.java

+package p01_zmienne;
+
+import java.util.Locale;
+import java.util.Scanner;
+
+public class Skaner {
+
+    public static void main(String[] args) {
+   	 // Aby wczytywać dane ze standardowego wejścia, w Javie w praktyce używa się klasy Scanner.
+   	 // Deklaruję zmienną scanner typu Scanner i wpisuję do niej (wskaźnik do...) nowy obiekt klasy Scanner.
+   	 // Ten Scanner czyta dane ze standardowego wejścia (System.in).
+   	 Scanner scanner = new Scanner(System.in);
+   	 // Domyślnie Scanner bierze pod uwagę ustawienia regionalne systemu.
+   	 // Przy ustawieniach polskich, za separator dziesiętny jest uważany przecinek,
+   	 // Jeśli chcemy, aby Scanner czytał liczby z kropką, to zmieniamy ustawienia na amerykańskie:
+   	 // scanner.useLocale(Locale.US);
+   	 
+   	 System.out.println("Wpisz linię tekstu:");
+   	 String linia = scanner.nextLine();
+   	 System.out.println("Wczytana linia: " + linia);
+   	 
+   	 System.out.println("Wpisz kilka słów:");
+   	 String slowo1 = scanner.next();
+   	 String slowo2 = scanner.next();
+   	 String reszta = scanner.nextLine();
+   	 
+   	 System.out.println("Pierwsze słowo: " + slowo1);
+   	 System.out.println("Drugie słowo: " + slowo2);
+   	 System.out.println("Reszta linii: " + reszta);
+   	 System.out.println();
+   	 
+   	 // Scanner pozwala wczytywać dane liczbowe (bez dodatkowych konwersji)
+   	 System.out.print("Wpisz liczbę całkowitą: ");
+   	 int x = scanner.nextInt();
+
+   	 System.out.print("Wpisz liczbę z ułamkiem: ");
+   	 double y = scanner.nextDouble();
+   	 
+   	 System.out.println("wczytane liczby: " + x + " " + y);
+   	 System.out.println("wynik mnożenia: " + (x*y));
+    }
+
+}

src/p01_zmienne/TeoriaZmiennych.java

+package p01_zmienne;
+
+public class TeoriaZmiennych {
+
+	public static void main(String[] args) {
+		// W Javie nie wolno używać zmiennych, które nie są zadeklarowane
+		// System.out.println(zmienna);
+		// Nie można nawet wpisać wartości do zmiennej (co można w Python, PHP, JS)
+		// zmienna = 123;
+		
+		// Deklaracja zmiennej wygląda tak: typ zmienna
+		int zmienna;
+		// Od tego miejsca do końca bieżącego {bloku} można używać tej zmiennej
+		zmienna = 321;
+		System.out.println(zmienna);
+		zmienna += 5;
+		System.out.println(zmienna);
+		
+		// Uwaga. W Javie nie wolno odczytywać wartości zmiennej lokalnej, do której nie wpisaliśmy żadnej wartości.
+		int x, y;
+		// To się nie kompiluje:
+//		if(x > 0) {
+//			System.out.println(y);
+//		}
+		
+		x = 20;
+		System.out.println(x); // OK
+		if(x > 0) {
+			y = 200;
+		}
+		// Tutaj kompilator nie ma pewności, że y posiada jakąś wartość, bo teoretycznie program mógł nie wejść do ifa
+		// System.out.println(y);
+		if(x > 0) {
+			y = 200;
+		} else {
+			y = 100;
+		}
+		System.out.println(y); // teraz OK
+		
+		// Najczęściej w Javie zmienne deklaruje się dopiero wtedy, gdy są potrzebne,
+		// i od razu wpisuje do nich początkową wartość:
+		String imie = "Ala";
+		int liczba = 333;
+		double pi = 3.14;
+		System.out.println(imie + " " + liczba + " " + pi);
+		
+		// Od Javy 10 zmienne lokalne można dekalrować bez podania typu, za pomocą słowa var
+		// Typ zmiennej jest wówczas ustalany na podstawie wartości wpisywanej.
+		
+		var a = "Ola ma psa";
+		System.out.println(a);
+		// teraz zmienna a jest typu String - nie wolno wpisać innych wartości
+		//błąd! a = 5432;
+		
+		// Typem uniwersalnym, że do zmiennej można wpisać praktycznie wszystko, jest Object
+		
+		Object o;
+		o = "Ula ma rybki";
+		System.out.println(o);
+		
+		o = 12 * 34; // mówiąc precyzyjnie, powstaje tu obiekt klasy Integer
+		System.out.println(o);
+	}
+
+}

src/p01_zmienne/Typy.java

+package p01_zmienne;
+
+import java.math.BigDecimal;
+
+public class Typy {
+
+	public static void main(String[] args) {
+		// W Javie istnieje 8 typów "prostych":
+		// byte, short, int, long - liczby całkowite ze znakiem z różnymi zakresami wartości
+		
+		short s1 = 10000;
+		System.out.println(s1);
+		// short s2 = 1000000; // nie da się wpisać miliona, bo za duża wartość
+		
+		int milion = 1000000;
+		System.out.println(milion);
+		System.out.println(milion * milion);
+		// gdy wynik obliczenie wychodzi poza zakres, to pojawi się błędny wynik - "integer overflow"
+		
+		// float, double - liczby "zmiennoprzecinkowe", czyli liczby z ułamkiem, ale działające "dziwnie"
+		// float (32 bity) ma mniejszy zakres i precyzję, a double (64 bity) większy zakres i precyzję
+		double cena = 1.20;
+		System.out.println(cena);
+		System.out.println(3 * cena);
+
+		// char - pojedynczy znak, który technicznie jest tak naprawdę kodem znaku
+		char c = 'A';
+		System.out.println(c);   // A
+		System.out.println(c+1); // 66
+		
+		// boolean - wartości logiczne false i true
+		boolean warunek = cena * 3 == 3.6;
+		System.out.println(warunek);
+	
+		// Poza typami prostymi, istnieją typy obiektowe:
+		// - klasy, interfejsy, rekordy, enumy, ale też tablice
+		// - sama platforma Java definiuje kilka tysięcy takich typów
+		// - ale każdy programista może definiować swoje
+		
+		String napis = "Ala";
+		napis += " ma kota";
+		System.out.println(napis);
+		
+		BigDecimal cenaBD = new BigDecimal("1.20");
+		BigDecimal trzy = BigDecimal.valueOf(3);
+		System.out.println(cenaBD.multiply(trzy));
+	}
+
+}

src/p01_zmienne/Zakupy.java

+package p01_zmienne;
+
+import javax.swing.JOptionPane;
+
+/* Program zadaje trzy pytania i pobiera od użytkownika dane:
+   - nazwę towaru (np. "Co chcesz kupić?")
+   - cenę jednostkową ("Ile kosztuje jedna sztuka?")
+   - liczbę sztuk
+   Na tej podstawie program oblicza kwotę do zapłaty i wyświetla komunikat postaci:
+   "Za 3 sztuk towaru jajo zapłacisz 4.50"
+   (jako liczba sztuk i nazwa mają zostać użyte wartości wprowadzone przez użytkownika)
+*/
+
+public class Zakupy {
+
+	public static void main(String[] args) {
+		String towar = JOptionPane.showInputDialog("Co chcesz kupić?");
+		double cena = Double.parseDouble(JOptionPane.showInputDialog("Ile kosztuje jedna sztuka?"));
+		int sztuk = Integer.parseInt(JOptionPane.showInputDialog("Ile sztuk chcesz kupić?"));
+		
+		JOptionPane.showMessageDialog(null, "Za " + sztuk + " sztuk towaru "
+					+ towar + " zapłacisz " + (cena * sztuk));
+	}
+
+}