Skip to content

A
alx_java1
Commit 8ad1df8d by Patryk Czarnik
Options

niedziala rano

parents
Showing with 1540 additions and 0 deletions
.gitignore 0 → 100644
target/
!.mvn/wrapper/maven-wrapper.jar
!**/src/main/**/target/
!**/src/test/**/target/
### IntelliJ IDEA ###
/.idea/
*.iws
*.iml
*.ipr
### Eclipse ###
.apt_generated
.classpath
.factorypath
.project
.settings/
.springBeans
.sts4-cache
### NetBeans ###
/nbproject/private/
/nbbuild/
/dist/
/nbdist/
/.nb-gradle/
build/
!**/src/main/**/build/
!**/src/test/**/build/
### VS Code ###
.vscode/
### Mac OS ###
.DS_Store
\ No newline at end of file
pom.xml 0 → 100644
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>org.example</groupId>
<artifactId>alx_java1</artifactId>
<version>1.0-SNAPSHOT</version>
<properties>
<maven.compiler.source>17</maven.compiler.source>
<maven.compiler.target>17</maven.compiler.target>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
</project>
\ No newline at end of file
src/main/java/gotowe1/p01_okna_dialogowe/RodzajeOkien.java 0 → 100644
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 0 → 100644
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 0 → 100644
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 0 → 100644
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 0 → 100644
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 0 → 100644
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 0 → 100644
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 0 → 100644
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 0 → 100644
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 0 → 100644
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 0 → 100644
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 0 → 100644
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 0 → 100644
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 0 → 100644
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 0 → 100644
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 0 → 100644
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 0 → 100644
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 0 → 100644
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 0 → 100644
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 0 → 100644
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 0 → 100644
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 0 → 100644
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 0 → 100644
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 0 → 100644
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 0 → 100644
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 0 → 100644
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 0 → 100644
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 0 → 100644
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 0 → 100644
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/p01_okna_dialogowe/Main.java 0 → 100644
package p01_okna_dialogowe;
// Press Shift twice to open the Search Everywhere dialog and type `show whitespaces`,
// then press Enter. You can now see whitespace characters in your code.
public class Main {
public static void main(String[] args) {
// Press Alt+Enter with your caret at the highlighted text to see how
// IntelliJ IDEA suggests fixing it.
System.out.printf("Hello and welcome!");
// Press Shift+F10 or click the green arrow button in the gutter to run the code.
for (int i = 1; i <= 5; i++) {
// Press Shift+F9 to start debugging your code. We have set one breakpoint
// for you, but you can always add more by pressing Ctrl+F8.
System.out.println("i = " + i);
}
}
}
\ No newline at end of file
src/main/java/p01_okna_dialogowe/Rozmowa.java 0 → 100644
package p01_okna_dialogowe;
import javax.swing.*;
import java.time.LocalDateTime;
public class Rozmowa {
public static void main(String[] args) {
JOptionPane.showMessageDialog(null, "Teraz jest " + LocalDateTime.now());
String imie = JOptionPane.showInputDialog("Jak masz na imię?");
int wiek = Integer.parseInt(JOptionPane.showInputDialog("Ile masz lat, " + imie + "?"));
if(wiek >= 18) {
JOptionPane.showMessageDialog(null, "Cześć " + imie +", chodź na piwo");
} else {
JOptionPane.showMessageDialog(null, "Niepełnoletni dostają mleko",
"Ostrzeżenie", JOptionPane.WARNING_MESSAGE);
}
}
}
src/main/java/p01_okna_dialogowe/RozmowaBezImportow.java 0 → 100644
package p01_okna_dialogowe;
// W Javie import nie "ładuje" klas, tylko służy wskazaniu o jaką klasę mi chodzi
// W Javie zawsze da się napisać program bez użycia import - trzeba wtedy wskazać pakiet przed każdym odwołaniem do klasy
public class RozmowaBezImportow {
public static void main(String[] args) {
javax.swing.JOptionPane.showMessageDialog(null, "Teraz jest " + java.time.LocalDateTime.now());
String imie = javax.swing.JOptionPane.showInputDialog("Jak masz na imię?");
int wiek = Integer.parseInt(javax.swing.JOptionPane.showInputDialog("Ile masz lat, " + imie + "?"));
if(wiek >= 18) {
javax.swing.JOptionPane.showMessageDialog(null, "Cześć " + imie +", chodź na piwo");
} else {
javax.swing.JOptionPane.showMessageDialog(null, "Niepełnoletni dostają mleko",
"Ostrzeżenie", javax.swing.JOptionPane.WARNING_MESSAGE);
}
}
}
src/main/java/p01_okna_dialogowe/Rozmowa_WyjasnienieParenta.java 0 → 100644
package p01_okna_dialogowe;
import javax.swing.*;
public class Rozmowa_WyjasnienieParenta {
public static void main(String[] args) {
JFrame okno = new JFrame("Okno");
okno.setSize(600, 400);
okno.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
okno.setVisible(true);
String imie = JOptionPane.showInputDialog(okno, "Jak masz na imię?");
int wiek = Integer.parseInt(JOptionPane.showInputDialog("Ile masz lat, " + imie + "?"));
if(wiek >= 18) {
JOptionPane.showMessageDialog(okno, "Cześć " + imie +", chodź na piwo");
} else {
JOptionPane.showMessageDialog(okno, "Niepełnoletni dostają mleko",
"Ostrzeżenie", JOptionPane.WARNING_MESSAGE);
}
}
}
src/main/java/p01_okna_dialogowe/WymiaryPomieszczenia.java 0 → 100644
package p01_okna_dialogowe;
import javax.swing.*;
/* Program wczytuje dwie liczby: długość i szerokość pokoju
oblicza pole powierzchni oraz obwód tego pokoju.
*/
public class WymiaryPomieszczenia {
public static void main(String[] args) {
int dlugosc = Integer.parseInt(JOptionPane.showInputDialog("Podaj długość"));
int szerokosc = Integer.parseInt(JOptionPane.showInputDialog("Podaj szerokość"));
int pole = dlugosc * szerokosc;
int obwod = 2 * dlugosc + 2 * szerokosc;
JOptionPane.showMessageDialog(null,
"Pole = " + pole + "\nObwód = " + obwod);
}
}
src/main/java/p01_okna_dialogowe/WymiaryPomieszczeniaDouble.java 0 → 100644
package p01_okna_dialogowe;
import javax.swing.*;
/* Program wczytuje dwie liczby: długość i szerokość pokoju
oblicza pole powierzchni oraz obwód tego pokoju.
*/
public class WymiaryPomieszczeniaDouble {
public static void main(String[] args) {
double dlugosc = Double.parseDouble(JOptionPane.showInputDialog("Podaj długość"));
double szerokosc = Double.parseDouble(JOptionPane.showInputDialog("Podaj szerokość"));
double pole = dlugosc * szerokosc;
double obwod = 2 * dlugosc + 2 * szerokosc;
JOptionPane.showMessageDialog(null,
"Pole = " + pole + "\nObwód = " + obwod);
}
}
src/main/java/p02_scanner/CzytaniePliku.java 0 → 100644
package p02_scanner;
import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;
public class CzytaniePliku {
public static void main(String[] args) throws FileNotFoundException {
// Deklaruję zmienną scanner typu Scanner i wpisuję do niej nowy obiekt klasy Scanner,
// który będzie czytać dane z podanego pliku
Scanner scanner = new Scanner(new File("wejscie.txt"));
// Zadajemy pytanie i pobieramy odpowiedź:
System.out.println("Wpisz linię tekstu:");
String linia = scanner.nextLine();
System.out.println("Twój tekst: " + linia);
// Scanner potrafi wczytywać dane liczbowe i pojedyncze słowa:
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("Iloczyn tych liczb: " + (x*y));
}
}
src/main/java/p02_scanner/DzialanieScannera.java 0 → 100644
package p02_scanner;
import java.util.Scanner;
public class DzialanieScannera {
public static void main(String[] args) {
// Deklaruję zmienną scanner typu Scanner i wpisuję do niej nowy obiekt klasy Scanner,
// który będzie czytać dane ze standardowego wejścia (System.in)
Scanner scanner = new Scanner(System.in);
// Zadajemy pytanie i pobieramy odpowiedź:
System.out.println("Wpisz linię tekstu:");
String linia = scanner.nextLine();
System.out.println("Twój tekst: " + linia);
// Scanner potrafi wczytywać dane liczbowe i pojedyncze słowa:
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("Iloczyn tych liczb: " + (x*y));
}
}
src/main/java/p02_scanner/Zakupy1.java 0 → 100644
package p02_scanner;
/* Program za pomocą Scannera czyta 3 informacje:
- nazwa produktu
- cena jednostkowa
- liczba sztuk
a następnie oblicza kwotę do zapłaty i wypisuje komunikat takiej postaci:
Za 5 sztuk towaru kawa zapłacisz 25.50
(nazwę towaru oraz kwotę należy podstawić ze zmiennych)
*/
import java.util.Scanner;
public class Zakupy1 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("Co chcesz kupić? ");
String towar = scanner.nextLine();
System.out.print("Ile kosztuje jedna sztuka? ");
double cena = scanner.nextDouble();
System.out.print("Ile sztuk " + towar + " kupujesz? ");
int sztuk = scanner.nextInt();
double wartosc = cena * sztuk;
System.out.println("Za " + sztuk + " sztuk towaru " + towar + " zapłacisz " + wartosc);
}
}
src/main/java/p02_scanner/Zakupy2.java 0 → 100644
package p02_scanner;
import java.util.Scanner;
public class Zakupy2 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("Co chcesz kupić? ");
String towar = scanner.nextLine();
System.out.print("Ile kosztuje jedna sztuka? ");
double cena = scanner.nextDouble();
System.out.print("Ile sztuk " + towar + " kupujesz? ");
int sztuk = scanner.nextInt();
double wartosc = cena * sztuk;
System.out.printf("Za %d sztuk towaru %s zapłacisz %.2f zł\n", sztuk, towar, wartosc);
}
}
src/main/java/p02_scanner/Zakupy3_BigDecimal.java 0 → 100644
package p02_scanner;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.Locale;
import java.util.Scanner;
// Ta wersja:
// - używa BigDecimal do obliczeń, aby były w pełni precyzyjne
// - zmiania ustawienia regionalne w Scannerze na amerykańskie, aby użytkownik wpisywał liczbę z kropką
public class Zakupy3_BigDecimal {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
scanner.useLocale(Locale.US);
System.out.print("Co chcesz kupić? ");
String towar = scanner.nextLine();
System.out.print("Ile kosztuje jedna sztuka? ");
BigDecimal cena = scanner.nextBigDecimal();
System.out.print("Ile sztuk " + towar + " kupujesz? ");
int sztuk = scanner.nextInt();
BigDecimal wartosc = cena.multiply(BigDecimal.valueOf(sztuk));
// Gdybyśmy chcieli wynik zaokrąglićd o2 miejsc pp , to w taki sposób:
// wartosc = wartosc.setScale(2, RoundingMode.HALF_UP);
System.out.printf("Za %d sztuk towaru %s zapłacisz %s zł\n", sztuk, towar, wartosc);
}
}
src/main/java/p03_if/Bagaz1.java 0 → 100644
package p03_if;
/* Program odczytuje 3 liczby - wymiary bagażu w cm.
Program sprawdza, czy bagaż mieści się w wymaganiach:
- żaden wymiar nie może przekroczyć 50 cm
- objętość nie może przekroczyć 50 tys cm3
Program ma napisać, czy bagaż spełnia normę, czy nie.
*/
import java.util.Scanner;
public class Bagaz1 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("Podaj trzy liczby - wymiary bagażu w cm:");
int a = scanner.nextInt();
int b = scanner.nextInt();
int c = scanner.nextInt();
int obj = a*b*c;
// w tej wersji sprawdzmy wszystko w jednym ifie i dajemy ogólną informację, że było dobrze lub źle
// warunek pozyywny "czy jest dobrze?"
if(a <= 50 && b <= 50 && c <= 50 && obj <= 50_000) {
System.out.println("OK");
} else {
System.out.println("bagaż odrzucony");
}
}
}
src/main/java/p03_if/Bagaz2.java 0 → 100644
package p03_if;
import java.util.Scanner;
public class Bagaz2 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("Podaj trzy liczby - wymiary bagażu w cm:");
int a = scanner.nextInt();
int b = scanner.nextInt();
int c = scanner.nextInt();
int obj = a*b*c;
// w tej wersji sprawdzmy wszystko w jednym ifie i dajemy ogólną informację, że było dobrze lub źle
// warunek negatywny "czy jest źle?"
if (a > 50 || b > 50 || c > 50 || obj > 50_000) {
System.out.println("bagaż odrzucony");
} else {
System.out.println("OK");
}
}
}
src/main/java/p03_if/Bagaz3.java 0 → 100644
package p03_if;
import java.util.Scanner;
public class Bagaz3 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("Podaj długość: ");
int dlugosc = scanner.nextInt();
System.out.print("Podaj szerokość: ");
int szerokosc = scanner.nextInt();
System.out.print("Podaj wysokość: ");
int wysokosc = scanner.nextInt();
int objetosc = dlugosc*szerokosc*wysokosc;
if (dlugosc <= 50) {
if (szerokosc <= 50) {
if (wysokosc <= 50) {
if (objetosc <= 50_000) {
System.out.println("Bagaż zaakceptowany");
} else {
System.out.println("objętość za duża");
}
} else {
System.out.println("wysokość za duża");
}
} else {
System.out.println("szerokość za duża");
}
} else {
System.out.println("długość za duża");
}
}
}
src/main/java/p03_if/Bagaz4.java 0 → 100644
package p03_if;
import java.util.Scanner;
public class Bagaz4 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("Podaj długość: ");
int dlugosc = scanner.nextInt();
System.out.print("Podaj szerokość: ");
int szerokosc = scanner.nextInt();
System.out.print("Podaj wysokość: ");
int wysokosc = scanner.nextInt();
int objetosc = dlugosc*szerokosc*wysokosc;
if (dlugosc > 50) {
System.out.println("długość za duża");
} else if (szerokosc > 50) {
System.out.println("szerokość za duża");
} else if (wysokosc > 50) {
System.out.println("wysokość za duża");
} else if (objetosc > 50_000) {
System.out.println("objętość za duża");
} else {
System.out.println("Bagaż zaakceptowany");
}
}
}
src/main/java/p03_if/Bagaz5.java 0 → 100644
package p03_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.print("Podaj długość: ");
int dlugosc = scanner.nextInt();
System.out.print("Podaj szerokość: ");
int szerokosc = scanner.nextInt();
System.out.print("Podaj wysokość: ");
int wysokosc = scanner.nextInt();
int objetosc = dlugosc*szerokosc*wysokosc;
List<String> bledy = new ArrayList<>();
if (dlugosc > 50) {
bledy.add("długość za duża");
}
if (szerokosc > 50) {
bledy.add("szerokość za duża");
}
if (wysokosc > 50) {
bledy.add("wysokość za duża");
}
if (objetosc > 50_000) {
bledy.add("objętość za duża");
}
// po zebraniu informacji sprawdzam, czy wystąpiły jakiekolwiek błędy
if(bledy.isEmpty()) {
System.out.println("Bagaż zaakceptowany");
} else {
System.out.println("Wystąpiły błędy: ");
for (String blad : bledy) {
System.out.println(" * " + blad);
}
}
}
}
src/main/java/p03_if/TeoriaIf.java 0 → 100644
package p03_if;
import java.util.Random;
public class TeoriaIf {
public static void main(String[] args) {
// Wylosuję sobie liczbę:
Random random = new Random();
int x = random.nextInt(100) - 50; // liczba z zakresu od -50 do 49
System.out.println("Wysolowana liczba: " + x);
// podstawowa wersja if:
if(x % 2 == 0) {
System.out.println("liczba parzysta");
System.out.println("Wynik dzielenia przez 2 = " + x / 2);
} else {
System.out.println("liczba nieparzysta");
}
// Gdy do wykonania jest tylko jedna instrukcja, można nie brać jej w {nawiasy klamrowe}
// ale większośc ludzi powie "lepiej na wszelki wypadek {wziąć w nawiasy}"
// Istnieje wersja if bez else:
if(Math.abs(x % 10) == 7) {
System.out.println("Ostatnią cyfrą jest 7");
}
// W Pythonie można używać słowa kluczowego elif, aby utworzyć ifa z wieloma gałęziami
// W Javie zamiast tego używa się połączenie słów else if pisząc je w jednej linii:
if(x > 0) {
System.out.println("liczba dodatnia");
} else if(x < 0) {
System.out.println("liczba ujemna");
} else {
System.out.println("zero");
}
// W Pythonie jako warunek można przekazać liczbę, napis, listę, ...
// Np. if lista:
// będzie prawdą, jeśli lista jest niepusta
// W Javie nie ma żadnych automatycznych konwersji innych typów na typ logiczny
// if(x) {
// System.out.println("W Pythonie i w C to by zadziałało, gdy x nie jest zerem");
// }
System.out.println();
int y = random.nextInt(100) - 50;
System.out.println("x: " + x + " , y: " + y);
// spójniki logiczne
// && czyli and, "i", koniunkcja
if(x > 0 && y > 0) {
System.out.println("Obie liczby są dodatnie");
} else {
System.out.println("Przynajmniej jedna z liczb nie jest dodatnia");
}
// || czyli or, "lub", alternatywa
if(x > 0 || y > 0) {
System.out.println("Co najmniej jedna z liczb jest dodatnia");
} else {
System.out.println("Żadna z liczb nie jest dodatnia");
}
// alternatywa rozłączna, "albo", "xor" zapisuje się ^
// tego w praktyce się nie używa
// negacja !
String napis = "raz raz...";
if(!napis.isEmpty()) {
System.out.println("napis nie jest pusty");
}
}
}
wejscie.txt 0 → 100644
Pierwsza linia pliku, lalalalala
5432
1,23
\ No newline at end of file
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