Skip to content

A
alx_java1
Commit ffd2f18e by Patryk Czarnik
Options

pętle i porządki w pakietach

parent 5d119f40
Showing with 0 additions and 1492 deletions
src/main/java/gotowe1/p01_okna_dialogowe/RodzajeOkien.java deleted 100644 → 0
package gotowe1.p01_okna_dialogowe;
import java.time.LocalDateTime;
import javax.swing.JOptionPane;
public class RodzajeOkien {
public static void main(String[] args) {
JOptionPane.showMessageDialog(null, "To jest zwykły MessageDialog");
JOptionPane.showMessageDialog(null, "To jest MessageDialog typu WARNING", "Uwaga", JOptionPane.WARNING_MESSAGE);
// są też inne typy: PLAIN_MESSAGE, INFORMATION_MESSAGE, QUESTION_MESSAGE, WARNING_MESSAGE, ERROR_MESSAGE
String cos = JOptionPane.showInputDialog("To jest inputDialog.\nNapisz coś:");
String data = JOptionPane.showInputDialog("To jest inputDialog z początkową wartością.", LocalDateTime.now());
// Rozbudowana wersja showInputDialog pozwala wybrać wartość z rozwijanej listy
// Należy przekazać tablicę wartości do wyboru
String[] opcje = {"wiosna", "lato", "jesień", "zima"};
String poraRoku = (String)JOptionPane.showInputDialog(null, "Którą porę roku lubisz najbardziej?",
"Pytanie", JOptionPane.QUESTION_MESSAGE, null, opcje, "jesień");
int pora2 = JOptionPane.showOptionDialog(null, "A której pory nie lubisz?",
"Pytanie 2", 0, JOptionPane.QUESTION_MESSAGE, null, opcje, "zima");
// dostajemy numer wybranej opcji, od 0
int wybor = JOptionPane.showConfirmDialog(null, "Czy chcesz " + cos + " o godzinie " + data + "?");
switch(wybor) {
case JOptionPane.YES_OPTION ->
JOptionPane.showMessageDialog(null, "TAK");
case JOptionPane.NO_OPTION ->
JOptionPane.showMessageDialog(null, "NO");
case JOptionPane.CANCEL_OPTION ->
JOptionPane.showMessageDialog(null, "Cancel");
default ->
JOptionPane.showMessageDialog(null, "Inna wartość: " + wybor);
// zamknięcie okna daje wynik -1 czyli CLOSED_OPTION
}
}
}
src/main/java/gotowe1/p01_okna_dialogowe/Rozmowa1.java deleted 100644 → 0
package gotowe1.p01_okna_dialogowe;
import javax.swing.JOptionPane;
public class Rozmowa1 {
public static void main(String[] args) {
String imie = JOptionPane.showInputDialog("Jak masz na imię?");
String miasto = JOptionPane.showInputDialog("Z jakiego miasta jesteś?");
JOptionPane.showMessageDialog(null, "Witaj " + imie + " z miasta " + miasto);
}
}
// uruchamianie w Eclipse: Ctrl + F11
\ No newline at end of file
src/main/java/gotowe1/p01_okna_dialogowe/Rozmowa2.java deleted 100644 → 0
package gotowe1.p01_okna_dialogowe;
import javax.swing.JOptionPane;
public class Rozmowa2 {
public static void main(String[] args) {
String imie = JOptionPane.showInputDialog("Jak masz na imię?");
String miasto = JOptionPane.showInputDialog("Z jakiego miasta jesteś?");
JOptionPane.showMessageDialog(null, "Witaj " + imie + " z miasta " + miasto);
int wiek = Integer.parseInt(JOptionPane.showInputDialog("Ile masz lat?"));
if(wiek >= 18) {
JOptionPane.showMessageDialog(null, "Możesz kupić piwo");
} else {
JOptionPane.showMessageDialog(null, "Nie możesz kupić piwa, bo masz tylko " + wiek + " lat.");
}
}
}
src/main/java/gotowe1/p01_okna_dialogowe/Zakupy1.java deleted 100644 → 0
package gotowe1.p01_okna_dialogowe;
import javax.swing.JOptionPane;
public class Zakupy1 {
public static void main(String[] args) {
String nazwa = JOptionPane.showInputDialog("Podaj nazwę towaru");
double cena = Double.parseDouble(JOptionPane.showInputDialog("Podaj cenę towaru"));
int ile = Integer.parseInt(JOptionPane.showInputDialog("Ile sztuk kupujesz?"));
JOptionPane.showMessageDialog(null, "Za " + ile + " sztuk towaru " + nazwa + " zapłacisz " + ile*cena);
}
}
src/main/java/gotowe1/p01_okna_dialogowe/Zakupy2.java deleted 100644 → 0
package gotowe1.p01_okna_dialogowe;
import javax.swing.JOptionPane;
public class Zakupy2 {
public static void main(String[] args) {
String nazwa = JOptionPane.showInputDialog("Podaj nazwę towaru");
double cena = Double.parseDouble(JOptionPane.showInputDialog("Podaj cenę towaru"));
int ile = Integer.parseInt(JOptionPane.showInputDialog("Ile sztuk kupujesz?"));
// Pierwszy sposób, aby poradzić sobie z niedokładnościami obliczeń double:
// Zaokrąglanie podczas wypisywania.
// Na tekstową konsolę można wypisać System.out.printf
// Tutaj użyjemy String.format, aby uzyskać napis do wyświetlenia w oknie
JOptionPane.showMessageDialog(null, String.format("Za %d sztuk towaru %s zapłacisz %.2f", ile, nazwa, ile*cena));
// wersje, które wypisują w ten sposób na stadardowe wyjście (obie nazwy działają tak samo):
// System.out.format("Za %d sztuk towaru %s zapłacisz %.2f%n", ile, nazwa, ile*cena);
// System.out.printf("Za %d sztuk towaru %s zapłacisz %.2f%n", ile, nazwa, ile*cena);
}
}
src/main/java/gotowe1/p01_okna_dialogowe/Zakupy3.java deleted 100644 → 0
package gotowe1.p01_okna_dialogowe;
import java.math.BigDecimal;
import java.math.RoundingMode;
import javax.swing.JOptionPane;
public class Zakupy3 {
// Drugi sposób, aby poradzić sobie z niedokładnościami obliczeń double:
// Używamy klasy BigDecimal, która zapewnia dokładne obliczenia z ułamkami dziesiętnymi.
// Operacje trzeba zapisywać słownie...
public static void main(String[] args) {
String nazwa = JOptionPane.showInputDialog("Podaj nazwę towaru");
BigDecimal cena = new BigDecimal(JOptionPane.showInputDialog("Podaj cenę towaru"));
BigDecimal ile = new BigDecimal(JOptionPane.showInputDialog("Ile towaru kupujesz?"));
// BigDecimal kwota = ile.multiply(cena);
BigDecimal kwota = ile.multiply(cena).setScale(2, RoundingMode.HALF_UP);
JOptionPane.showMessageDialog(null, String.format("Za %s sztuk towaru %s zapłacisz %s", ile, nazwa, kwota));
}
}
src/main/java/gotowe1/p01_okna_dialogowe/Zgadywanka1.java deleted 100644 → 0
package gotowe1.p01_okna_dialogowe;
import java.util.Random;
import javax.swing.JOptionPane;
public class Zgadywanka1 {
public static void main(String[] args) {
Random random = new Random();
int x = random.nextInt(1, 11);
int y = random.nextInt(1, 11);
int odp = Integer.parseInt(JOptionPane.showInputDialog("Ile to jest " + x + " razy " + y + "?"));
if(odp == x * y) {
JOptionPane.showMessageDialog(null, "Gratulacje, poprawna odpowiedz");
} else {
JOptionPane.showMessageDialog(null, "Źle, wróć do szkoły!", "Alarm", JOptionPane.ERROR_MESSAGE);
}
}
}
src/main/java/gotowe1/p02_zmienne_i_typy/DeklaracjeZmiennych.java deleted 100644 → 0
package gotowe1.p02_zmienne_i_typy;
public class DeklaracjeZmiennych {
public static void main(String[] args) {
// Nie wolno używać zmiennych, które nie są zadelarowane
// x = 123;
// System.out.println(x);
// Sama deklaracja wygląda tak:
int x;
// teraz do takiej zmiennej mógłbym już wpisać wartość, ale nie mogę jej jeszcze czytać, bo jest niezainicjowana:
// System.out.println(x);
// Przypisanie wartości do zmiennej
x = 345;
System.out.println(x);
// Wartość zmiennej można zmienić (o ile ta zmienna nie jest "final")
x++; // zwiększenie liczby o 1
System.out.println(x);
x += 5; // zmiana względem poprzedniej wartości
System.out.println(x);
// wpisanie zupełnie innej wartości
x = 200 * 4;
System.out.println(x);
System.out.println();
int y;
if(x > 100) {
y = 333;
System.out.println(y); // tutaj OK
}
// Kompilator myśli: "Gdyby program nie wszedł do if-a, to zmienna y nie byłaby zainicjowana".
// I dlatego w tym miejscu jest zgłaszany błąd kompilacji.
// System.out.println(y);
if(x > 200) {
y = 444;
} else {
y = 555;
}
// Ale teraz y na pewo ma jakąś wartość, więc ta linia jest OK:
System.out.println(y);
// W praktyce najczęściej deklarując zmienną od razu wpisuje się jej początkową wartość:
double z = 321.123;
System.out.println(z);
// Wpisując inną wartość do już istniejącej zmiennej, nie podajemy jej typu:
// double z = 321.123;
// int x = 5432;
x = 5432;
System.out.println(x);
}
}
src/main/java/gotowe1/p02_zmienne_i_typy/Losowanie.java deleted 100644 → 0
package gotowe1.p02_zmienne_i_typy;
import java.util.Random;
import java.util.concurrent.ThreadLocalRandom;
public class Losowanie {
public static void main(String[] args) {
// tworzymy obiekt Random - "generator liczb pseudolosowych"
Random random = new Random();
double d = random.nextDouble();
// liczba z zakresu [0.0 , 1.0)
System.out.println("double: " + d);
// losowy int z całego zakresu intów (orientacyjnie od -2mld do +2mld)
int x = random.nextInt();
// int z zakresu od 0 do limit-1, czyli tu od 0 do 99
int y = random.nextInt(100);
// int z zakresu od 500 włącznie do 1000 wyłączając, czyli od 500 do 999
// dostępne od niedawna, od Java 17
int z = random.nextInt(500, 1000);
System.out.println(x + " " + y + " " + z);
}
}
src/main/java/gotowe1/p02_zmienne_i_typy/PrzegladTypow.java deleted 100644 → 0
package gotowe1.p02_zmienne_i_typy;
import java.time.LocalDateTime;
public class PrzegladTypow {
public static void main(String[] args) {
// 8 typów prostych:
// liczby calkowite: byte, short, int, long
byte b = 100;
short s = 1000;
int i = 23;
long l = 333;
System.out.println(b * s * i * l);
// 2 typy dla liczb z ułamkiem. liczby "zmiennopozycyjne" / "zmiennoprzeconkowe" (floating point)
float f = 3.14F;
double d = 123.456;
System.out.println(f * d);
System.out.println();
// char - pojedynczy znak, ale patrząc technicznie, to jest liczba 16-bitowa, która może być kodem znaku
char c = 'A';
System.out.println(c);
System.out.println(c+1); // kodem litery A jest 65
c++;
// teraz jednak "przesuwamy znak" o jedną pozycję do przodu
System.out.println(c);
boolean warunek = true;
System.out.println(warunek);
warunek = f < 3;
System.out.println(warunek);
// przy okazji dwa sposoby umieszczania egzotycznych znaków w napisach:
if(warunek) {
System.out.println("\u03C0 jest małe");
} else {
System.out.println("π jest duże");
}
System.out.println();
// Typy obiektowe: klasa, interfejs, enum, rekord oraz tablice
// Sama Java definiuje ich kilka tysięcy, a programiści mogą tworzyć własne
String napis = "Ala ma kota";
System.out.println(napis);
System.out.println(napis.toUpperCase());
LocalDateTime czas = LocalDateTime.now();
System.out.println(czas);
System.out.println("Godzina " + czas.getHour() + " minut " + czas.getMinute());
// itd, jest tego bardzo dużo
}
}
src/main/java/gotowe1/p03_skaner/ObliczPowierzchnie.java deleted 100644 → 0
package gotowe1.p03_skaner;
import java.util.Locale;
import java.util.Scanner;
public class ObliczPowierzchnie {
/* Za pomocą Scannera program wczytuje wymiary pomieszczenia: długość i szerokość w metrach.
* Na tej podstawie oblicza powierzchnię tego pomieszczenia.
* Można też obliczyć obwód.
*/
public static void main(String[] args) {
// Locale.setDefault(Locale.US);
Scanner sc = new Scanner(System.in);
System.out.println("Podaj wymiary pomieszczenia w metrach.");
System.out.print("długość: ");
double a = sc.nextDouble();
System.out.print("szerokość: ");
double b = sc.nextDouble();
double pole = a*b;
double obwod = 2*a + 2*b;
// System.out.println("Pole wynosi " + pole + " m² a obwód " + obwod + " m");
System.out.printf("Pole wynosi %.3f m² a obwód %.3f m%n", pole, obwod);
}
}
src/main/java/gotowe1/p03_skaner/Skaner1.java deleted 100644 → 0
package gotowe1.p03_skaner;
import java.util.Locale;
import java.util.Scanner;
public class Skaner1 {
public static void main(String[] args) {
// Deklaruję zmienną scanner typu Scanner
// i wpisuję do niej nowy obiekt klasy Scanner.
// Ten skaner będzie czytał dane ze standardowego wejścia (System.in)
Scanner scanner = new Scanner(System.in);
// Gdy zmieniemy ustawienia na amerykańskie, to liczby będzie trzeba wpisywać z kropką.
// scanner.useLocale(Locale.US);
// Jeśli tego nie zrobimy, to wszystko zależy od ustawień językowych komputera. Jeśli są PL, to wpisujemy liczby z przecinkiem
System.out.println("Wpisz linię tekstu:");
String linia = scanner.nextLine();
System.out.println("linia: " + linia);
System.out.println("Napisz kilka słów:");
String slowo1 = scanner.next();
String slowo2 = scanner.next();
// Po wczytaniu pojedynczych słów lub liczb, warto wykonać nextLine,
// aby wczytać wszystkie pozostałe znaki do końca linii - w ten sposób "oczyszczamy wejście"
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.print("Podaj liczbę całkowitą: ");
int x = scanner.nextInt();
System.out.println("x = " + x);
System.out.print("Podaj liczbę z ułamkiem: ");
double d = scanner.nextDouble();
System.out.println("d = " + d);
System.out.println("iloczyn tych liczb: " + x*d);
// można też long, BigDecimal, a nawet boolean
// Zamykanie skanera, który czyta stdin, nie jest konieczne,
// ale napiszemy tu close, aby Eclipse nie pokazywał warninga.
scanner.close();
}
}
src/main/java/gotowe1/p03_skaner/StandardoweWejscie.java deleted 100644 → 0
package gotowe1.p03_skaner;
import java.io.IOException;
public class StandardoweWejscie {
public static void main(String[] args) throws IOException {
// standardowe wyjście (stdout)
System.out.println("Normalny output");
// wyjście błędów (stderr)
System.err.println("Wyjście błędów");
System.out.println("Napisz kawałek tekstu:");
// standardowe wejście
int x = System.in.read();
System.out.println("pierwszy bajt: " + x);
x = System.in.read();
System.out.println("drugi bajt: " + x);
}
}
src/main/java/gotowe1/p03_skaner/StandardoweWejscie2.java deleted 100644 → 0
package gotowe1.p03_skaner;
import java.io.IOException;
import java.util.Arrays;
public class StandardoweWejscie2 {
public static void main(String[] args) throws IOException {
System.out.println("Napisz coś");
// Można też wczytać całą porcję bajtów do tablicy
byte[] bajty = new byte[100];
int ile = System.in.read(bajty);
System.out.println("Odczytano " + ile + " bajtów.");
System.out.println(Arrays.toString(bajty));
// Można utworzyć napis na podstawie ciągu bajtów:
String napis = new String(bajty, 0, ile);
// String napis = new String(bajty, 0, ile, "UTF-8");
System.out.println("Napisałeś: " + napis);
}
}
// System.in pozwala czytać surowe dane w postaci pojedynczych bajtów lub tablicy bajtów.
// Jest to niewygodne. Przydałaby nam się operacja czytania całej linii tekstu albo całych słów, albo liczb zapisanych dziesiętnie...
// W paktyce korzysta się z tego za pośrednictwem klasy Scanner (lub ewentualnie BufferedReader).
src/main/java/gotowe1/p04_if/Bagaz1.java deleted 100644 → 0
package gotowe1.p04_if;
import java.util.Scanner;
/* Program czyta od użytkownika 3 liczby: wymiary walizki w cm
* i sprawdza czy walizka mieści się w limitach wymiaru.
* Warunki:
* - żaden wymiar nie może przekraczać 50 cm
* - objętość nie może przekraczać 50_000 cm³
*/
public class Bagaz1 {
/* W tej wersji:
* - wszystkie warunki sprawdza są w jednym if, program nie informuje konkretnie dlaczego odrzucił
* - sprawdzamy warunek "pozytywny", czyli piszemy kiedy jest dobrze; spójnikiem jest &&
*/
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("Podaj trzy liczby - wymiary walizki w cm:");
double a = scanner.nextDouble();
double b = scanner.nextDouble();
double c = scanner.nextDouble();
if(a <= 50 && b <= 50 && c <= 50 && a*b*c <= 50_000) {
System.out.println("Bagaż mieści się w wymaganiach");
} else {
System.out.println("Bagaż za duży");
}
}
}
src/main/java/gotowe1/p04_if/Bagaz2.java deleted 100644 → 0
package gotowe1.p04_if;
import java.util.Scanner;
public class Bagaz2 {
/* W tej wersji:
* - wszystkie warunki sprawdza są w jednym if, program nie informuje konkretnie dlaczego odrzucił
* - sprawdzamy warunek "negatywny", czyli piszemy kiedy jest źle; spójnikiem jest &&
*/
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("Podaj trzy liczby - wymiary walizki w cm:");
double a = scanner.nextDouble();
double b = scanner.nextDouble();
double c = scanner.nextDouble();
if(a > 50 || b > 50 || c > 50 || a*b*c > 50_000) {
System.out.println("Bagaż za duży");
} else {
System.out.println("Bagaż mieści się w wymaganiach");
}
}
}
src/main/java/gotowe1/p04_if/Bagaz3.java deleted 100644 → 0
package gotowe1.p04_if;
import java.util.Scanner;
public class Bagaz3 {
/* W tej wersji:
* - rozbijamy warunki do oddzielnych if-ów, aby program napisał dlaczego bagaż został odrzucony
* - ważne jednak, aby program ostatecznie potwierdził akceptację bagażu, lub napisał jednoznacznie, że odrzuca
* - program wypisuje tylko pierwszą przyczynę odrzucenia
* - sprawdzanie warunków pozytywnych prowadzi tutaj do powstania kodu wielokrotnie zagnieżdżonego
* (if w ifie i kolejnym ifie...)
* "else jest daleko od swojego if-a"
*/
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("Podaj trzy liczby - wymiary walizki w cm:");
System.out.print("długość: ");
double a = scanner.nextDouble();
System.out.print("szerokość: ");
double b = scanner.nextDouble();
System.out.print("wysokość: ");
double c = scanner.nextDouble();
double obj = a*b*c;
if(a <= 50) {
if (b <= 50) {
if (c <= 50) {
if (obj <= 50_000) {
System.out.println("Bagaż mieści się w wymaganiach");
} else {
System.out.println("Zbyt duża objętość");
}
} else {
System.out.println("Zbyt duża wysokość");
}
} else {
System.out.println("Zbyt duża szerokość");
}
} else {
System.out.println("Zbyt duża długość");
}
}
}
src/main/java/gotowe1/p04_if/Bagaz4.java deleted 100644 → 0
package gotowe1.p04_if;
import java.util.Scanner;
public class Bagaz4 {
/* W tej wersji:
* - rozbijamy warunki do oddzielnych if-ów, aby program napisał dlaczego bagaż został odrzucony
* - program wypisuje tylko pierwszą przyczynę odrzucenia
* - dzięki sprawdzaniu warunków negatywnych, możemy zastosować schemat else-if
* i napisać to na zasadzie: sprawdź czy jest źle z 1. powodu, czy z 2. powodu itd.
* a jeśli nie było żadnego problemu, to na samym końcu jest wykonana operacja w przypadku braku błędów
*/
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("Podaj trzy liczby - wymiary walizki w cm:");
System.out.print("długość: ");
double a = scanner.nextDouble();
System.out.print("szerokość: ");
double b = scanner.nextDouble();
System.out.print("wysokość: ");
double c = scanner.nextDouble();
double obj = a*b*c;
if(a > 50) {
System.out.println("Zbyt duża długość");
} else if(b > 50) {
System.out.println("Zbyt duża szerokość");
} else if(c > 50) {
System.out.println("Zbyt duża wysokość");
} else if(obj > 50_000) {
System.out.println("Zbyt duża objętość");
} else {
System.out.println("Bagaż mieści się w wymaganiach");
}
}
}
src/main/java/gotowe1/p04_if/Bagaz5.java deleted 100644 → 0
package gotowe1.p04_if;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class Bagaz5 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("Podaj trzy liczby - wymiary walizki w cm:");
System.out.print("długość: ");
double a = scanner.nextDouble();
System.out.print("szerokość: ");
double b = scanner.nextDouble();
System.out.print("wysokość: ");
double c = scanner.nextDouble();
double obj = a*b*c;
List<String> bledy = new ArrayList<>();
if(a > 50) {
bledy.add("Zbyt duża długość");
}
if(b > 50) {
bledy.add("Zbyt duża szerokość");
}
if(c > 50) {
bledy.add("Zbyt duża wysokość");
}
if(obj > 50_000) {
bledy.add("Zbyt duża objętość");
}
if(bledy.isEmpty()) {
System.out.println("Bagaż mieści się w wymaganiach");
} else {
System.out.println("Bagaż odrzucony. Znalezione problemy:");
for (String blad : bledy) {
System.out.println(blad);
}
}
}
}
src/main/java/gotowe1/p04_if/SpojnikiLogiczne.java deleted 100644 → 0
package gotowe1.p04_if;
import java.util.Random;
public class SpojnikiLogiczne {
public static void main(String[] args) {
Random random = new Random();
int x = random.nextInt(20);
int y = random.nextInt(20);
System.out.println("x = " + x + " , y = " + y);
// && - koniunkcja, "i", "and"
// warunek jest prawdziwy tylko gdy obie części są prawdziwe
if(x >= 10 && y >= 10) {
System.out.println("AAA obie liczby są dwucyfrowe");
} else {
System.out.println("BBB nieprawda, że obie na raz są dwucyfrowe");
}
// || - alternatywa, "lub", "or"
// warunek jest prawdziwy gdy co najmniej jedna część jest prawdziwa
if(x >= 10 || y >= 10) {
System.out.println("CCC któraś z liczb jest dwucyfrowa");
} else {
System.out.println("DDD obie liczby są jednocyfrowe");
}
// Istnieje też ^ - to jest alternatywa rozłączna, tzw. "xor",
// Jest prawdą, gdy dokładnie jedna z części jest prawdą.
// Inaczej mówiąc ^ sprawdza czy warunki składowe dają różne wyniki.
// W praktyce nieużywane
if(x >= 10 ^ y >= 10) {
System.out.println("EEE tylko jedna z liczb jest dwucyfrowa");
} else {
System.out.println("FFF warunki są jednakowe dla obu liczb");
}
}
}
src/main/java/gotowe1/p04_if/SprawdzWiek.java deleted 100644 → 0
package gotowe1.p04_if;
import java.util.Scanner;
public class SprawdzWiek {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("Ile masz lat? ");
int wiek = scanner.nextInt();
// W zależności od wieku opisz status osoby:
if(wiek < 0) {
System.err.println("Wiek nie może być ujemny");
} else if(wiek < 4) {
System.out.println("Jesteś niemowlakiem");
} else if(wiek < 7) {
System.out.println("Jesteś przedszkolakiem");
} else if(wiek < 19) {
System.out.println("Jesteś uczniem");
} else if(wiek < 65) {
System.out.println("Jesteś pracownikiem");
} else {
System.out.println("Jesteś emerytem");
}
}
}
src/main/java/gotowe1/p04_if/TeoriaIf.java deleted 100644 → 0
package gotowe1.p04_if;
import java.util.Scanner;
public class TeoriaIf {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("Podaj liczbę: ");
int liczba = scanner.nextInt();
System.out.println("Wczytana liczba: " + liczba);
if(liczba < 10) {
System.out.println("liczba mniejsza niż 10");
System.out.println("czyli jednocyfrowa (albo ujemna)");
} else {
System.out.println("liczba nie była malutka");
}
// Jeśli za if-em lub else-em do wykonania jest tylko jedna instrukcja,
// to teoretycznie nie trzeba brać jej w nawiasy klamrowe
if(liczba % 2 == 0)
System.out.println("liczba jest parzysta");
else
System.out.println("liczba jest nieparzysta");
// Ale ze względu na czytelność kodu oraz perspektywę dalszej modyfikacji
// lepiej od początku stosować nawiasy klamrowe.
// Za instrukcjami strukturalnymi (if, switch, while, for) w praktyce nie stawia się średnika ;
// if może istnieć bez części else.
// Wtedy: jeśli warunek prawdziwy: wykonujemy instrukcje z podanego bloku
// jeśli nieprawdziwy - to ich nie wykonujemy (program idzie dalej)
if(liczba == 21) {
System.out.println("BINGO!");
System.out.println("To jest dokładnie 21");
}
System.out.println("To się zawsze wypisze");
// Jeśli do rozpatrzenia mam więcej niż 2 sytuacje, to typowy zapis jest taki:
if(liczba > 0) {
System.out.println("Liczba dodatnia");
} else if(liczba < 0) {
System.out.println("Liczba ujemna");
} else {
System.out.println("Równa zero");
}
// W Javie, inaczej niż w C, nie można do ifa przekazywać liczb.
// Ani, inaczej niż w Pythonie, napisów, list itp rzeczy. W Javie tylko boolean.
// if(liczba) {
// System.out.println("nie zero");
// } else {
// System.out.println("zero");
// }
System.out.println("Koniec programu");
}
}
src/main/java/gotowe1/p05_switch/DzienTygodnia0.java deleted 100644 → 0
package gotowe1.p05_switch;
import javax.swing.JOptionPane;
public class DzienTygodnia0 {
public static void main(String[] args) {
int numer = Integer.parseInt(JOptionPane.showInputDialog("Podaj nr dnia tygodnia"));
if(numer == 1) {
JOptionPane.showMessageDialog(null, "To jest poniedziałek");
} else if(numer == 2) {
JOptionPane.showMessageDialog(null, "To jest wtorek");
} else if(numer == 3) {
JOptionPane.showMessageDialog(null, "To jest środa");
} else if(numer == 4) {
JOptionPane.showMessageDialog(null, "To jest czwartek");
} else if(numer == 5) {
JOptionPane.showMessageDialog(null, "To jest piątek");
JOptionPane.showMessageDialog(null, "Weekendu początek");
} else if(numer == 6) {
JOptionPane.showMessageDialog(null, "To jest sobota");
} else if(numer == 7) {
JOptionPane.showMessageDialog(null, "To jest niedziela");
} else {
JOptionPane.showMessageDialog(null, "Niepoprawny numer dnia: " + numer, "Błąd", JOptionPane.ERROR_MESSAGE);
}
JOptionPane.showMessageDialog(null, "Koniec programu");
}
}
src/main/java/gotowe1/p05_switch/DzienTygodnia1.java deleted 100644 → 0
package gotowe1.p05_switch;
import javax.swing.JOptionPane;
public class DzienTygodnia1 {
/* switch przechodzi do tego case, którego wartość została przekazana w parametrze
* i od tego miejsca kontynuuje wykonanie do samego końca
* albo do napotkania instrukcji break (która powoduje wyjście ze switcha).
*
* W tej wersji pomiędzy case'ami nie ma breaków, dlatego wykonują się dalsze instrukcje aż do końca.
*/
public static void main(String[] args) {
int numer = Integer.parseInt(JOptionPane.showInputDialog("Podaj nr dnia tygodnia"));
switch(numer) {
case 1:
JOptionPane.showMessageDialog(null, "To jest poniedziałek");
case 2:
JOptionPane.showMessageDialog(null, "To jest wtorek");
case 3:
JOptionPane.showMessageDialog(null, "To jest środa");
case 4:
JOptionPane.showMessageDialog(null, "To jest czwartek");
case 5:
JOptionPane.showMessageDialog(null, "To jest piątek");
JOptionPane.showMessageDialog(null, "Weekendu początek");
case 6:
JOptionPane.showMessageDialog(null, "To jest sobota");
case 7:
JOptionPane.showMessageDialog(null, "To jest niedziela");
default:
JOptionPane.showMessageDialog(null, "Niepoprawny numer dnia: " + numer, "Błąd", JOptionPane.ERROR_MESSAGE);
}
JOptionPane.showMessageDialog(null, "Koniec programu");
}
}
src/main/java/gotowe1/p05_switch/DzienTygodnia2.java deleted 100644 → 0
package gotowe1.p05_switch;
import javax.swing.JOptionPane;
public class DzienTygodnia2 {
/* Ta wersja pokazuje najbardziej klasyczny zapis switch, jaki działa w Javie od samego początku.
* Tak samo jest też w C, C++.
*
* Pod koniec każdego case'a jest break, który powoduje, że program nie przejdzie do następnego.
* break powoduje wyjście ze switch, ale break nie przerywa całego programu.
*/
public static void main(String[] args) {
int numer = Integer.parseInt(JOptionPane.showInputDialog("Podaj nr dnia tygodnia"));
switch(numer) {
case 1:
JOptionPane.showMessageDialog(null, "To jest poniedziałek");
break;
case 2:
JOptionPane.showMessageDialog(null, "To jest wtorek");
break;
case 3:
JOptionPane.showMessageDialog(null, "To jest środa");
break;
case 4:
JOptionPane.showMessageDialog(null, "To jest czwartek");
break;
case 5:
JOptionPane.showMessageDialog(null, "To jest piątek");
JOptionPane.showMessageDialog(null, "Weekendu początek");
break;
case 6:
JOptionPane.showMessageDialog(null, "To jest sobota");
break;
case 7:
JOptionPane.showMessageDialog(null, "To jest niedziela");
return;
default:
JOptionPane.showMessageDialog(null, "Niepoprawny numer dnia: " + numer, "Błąd", JOptionPane.ERROR_MESSAGE);
}
JOptionPane.showMessageDialog(null, "Koniec programu");
}
}
src/main/java/gotowe1/p05_switch/DzienTygodnia3.java deleted 100644 → 0
package gotowe1.p05_switch;
import javax.swing.JOptionPane;
public class DzienTygodnia3 {
/* W Java 14 pojawiły się nowe możliwości dla switch.
* Jedną z nich jest wpisanie za case znaków -> zamiast :
* powoduje to, że wykona się tylko jeden case i nie trzeba pisać break, aby przerwać.
* Za strzałką może być albo jedna instrukcja; albo {blok}
*/
public static void main(String[] args) {
int numer = Integer.parseInt(JOptionPane.showInputDialog("Podaj nr dnia tygodnia"));
switch(numer) {
case 1 -> JOptionPane.showMessageDialog(null, "To jest poniedziałek");
case 2 -> JOptionPane.showMessageDialog(null, "To jest wtorek");
case 3 -> JOptionPane.showMessageDialog(null, "To jest środa");
case 4 -> JOptionPane.showMessageDialog(null, "To jest czwartek");
case 5 -> {
JOptionPane.showMessageDialog(null, "To jest piątek");
JOptionPane.showMessageDialog(null, "Weekendu początek");
}
case 6 -> JOptionPane.showMessageDialog(null, "To jest sobota");
case 7 -> JOptionPane.showMessageDialog(null, "To jest niedziela");
default -> JOptionPane.showMessageDialog(null, "Niepoprawny numer dnia: " + numer, "Błąd", JOptionPane.ERROR_MESSAGE);
}
JOptionPane.showMessageDialog(null, "Koniec programu");
}
}
src/main/java/gotowe1/p05_switch/DzienTygodnia4.java deleted 100644 → 0
package gotowe1.p05_switch;
import javax.swing.JOptionPane;
// Rozwiązanie wykorzystujące zmienną, w której zapamiętamy nazwę dnia → dzięki temu nie będzie tyle razy showMessageDialog
public class DzienTygodnia4 {
public static void main(String[] args) {
int numer = Integer.parseInt(JOptionPane.showInputDialog("Podaj nr dnia tygodnia"));
String dzien;
switch(numer) {
case 1:
dzien = "poniedziałek";
break;
case 2:
dzien = "wtorek";
break;
case 3:
dzien = "środa";
break;
case 4:
dzien = "czwartek";
break;
case 5:
dzien = "piątek";
break;
case 6:
dzien = "sobota";
break;
case 7:
dzien = "niedziela";
return;
default:
dzien = "Niepoprawny numer dnia: " + numer;
}
JOptionPane.showMessageDialog(null, "To jest " + dzien);
}
}
src/main/java/gotowe1/p05_switch/DzienTygodnia5.java deleted 100644 → 0
package gotowe1.p05_switch;
import javax.swing.JOptionPane;
// W tej wersji piszemy własną funkcję (czyli w Javie "metodę statyczną"),
// która dokonuje tłumaczenia numeru na nazwę dnia tygodnia.
// To jest poprawne również w starszych wersjach Javy.
public class DzienTygodnia5 {
static String nazwaDniaTygodnia(int nr) {
switch(nr) {
case 1: return "poniedziałek";
case 2: return "wtorek";
case 3: return "środa";
case 4: return "czwartek";
case 5: return "piątek";
case 6: return "sobota";
case 7: return "niedziela";
default: throw new IllegalArgumentException("Niepoprawny numer dnia: " + nr);
}
}
public static void main(String[] args) {
try {
int numer = Integer.parseInt(JOptionPane.showInputDialog("Podaj nr dnia tygodnia"));
String dzien = nazwaDniaTygodnia(numer);
JOptionPane.showMessageDialog(null, "To jest " + dzien);
} catch (Exception e) {
JOptionPane.showMessageDialog(null, e, "Błąd", JOptionPane.ERROR_MESSAGE);
}
JOptionPane.showMessageDialog(null, "Koniec programu");
}
}
src/main/java/gotowe1/p05_switch/DzienTygodnia6.java deleted 100644 → 0
package gotowe1.p05_switch;
import javax.swing.JOptionPane;
public class DzienTygodnia6 {
// W tej wersj używamy "switch expression" (od Java 14), czyli switch zwraca wynik,
// który można np. wpisać do zmiennej.
// switch jest jakby funkcją, której wynik pobieramy
public static void main(String[] args) {
try {
int numer = Integer.parseInt(JOptionPane.showInputDialog("Podaj nr dnia tygodnia"));
String dzien = switch(numer) {
case 1 -> "poniedziałek";
case 2 -> "wtorek";
case 3 -> "środa";
case 4 -> "czwartek";
case 5 -> "piątek";
case 6 -> "sobota";
case 7 -> "niedziela";
default -> throw new IllegalArgumentException("Niepoprawny numer dnia: " + numer);
};
JOptionPane.showMessageDialog(null, "To jest " + dzien);
} catch (Exception e) {
JOptionPane.showMessageDialog(null, e, "Błąd", JOptionPane.ERROR_MESSAGE);
}
JOptionPane.showMessageDialog(null, "Koniec programu");
}
}
src/main/java/gotowe1/p05_switch/IleDniMaMiesiac1.java deleted 100644 → 0
package gotowe1.p05_switch;
import javax.swing.JOptionPane;
/* Program dla podanej nazwy miesiąca (np "styczeń")
* ma wypisać, ile dni ma ten miesiąc. */
public class IleDniMaMiesiac1 {
// Wersja poprawna, ale napisana w bardzo prymitywny sposób - każda sytuacja opisana oddzielnym casem , jest duplikacja kodu
public static void main(String[] args) {
String miesiac = JOptionPane.showInputDialog("Podaj nazwę miesiąca");
switch(miesiac) {
case "styczeń":
JOptionPane.showMessageDialog(null, "31 dni");
break;
case "luty":
JOptionPane.showMessageDialog(null, "28 lub 29 dni");
break;
case "marzec":
JOptionPane.showMessageDialog(null, "31 dni");
break;
case "kwiecień":
JOptionPane.showMessageDialog(null, "30 dni");
break;
case "maj":
JOptionPane.showMessageDialog(null, "31 dni");
break;
case "czerwiec":
JOptionPane.showMessageDialog(null, "30 dni");
break;
case "lipiec":
JOptionPane.showMessageDialog(null, "31 dni");
break;
case "sierpień":
JOptionPane.showMessageDialog(null, "31 dni");
break;
case "wrzesień":
JOptionPane.showMessageDialog(null, "30 dni");
break;
case "październik":
JOptionPane.showMessageDialog(null, "31 dni");
break;
case "listopad":
JOptionPane.showMessageDialog(null, "30 dni");
break;
case "grudzień":
JOptionPane.showMessageDialog(null, "31 dni");
break;
default:
JOptionPane.showMessageDialog(null, "Nieznany miesiąc " + miesiac, "Błąd", JOptionPane.ERROR_MESSAGE);
}
}
}
src/main/java/gotowe1/p05_switch/IleDniMaMiesiac2.java deleted 100644 → 0
package gotowe1.p05_switch;
import javax.swing.JOptionPane;
public class IleDniMaMiesiac2 {
// Wersja z tradycyjnym switch z : i break. - działa w starych wersjach Javy oraz w C
// W tej wersji staramy się grupować przypadki z taką samą odpowiedzią.
// Jeśli napiszemy wiele case-ów bez break, to dla każdego z nich wykonamy taką samą rzecz.
// W przypadku lutego zadajemy dodatkowe pytanie o rok przestępny.
public static void main(String[] args) {
String miesiac = JOptionPane.showInputDialog("Podaj nazwę miesiąca");
switch(miesiac) {
case "styczeń":
case "marzec":
case "maj":
case "lipiec":
case "sierpień":
case "październik":
case "grudzień":
JOptionPane.showMessageDialog(null, "31 dni");
break;
case "kwiecień":
case "czerwiec":
case "wrzesień":
case "listopad":
JOptionPane.showMessageDialog(null, "30 dni");
break;
case "luty":
if(JOptionPane.showConfirmDialog(null, "Czy to jest rok przestępny?") == JOptionPane.YES_OPTION) {
JOptionPane.showMessageDialog(null, "29 dni");
} else {
JOptionPane.showMessageDialog(null, "28 dni");
}
break;
default:
JOptionPane.showMessageDialog(null, "Nieznany miesiąc " + miesiac, "Błąd", JOptionPane.ERROR_MESSAGE);
}
}
}
src/main/java/gotowe1/p05_switch/IleDniMaMiesiac3.java deleted 100644 → 0
package gotowe1.p05_switch;
import javax.swing.JOptionPane;
public class IleDniMaMiesiac3 {
// Wersja dla Javy 14:
// Dzięki użyciu -> nie trzeba pisać break.
// W przypadku lutego zadajemy dodatkowe pytanie o rok przestępny - trzeba to umieścić w {bloku}.
// Od Javy 14 wiele wartości można umieścić w jednym case rozdzielając przecinkiem ,
// W tej wersji wielkość liter jest ignorowana, dzięki temu, że napis użytkownika zamieniamy na małe litery
// I usuwamy niepotrzebne spacje.
public static void main(String[] args) {
String miesiac = JOptionPane.showInputDialog("Podaj nazwę miesiąca");
switch(miesiac.strip().toLowerCase()) {
case "styczeń", "marzec", "maj", "lipiec", "sierpień", "październik", "grudzień" ->
JOptionPane.showMessageDialog(null, "31 dni");
case "kwiecień", "czerwiec", "wrzesień", "listopad" ->
JOptionPane.showMessageDialog(null, "30 dni");
case "luty" -> {
if(JOptionPane.showConfirmDialog(null, "Czy to jest rok przestępny?") == JOptionPane.YES_OPTION) {
JOptionPane.showMessageDialog(null, "29 dni");
} else {
JOptionPane.showMessageDialog(null, "28 dni");
}
}
default ->
JOptionPane.showMessageDialog(null, "Nieznany miesiąc " + miesiac, "Błąd", JOptionPane.ERROR_MESSAGE);
}
}
}
src/main/java/gotowe1/p05_switch/IleDniMaMiesiac4.java deleted 100644 → 0
package gotowe1.p05_switch;
import javax.swing.JOptionPane;
public class IleDniMaMiesiac4 {
/* W tej wersji używamy "switch expression".
* W prostych przypadkach (30 lub 31 dni) wystarczy wpisac wartośc za strzałką ->
* W przypadku lutego mamy dodatkowego if-a i aby w tej sytuacji (generalnie: gdy mamy {blok kodu})
* to wynik switcha zwracamy za pomocą słowa kluczowego yield.
*
* Z kolei w przypadku niepoprawnej nazwy nie ma żadnego wyniku - zamiast tego wyrzucamy wyjątek.
*/
public static void main(String[] args) {
String miesiac = JOptionPane.showInputDialog("Podaj nazwę miesiąca");
int ileDni = switch(miesiac.strip().toLowerCase()) {
case "styczeń", "marzec", "maj", "lipiec", "sierpień", "październik", "grudzień" ->
31;
case "kwiecień", "czerwiec", "wrzesień", "listopad" ->
30;
case "luty" -> {
int rok = Integer.parseInt(JOptionPane.showInputDialog("O który rok chodzi?"));
if(rok % 4 == 0 && rok % 100 != 0 || rok % 400 == 0) {
yield 29;
} else {
yield 28;
}
}
default -> throw new IllegalArgumentException("Nieznany miesiąc " + miesiac);
};
JOptionPane.showMessageDialog(null, "Miesiąc " + miesiac + " ma " + ileDni + " dni");
}
}
src/main/java/gotowe1/p06_liczby/BityIBajty.java deleted 100644 → 0
package gotowe1.p06_liczby;
public class BityIBajty {
public static void main(String[] args) {
System.out.println("Zwiększanie bajta:");
byte b = 0;
for (int i = 1; i <= 260; i++) {
String bity = Integer.toBinaryString(Byte.toUnsignedInt(b));
bity = String.format("%8s", bity);
bity = bity.replace(' ', '0');
System.out.printf("%4d : %s%n", b, bity);
b++;
}
}
}
src/main/java/gotowe1/p06_liczby/Ciekawostki.java deleted 100644 → 0
package gotowe1.p06_liczby;
public class Ciekawostki {
public static void main(String[] args) {
// Liczby całkowite mają ograniczony zakres,
// a wyjście poza ten zakres (gdy wynik obliczenia nie mieści się w zakresie)
// daje w efekcie "integer overflow", czyli przekręcenie licznika
int miliard = 1_000_000_000;
System.out.println(2 * miliard);
System.out.println(3 * miliard);
System.out.println(5 * miliard); // typ int - granica to nieco ponad 2 mld
System.out.println(5L * miliard); // typ long
System.out.println(10L * miliard * miliard); // ale long też ma swój limit
// To jest bardzo groźne, bo wychodzi błędny wynik i program działa dalej, ale pracuje na niepoprawnych danych.
// efekt: Ariane 5
// Sposób na obsługę liczb całkowitych bez limitu: BigInteger.
System.out.println();
// Obliczenia na liczbach zmiennoprzecinkowych (float oraz double) są nieprecyzyjne.
// Wewnętrznie liczba zapisana jest w systemie dwójkowym, a nie każdy ułamek dziesiętny da się w ten sposób zapisać.
// Liczby są pamiętane "w lekkim zniekształceniu", a niektóre operacje mogą ten błąd kumulować i staje się on coraz bardziej zauważalny.
double cena = 1.2;
System.out.println(3 * cena);
System.out.println();
// Sposób na obsługę liczb z ułamkiem dziesiętnym bez pomyłek: BigDecimal.
// Zalecany sposób liczenie pieniędzy w Javie.
int x = 0321;
// System ósemkowy (oktalny), czyli to jest równe 3×8² + 2×8 + 1 = 192 + 16 + 1 = 209
System.out.println("x = " + x);
System.out.println();
x = 19;
System.out.println(x / 5);
// Dzielenie całkowite (gdy l.całkowitą dzielimy przez całkowitą) daje w wyniku część całkowitą ilorazu.
// Część ułamkowa jest odrzucana; to nie jest zaokrąglenie, tylko obcięcie.
}
}
src/main/java/gotowe1/p06_liczby/Dzielenie.java deleted 100644 → 0
package gotowe1.p06_liczby;
public class Dzielenie {
public static void main(String[] args) {
double d = 1.25;
int n = 5;
// Uwaga na kolejność działań gdy miesza się inty i double
// Tutaj: int dzielony porzez int - wynik obcinany do liczby całkowitej
System.out.println(n / 3 * d);
// dzielenie na doublach
System.out.println(n * d / 3);
System.out.println(1.0 * n / 3 * d);
System.out.println((double)n / 3 * d);
System.out.println();
System.out.println("Dzielenie całkowite i reszta z dzielenia:");
for(int i = -10; i <= 10; i++) {
System.out.printf("%3d / 3 = %2d %3d %% 3 = %2d\n", i, i / 3, i, i % 3);
}
}
}
src/main/java/gotowe1/p06_liczby/JakSprawdzicOverflow.java deleted 100644 → 0
package gotowe1.p06_liczby;
import java.util.Scanner;
public class JakSprawdzicOverflow {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("Podaj pierwszą liczbę: ");
int x = sc.nextInt();
System.out.println("Podaj drugą liczbę: ");
int y = sc.nextInt();
int iloczyn = x * y;
System.out.println("Wynik zwykłego mnożenia: " + iloczyn);
try {
int sprawdzony = Math.multiplyExact(x, y);
System.out.println("Wynik zabezpieczonego mnożenia: " + sprawdzony);
} catch (ArithmeticException e) {
System.out.println("Overflow");
}
}
}
// YT "Ariane 5"
// przerwa do 13:30
src/main/java/gotowe1/p06_liczby/LiteralyLiczbowe.java deleted 100644 → 0
package gotowe1.p06_liczby;
public class LiteralyLiczbowe {
public static void main(String[] args) {
int x;
x = 123; // format dziesiętny
System.out.println(x);
x = 0123; // system ósemkowy
//NK x = 08; // cyfry od 0 do 7
System.out.println(x);
x = 0x100; // system szesnastkowy
System.out.println(x);
x = 0x7F;
System.out.println(x);
// system dwójkowy - od Javy 7
x = 0b1101;
System.out.println(x);
// odstępy pomiędzy cyframi - od Javy 7
x = 2_000_000;
System.out.println(x);
//NK long l = 4000000000; // wartość nie mieszcząca się w int
long l = 4000000000L; // OK
// int _1000 = 1313;
// x = _1000; // odwołanie do zmiennej :)
// x = 1000_;
x = 10______00; // po prostu tysiąc
// dopuszczalne są tylko pomiędzy cyframi.
// nie na początku, nie na końcu, nie obok kropki ani obok litery typu i wykładnika
x = 0x0F_FF_80_00;
x = 0b0011_0101;
System.out.println(x); // 1000
double dd = 10__00;
dd = 3.14; // literał liczbowy z częścią ułamkową jest typu double (a nie float)
dd = 1_00.0__0;
//dd = 100._9;
//dd = 100_.9;
dd = 100.99d;
//dd = 100.99_f;
// x = 0x_FF;
// NK x = 1L; // L na końcu oznacza typ long (może być duże lub małe)
l = 1L;
l = 1; // inta można wpisać na zmienną long
System.out.println();
float f = 12; // int na float - OK
// f = 3.14;
// literał z ułamkiem jest typu double, a double nie można wpisać na float
f = 3.14F;
f = 1.0f;
f = 3f;
f = 1.13e2F;
f = (float)3.14; // kompiluje się, ale niezalecane, bo można zgubić precyzję
System.out.println(f);
double d = 3.14;
// NK f = d;
// na końcu double'a też można podać info o typie: D albo d
d = 4.44d;
d = 4.445D;
// liczba w notacji dziesiętnej razy 10 do podanej potęgi
d = 1.25e3;
System.out.println(d);
d = 4.44e-3;
System.out.println(d);
System.out.println();
// liczba w notacji szestastkowej razy 2 do podanej potęgi - tak to jest przechowywane wewnętrznie!
d = 0x3p2; // 12
System.out.println(d);
d = 0x0.2p0; // 2/16 = 1/8 = 0.125
System.out.println(d);
d = 0x1p-3;
System.out.println(d);
}
}
src/main/java/gotowe1/p06_liczby/Mnozenie1_Int.java deleted 100644 → 0
package gotowe1.p06_liczby;
import java.util.Scanner;
public class Mnozenie1_Int {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("Podaj dwie liczby do pomnożenia: ");
long x = scanner.nextLong();
long y = scanner.nextLong();
long wynik = x * y;
System.out.println("wynik normalnego mnożenia: " + wynik);
// operacje matematyczne pod większą kontrolą (ale działające wolniej):
try {
long wynik2 = Math.multiplyExact(x, y);
System.out.println("wynik exact mnożenia: " + wynik2);
} catch(ArithmeticException e) {
System.out.println("wynik nie mieści się w zakresie");
}
}
}
src/main/java/gotowe1/p06_liczby/Mnozenie2_Long.java deleted 100644 → 0
package gotowe1.p06_liczby;
import java.util.Scanner;
public class Mnozenie2_Long {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("Podaj dwie liczby do pomnożenia: ");
int x = scanner.nextInt();
int y = scanner.nextInt();
int wynik = x * y;
System.out.println("wynik normalnego mnożenia: " + wynik);
// operacje matematyczne pod większą kontrolą (ale działające wolniej):
try {
int wynik2 = Math.multiplyExact(x, y);
System.out.println("wynik exact mnożenia: " + wynik2);
} catch(ArithmeticException e) {
System.out.println("wynik nie mieści się w zakresie");
}
}
}
src/main/java/gotowe1/p06_liczby/Mnozenie3_Double.java deleted 100644 → 0
package gotowe1.p06_liczby;
import java.math.BigDecimal;
import java.util.Locale;
import java.util.Scanner;
public class Mnozenie3_Double {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
scanner.useLocale(Locale.US);
System.out.println("Podaj dwie liczby do pomnożenia: ");
double x = scanner.nextDouble();
double y = scanner.nextDouble();
double wynik = x * y;
System.out.println("wynik mnożenia: " + wynik);
BigDecimal x_dokladny = new BigDecimal(x);
BigDecimal y_dokladny = new BigDecimal(y);
BigDecimal w_dokladny = new BigDecimal(wynik);
System.out.println("\nDokładnie w pamięci komputera");
System.out.println("x = " + x_dokladny);
System.out.println("y = " + y_dokladny);
System.out.println("w = " + w_dokladny);
}
}
src/main/java/gotowe1/p06_liczby/WypiszZakresy.java deleted 100644 → 0
package gotowe1.p06_liczby;
public class WypiszZakresy {
public static void main(String[] args) {
System.out.println("byte " + Byte.BYTES + " bajtów, od " + Byte.MIN_VALUE + " do " + Byte.MAX_VALUE);
System.out.println("short " + Short.BYTES + " bajtów, od " + Short.MIN_VALUE + " do " + Short.MAX_VALUE);
System.out.println("int " + Integer.BYTES + " bajtów, od " +Integer.MIN_VALUE + " do " + Integer.MAX_VALUE);
System.out.println("long " + Long.BYTES + " bajtów, od " +Long.MIN_VALUE + " do " + Long.MAX_VALUE);
System.out.println("char " + Character.BYTES + " bajtów, od " + (int) Character.MIN_VALUE + " do " + (int) Character.MAX_VALUE);
System.out.println();
// bez ograniczen: klasy BigInteger (calkowite) i BigDecimal (z ulamkiem)
System.out.println("float " + Float.BYTES + " bajtów, od " +Float.MIN_VALUE + " do " + Float.MAX_VALUE);
System.out.println(" min normal : " + Float.MIN_NORMAL);
System.out.println("double " + Double.BYTES + " bajtów, od " +Double.MIN_VALUE + " do " + Double.MAX_VALUE);
System.out.println(" min normal : " + Double.MIN_NORMAL);
System.out.println();
System.out.println("boolean : false i true");
}
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment