Skip to content

2
20250331
Commit ad56980e by Patryk Czarnik
Options

pierwsza porcja "gotowe"

parent b5e2f163
Showing with 4502 additions and 0 deletions
src/main/java/gotowe/p01_interakcja/argumenty/Argumenty.java 0 → 100644
package gotowe.p01_interakcja.argumenty;
/*
Gdy uruchamiamy jakiś program w systemowym wierszu poleceń,
możemy po jego nazwie podać dowolne napisy – argumenty programu.
java pcz.p01_interakcja.argumenty.Argumenty Jeden Dwa "Ala ma kota" Cztery
*/
public class Argumenty {
public static void main(String[] args) {
System.out.println("Liczba argumentów: " + args.length);
// System.out.println("Argument nr 1: " + args[1]);
for(String arg: args) {
System.out.println(arg);
}
}
}
src/main/java/gotowe/p01_interakcja/konsola/A_Print.java 0 → 100644
package gotowe.p01_interakcja.konsola;
import java.util.Locale;
public class A_Print {
public static void main(String[] args) {
// println wypisuje coś i potem przechodzi do nast. linii
System.out.println("Wypisuję pierwszą linię");
System.out.println("Wypisuję drugą linię");
System.err.println("To jest niby błąd");
// pusty println - pusta linia
System.out.println();
// print - wypisuje coś i nie przechodzi do nowej linii
System.out.print("Ala");
System.out.print("Ola");
System.out.print("Ela");
System.out.println("Koniec");
int x = 50;
String s = "Ala";
// print, println przyjmują dowolne parametry
System.out.println(x);
// ale przyjmują tylko jeden parametr
//System.out.println("Liczba:", x);
// Jeśli chcemy wypisać kilka rzeczy, to najczęściej łączy się je znakiem +
// Do napisu można dodać także inne wartoścu (liczby, obiekty...)
System.out.println("Liczba: " + x);
System.out.println();
// W Javie dostępne jest też printf, prawie takie samo jak w C i podobne jak % w Pythonie.
// Pierwszym parametrem jest wzorzec (pattern), w którym są normalne fragmenty tekstu oraz znaczniki %X,
// na które są wstawiane wartości podane później po przecinku.
// %s - string lub dowolna wartość przekonwertowana na tekst tak, jakbyśmy wypisali ją printem
// %d - liczba całkowita
// %f - liczba z ułamkiem
// %x - liczba szesnastkowo
System.out.printf("Osoba %s ma %d lat.\n", s, x);
double pi = Math.PI;
// Zostaną użyte "lokale" z ustawień systemu, u mnie polskie - liczba wypisuje się z przecinkiem
System.out.printf("|%10s|%4d|%-4d|%04d|%6.3f|%n", s, x, x, x, pi);
// Wskazuję lokale amerykańskie - liczba wypisze się z kropką
System.out.printf(Locale.US, "|%10s|%4d|%-4d|%04d|%6.3f|%n", s, x, x, x, pi);
System.out.println();
// Jeśli bardzo potrzebujemy, to na standadowe wyjście można wypisywać też dane binarne.
System.out.write(65);
System.out.write(66);
System.out.write(67);
System.out.write(10);
}
}
src/main/java/gotowe/p01_interakcja/konsola/B_SuroweWejscie1.java 0 → 100644
package gotowe.p01_interakcja.konsola;
import java.io.IOException;
public class B_SuroweWejscie1 {
public static void main(String[] args) throws IOException {
System.out.println("Napisz coś");
// Wczytanie jednego bajtu z wejścia - w praktyce to co odczytamy, jest kodem pierwszej litery.
int x = System.in.read();
System.out.println("wartość x: " + x);
}
}
src/main/java/gotowe/p01_interakcja/konsola/B_SuroweWejscie2.java 0 → 100644
package gotowe.p01_interakcja.konsola;
import java.io.IOException;
import java.nio.charset.Charset;
import java.util.Arrays;
public class B_SuroweWejscie2 {
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);
}
}
src/main/java/gotowe/p01_interakcja/konsola/C_Skaner1.java 0 → 100644
package gotowe.p01_interakcja.konsola;
import java.util.Scanner;
public class C_Skaner1 {
public static void main(String[] args) {
// Tworzymy obiekt klasy Scanner. Ten skaner będzie czytał dane ze standardowego wejścia.
Scanner sc = new Scanner(System.in);
System.out.println("Napisz linię tekstu:");
String linia = sc.nextLine();
System.out.println("Napisałeś: " + linia);
System.out.println("Wpisz liczbę całkowitą:");
int x = sc.nextInt();
System.out.println("Wpisz liczbę z przecinkiem (!):");
double d = sc.nextDouble();
System.out.println("Liczby: " +x + " , " + d);
System.out.print("Wpisz dwa słowa: ");
String slowo1 = sc.next();
String slowo2 = sc.next();
System.out.println("Pierwsze: " + slowo1);
System.out.println("Drugie : " + slowo2);
// Gdy teraz wczytam "linię" co tam będzie? Reszta linii wpisana za tymi ↑ dwoma słowami
linia = sc.nextLine();
System.out.println("Linia zawiera: " + linia);
System.out.println("KONIEC");
}
}
src/main/java/gotowe/p01_interakcja/konsola/C_Skaner2_LiczbaCzyNieLiczba.java 0 → 100644
package gotowe.p01_interakcja.konsola;
import java.util.Scanner;
public class C_Skaner2_LiczbaCzyNieLiczba {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("Napisz coś:");
if(sc.hasNextInt()) {
int liczba = sc.nextInt();
System.out.println("Wpisałeś int: " + liczba);
} else if(sc.hasNextDouble()) {
double liczba = sc.nextDouble();
System.out.println("Wpisałeś double: " + liczba);
} else {
String slowo = sc.next();
System.out.println("Wpisałeś tekst: " + slowo);
}
String reszta = sc.nextLine();
System.out.println("Reszta linii: " + reszta);
System.out.println("Reszta miała znaków: " + reszta.length());
}
}
src/main/java/gotowe/p01_interakcja/konsola/D_BufRead.java 0 → 100644
package gotowe.p01_interakcja.konsola;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
// Aby czytać wejście linia po linii, można użyć klas Scanner (inny przykład) lub BufferedReader (tutaj).
// Pośrednio potrzebna jest klasa InputStreamReader.
// Gdybyśmy chcieli podać własne kodowane znaków (inne niż systemowe), to wtedy:
// InputStreamReader isr = new InputStreamReader(System.in, "UTF-8");
public class D_BufRead {
public static void main(String[] args) {
try {
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader br = new BufferedReader(isr);
String wiersz;
while((wiersz = br.readLine()) != null) {
System.out.println("Napisałeś " + wiersz);
if("koniec".equalsIgnoreCase(wiersz))
break;
}
System.out.println("KONIEC");
} catch(IOException e) {
e.printStackTrace();
}
}
}
src/main/java/gotowe/p01_interakcja/konsola/E_KlasaConsole.java 0 → 100644
package gotowe.p01_interakcja.konsola;
import java.io.Console;
import java.util.Arrays;
public class E_KlasaConsole {
public static void main(String[] args) {
System.out.println("Początek");
Console konsola = System.console();
System.out.println("System.console() = " + konsola);
if(konsola == null) {
System.out.println("Brak możliwości utworzenia konsoli.");
return;
}
String wiersz;
while((wiersz = konsola.readLine("> ")) != null) {
konsola.printf("Napisałeś %s %n", wiersz);
if("koniec".equals(wiersz))
break;
}
System.out.println("KONIEC");
char[] hasło = konsola.readPassword("Podaj tajne hasło: ");
konsola.printf("Hasło ma długość %d %n", hasło.length);
// "zamazuję" hasło w pamięci, żeby inne programy nie mogły go odczytać
Arrays.fill(hasło, 'X');
}
}
src/main/java/gotowe/p01_interakcja/okna/OknoDialogowe1.java 0 → 100644
package gotowe.p01_interakcja.okna;
import javax.swing.JOptionPane;
/* Jednym ze sposobów komunikacji z użytkownikiem są okna dialogowe.
W Javie są one łatwe w użyciu (łatwiejsze niż pełnowartościowe aplikacje okienkowe),
korzysta się poprzez klasę JOptionPane.
Najważniejsze są trzy rodzaje okien dialogowych:
* showMessageDialog - tylko komunikat
* showInputDialog - pytanie i mozliwośc podania tekstowej odpowiedzi
* showConfirmDialog - pytanie i odpowiedź Yes/No/Cancel
*/
public class OknoDialogowe1 {
public static void main(String[] args) {
String imie = JOptionPane.showInputDialog("Jak masz na imię?");
JOptionPane.showMessageDialog(null, "Witaj " + imie);
}
}
src/main/java/gotowe/p01_interakcja/okna/OknoDialogowe2.java 0 → 100644
package gotowe.p01_interakcja.okna;
import javax.swing.JOptionPane;
public class OknoDialogowe2 {
public static void main(String[] args) {
String imie = JOptionPane.showInputDialog("Jak masz na imię?");
String wiekTekstowo = JOptionPane.showInputDialog("Ile masz lat, " + imie + "?");
int wiek = Integer.parseInt(wiekTekstowo);
if(wiek >= 18) {
JOptionPane.showMessageDialog(null, "Witaj " + imie + ", możesz kupić piwo :)");
} else {
JOptionPane.showMessageDialog(null, "Witaj " + imie + ", dla niepełnoletnich tylko cukierki...");
}
}
}
src/main/java/gotowe/p01_interakcja/okna/OknoDialogowe3.java 0 → 100644
package gotowe.p01_interakcja.okna;
import java.awt.HeadlessException;
import javax.swing.JOptionPane;
public class OknoDialogowe3 {
public static void main(String[] args) {
try {
String imie = JOptionPane.showInputDialog("Jak masz na imię?");
String wiekTekstowo = JOptionPane.showInputDialog("Ile masz lat, " + imie + "?");
int wiek = Integer.parseInt(wiekTekstowo);
if(wiek >= 18) {
JOptionPane.showMessageDialog(null, "Witaj " + imie + ", możesz kupić piwo :)");
} else {
JOptionPane.showMessageDialog(null, "Witaj " + imie + ", dla niepełnoletnich tylko cukierki...");
}
} catch(HeadlessException e) {
System.out.println("Brak interfejsu graficznego - nie pogadamy...");
} catch(NumberFormatException e) {
JOptionPane.showMessageDialog(null, "Nieprawidłowy format liczby", "Błąd", JOptionPane.ERROR_MESSAGE);
} catch(Exception e) {
JOptionPane.showMessageDialog(null, "Inny błąd " + e, "Błąd", JOptionPane.ERROR_MESSAGE);
}
}
}
src/main/java/gotowe/p01_interakcja/okna/RodzajeOkien.java 0 → 100644
package gotowe.p01_interakcja.okna;
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/gotowe/p02_zmienne/A_TeoriaZmiennych.java 0 → 100644
package gotowe.p02_zmienne;
public class A_TeoriaZmiennych {
public static void main(String[] args) {
System.out.println("Początek programu");
// Aby użyć zmiennej, trzeba ją zadeklarować.
//NK x = 15;
//NK System.out.println(x);
// Deklaracja zmiennej:
String txt;
int x, innaZmienna;
// Zmienne lokalne (czyli deklarowane wewnątrz metod)
// nie są automatycznie inicjowane na żadną wartość.
// Niezainicjowanych zmiennych lokalnych nie wolno odczytywać (błąd kompilacji).
//NK System.out.println(txt);
//NK System.out.println(x);
//NK x = 2 * x;
//NK x += 5;
// Instrukcja przypisania (assignment)
txt = "Ala";
x = 25;
System.out.println(x); // OK
System.out.println(txt); // OK
// ponowne przypisanie = zmiana wartości zmiennej
txt = "Ola";
x = x + 1;
System.out.println(x);
// Rozszerzone operatory przypisania:
x += 4; // równoważne x = x + 4
System.out.println(x);
// dostępne także dla innych operatorów
x *= 2;
System.out.println(x);
System.out.println();
// Zazwyczaj wartość zmiennej podaje się od razu w miejscu deklaracji (deklaracja z inicjalizacją):
int y = 100, z = 200;
String miasto = "Warszawa";
System.out.println(y + z);
System.out.println(miasto);
// Typowe podejście Javy:
// Zmienne lokalne deklaruje się dopiero kiedy są potrzebne
// i od razu podaje się ich początkową wartość.
}
}
src/main/java/gotowe/p02_zmienne/B_RodzajeZmiennych.java 0 → 100644
package gotowe.p02_zmienne;
//NK int globalna;
public class B_RodzajeZmiennych {
// zmienna statyczna - istnieje jeden egzemplarz w pamięci
static int statyczna = 10;
// zmienna instancyjna (inaczej: pole, atrybut) należy do obiektu
// Każdy obiekt tej klasy, w której jesteśmy, będzie posiadał taką zmienną
int instancyjna = 20;
public static void main(String[] args) {
// zmienna lokalna, czyli deklarowana w obrębie metody
int lokalna = 30;
metodaStatyczna(40);
// metody instancyjnej nie da się wywołać w kontekście statycznym (np. w main)
// metodaInstancyjna(50);
// Trzeba utworzyć obiekt i wywołać tę metodę na obiekcie.
// Tworzę obiekt, czyli "instancję"
B_RodzajeZmiennych obiekt = new B_RodzajeZmiennych();
obiekt.metodaInstancyjna(50);
System.out.println(statyczna);
System.out.println(obiekt.instancyjna);
B_RodzajeZmiennych innyObiekt = new B_RodzajeZmiennych();
innyObiekt.instancyjna = 123;
innyObiekt.metodaInstancyjna(33);
}
static void metodaStatyczna(int parametr) {
int lokalna = 60;
System.out.println("metodaStatyczna:");
System.out.println("statyczna: " + statyczna);
// m "kontekście statycznym", czyli w metodzie statycznej nie ma dostępu do zmiennych instancyjnych,
// bo "nie wiemy w jakim obiekcie"
//NK System.out.println("instancyjna: " + instancyjna);
System.out.println("lokalna: " + lokalna);
System.out.println("parametr: " + parametr);
System.out.println();
}
void metodaInstancyjna(int parametr) {
int lokalna = 70;
System.out.println("metodaInstancyjna:");
System.out.println("statyczna: " + statyczna);
System.out.println("instancyjna: " + instancyjna);
System.out.println("lokalna: " + lokalna);
System.out.println("parametr: " + parametr);
System.out.println();
}
}
src/main/java/gotowe/p02_zmienne/BlokiTekstowe.java 0 → 100644
package gotowe.p02_zmienne;
public class BlokiTekstowe {
public static void main(String[] args) {
String napis = """
Ala ma kota.
Ola ma psa.
Ela ma "chomika", \ttak tak.
""";
System.out.println(napis.length());
System.out.println(napis);
}
}
src/main/java/gotowe/p02_zmienne/C_Inicjalizacja.java 0 → 100644
package gotowe.p02_zmienne;
public class C_Inicjalizacja {
// zmienne statyczne - inicjowane domyślnie na 0, false lub null
static int st;
// zmienne instancyjne - inicjowane domyślnie na 0, false lub null
int inst;
public static void main(String[] args) {
// zmienne lokalne - nie są automatyczne inicjowane
int lokalna;
System.out.println(st); // 0
//NK System.out.println(inst); // próba dostępu do zmiennej niestatycznej w kontekście statycznym
C_Inicjalizacja obiekt = new C_Inicjalizacja();
System.out.println(obiekt.inst); // 0
// błąd kompilacji - aby odczytać zmienną lokalną, musi zostać wcześniej zainicjalizowana (w taki sposób, żeby kompilator miał pewność)
//NK System.out.println(lokalna);
if(st >= 0) {
lokalna = 13;
System.out.println(lokalna); // OK - tu zmienna "na pewno jest zainicjowana"
}
//NK System.out.println(lokalna); // tutaj wg kompilatora "może być niezainicjowana"
if(st >= 0) {
lokalna = 10;
} else {
lokalna = 20;
}
System.out.println(lokalna); // OK
}
}
src/main/java/gotowe/p02_zmienne/D_Zasieg.java 0 → 100644
package gotowe.p02_zmienne;
public class D_Zasieg {
static int x;
public static void main(String[] args) {
System.out.println("A: " + x);
x = 100;
System.out.println("B: " + x);
int x = 500;
System.out.println("C: " + x);
metoda();
System.out.println("I: " + x);
}
static void metoda() {
// w tym miejscu nie widać lokalnych zmiennych z innych metod (np. main)
// a widać zmienne z poziomu klasy ("globalne")
System.out.println("D: " + x);
if(x > 0) {
String x = "700";
System.out.println("E: " + x);
}
System.out.println("F: " + x);
{
// wolno przesłaniać zmienne klasowe za pomocą zmiennych lokalnych
int x = 300;
System.out.println("G: " + x);
if(true) {
// nie wolno przesłaniać zmiennych lokalnych
//NK int x = 400;
// System.out.println("H: " + x);
}
}
System.out.println("K: " + x);
}
}
src/main/java/gotowe/p02_zmienne/Nazwy.java 0 → 100644
package gotowe.p02_zmienne;
public class Nazwy {
public static void main(String[] args) {
// Nazwa nie może zaczynać się od cyfry
//NK String 1rstElement = "pierwszy";
// Nazwa może zaczynać się od litery, znaku _ lub znaku $
String abc123 = "abc123";
String _123 = "qwerty";
String $123 = "qwertz";
// wielkość liter ma znaczenie, to są dwie różne zmienne
int x = 10, X = 20;
System.out.println(x);
System.out.println(X);
// Można używać liter z różnych alfabetów
int żółć = 333;
System.out.println(żółć);
String 李 = "李";
System.out.println(李);
\u674e = "babajaga"; // podaję kod Unicode chińskiego znaczka
System.out.println(李); // babajaga
int $a, a; // to są różne zmienne
int $ = 444, $3 = 33, __ = 44;
System.out.println($);
System.out.println($3);
System.out.println(__);
// Nazwami nie mogą być słowa kluczowe ani pojedynczy znak podkreślenia
// String int = "pomyłka";
// String _ = "aaa";
// System.out.println(_);
String var = "okej, nawet w Javie 11";
System.out.println(var);
}
}
src/main/java/gotowe/p02_zmienne/PolaFinal.java 0 → 100644
package gotowe.p02_zmienne;
public class PolaFinal {
// pola które są final muszą być jawnie zainicjalizowane
// albo w tym miejscu, albo w bloku inicjalizacyjnym, albo w konstruktorze
final int numer;
public PolaFinal() {
numer = 0;
}
public PolaFinal(int nr) {
numer = nr;
}
}
src/main/java/gotowe/p02_zmienne/SlowoVar.java 0 → 100644
package gotowe.p02_zmienne;
import java.time.LocalTime;
public class SlowoVar {
public static void main(String[] args) {
// Przykład kompiluje się od Javy 10.
// Deklaracja zmiennej lokalnej bez podawania typu.
// Kompilator domyśla się typu na podstawie tego, co wpisujemy
var y = 100;
System.out.println(y);
y = 101; // OK
System.out.println(y);
// Zmienna ma jednak typ int i nie wolno wpisać wartości niezgodnego typu
// y = 3.14; // źle
// y = "Ala ma kota"; // źle
// System.out.println(y);
// Konstrukcja dostępna tylka dla zmiennych lokalnych, gdy początkową wartość wpisuje się od razu w miejscu deklaracji.
// var z;
// var nie jest słowem kluczowym i w niekolidujących miejscach można go używać jako nazwy:
String var = "tajemnicza zmienna";
System.out.println(var);
// BTW, odpowiednikiem takich zmiennych jak w Pythonie i PHP, na które można wpisać "wszystko",
// w Javie jest raczej zmienna typu Object.
Object o;
o = "Ala ma kota";
System.out.println(o.getClass().getSimpleName() + " : " + o);
o = 100 + 15;
System.out.println(o.getClass().getSimpleName() + " : " + o);
o = LocalTime.now();
System.out.println(o.getClass().getSimpleName() + " : " + o);
}
}
src/main/java/gotowe/p02_zmienne/Typy.java 0 → 100644
package gotowe.p02_zmienne;
import java.time.LocalDate;
public class Typy {
public static void main(String[] args) {
// Typy dzielą się na dwie kategorie:
// 1) typy proste
byte b = 15;
short s = 1000;
int i = 100000;
long l1 = 10, l2 = 5000000000L;
float f = 3.14F;
double d = 3.14;
// char to pojedynczy znak, ale jednocześnie może być traktowany jak liczba z zakresu 0-64k
char znak = 'A';
boolean falsz = false, prawda = true, niewiem = d > 3.0;
// typów byte i short nie opłaca sie używać, chyba że w dużych tablicach
// 2) typy obiektowe
Object o = new Object();
System.out.println(o);
// klasa String - napisy
String imie = "Ala";
// platforma Java SE definiuje ok 4 tys. klas
LocalDate data = LocalDate.now();
System.out.println(data);
System.out.println(data.getDayOfMonth());
System.out.println(data.getDayOfYear());
System.out.println();
// programiści mogą tworzyć własne klasy
// w Javie również tablice są obiektami:
int[] liczby = { 1, 2, 3, 4 };
System.out.println(liczby.length);
System.out.println(liczby[1]); // 2
}
}
src/main/java/gotowe/p03_instrukcje/a_if/A_TeoriaIf.java 0 → 100644
package gotowe.p03_instrukcje.a_if;
import java.util.Random;
public class A_TeoriaIf {
public static void main(String[] args) {
Random random = new Random();
int x = random.nextInt(100); // liczba od 0 do 99 włącznie
int y = random.nextInt(100);
System.out.println("Wylosowane liczby:");
System.out.printf("x = %d , y = %d\n", x, y);
// Wzorcowa wersja if:
// if(WARUNEK) { INSTRUKCJE1 } else { INSTRUKCJE2 }
// Gdy WARUNEK jest prawdą, wykonają się INSTRUKCJE1, a jeśli nieprawdą to INSTRUKCJE2
if(x % 2 == 0) {
System.out.println("x jest parzysty");
System.out.println("Ala ma kota");
} else {
System.out.println("x jest nieparzysty");
System.out.println("Ola ma psa");
}
System.out.println("a kuku");
System.out.println();
// Jeśli za ifem lub elsem do wykonania jest tylko jedna instrukcja, to można pominąć nawiasy klamrowe.
if(x >= 50)
System.out.println(">= 50");
else
System.out.println("< 50");
// Używajmy tego jednak z umiarem, tylko w bardzo prostych przypadkach, np. break, throw, return...
// W większości przypadków zalecane jest wzięcie wykonywanego kodu w {nawiasy klamrowe},
// gdyż łatwiej dokonać późniejszych zmian, np. dodać kolejną linię itp...
/* Za instrukcją strukturalną (if, while, for...) w praktyce nigdy nie stawia się średnika
if(x == y); {
System.out.println("Obie liczby są równe!");
}
Powyższy kod zawsze wyświetliłby podany napis, bo struktiura jest taka:
"jeśli x == y, nie rób nic; a później ZAWSZE wypisuj ten tekst"
*/
// Można użyć samego if, bez else:
if(x + y >= 100) {
System.out.println("suma x i y jest trzycyfrowa");
}
// ify (i inne instrukcje blokowe) można zagnieżdżać. Tutaj tym bardziej zalecamy pisanie nawiasów {}
if(x % 2 == 0) {
if(y % 2 == 0) {
System.out.println("obie liczby są parzyste");
} else {
System.out.println("x parzysty, y nieparzysty");
}
} else {
if(y % 2 == 0) {
System.out.println("x nieparzysty, y parzysty");
} else {
System.out.println("obie liczby nieparzyste");
}
}
System.out.println();
// Jeśli rozpatrywanych sytuacji jest więcej niż 2, to typowym sposobem zapisu jest ciąg
// if - else if - ... - else
if(x > y) {
System.out.println("x > y");
} else if(x < y) {
System.out.println("x < y");
} else {
System.out.println("x = y");
}
// W Javie nie ma automatycznej konwersji liczb (ani innych rzeczy) na boolean
// if(liczba) {
// System.out.println("Nie zero");
// }
//
// if(liczba = 0) {
// System.out.println("Nie zero");
// }
// Warunkiem najczęściej jest porównanie, ale może też być wywołanie metody typu boolean
String str = "Ala ma kota";
if(str.isEmpty()) {
System.out.println("puste");
}
// może też być bezpośrednie użycie zmiennej typu boolean
boolean logika = x > 10 && y % 3 == 0;
if(logika) {
System.out.println("Dziwny warunek jest prawdą");
} else {
System.out.println("Nieprawda");
}
System.out.println("Koniec programu");
}
}
src/main/java/gotowe/p03_instrukcje/b_petle/A_RodzajePetli.java 0 → 100644
package gotowe.p03_instrukcje.b_petle;
public class A_RodzajePetli {
public static void petlaWhile() {
int i = 1;
while(i <= 5) {
System.out.println("w pętli: " + i);
i++;
}
System.out.println("za pętlą: " + i);
}
public static void doWhile() {
int i = 1;
do {
System.out.println("w pętli: " + i);
i++;
} while(i <= 5);
System.out.println("za pętlą: " + i);
}
// ominięte w main
public static void petlaFor() {
for(int i = 1; i <= 5; i++) {
System.out.println("w pętli " + i);
}
// NK System.out.println("za pętlą: " + i);
int i; // OK
}
public static void petlaFor2() {
int i;
for(i = 1; i <= 5; i++) {
System.out.println("w pętli " + i);
}
System.out.println("za pętlą: " + i); // 6
// NK int i;
}
// ominięte w main
public static void petlaFor3() {
// int i;
for(int i = 1, j = 10; i <= 5 && j < 3; i++, j = i / 10, System.out.println("z pętli " + j)) {
System.out.println("w pętli " + i);
}
// System.out.println("za pętlą: " + i);
}
// ominięte w main
// w for moga byc dowolne instrukcje
public static void petlaFor4(org.w3c.dom.Node node) {
for(org.w3c.dom.Node child = node.getFirstChild(); child != null; child = child.getNextSibling()) {
System.out.println(child.getTextContent());
}
}
public static void losowanie() {
for(;;) {
double x = Math.random();
System.out.println("Wylosowałem " + x);
if(x > 0.8)
break;
}
System.out.println("za pętlą");
}
public static void forEach() {
String[] imiona = { "Ala", "Ola", "Ela", "Ula" };
// pozwala przeglądać zawartość tablicy, albo obiekty, które są Iterable
// tzw. "for-each" albo "enhanced for loop", od Javy 5
for(String imie: imiona) {
System.out.println("Kolejna osoba to " + imie);
}
// Od Javy 10 można tak:
// for(var imie : imiona) {
// System.out.println("Kolejna osoba to " + imie);
// }
}
public static void forEachEgzamin() {
// typowa zmyłka z egzaminu
int[] t = { 1, 2, 3 };
for(int i: t) {
// i oznacza WARTOŚĆ z tablicy, a nie indeks
// więc tu dojdzie do wyjścia poza zakres tablicy
System.out.println(t[i]);
}
}
public static void przerwanie() {
for(int i = 1; i <= 10; i++) {
System.out.println("i = " + i);
if(i % 2 == 1) {
System.out.println(" nieparzysta, continue");
continue;
}
System.out.println(" nie było continue");
if(i % 3 == 0) {
System.out.println(" podzielna przed 3, break");
break;
}
System.out.println(" nie było break");
}
System.out.println("za pętlą");
}
public static int etykiety() {
int suma = 0;
duza: while(true) {
for(int i = 1; i < 10; i++) {
suma += i;
if(suma > 100)
break duza;
}
}
return suma;
}
public static void main(String[] args) {
etykieta: // kompiluje się, ale nie ma jak tego użyć
System.out.println("while");
petlaWhile();
//NK goto etykieta;
System.out.println("\ndo-while");
doWhile();
System.out.println("\nfor");
petlaFor2();
System.out.println("\nLosowanie:");
losowanie();
System.out.println("\nfor-each");
forEach();
System.out.println();
przerwanie();
System.out.println();
int x = etykiety();
System.out.println(x);
}
}
src/main/java/gotowe/p03_instrukcje/b_petle/BreakContinue_Prezentacja.java 0 → 100644
package gotowe.p03_instrukcje.b_petle;
import javax.swing.JOptionPane;
public class BreakContinue_Prezentacja {
public static void main(String[] args) {
int licznik = 0;
while(true) {
licznik++;
JOptionPane.showMessageDialog(null, "Początek pętli, licznik = " + licznik);
int odp1 = JOptionPane.showConfirmDialog(null, "Czy zrobić break?");
if(odp1 == JOptionPane.YES_OPTION) {
break;
// break w pętli powoduje natychmiastowe zakończenie tej pętli i przejście do następnej instrukcji za pętlą
}
JOptionPane.showMessageDialog(null, "Środek pętli. Nie było break.");
int odp2 = JOptionPane.showConfirmDialog(null, "Czy zrobić continue?");
if(odp2 == JOptionPane.YES_OPTION) {
continue;
// continue powoduje pominięcie reszty instrukcji w bieżącym obrocie pętli
// i przejście od razu na początek następnego obrotu
}
JOptionPane.showMessageDialog(null, "Koniec pętli, nie było break ani continue");
}
JOptionPane.showMessageDialog(null, "Koniec programu");
}
}
src/main/java/gotowe/p03_instrukcje/b_petle/DziwnyWhile.java 0 → 100644
package gotowe.p03_instrukcje.b_petle;
public class DziwnyWhile {
public static void main(String[] args) {
int x = 1;
{
System.out.println("Ala ma kota " + x);
x++;
}
while(x <= 10)
;
// To jest zwykły blok a potem pętla nieskończona
System.out.println("Koniec");
}
}
src/main/java/gotowe/p03_instrukcje/b_petle/Label.java 0 → 100644
package gotowe.p03_instrukcje.b_petle;
public class Label {
public static void main(String[] args) {
label1: System.out.println("Cokolwiek");
label2: while(true) {
double x = Math.random();
if(x > 0.5)
break label2;
}
// goto label1;
// const int n = 10;
}
}
src/main/java/gotowe/p03_instrukcje/b_petle/MartwyKod.java 0 → 100644
package gotowe.p03_instrukcje.b_petle;
public class MartwyKod {
void metoda1() {
System.out.println("OK");
return;
// System.out.println("błąd");
// System.out.println("kolejna linia");
}
void metoda2() throws Exception {
System.out.println("OK");
throw new Exception("katastrofa");
// System.out.println("błąd");
}
public static void main(String[] args) {
// if(true) / if(false) NIE są traktowane jako martwy kod
if(false) {
System.out.println("Ala ma kota");
}
if(true) {
System.out.println("AAAA");
} else {
System.out.println("BBBB");
}
// while(false) {
// System.out.println("błąd");
// }
while(true) {
System.out.println("lkdfjg");
}
// System.out.println("błąd");
}
}
src/main/java/gotowe/p03_instrukcje/b_petle/PetlaNieskonczona.java 0 → 100644
package gotowe.p03_instrukcje.b_petle;
import java.time.LocalTime;
public class PetlaNieskonczona {
public static void main(String[] args) {
int licznik = 0;
while(true) {
System.out.printf("%12d : %s%n", ++licznik, LocalTime.now());
}
// Kod w tym miejscu jest niepoprawny (Java go nie skompiluje), bo to jest "martwy kod".
// System.out.println("Koniec świata");
}
}
src/main/java/gotowe/p03_instrukcje/b_petle/Przerwania.java 0 → 100644
package gotowe.p03_instrukcje.b_petle;
public class Przerwania {
static void tabliczka(int n) {
for(int i = 1; i <= n; i++) {
for(int j = 1; j <= n; j++) {
System.out.printf("%3d", i * j);
System.out.print(",");
}
System.out.println("#");
}
System.out.println("\n----------------\n");
}
static void tabliczkaBreak(int n) {
for(int i = 1; i <= n; i++) {
for(int j = 1; j <= n; j++) {
System.out.printf("%3d", i * j);
if(i + j > n)
break;
System.out.print(",");
}
System.out.println("#");
}
System.out.println("\n----------------\n");
}
static void tabliczkaBreakEtykieta(int n) {
pierwsza: for(int i = 1; i <= n; i++) {
for(int j = 1; j <= n; j++) {
System.out.printf("%3d", i * j);
if(i + j > n)
break pierwsza;
System.out.print(",");
}
System.out.println("#");
}
System.out.println("\n----------------\n");
}
static void tabliczkaContinue(int n) {
for(int i = 1; i <= n; i++) {
for(int j = 1; j <= n; j++) {
System.out.printf("%3d", i * j);
if(i + j > n)
continue;
System.out.print(",");
}
System.out.println("#");
}
System.out.println("\n----------------\n");
}
static void tabliczkaContinueEtykieta(int n) {
pierwsza: for(int i = 1; i <= n; i++) {
System.out.println(); // dodane
for(int j = 1; j <= n; j++) {
System.out.printf("%3d", i * j);
if(i + j > n)
continue pierwsza;
System.out.print(",");
}
System.out.println("#");
}
System.out.println("\n----------------\n");
}
public static void main(String[] args) {
tabliczka(9);
tabliczkaBreak(9);
tabliczkaBreakEtykieta(9);
tabliczkaContinue(9);
tabliczkaContinueEtykieta(9);
}
}
src/main/java/gotowe/p03_instrukcje/c_switch/Switch1.java 0 → 100644
package gotowe.p03_instrukcje.c_switch;
import javax.swing.JOptionPane;
public class Switch1 {
public static void main(String[] args) {
String tekst = JOptionPane.showInputDialog("Podaj numer dnia tygodnia");
int numer = Integer.parseInt(tekst);
switch(numer) {
case 1:
System.out.println("poniedziałek");
case 2:
System.out.println("wtorek");
case 3:
System.out.println("środa");
case 4:
System.out.println("czwartek");
case 5:
System.out.println("piątek");
System.out.println("czyli weekendu początek");
case 6:
System.out.println("sobota");
case 7:
System.out.println("niedziela");
default:
System.out.println("niepoprawny numer dnia tygodnia");
}
System.out.println("Koniec programu");
}
}
src/main/java/gotowe/p03_instrukcje/c_switch/Switch2.java 0 → 100644
package gotowe.p03_instrukcje.c_switch;
import javax.swing.JOptionPane;
public class Switch2 {
public static void main(String[] args) {
String tekst = JOptionPane.showInputDialog("Podaj numer dnia tygodnia");
int numer = Integer.parseInt(tekst);
switch(numer) {
case 1:
System.out.println("poniedziałek");
break;
case 2:
System.out.println("wtorek");
break;
case 3:
System.out.println("środa");
break;
case 4:
System.out.println("czwartek");
break;
case 5:
System.out.println("piątek");
System.out.println("czyli weekendu początek");
break;
case 6:
System.out.println("sobota");
break;
case 7:
System.out.println("niedziela");
break;
default:
System.out.println("niepoprawny numer dnia tygodnia");
}
System.out.println("Koniec programu");
}
}
src/main/java/gotowe/p03_instrukcje/c_switch/Switch3.java 0 → 100644
package gotowe.p03_instrukcje.c_switch;
import java.util.Random;
import javax.swing.JOptionPane;
public class Switch3 {
public static void main(String[] args) {
String tekst = JOptionPane.showInputDialog("Podaj numer dnia tygodnia");
int numer = Integer.parseInt(tekst);
final int SOBOTA = 6; // stała
// final int SOBOTA = new Random().nextInt(10);
switch(numer) {
case 3:
System.out.println("środa");
break;
case 1:
System.out.println("poniedziałek");
break;
case 2:
System.out.println("wtorek");
break;
default:
System.out.println("niepoprawny numer dnia tygodnia");
break;
case 4:
System.out.println("czwartek");
break;
case 2 + 3:
System.out.println("piątek");
break;
case SOBOTA:
System.out.println("sobota");
// tu nie ma break i wypisze się sobota niedziela
case 7:
System.out.println("niedziela");
}
System.out.println("Koniec programu");
}
}
src/main/java/gotowe/p03_instrukcje/c_switch/Switch4.java 0 → 100644
package gotowe.p03_instrukcje.c_switch;
import javax.swing.JOptionPane;
public class Switch4 {
static String nazwaDniaTygodnia(int numer) {
switch(numer) {
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 tygodnia");
}
}
public static void main(String[] args) {
String tekst = JOptionPane.showInputDialog("Podaj numer dnia tygodnia");
try {
int numer = Integer.parseInt(tekst);
String nazwa = nazwaDniaTygodnia(numer);
System.out.println("Ten dzień to " + nazwa);
} catch(Exception wylapanyWyjatek) {
System.out.println("Wystąpił wyjątek " + wylapanyWyjatek);
}
System.out.println("Koniec programu");
}
}
src/main/java/gotowe/p03_instrukcje/c_switch/Switch5.java 0 → 100644
package gotowe.p03_instrukcje.c_switch;
public class Switch5 {
static int ileDniMaMiesiac(String nazwa) {
switch(nazwa) {
case "styczeń":
case "marzec":
case "maj":
case "lipiec":
case "sierpień":
case "październik":
case "grudzień":
return 31;
case "kwiecień":
case "czerwiec":
case "wrzesień":
case "listopad":
return 30;
case "luty":
return 28;
// case null się nie skompiluje
// case null:
// return 0;
default:
return 0;
}
}
public static void main(String[] args) {
System.out.println(ileDniMaMiesiac("styczeń"));
System.out.println(ileDniMaMiesiac("luty"));
System.out.println(ileDniMaMiesiac("listopad"));
System.out.println();
// takie bajery nie działają:
System.out.println(ileDniMaMiesiac("Lipiec"));
System.out.println(ileDniMaMiesiac(" lipiec "));
System.out.println(ileDniMaMiesiac("*ec"));
System.out.println(ileDniMaMiesiac("%ec"));
System.out.println(ileDniMaMiesiac(""));
System.out.println(ileDniMaMiesiac(null)); // NPE
}
}
src/main/java/gotowe/p03_instrukcje/c_switch/Switch6.java 0 → 100644
package gotowe.p03_instrukcje.c_switch;
public class Switch6 {
public static void main(String[] args) {
byte bb = 100;
// Wartości podawane w case muszą być zgodne z typem parametru switch-a.
// W przypadku liczb oznacza to także, że liczba musi mieścić się w zakresie,
switch(bb) {
case 100:
System.out.println("100");
break;
//NK case 200: System.out.println("200"); break;
}
short ss = 100;
switch(ss) {
case 100:
System.out.println("100");
break;
case 200:
System.out.println("200");
break;
case 4000:
System.out.println("4000");
break;
//NK case 33000: System.out.println("100"); break;
}
char cc = 'A';
switch(cc) {
case 'A':
System.out.println("AAA");
break;
case 120:
System.out.println("BBB");
break;
// case 10 : System.out.println("10"); break;
case 0xA:
System.out.println("0xA");
break;
//NK case 65 : System.out.println("CCC"); break;
//NK case -1 : System.out.println("DDD"); break;
case 64000:
System.out.println("EEE");
break;
//NK case 66000: System.out.println("FFF"); break;
}
/*
long l = 27L;
// nie ma switch na typach long, float, double
switch(l) {
case 27L : System.out.println("long 27");
}
*/
}
}
src/main/java/gotowe/p03_instrukcje/c_switch/Switch8.java 0 → 100644
package gotowe.p03_instrukcje.c_switch;
public class Switch8 {
public static void main(String[] args) {
int x = 2;
switch(x) {
// to jest po prostu operacja arytmetyczna (dokładnie "suma bitowa")
// nie ma to żadnego szczególnego znaczenia dla switch-a
// w tym konkretnym miejscu to wylicza się do wartości 3
case 2 | 3:
System.out.println("2 | 3");
break;
//NK case 3:
// System.out.println("3");
case 2: // bo to nie jest naruszenie unikalności
System.out.println("2");
break;
default:
System.out.println("default");
}
}
}
src/main/java/gotowe/p03_instrukcje/c_switch/SwitchNull_Pusty.java 0 → 100644
package gotowe.p03_instrukcje.c_switch;
import javax.swing.JOptionPane;
public class SwitchNull_Pusty {
public static void main(String[] args) {
String s = JOptionPane.showInputDialog("Wpisz napis");
System.out.println("Jestem przed switchem, napis = " + s);
switch(s) {}
System.out.println("Jestem za switchem");
// morał: przekazanie wartości null do switcha (na napisach lub na enumach)
// skutkuje wyjątkiem NPE
}
}
src/main/java/gotowe/p03_instrukcje/c_switch/SwitchString_Interaktywnie.java 0 → 100644
package gotowe.p03_instrukcje.c_switch;
import javax.swing.JOptionPane;
public class SwitchString_Interaktywnie {
public static void main(String[] args) {
String s = JOptionPane.showInputDialog("Wpisz napis");
System.out.println("Jestem przed switchem, napis = " + s);
// Wielkość liter, spacje itp.: mają znaczenie.
// Nie są przeprowadzane żadne "normalizacje".
// Nie działają żadne "wildcardy" typu * % itp.
// Jeśli do switch przekażemy wartość null dojdzie d wyjątku NullPointerException
switch(s) {
case "Ala":
System.out.println("Ala ma kota");
break;
case "Ola":
System.out.println("Ola ma psa");
break;
//NK case null: System.out.println("NULL");
default:
System.out.println("Nieznana osoba");
}
}
}
src/main/java/gotowe/p04_operatory/Bitowe1.java 0 → 100644
package gotowe.p04_operatory;
public class Bitowe1 {
public static void main(String[] args) {
byte x = 25;
byte y = -25;
byte shift = 2;
System.out.printf("x = %d y = %d %n", x, y);
System.out.println("Bez przycinania (w zakresie int):");
System.out.printf("x << %d = %d %n", shift, x << shift);
System.out.printf("y << %d = %d %n", shift, y << shift);
System.out.printf("x >> %d = %d %n", shift, x >> shift);
System.out.printf("y >> %d = %d %n", shift, y >> shift);
System.out.printf("x >>> %d = %d %n", shift, x >>> shift);
System.out.printf("y >>> %d = %d %n", shift, y >>> shift);
System.out.println();
System.out.println("Przycięte do byte: ");
System.out.printf("x << %d = %d %n", shift, (byte)(x << shift));
System.out.printf("y << %d = %d %n", shift, (byte)(y << shift));
System.out.printf("x >> %d = %d %n", shift, (byte)(x >> shift));
System.out.printf("y >> %d = %d %n", shift, (byte)(y >> shift));
System.out.printf("x >>> %d = %d %n", shift, (byte)(x >>> shift));
System.out.printf("y >>> %d = %d %n", shift, (byte)(y >>> shift));
}
}
src/main/java/gotowe/p04_operatory/Bitowe2.java 0 → 100644
package gotowe.p04_operatory;
public class Bitowe2 {
public static void main(String[] args) {
int x = 0b00000000000000000000000000011001;
int y = -x;
int z = 0b11111111111111111111111111100111;
System.out.println(x);
System.out.println(y);
System.out.println(z);
System.out.println();
System.out.println("<<");
System.out.println(x << 2);
System.out.println(y << 2);
System.out.println(z << 2);
System.out.println(0b11111111111111111111111110011100); // -100
System.out.println();
System.out.println(">>");
System.out.println(x >> 2);
System.out.println(y >> 2);
System.out.println(0b11111111111111111111111111111001);
System.out.println();
System.out.println(">>>");
System.out.println(x >>> 2);
System.out.println(y >>> 2);
System.out.println(0b00111111111111111111111111111001);
System.out.println();
}
}
src/main/java/gotowe/p04_operatory/Leniwosc1.java 0 → 100644
package gotowe.p04_operatory;
public class Leniwosc1 {
public static void gorliwa() {
// opertor "gorliwy"
// zawsze oblicza obie strony wyrażenia logicznego, a dopiero potem daje wynik false / true
if(lewy() & prawy()) {
System.out.println("prawda");
} else {
System.out.println("fałsz");
}
}
public static void leniwa() {
// operator "leniwy"
// jeśli lewa strona rozstrzyga o ostatecznym wyniku, to prawa strona nie jest sprawdzana
if(lewy() && prawy()) {
System.out.println("prawda");
} else {
System.out.println("fałsz");
}
}
private static boolean lewy() {
System.out.print("lewy ");
return false;
}
private static boolean prawy() {
System.out.print("prawy ");
return true;
}
public static void main(String[] args) {
System.out.println("wersja gorliwa");
gorliwa();
System.out.println("\nwersja leniwa:");
leniwa();
}
}
src/main/java/gotowe/p04_operatory/Leniwosc2.java 0 → 100644
package gotowe.p04_operatory;
public class Leniwosc2 {
public static void main(String[] args) {
int x = 0, y = 0;
if(++x > 0 | y++ > 0) {
System.out.println("prawda");
} else {
System.out.println("fałsz");
}
System.out.println("x == " + x);
System.out.println("y == " + y);
System.out.println();
x = y = 0;
if(++x > 0 || y++ > 0) {
System.out.println("prawda");
} else {
System.out.println("fałsz");
}
System.out.println("x == " + x);
System.out.println("y == " + y);
System.out.println();
x = y = 0;
if(x++ > 0 || ++y > 0) {
System.out.println("prawda");
} else {
System.out.println("fałsz");
}
System.out.println("x == " + x);
System.out.println("y == " + y);
}
}
src/main/java/gotowe/p04_operatory/Leniwosc3.java 0 → 100644
package gotowe.p04_operatory;
public class Leniwosc3 {
public static void main(String[] args) {
int x = 0, y = 0;
if(x++ > 0 || y++ > 0) {
System.out.println("prawda");
} else {
System.out.println("fałsz");
}
System.out.println("x == " + x);
System.out.println("y == " + y);
System.out.println();
x = y = 0;
if(++x > 0 || ++y > 0) {
System.out.println("prawda");
} else {
System.out.println("fałsz");
}
System.out.println("x == " + x);
System.out.println("y == " + y);
}
}
src/main/java/gotowe/p04_operatory/Leniwosc4.java 0 → 100644
package gotowe.p04_operatory;
public class Leniwosc4 {
public static void main(String[] args) {
// z prawdopodobieństwem 0.33 na imie wpisz nulla
// z prawdopodobieństwem 0.33 na imie wpisz "Ala"
// z prawdopodobieństwem 0.34 na imie wpisz "Tadeusz"
double los = Math.random();
String imie;
if(los < 0.33) {
imie = null;
} else if(los < 0.66) {
imie = "Ala";
} else {
imie = "Tadeusz";
}
System.out.println("imie = " + imie);
// if(imie != null & imie.length() >= 5) {
// System.out.println("długie imię");
// } else {
// System.out.println("null albo krótkie imię");
// }
// jeśli imie będzie null, to w ogóle nie przejdziemy do drugiej części sprawdzenia
if(imie != null && imie.length() >= 5) {
System.out.println("długie imię");
} else {
System.out.println("null albo krótkie imię");
}
if(imie == null || imie.isEmpty()) {
System.out.println("Brak danych");
}
if(args.length >= 1 && "Ala".equalsIgnoreCase(args[0])) {
System.out.println("Ala ma kota");
}
}
}
src/main/java/gotowe/p04_operatory/Logiczne.java 0 → 100644
package gotowe.p04_operatory;
import java.util.Random;
public class Logiczne {
public static void main(String[] args) {
Random random = new Random();
int x = random.nextInt(1000);
int y = random.nextInt(1000);
System.out.println("Wylosowane liczby: " + x + " , " + y);
// koniunkcja, logiczne "i"
// alternatywa, logiczne "lub"
if(x > 500 && y > 500) {
System.out.println("Obie liczby > 500");
} else {
System.out.println("Któraś z liczb <= 500");
}
if(x > 500 || y > 500) {
System.out.println("Co najmniej jedna z liczb > 500");
} else {
System.out.println("Obie liczby <= 500");
}
// alternatywa rozłączna, "albo", technicznie "xor" (exclusive or)
if((x > 500) ^ (y > 500)) {
System.out.println("Dokładnie jedna z liczb > 500");
} else {
System.out.println("Obie liczby są > 500 albo obie liczby są <= 500");
}
// ! negacja
if(!(x % 3 == 0)) {
System.out.println("Nieprawda, że liczba jest podzielna przez 3");
}
}
}
src/main/java/gotowe/p04_operatory/OperatorWarunkowy1.java 0 → 100644
package gotowe.p04_operatory;
public class OperatorWarunkowy1 {
public static void main(String[] args) {
int x = 10;
String s;
s = x > 10 ? "A" : "B";
System.out.println(s);
// różwnoważne:
if(x > 10) {
s = "A";
} else {
s = "B";
}
s = x > 10 ? "A" : x > 5 ? "B" : "C";
System.out.println(s);
s = x > 10 ? "A" : (x > 5 ? "B" : "C");
System.out.println(s);
s = x > 8 ? x < 20 ? "A" : "B" : " C";
System.out.println(s);
s = x > 8 ? (x < 20 ? "A" : "B") : " C";
System.out.println(s);
s = x > 8 ? x < 20 ? "A" : "B" : x % 2 == 0 ? "C" : " D";
System.out.println(s);
s = x > 8 ? (x < 20 ? "A" : "B") : (x % 2 == 0 ? "C" : " D");
}
}
src/main/java/gotowe/p04_operatory/OperatorWarunkowy2.java 0 → 100644
package gotowe.p04_operatory;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
public class OperatorWarunkowy2 {
public static void main(String[] args) {
int[] liczby = { 100, 10, 20, 150, 7, 120 };
String wynik = IntStream.of(liczby)
.mapToObj(a -> a >= 100 ? "duże" : "małe")
.collect(Collectors.joining("; "));
System.out.println(wynik);
}
}
src/main/java/gotowe/p04_operatory/OperatorWarunkowy3.java 0 → 100644
package gotowe.p04_operatory;
public class OperatorWarunkowy3 {
public static void main(String[] args) {
// ilustracja zastosowań:
String s = Math.random() > 0.5 ? "ala" : null;
if(s != null && s.length() > 2) {
System.out.println("ok");
} else {
System.out.println("puste");
}
}
}
src/main/java/gotowe/p04_operatory/PlusPlus.java 0 → 100644
package gotowe.p04_operatory;
public class PlusPlus {
public static void main(String[] args) {
int x;
int y;
x = 10;
y = ++x;
System.out.println("++x preinkrementacja");
System.out.println("x: " + x + " , y: " + y);
System.out.println();
x = 20;
y = x++;
System.out.println("x++ postinkrementacja");
System.out.println("x: " + x + " , y: " + y);
System.out.println();
x = 50;
System.out.println(x++);
System.out.println(++x);
System.out.println();
Integer a = 100;
a++;
System.out.println(a); // a wskazuje już na inny obiekt
System.out.println();
double d = 0.5;
System.out.println(d);
d++; // można inkrementować też float i double
System.out.println(d);
System.out.println();
y = x = 100;
System.out.println("x: " + x + " , y: " + y);
y = 33;
y = x += 5; // x zwiększam o 5, a to co wyjdzie, wpisuję także na y
System.out.println(" += 5");
System.out.println("x: " + x + " , y: " + y);
}
}
src/main/java/gotowe/p04_operatory/PlusPlusZagadki.java 0 → 100644
package gotowe.p04_operatory;
public class PlusPlusZagadki {
public static void main(String[] args) {
int x, y, z;
x = 1;
x = x++ + ++x; // 1 + 3
System.out.println(x);
x = 1;
x = ++x + x++; // 2 + 2
System.out.println(x);
y = 1;
y += y++;
// y = (y + y++)
// y = 1 + 1
System.out.println(y);
z = 1;
z += z++ + ++z;
// z = z + z++ + ++z
// z = 1 + 1 + 3 = 5
System.out.println(z);
}
}
src/main/java/gotowe/p04_operatory/PlusPlusZastosowania.java 0 → 100644
package gotowe.p04_operatory;
public class PlusPlusZastosowania {
static int suma(int[] t) {
int suma = 0;
int i = 0;
while(i < t.length) {
suma += t[i++];
}
return suma;
}
public static void main(String[] args) {
int[] a = { 10, 20, 30, 40 };
System.out.println(suma(a));
}
}
src/main/java/gotowe/p04_operatory/Przypisania.java 0 → 100644
package gotowe.p04_operatory;
public class Przypisania {
public static void main(String[] args) {
int x, y, z;
z = y = x = 10;
System.out.printf("x=%d, y=%d, z=%d%n", x, y, z);
x = 10;
y = 50;
z = 100;
z += y = x += 3;
System.out.printf("x=%d, y=%d, z=%d%n", x, y, z);
}
}
src/main/java/gotowe/p04_operatory/ZastosowaniaLeniwychOperatorow.java 0 → 100644
package gotowe.p04_operatory;
import javax.swing.JOptionPane;
public class ZastosowaniaLeniwychOperatorow {
public static void main(String[] args) {
String imie = JOptionPane.showInputDialog("Jak masz na imię?");
if(imie != null && imie.length() <= 3) {
JOptionPane.showMessageDialog(null, "Masz krótkie imię");
}
// Gdybym nie sprawdzał czy napis nie jest nullem,
// to w przypadku Cancel dochodziłoby do błedu NullPointerException (NPE)
// w momencie próby wywołania length()
// if (imie.length() <= 3) {
// JOptionPane.showMessageDialog(null, "Masz krótkie imię");
// }
// Gdybym zamiast "leniwego" && użył "gorliwego" &
// to także doszłoby do błędu, bo Java sprawdzałaby prawą stronę warunku nawet wtedy gdy lewa jest fałszem
// if(imie != null & imie.length() <= 3) {
// JOptionPane.showMessageDialog(null, "Masz krótkie imię");
// }
String jezyk = JOptionPane.showInputDialog("Jaki jest Twój ulubiony język programowania?");
if(jezyk != null && jezyk.equals("Java")) {
JOptionPane.showMessageDialog(null, "Brawo");
} else {
JOptionPane.showMessageDialog(null, "Źle");
}
// jeśli chodzi o tę konkretną sytuację, to pisząc w tej kolejności zapobiegamy wyjątkowi NPE
if("Java".equals(jezyk)) {
JOptionPane.showMessageDialog(null, "Brawo");
} else {
JOptionPane.showMessageDialog(null, "Źle");
}
}
}
src/main/java/gotowe/p05_liczby/BityIBajty.java 0 → 100644
package gotowe.p05_liczby;
public class BityIBajty {
/* Program wypisuje wartość zmiennej typu byte oraz jej zapis w pamięci w postaci ciągu 8 bitów, zwiększając w pętli wartość o 1.
* Widać zjawisko integer overflow: wartość +127 przechodzi w wartość -128.
* Dla zmiennych typu short, int, long jest analogicznie; różnica jest w długości ciągu bitów (16, 32 i 64) i zakresie liczb.
*/
public static void main(String[] args) {
System.out.println("Zwiększanie bajta:");
byte b = 0;
for(int i = 0; i <= 512; 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/gotowe/p05_liczby/Ciekawostki.java 0 → 100644
package gotowe.p05_liczby;
public class Ciekawostki {
public static void main(String[] args) {
int x = 5, y = 1000000000;
int z = x * y;
System.out.println(z);
System.out.println(5 * 1000000000);
System.out.println(5L * 1000000000);
System.out.println(3 * 1000000000);
// Gdy wynik obliczenia nie mieści się w zakresie dla danego typu (int lub long)
// dochodzi do "integer overflow". W Javie nie powoduje to błędu (w sensie wyjątku),
// po prostu wychodzi "przekręcony" wynik.
System.out.println();
double a = 3.0, b = 1.2;
System.out.println(a * b);
System.out.println(3 * 1.2);
double oczekiwany = 3.6;
if(a * b == oczekiwany) {
System.out.println("OK");
} else {
System.out.println("Nie OK");
System.out.println("różnica: " + (oczekiwany - a * b));
}
System.out.println();
// Liczby zmiennoprzecinkowe (w Javie: float i double) działają w przybliżeniu.
// W pamięci są zapisany w systemie dwójkowym, a nie dziesiętnym, więc zaokrąglenia nastepują w zapisie binarnym liczby, co utrudnia zrozumienie.
// Praktyczny morał: double nie używa się do liczenia pieniędzy.
// Lepszą alternatywą jest wyspecjalizowana klasa BigDecimal.
// Liczba całkowita zapisana w kodzie zaczynając od cyfry 0, jest w systemie ósemkowym.
int n = 0321; // = 3*64 + 2*8 + 1*1
System.out.println(n);
System.out.println(0321);
//NK int m = 098;
System.out.println();
// Od Javy 7 między cyframi można wpisywać znaki _ , które nie zmieniają wartości
int i = 123_456_789;
System.out.println(i);
int j = 123____4___5;
System.out.println(j);
}
}
src/main/java/gotowe/p05_liczby/Dzielenie.java 0 → 100644
package gotowe.p05_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/gotowe/p05_liczby/Floaty.java 0 → 100644
package gotowe.p05_liczby;
public class Floaty {
public static void main(String[] args) {
float f = 1.0000001f;
System.out.println(f);
f += 1;
System.out.println(f);
f -= 1;
System.out.println(f);
System.out.println();
// Zaokroglęnia nie są robione w systemie dziesiętnym, tylko dwójkowym
f = 1.0000003f;
System.out.println(f);
f += 1;
System.out.println(f);
f -= 1;
System.out.println(f);
System.out.println();
f = 2222222222f;
// System.out.println(f);
System.out.printf("%8.0f\n", f);
f += 1000;
System.out.printf("%8.0f\n", f);
f -= 10000000;
System.out.printf("%8.0f\n", f);
// lepsze dla pieniędzy: BigDecimal
}
}
src/main/java/gotowe/p05_liczby/IntegerOverflow.java 0 → 100644
package gotowe.p05_liczby;
public class IntegerOverflow {
public static void main(String[] args) {
System.out.println(2 * 1000_000_000);
System.out.println(3 * 1000_000_000);
System.out.println(5 * 1000_000_000);
System.out.println(3L * 1000_000_000);
System.out.println();
int x = 2147483646;
System.out.println(x);
x++;
System.out.println(x);
x++;
System.out.println(x);
x++;
System.out.println(x);
}
}
src/main/java/gotowe/p05_liczby/JakSprawdzicOverflow.java 0 → 100644
package gotowe.p05_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/gotowe/p05_liczby/LiteralyLiczbowe.java 0 → 100644
package gotowe.p05_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/gotowe/p05_liczby/PomylonyDouble.java 0 → 100644
package gotowe.p05_liczby;
public class PomylonyDouble {
public static void zaszachraj(int n, double arg) {
System.out.println("mnożenie : " + n * arg);
double suma = 0.0;
for(int i = 1; i <= n; i++) {
suma += arg;
}
System.out.println("dodawanie: " + suma);
System.out.println();
}
public static void main(String[] args) {
zaszachraj(1000, 0.5); // 1/2
zaszachraj(1000, 0.125); // 1/8
zaszachraj(1000, 0.2); // 1/5 - nieskończone rozwinięcie w systemie dwójkowym
zaszachraj(1000, 0.3);
zaszachraj(1000, 1.0 / 3.0);
}
}
src/main/java/gotowe/p05_liczby/ProcentyNaCalkowitych.java 0 → 100644
package gotowe.p05_liczby;
public class ProcentyNaCalkowitych {
public static void main(String[] args) {
long netto = 10005;
long procent = 23;
long brutto = (netto * (100 + procent) + 50) / 100;
System.out.println(brutto);
}
}
src/main/java/gotowe/p05_liczby/PrzeciazanieIntLong.java 0 → 100644
package gotowe.p05_liczby;
public class PrzeciazanieIntLong {
public static void main(String[] args) {
try {
System.out.println("oblicza w wersji int:");
System.out.println(Math.multiplyExact(5, 1000_000_000));
} catch(Exception e) {
System.out.println("wersja int: wyjątek " + e);
}
System.out.println();
try {
System.out.println("oblicza w wersji long:");
System.out.println(Math.multiplyExact(5L, 1000_000_000L));
} catch(Exception e) {
System.out.println("wersja long: wyjątek " + e);
}
}
}
src/main/java/gotowe/p05_liczby/Rzutowania.java 0 → 100644
package gotowe.p05_liczby;
public class Rzutowania {
// "Hierarchia" typów prostych:
// byte < short < int < long < float < double
// char < int
public static void main(String[] args) {
int x = 107;
float f = 3.14f;
long l3 = 13;
// rzutowanie niejawne - na zmienną typu "szerszego" można zapisać wartość typu "węższego" (widening)
long l = x;
float f2 = l3;
//NK x = l;
//NK l = f;
f = l;
// rzutowanie jawne można stosować zawsze; czasem może wiązać się z "popsuciem" wartości liczbowej
x = (int)l;
System.out.println(x);
// można stosować jawne rzutowanie nawet gdy nie jest konieczne
l = x;
l = (long)x;
System.out.println(l);
l = 4_000_000_000L;
x = (int)l;
System.out.println(x); // zmieniona wartość, ostatnie 32 bity z zapisu tej liczby
f = 100.99F;
x = (int)f; // obcina do wartości całkowitej
System.out.println(x); // 100
f = 4e9f; // 4 * 10^9 czyli 4mld
x = (int)f; // po wyjściu poza zakres przyjmuje MAXINT / MININT
System.out.println(x);
// Na zmienne typu byte, short i char można wpisywać konkretne wartości całkowite, o ile kompilator widzi, że mieszczą się w zakresie
byte b1 = 100;
//NK byte b2 = 200;
x = 100;
//NK byte b3 = x;
final int fi = 10;
b1 = fi; // jeśli wartość jest "stałą" (jest final i jest znana w czasie kompilacji)
b1 = 50;
//NK b1 = x; // bo "nie każdy int mieści się w byte"
x = b1; // OK, bo byte mieści się w int
//NK int i3 = 3L;
float f3 = 3L;
byte b = 13;
b = 15;
//NK b = 130;
x = 15;
//NK b = x;
b = (byte)x;
//NK wezByte(88);
wezByte((byte)88);
wezByte(b);
System.out.println();
System.out.println(dajByte());
System.out.println(dajZnak());
System.out.println();
l = 5_000_000_000L;
x = (int)l;
System.out.println(x);
// rzutowanie liczb całkowitych - bierzemye ostatnie bity z zapisu liczby w pamięci
// zobaczę to samo, co w int overflow gdy mnożyłem 5 * 1000000000
System.out.println("5mld long rzut na int: " + x);
double d = 5_000_000_000.0;
x = (int)d;
System.out.println("5mld double rzut na int: " + x);
// rzutowanie float i double na liczbę całkowitą - bierzemy wartość, która jest najbliżej,
// w tym przypadku będzie to Integer.MAX_VALUE
byte b2 = 40, b3 = 50;
// Operacje arytmetyczne + - * / % - są zdefiniowane dla typu int, a nie dla byte i short
// dlatego ich ywniki trzeba zrzutowa, aby pisać na zmienne tych typów
//NK byte b4 = b2 + b3;
byte b4 = (byte)(b2 + b3);
// ale bez rzutowania działają ++ i +=
System.out.println(b2);
b2++;
System.out.println(b2);
b2 += 10;
System.out.println(b2);
}
static byte dajByte() {
return 65;
}
/* NK
static byte dajByteInaczej() {
int x = 65;
return x;
}
*/
static char dajZnak() {
return 65;
}
static void wezByte(byte bbb) {
System.out.println(bbb);
}
}
src/main/java/gotowe/p05_liczby/Silnia.java 0 → 100644
package gotowe.p05_liczby;
import java.util.Scanner;
public class Silnia {
// 1 * 2 * 3 * .... * n
static long silnia(int n) {
long wynik = 1;
for(int i = 2; i <= n; i++) {
wynik *= i;
}
return wynik;
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while(true) {
System.out.println("Podaj liczbę (-1 aby zakończyć)");
int n = sc.nextInt();
if(n < 0)
break;
long wynik = silnia(n);
System.out.println("Wynik: " + wynik);
}
}
}
src/main/java/gotowe/p05_liczby/SilniaNaRozneSposoby.java 0 → 100644
package gotowe.p05_liczby;
import java.math.BigInteger;
import java.util.stream.IntStream;
import java.util.stream.LongStream;
public class SilniaNaRozneSposoby {
static int silniaInt(int n) {
int wynik = 1;
for(int i = 2; i <= n; i++) {
wynik *= i;
}
return wynik;
}
static long silniaFor(int n) {
long wynik = 1;
for(int i = 2; i <= n; i++) {
wynik *= i;
}
return wynik;
}
static long silniaWhile(int n) {
long wynik = 1;
while(n > 1) {
wynik *= n;
n--;
}
return wynik;
}
static long silniaRek(int n) {
// rekurencja
if(n < 2) {
return 1;
} else {
return n * silniaRek(n - 1);
}
}
static BigInteger silniaBig(int n) {
BigInteger wynik = BigInteger.ONE;
for(int i = 2; i <= n; i++) {
wynik = wynik.multiply(BigInteger.valueOf(i));
}
return wynik;
}
static long silniaKontrolowana(int n) {
long wynik = 1;
for(int i = 2; i <= n; i++) {
wynik = Math.multiplyExact(wynik, i);
}
return wynik;
}
static long silniaFun(int n) {
// też OK return LongStream.rangeClosed(1, n).reduce(1, Math::multiplyExact );
return LongStream.rangeClosed(1L, n).reduce(1L, (wynik, i) -> wynik * i);
}
static BigInteger silniaBigFun(int n) {
return IntStream.rangeClosed(1, n)
.mapToObj(BigInteger::valueOf)
.reduce(BigInteger.ONE, BigInteger::multiply);
}
public static void main(String[] args) {
int wynik1 = silniaInt(5);
System.out.println(wynik1);
System.out.println("int, for:");
for(int arg = 0; arg <= 50; arg++) {
System.out.println(arg + "! = " + silniaInt(arg));
}
System.out.println();
System.out.println("long, for:");
for(int arg = 0; arg <= 50; arg++) {
System.out.println(arg + "! = " + silniaFor(arg));
}
System.out.println();
System.out.println("long, while:");
for(int arg = 0; arg <= 50; arg++) {
System.out.println(arg + "! = " + silniaWhile(arg));
}
System.out.println();
System.out.println("long, rekurencja:");
for(int arg = 0; arg <= 50; arg++) {
System.out.println(arg + "! = " + silniaRek(arg));
}
System.out.println();
System.out.println("long, multiplyExact:");
for(int arg = 0; arg <= 50; arg++) {
try {
System.out.println(arg + "! = " + silniaKontrolowana(arg));
} catch(ArithmeticException e) {
System.out.println("OVERFLOW");
}
}
System.out.println();
System.out.println("BigInteger, for:");
for(int arg = 0; arg <= 100; arg++) {
System.out.println(arg + "! = " + silniaBig(arg));
}
System.out.println();
System.out.println("long, reduce:");
for(int arg = 0; arg <= 50; arg++) {
System.out.println(arg + "! = " + silniaFun(arg));
}
System.out.println();
System.out.println("BigInteger, reduce:");
for(int arg = 0; arg <= 100; arg++) {
System.out.println(arg + "! = " + silniaBigFun(arg));
}
System.out.println();
}
}
/* wersja w Pythonie:
def silnia(n):
wynik = 1
for i in range(1, n+1):
wynik *= i
return wynik
print(silnia(1))
print(silnia(5))
print(silnia(100))
*/
/* wersja w Haskellu:
silnia n = foldl (*) 1 [1..n]
silnia 5
silnia 100
*/
src/main/java/gotowe/p05_liczby/TestMegaSilni.java 0 → 100644
package gotowe.p05_liczby;
import java.io.IOException;
import java.math.BigInteger;
import java.nio.charset.Charset;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;
import java.util.Collections;
public class TestMegaSilni {
public static void main(String[] args) {
System.out.println("Wyliczam silnię od 100 tys.");
BigInteger silnia100tys = SilniaNaRozneSposoby.silniaBig(100_000);
String silnia100tysTXT = silnia100tys.toString();
System.out.printf("Gotowe, wynik ma %d cyfr.", silnia100tysTXT.length());
try {
final String plik = "silnia_100_tys.txt";
Files.write(Paths.get(plik), Collections.singleton(silnia100tysTXT), Charset.defaultCharset(),
StandardOpenOption.CREATE);
System.out.println("Zapisałem do pliku " + plik);
} catch(IOException e) {
System.out.println("Błąd zapisu do pliku");
}
System.out.println();
}
}
src/main/java/gotowe/p05_liczby/WypiszZakresy.java 0 → 100644
package gotowe.p05_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");
}
}
src/main/java/gotowe/p05_liczby/Znaki.java 0 → 100644
package gotowe.p05_liczby;
public class Znaki {
public static void main(String[] args) {
System.out.println("A");
System.out.println("A" + 5);
System.out.println('A');
System.out.println('A' + 5);
System.out.println('A' + 'B');
System.out.println();
char c = 65; // można wpisywać konkretną wartość int, o ile mieści się w zakresie
//NK char d = -1;
int x = 65;
int y = 'A';
//NK c = x; // ale nie int-a ze zmiennej
c = (char)x;
System.out.println(c);
x = c;
System.out.println(x);
x = (int)c;
System.out.println((int)c);
System.out.println();
for(char znak = 'A'; znak <= 'Z'; znak++) {
System.out.print(znak + " ");
}
System.out.println();
int ącki = 'Ą';
System.out.println(ącki);
}
}
src/main/java/gotowe/p06_funkcje/gdyby_nie_bylo_static/Geometria.java 0 → 100644
package gotowe.p06_funkcje.gdyby_nie_bylo_static;
public class Geometria {
// W tej wersji metody geometryczne nie są static.
// Powoduje to konieczność utworzenia obiektu ("instancji") tej klasy, gdy ktoś chce użyć tych metod - zob. Program i Testy w tym pakiecie
double poleKwadratu(double a) {
return a * a;
}
double poleKola(double r) {
return Math.PI * Math.pow(r, 2);
}
}
src/main/java/gotowe/p06_funkcje/gdyby_nie_bylo_static/TestyGeometrii.java 0 → 100644
package gotowe.p06_funkcje.gdyby_nie_bylo_static;
public class TestyGeometrii {
public static void main(String[] args) {
// ponieważ w tej wersji metody nie są static, to aby je wywołać trzeba utworzyć obiekt
// System.out.println("Pole kwadratu 5 = " + Geometria.poleKwadratu(5.0));
Geometria geo = new Geometria();
System.out.println("Pole kwadratu 5 = " + geo.poleKwadratu(5.0));
System.out.println("Pole koła 5 = " + geo.poleKola(5.0));
}
}
src/main/java/gotowe/p06_funkcje/importowanie/Importowanie0.java 0 → 100644
package gotowe.p06_funkcje.importowanie;
/* W tej wersji programu nie ma żadnych importów, a wszystkie odwołania do klasy Geometria
* oraz standardowych klas JOptionPane i Random są poprzedzone nazwą pakietu.
*
* W języku Java ZAWSZE da się napisać program bez użycia import.
*/
public class Importowanie0 {
public static void main(String[] args) {
@SuppressWarnings("resource")
java.util.Scanner scanner = new java.util.Scanner(System.in);
petla:
while(true)
try {
System.out.println("\nWybierz figurę:");
System.out.println(" K - kwadrat");
System.out.println(" O - koło");
System.out.println(" P - prostokąt");
System.out.println(" T - trójkąt");
System.out.println(" KM - przelicz kilometry na mile");
System.out.println(" MK - przelicz mile na kilometry");
System.out.println(" CF - przelicz °C na °F");
System.out.println(" FC - przelicz °F na °C");
System.out.println(" Q - zakończ");
String wybor = scanner.next().toUpperCase();
switch(wybor) {
case "Q" -> {
// muszę użyć "etykiety", aby powiedzieć Javie, że przerywam pętlę while, a nie samego switcha
break petla;
}
case "K" -> {
System.out.print("Podaj długość boku kwadratu: ");
double a = scanner.nextDouble();
double pole = gotowe.p06_funkcje.przyklady.Geometria.poleKwadratu(a);
double obwod = gotowe.p06_funkcje.przyklady.Geometria.obwodKwadratu(a);
System.out.printf("Dla kwadratu o boku %.3f pole wynosi %.3f, a obwód %.3f\n", a, pole, obwod);
}
case "P" -> {
System.out.print("Podaj długość pierwszego boku prostokąta: ");
double a = scanner.nextDouble();
System.out.print("Podaj długość drugiego boku prostokąta: ");
double b = scanner.nextDouble();
double pole = gotowe.p06_funkcje.przyklady.Geometria.poleProstokata(a, b);
double obwod = gotowe.p06_funkcje.przyklady.Geometria.obwodProstokata(a, b);
System.out.printf("Dla prostokąta o bokach %.3f i %.3f pole wynosi %.3f, a obwód %.3f\n", a, b, pole, obwod);
}
case "T" -> {
System.out.print("Podaj długość pierwszego boku trójkąta: ");
double a = scanner.nextDouble();
System.out.print("Podaj długość drugiego boku trójkąta: ");
double b = scanner.nextDouble();
System.out.print("Podaj długość trzeciego boku trójkąta: ");
double c = scanner.nextDouble();
double pole = gotowe.p06_funkcje.przyklady.Geometria.poleTrojkata(a, b, c);
double obwod = gotowe.p06_funkcje.przyklady.Geometria.obwodTrojkata(a, b, c);
System.out.printf("Dla prostokąta o bokach %.3f i %.3f pole wynosi %.3f, a obwód %.3f\n", a, b, pole, obwod);
}
case "O" -> {
System.out.print("Podaj promień koła: ");
double r = scanner.nextDouble();
double pole = gotowe.p06_funkcje.przyklady.Geometria.poleKola(r);
double obwod = gotowe.p06_funkcje.przyklady.Geometria.obwodKola(r);
System.out.printf("Dla koła o promieniu %.3f pole wynosi %.3f, a obwód %.3f\n", r, pole, obwod);
}
case "KM" -> {
System.out.print("Podaj odległość w kilometrach: ");
double km = scanner.nextDouble();
double wynik = gotowe.p06_funkcje.przyklady.JednostkiMiary.km_na_mile(km);
System.out.printf("%.3f km = %.3f mil\n", km, wynik);
}
case "MK" -> {
System.out.print("Podaj odległość w milach: ");
double mile = scanner.nextDouble();
double wynik = gotowe.p06_funkcje.przyklady.JednostkiMiary.mile_na_km(mile);
System.out.printf("%.3f mil = %.3f km\n", mile, wynik);
}
case "FC" -> {
System.out.print("Podaj temperaturę w Fahrenheitach: ");
double f = scanner.nextDouble();
double wynik = gotowe.p06_funkcje.przyklady.JednostkiMiary.far_na_cel(f);
System.out.printf("%.3f °F = %.3f °C\n", f, wynik);
}
case "CF" -> {
System.out.print("Podaj temperaturę w Celsjuszach: ");
double c = scanner.nextDouble();
double wynik = gotowe.p06_funkcje.przyklady.JednostkiMiary.cel_na_far(c);
System.out.printf("%.3f °C = %.3f °F\n", c, wynik);
}
default -> {
System.out.println("Nieznane polecenie " + wybor);
}
}
} catch(Exception e) {
System.out.println("Błąd: " + e);
}
}
}
src/main/java/gotowe/p06_funkcje/importowanie/Importowanie1.java 0 → 100644
package gotowe.p06_funkcje.importowanie;
import java.util.Scanner;
import gotowe.p06_funkcje.przyklady.Geometria;
import gotowe.p06_funkcje.przyklady.JednostkiMiary;
/* W tej wersji stosujemy najbardziej standardowy sposób importowania, najczęściej używany:
każda klasa, do której odwołuje się nasz program, jest zaimportowana osobnym poleceniem.
import w Javie NIE służy załadowaniu klas do pamięci, nie wykonuje się w czasie działania programu (tak się dzieje w Python i PHP)
To jest tylko wskazanie z jakiego pakietu pochodzi klasa.
import nie wpływa na wydajność!
*/
public class Importowanie1 {
public static void main(String[] args) {
@SuppressWarnings("resource")
Scanner scanner = new Scanner(System.in);
petla:
while(true)
try {
System.out.println("\nWybierz figurę:");
System.out.println(" K - kwadrat");
System.out.println(" O - koło");
System.out.println(" P - prostokąt");
System.out.println(" T - trójkąt");
System.out.println(" KM - przelicz kilometry na mile");
System.out.println(" MK - przelicz mile na kilometry");
System.out.println(" CF - przelicz °C na °F");
System.out.println(" FC - przelicz °F na °C");
System.out.println(" Q - zakończ");
String wybor = scanner.next().toUpperCase();
switch(wybor) {
case "Q" -> {
// muszę użyć "etykiety", aby powiedzieć Javie, że przerywam pętlę while, a nie samego switcha
break petla;
}
case "K" -> {
System.out.print("Podaj długość boku kwadratu: ");
double a = scanner.nextDouble();
double pole = Geometria.poleKwadratu(a);
double obwod = Geometria.obwodKwadratu(a);
System.out.printf("Dla kwadratu o boku %.3f pole wynosi %.3f, a obwód %.3f\n", a, pole, obwod);
}
case "P" -> {
System.out.print("Podaj długość pierwszego boku prostokąta: ");
double a = scanner.nextDouble();
System.out.print("Podaj długość drugiego boku prostokąta: ");
double b = scanner.nextDouble();
double pole = Geometria.poleProstokata(a, b);
double obwod = Geometria.obwodProstokata(a, b);
System.out.printf("Dla prostokąta o bokach %.3f i %.3f pole wynosi %.3f, a obwód %.3f\n", a, b, pole, obwod);
}
case "T" -> {
System.out.print("Podaj długość pierwszego boku trójkąta: ");
double a = scanner.nextDouble();
System.out.print("Podaj długość drugiego boku trójkąta: ");
double b = scanner.nextDouble();
System.out.print("Podaj długość trzeciego boku trójkąta: ");
double c = scanner.nextDouble();
double pole = Geometria.poleTrojkata(a, b, c);
double obwod = Geometria.obwodTrojkata(a, b, c);
System.out.printf("Dla prostokąta o bokach %.3f i %.3f pole wynosi %.3f, a obwód %.3f\n", a, b, pole, obwod);
}
case "O" -> {
System.out.print("Podaj promień koła: ");
double r = scanner.nextDouble();
double pole = Geometria.poleKola(r);
double obwod = Geometria.obwodKola(r);
System.out.printf("Dla koła o promieniu %.3f pole wynosi %.3f, a obwód %.3f\n", r, pole, obwod);
}
case "KM" -> {
System.out.print("Podaj odległość w kilometrach: ");
double km = scanner.nextDouble();
double wynik = JednostkiMiary.km_na_mile(km);
System.out.printf("%.3f km = %.3f mil\n", km, wynik);
}
case "MK" -> {
System.out.print("Podaj odległość w milach: ");
double mile = scanner.nextDouble();
double wynik = JednostkiMiary.mile_na_km(mile);
System.out.printf("%.3f mil = %.3f km\n", mile, wynik);
}
case "FC" -> {
System.out.print("Podaj temperaturę w Fahrenheitach: ");
double f = scanner.nextDouble();
double wynik = JednostkiMiary.far_na_cel(f);
System.out.printf("%.3f °F = %.3f °C\n", f, wynik);
}
case "CF" -> {
System.out.print("Podaj temperaturę w Celsjuszach: ");
double c = scanner.nextDouble();
double wynik = JednostkiMiary.cel_na_far(c);
System.out.printf("%.3f °C = %.3f °F\n", c, wynik);
}
default -> {
System.out.println("Nieznane polecenie " + wybor);
}
}
} catch(Exception e) {
System.out.println("Błąd: " + e);
}
}
}
src/main/java/gotowe/p06_funkcje/importowanie/Importowanie2.java 0 → 100644
package gotowe.p06_funkcje.importowanie;
import java.util.*;
import gotowe.p06_funkcje.przyklady.*;
/* Gdy na końcu polecenia import za nazwą pakietu umieścimy *,
* to importowane są wszystkie klasy z tego pakietu.
* To nie importuje podpakietów (podklatalogów).
* importy z * mają niższy priorytet niż importy bezpośrednie.
*
* Gdy w programie pojawia się jakaś nazwa, to kompilator szuka klasy w takiej kolejności:
* 1. rzeczy zaimportowane bezpośrednio (tak jak w Importowanie1)
* 2. bieżący pakiet
* 3. klasy zaimportowane za pomocą * (w tym java.lang)
* (bo w pewnym sensie kompilator Javy na początku robi niejawnie import java.lang.*;
*
* Czy importowanie wszystkich klas z dużego pakietu sprawia problemy?
* To nie jest problem z punktu widzenia wydajności, bo import nie ładuje tych klas do pamięci.
* Natomiast zwiększa to ryzyko kolizji nazw.
* Znany przykład: java.awt.List (lista wyboru w starej technologii okienkowej) i java.util.List (kolekcja).
* Sam import nie jest problemem, problem dopiero, gdy użyjemy tej klasy (błąd kompilacji).
*/
public class Importowanie2 {
public static void main(String[] args) {
@SuppressWarnings("resource")
Scanner scanner = new Scanner(System.in);
petla:
while(true)
try {
System.out.println("\nWybierz figurę:");
System.out.println(" K - kwadrat");
System.out.println(" O - koło");
System.out.println(" P - prostokąt");
System.out.println(" T - trójkąt");
System.out.println(" KM - przelicz kilometry na mile");
System.out.println(" MK - przelicz mile na kilometry");
System.out.println(" CF - przelicz °C na °F");
System.out.println(" FC - przelicz °F na °C");
System.out.println(" Q - zakończ");
String wybor = scanner.next().toUpperCase();
switch(wybor) {
case "Q" -> {
// muszę użyć "etykiety", aby powiedzieć Javie, że przerywam pętlę while, a nie samego switcha
break petla;
}
case "K" -> {
System.out.print("Podaj długość boku kwadratu: ");
double a = scanner.nextDouble();
double pole = Geometria.poleKwadratu(a);
double obwod = Geometria.obwodKwadratu(a);
System.out.printf("Dla kwadratu o boku %.3f pole wynosi %.3f, a obwód %.3f\n", a, pole, obwod);
}
case "P" -> {
System.out.print("Podaj długość pierwszego boku prostokąta: ");
double a = scanner.nextDouble();
System.out.print("Podaj długość drugiego boku prostokąta: ");
double b = scanner.nextDouble();
double pole = Geometria.poleProstokata(a, b);
double obwod = Geometria.obwodProstokata(a, b);
System.out.printf("Dla prostokąta o bokach %.3f i %.3f pole wynosi %.3f, a obwód %.3f\n", a, b, pole, obwod);
}
case "T" -> {
System.out.print("Podaj długość pierwszego boku trójkąta: ");
double a = scanner.nextDouble();
System.out.print("Podaj długość drugiego boku trójkąta: ");
double b = scanner.nextDouble();
System.out.print("Podaj długość trzeciego boku trójkąta: ");
double c = scanner.nextDouble();
double pole = Geometria.poleTrojkata(a, b, c);
double obwod = Geometria.obwodTrojkata(a, b, c);
System.out.printf("Dla prostokąta o bokach %.3f i %.3f pole wynosi %.3f, a obwód %.3f\n", a, b, pole, obwod);
}
case "O" -> {
System.out.print("Podaj promień koła: ");
double r = scanner.nextDouble();
double pole = Geometria.poleKola(r);
double obwod = Geometria.obwodKola(r);
System.out.printf("Dla koła o promieniu %.3f pole wynosi %.3f, a obwód %.3f\n", r, pole, obwod);
}
case "KM" -> {
System.out.print("Podaj odległość w kilometrach: ");
double km = scanner.nextDouble();
double wynik = JednostkiMiary.km_na_mile(km);
System.out.printf("%.3f km = %.3f mil\n", km, wynik);
}
case "MK" -> {
System.out.print("Podaj odległość w milach: ");
double mile = scanner.nextDouble();
double wynik = JednostkiMiary.mile_na_km(mile);
System.out.printf("%.3f mil = %.3f km\n", mile, wynik);
}
case "FC" -> {
System.out.print("Podaj temperaturę w Fahrenheitach: ");
double f = scanner.nextDouble();
double wynik = JednostkiMiary.far_na_cel(f);
System.out.printf("%.3f °F = %.3f °C\n", f, wynik);
}
case "CF" -> {
System.out.print("Podaj temperaturę w Celsjuszach: ");
double c = scanner.nextDouble();
double wynik = JednostkiMiary.cel_na_far(c);
System.out.printf("%.3f °C = %.3f °F\n", c, wynik);
}
default -> {
System.out.println("Nieznane polecenie " + wybor);
}
}
} catch(Exception e) {
System.out.println("Błąd: " + e);
}
}
}
src/main/java/gotowe/p06_funkcje/importowanie/Importowanie3.java 0 → 100644
package gotowe.p06_funkcje.importowanie;
import static gotowe.p06_funkcje.przyklady.Geometria.obwodKola;
import static gotowe.p06_funkcje.przyklady.Geometria.obwodKwadratu;
import static gotowe.p06_funkcje.przyklady.Geometria.obwodProstokata;
import static gotowe.p06_funkcje.przyklady.Geometria.obwodTrojkata;
import static gotowe.p06_funkcje.przyklady.Geometria.poleKola;
import static gotowe.p06_funkcje.przyklady.Geometria.poleKwadratu;
import static gotowe.p06_funkcje.przyklady.Geometria.poleProstokata;
import static gotowe.p06_funkcje.przyklady.Geometria.poleTrojkata;
import static gotowe.p06_funkcje.przyklady.JednostkiMiary.cel_na_far;
import static gotowe.p06_funkcje.przyklady.JednostkiMiary.far_na_cel;
import static gotowe.p06_funkcje.przyklady.JednostkiMiary.km_na_mile;
import static gotowe.p06_funkcje.przyklady.JednostkiMiary.mile_na_km;
// można też importować zmienne / stałe statyczne:
import static java.lang.Math.PI;
import java.util.Scanner;
/* Gdy w programie korzystamy tylko z elementów statycznych klasy X (z metod statycznych, zmiennych statycznych, stałych),
* to zamiast importować tę klasę i wywoływać te elementy pisząc X.metoda
* można zaimportować statycznie tę metodę (albo zmienną, stałą ...).
*
* Wtedy w treści programy używamy zaimportowanych rzeczy tak, jakby były zdefiniowane w naszej klasie.
* (albo tak jakby były funkcjami, tak jak w Pythonie, C++, PHP itp...)
*
* Nie ma jak użyć import static w stosunku do klasy Scanner, bo jej używamy w sposób "obiektowy":
* tworzony jest obiekt klasy Scanner i na nim wywoływana jest metoda (nie jest statyczna).
*/
public class Importowanie3 {
public static void main(String[] args) {
@SuppressWarnings("resource")
Scanner scanner = new Scanner(System.in);
System.out.println("Liczba pi: " + PI);
petla:
while(true)
try {
System.out.println("\nWybierz figurę:");
System.out.println(" K - kwadrat");
System.out.println(" O - koło");
System.out.println(" P - prostokąt");
System.out.println(" T - trójkąt");
System.out.println(" KM - przelicz kilometry na mile");
System.out.println(" MK - przelicz mile na kilometry");
System.out.println(" CF - przelicz °C na °F");
System.out.println(" FC - przelicz °F na °C");
System.out.println(" Q - zakończ");
String wybor = scanner.next().toUpperCase();
switch(wybor) {
case "Q" -> {
// muszę użyć "etykiety", aby powiedzieć Javie, że przerywam pętlę while, a nie samego switcha
break petla;
}
case "K" -> {
System.out.print("Podaj długość boku kwadratu: ");
double a = scanner.nextDouble();
double pole = poleKwadratu(a);
double obwod = obwodKwadratu(a);
System.out.printf("Dla kwadratu o boku %.3f pole wynosi %.3f, a obwód %.3f\n", a, pole, obwod);
}
case "P" -> {
System.out.print("Podaj długość pierwszego boku prostokąta: ");
double a = scanner.nextDouble();
System.out.print("Podaj długość drugiego boku prostokąta: ");
double b = scanner.nextDouble();
double pole = poleProstokata(a, b);
double obwod = obwodProstokata(a, b);
System.out.printf("Dla prostokąta o bokach %.3f i %.3f pole wynosi %.3f, a obwód %.3f\n", a, b, pole, obwod);
}
case "T" -> {
System.out.print("Podaj długość pierwszego boku trójkąta: ");
double a = scanner.nextDouble();
System.out.print("Podaj długość drugiego boku trójkąta: ");
double b = scanner.nextDouble();
System.out.print("Podaj długość trzeciego boku trójkąta: ");
double c = scanner.nextDouble();
double pole = poleTrojkata(a, b, c);
double obwod = obwodTrojkata(a, b, c);
System.out.printf("Dla prostokąta o bokach %.3f i %.3f pole wynosi %.3f, a obwód %.3f\n", a, b, pole, obwod);
}
case "O" -> {
System.out.print("Podaj promień koła: ");
double r = scanner.nextDouble();
double pole = poleKola(r);
double obwod = obwodKola(r);
System.out.printf("Dla koła o promieniu %.3f pole wynosi %.3f, a obwód %.3f\n", r, pole, obwod);
}
case "KM" -> {
System.out.print("Podaj odległość w kilometrach: ");
double km = scanner.nextDouble();
double wynik = km_na_mile(km);
System.out.printf("%.3f km = %.3f mil\n", km, wynik);
}
case "MK" -> {
System.out.print("Podaj odległość w milach: ");
double mile = scanner.nextDouble();
double wynik = mile_na_km(mile);
System.out.printf("%.3f mil = %.3f km\n", mile, wynik);
}
case "FC" -> {
System.out.print("Podaj temperaturę w Fahrenheitach: ");
double f = scanner.nextDouble();
double wynik = far_na_cel(f);
System.out.printf("%.3f °F = %.3f °C\n", f, wynik);
}
case "CF" -> {
System.out.print("Podaj temperaturę w Celsjuszach: ");
double c = scanner.nextDouble();
double wynik = cel_na_far(c);
System.out.printf("%.3f °C = %.3f °F\n", c, wynik);
}
default -> {
System.out.println("Nieznane polecenie " + wybor);
}
}
} catch(Exception e) {
System.out.println("Błąd: " + e);
}
}
}
src/main/java/gotowe/p06_funkcje/importowanie/Importowanie4.java 0 → 100644
package gotowe.p06_funkcje.importowanie;
import static gotowe.p06_funkcje.przyklady.Geometria.*;
import static gotowe.p06_funkcje.przyklady.JednostkiMiary.*;
// można też importować zmienne / stałe statyczne:
import static java.lang.Math.*;
import java.util.Scanner;
/* import static pakiet.Klasa.* importuje wszystkie rzeczy statyczne z podanej klasy.
*
* Nie da się użyć gwiazdek na poziomie pakietu i klasy w jednym imporcie.
* To nie przejdzie:
* import static funkcje.*.*;
*/
public class Importowanie4 {
public static void main(String[] args) {
@SuppressWarnings("resource")
Scanner scanner = new Scanner(System.in);
System.out.println("Liczba pi: " + PI);
petla:
while(true)
try {
System.out.println("\nWybierz figurę:");
System.out.println(" K - kwadrat");
System.out.println(" O - koło");
System.out.println(" P - prostokąt");
System.out.println(" T - trójkąt");
System.out.println(" KM - przelicz kilometry na mile");
System.out.println(" MK - przelicz mile na kilometry");
System.out.println(" CF - przelicz °C na °F");
System.out.println(" FC - przelicz °F na °C");
System.out.println(" Q - zakończ");
String wybor = scanner.next().toUpperCase();
switch(wybor) {
case "Q" -> {
// muszę użyć "etykiety", aby powiedzieć Javie, że przerywam pętlę while, a nie samego switcha
break petla;
}
case "K" -> {
System.out.print("Podaj długość boku kwadratu: ");
double a = scanner.nextDouble();
double pole = poleKwadratu(a);
double obwod = obwodKwadratu(a);
System.out.printf("Dla kwadratu o boku %.3f pole wynosi %.3f, a obwód %.3f\n", a, pole, obwod);
}
case "P" -> {
System.out.print("Podaj długość pierwszego boku prostokąta: ");
double a = scanner.nextDouble();
System.out.print("Podaj długość drugiego boku prostokąta: ");
double b = scanner.nextDouble();
double pole = poleProstokata(a, b);
double obwod = obwodProstokata(a, b);
System.out.printf("Dla prostokąta o bokach %.3f i %.3f pole wynosi %.3f, a obwód %.3f\n", a, b, pole, obwod);
}
case "T" -> {
System.out.print("Podaj długość pierwszego boku trójkąta: ");
double a = scanner.nextDouble();
System.out.print("Podaj długość drugiego boku trójkąta: ");
double b = scanner.nextDouble();
System.out.print("Podaj długość trzeciego boku trójkąta: ");
double c = scanner.nextDouble();
double pole = poleTrojkata(a, b, c);
double obwod = obwodTrojkata(a, b, c);
System.out.printf("Dla prostokąta o bokach %.3f i %.3f pole wynosi %.3f, a obwód %.3f\n", a, b, pole, obwod);
}
case "O" -> {
System.out.print("Podaj promień koła: ");
double r = scanner.nextDouble();
double pole = poleKola(r);
double obwod = obwodKola(r);
System.out.printf("Dla koła o promieniu %.3f pole wynosi %.3f, a obwód %.3f\n", r, pole, obwod);
}
case "KM" -> {
System.out.print("Podaj odległość w kilometrach: ");
double km = scanner.nextDouble();
double wynik = km_na_mile(km);
System.out.printf("%.3f km = %.3f mil\n", km, wynik);
}
case "MK" -> {
System.out.print("Podaj odległość w milach: ");
double mile = scanner.nextDouble();
double wynik = mile_na_km(mile);
System.out.printf("%.3f mil = %.3f km\n", mile, wynik);
}
case "FC" -> {
System.out.print("Podaj temperaturę w Fahrenheitach: ");
double f = scanner.nextDouble();
double wynik = far_na_cel(f);
System.out.printf("%.3f °F = %.3f °C\n", f, wynik);
}
case "CF" -> {
System.out.print("Podaj temperaturę w Celsjuszach: ");
double c = scanner.nextDouble();
double wynik = cel_na_far(c);
System.out.printf("%.3f °C = %.3f °F\n", c, wynik);
}
default -> {
System.out.println("Nieznane polecenie " + wybor);
}
}
} catch(Exception e) {
System.out.println("Błąd: " + e);
}
}
}
src/main/java/gotowe/p06_funkcje/przyklady/Geometria.java 0 → 100644
package gotowe.p06_funkcje.przyklady;
// Specjalne komentarze pisane /** Opis */ tworzą dokumentację nazywaną "javadoc".
// W Eclipse można je wprowadzać skrótem Alt+Shift+J
/**
* @author patryk
*
* Klasa narzędziowa zawierająca metody statyczne służące do obliczania pól i obwodów figur geometrycznych.
*
* To jest przykład klasy, w której nie ma metody main, tylko są zdefiniowane inne metody.
*/
public class Geometria {
static {
// Blok inicjalizacyjny statyczny to jest taki fragment kodu, który wykonuje się w momencie ładowania klasy do pamięci.
System.out.println("ładowana jest klasa Geometria");
}
/** Oblicza pole kwadratu o podanym boku.
*
* @param a długość boku
* @return obliczone pole kwadratu
*/
public static double poleKwadratu(double a) {
return a * a;
}
/** Oblicza obwód kwadratu o podanym boku.
*
* @param a długość boku
* @return obliczony obwód kwadratu
*/
public static double obwodKwadratu(double a) {
return 4 * a;
}
/** Oblicza pole prostokąta o podanych bokach.
*
* @param a długość pierwszego boku
* @param b długość drugiego boku
* @return obliczone pole prostokąta
*/
public static double poleProstokata(double a, double b) {
return a * b;
}
/** Oblicza obwód prostokąta o podanych bokach.
*
* @param a długość pierwszego boku
* @param b długość drugiego boku
* @return obliczony obwód prostokąta
*/
public static double obwodProstokata(double a, double b) {
return 2 * a + 2 * b;
}
/** Oblicza pole koła o podanym promieniu.
*
* @param r promień koła
* @return obliczone pole koła
*/
public static double poleKola(double r) {
return Math.PI * r * r;
}
/** Oblicza obwód koła (aka długość okręgu) o podanym promieniu.
*
* @param r promień koła
* @return obliczony obwód koła
*/
public static double obwodKola(double r) {
return Math.PI * 2 * r;
}
/** Sprawdza czy z boków o podanych długościach da się ułożyć trójkąt.
*
* @param a długość pierwszego boku
* @param b długość drugiego boku
* @param c długość trzeciego boku
* @return <code>true</code> jeśli podane boki spełniają <dfn>warunek trójkąta</dfn>, <code>false</code> w przeciwnym przypadku
*/
static boolean poprawnyTrojkat(double a, double b, double c) {
return a > 0 && b > 0 && c > 0 && a < b+c && b < a+c && c < a+b;
}
/** Oblicza pole trójkąta na podstawie długości boków.
*
* @param a długość pierwszego boku
* @param b długość drugiego boku
* @param c długość trzeciego boku
* @return obliczone pole trójkąta
* @throws IllegalArgumentException w przypadku, gdy z podanych boków nie da się ułożyć trójkąta
*/
public static double poleTrojkata(double a, double b, double c) {
if(!poprawnyTrojkat(a, b, c)) {
throw new IllegalArgumentException("Boki nie pasują, nie da się złożyć trójkąta.");
}
double p = (a + b + c) / 2.;
return Math.sqrt(p * (p - a) * (p - b) * (p - c));
}
/** Oblicza obwód trójkąta na podstawie długości boków.
*
* @param a długość pierwszego boku
* @param b długość drugiego boku
* @param c długość trzeciego boku
* @return obliczony obwód trójkąta
*/
public static double obwodTrojkata(double a, double b, double c) {
return a + b + c;
}
}
src/main/java/gotowe/p06_funkcje/przyklady/JednostkiMiary.java 0 → 100644
package gotowe.p06_funkcje.przyklady;
public class JednostkiMiary {
static {
System.out.println("ładowana jest klasa JednostkiMiary");
}
/** Funkcja przelicza podaną liczbę mil na kilometry. */
public static double mile_na_km(double mile) {
return mile * 1.609344;
}
// Napisz w tym miejscu funkcję km_na_mile , która przelicza w drugą stronę, a do main dopisz 2-3 przykładowe wywołania
public static double km_na_mile(double km) {
return km / 1.609344;
}
// Napisz funkcje far_na_cel i cel_na_far
// które przeliczają temperaturę w stopniach Fahrenheita na stopnie Celsjusza i odwrotnie
// https://pl.wikipedia.org/wiki/Skala_Fahrenheita
public static double far_na_cel(double far) {
// źle: return 5/9 * (far - 32);
// kilka poprawnych rozwiązań:
return 5. / 9. * (far - 32.);
// return (far - 32) * 5/9;
// return (far - 32) / 1.8;
}
public static double cel_na_far(double cel) {
//źle: return 32 + 9/5 * cel;
// poprawne:
// return 32. + 9./5. * cel;
// return cel * 9 / 5 + 32;
return 1.8 * cel + 32;
}
public static void main(String[] args) {
// Ten program nie będzie interaktywny, nie będzie pytać użytkownika o dane.
// Tutaj tylko przetestujemy funkcje na kilku wartościach.
System.out.println("100 mil = " + mile_na_km(100) + " km");
System.out.println("500 mil = " + mile_na_km(500) + " km");
System.out.println();
System.out.println("100 km = " + km_na_mile(100) + " mil");
System.out.println("160 km = " + km_na_mile(160) + " mil");
System.out.println();
System.out.println("0 F = " + far_na_cel(0) + " C");
System.out.println("100 F = " + far_na_cel(100) + " C"); // 37.7
System.out.println();
System.out.println("0 C = " + cel_na_far(0) + " F");
System.out.println("37 C = " + cel_na_far(37) + " F");
System.out.println("100 C = " + cel_na_far(100) + " F");
}
}
src/main/java/gotowe/p06_funkcje/przyklady/ProgramGeometrycznyKonsolowy.java 0 → 100644
package gotowe.p06_funkcje.przyklady;
import java.util.Scanner;
public class ProgramGeometrycznyKonsolowy {
public static void main(String[] args) {
@SuppressWarnings("resource")
Scanner scanner = new Scanner(System.in);
petla:
while(true)
try {
System.out.println("\nWybierz figurę:");
System.out.println(" K - kwadrat");
System.out.println(" O - koło");
System.out.println(" P - prostokąt");
System.out.println(" T - trójkąt");
System.out.println(" KM - przelicz kilometry na mile");
System.out.println(" MK - przelicz mile na kilometry");
System.out.println(" CF - przelicz °C na °F");
System.out.println(" FC - przelicz °F na °C");
System.out.println(" Q - zakończ");
String wybor = scanner.next().toUpperCase();
switch(wybor) {
case "Q" -> {
// muszę użyć "etykiety", aby powiedzieć Javie, że przerywam pętlę while, a nie samego switcha
break petla;
}
case "K" -> {
System.out.print("Podaj długość boku kwadratu: ");
double a = scanner.nextDouble();
double pole = Geometria.poleKwadratu(a);
double obwod = Geometria.obwodKwadratu(a);
System.out.printf("Dla kwadratu o boku %.3f pole wynosi %.3f, a obwód %.3f\n", a, pole, obwod);
}
case "P" -> {
System.out.print("Podaj długość pierwszego boku prostokąta: ");
double a = scanner.nextDouble();
System.out.print("Podaj długość drugiego boku prostokąta: ");
double b = scanner.nextDouble();
double pole = Geometria.poleProstokata(a, b);
double obwod = Geometria.obwodProstokata(a, b);
System.out.printf("Dla prostokąta o bokach %.3f i %.3f pole wynosi %.3f, a obwód %.3f\n", a, b, pole, obwod);
}
case "T" -> {
System.out.print("Podaj długość pierwszego boku trójkąta: ");
double a = scanner.nextDouble();
System.out.print("Podaj długość drugiego boku trójkąta: ");
double b = scanner.nextDouble();
System.out.print("Podaj długość trzeciego boku trójkąta: ");
double c = scanner.nextDouble();
double pole = Geometria.poleTrojkata(a, b, c);
double obwod = Geometria.obwodTrojkata(a, b, c);
System.out.printf("Dla prostokąta o bokach %.3f i %.3f pole wynosi %.3f, a obwód %.3f\n", a, b, pole, obwod);
}
case "O" -> {
System.out.print("Podaj promień koła: ");
double r = scanner.nextDouble();
double pole = Geometria.poleKola(r);
double obwod = Geometria.obwodKola(r);
System.out.printf("Dla koła o promieniu %.3f pole wynosi %.3f, a obwód %.3f\n", r, pole, obwod);
}
case "KM" -> {
System.out.print("Podaj odległość w kilometrach: ");
double km = scanner.nextDouble();
double wynik = JednostkiMiary.km_na_mile(km);
System.out.printf("%.3f km = %.3f mil\n", km, wynik);
}
case "MK" -> {
System.out.print("Podaj odległość w milach: ");
double mile = scanner.nextDouble();
double wynik = JednostkiMiary.mile_na_km(mile);
System.out.printf("%.3f mil = %.3f km\n", mile, wynik);
}
case "FC" -> {
System.out.print("Podaj temperaturę w Fahrenheitach: ");
double f = scanner.nextDouble();
double wynik = JednostkiMiary.far_na_cel(f);
System.out.printf("%.3f °F = %.3f °C\n", f, wynik);
}
case "CF" -> {
System.out.print("Podaj temperaturę w Celsjuszach: ");
double c = scanner.nextDouble();
double wynik = JednostkiMiary.cel_na_far(c);
System.out.printf("%.3f °C = %.3f °F\n", c, wynik);
}
default -> {
System.out.println("Nieznane polecenie " + wybor);
}
}
} catch(Exception e) {
System.out.println("Błąd: " + e);
}
}
}
src/main/java/gotowe/p06_funkcje/przyklady/ProgramGeometrycznyOkienkowy.java 0 → 100644
package gotowe.p06_funkcje.przyklady;
import javax.swing.JOptionPane;
public class ProgramGeometrycznyOkienkowy {
public static void main(String[] args) {
String[] figury = { "kwadrat", "prostokąt", "koło" };
String figura = (String)JOptionPane.showInputDialog(
null,
"Wybierz rodzaj figury",
"Wybór",
JOptionPane.QUESTION_MESSAGE,
null,
figury,
null);
switch(figura) {
case "kwadrat" -> {
double a = Double.parseDouble(JOptionPane.showInputDialog("Podaj długość boku:"));
double pole = Geometria.poleKwadratu(a);
double obwod = Geometria.obwodKwadratu(a);
JOptionPane.showMessageDialog(null, "Pole: " + pole + "\nObwód: " + obwod);
}
case "prostokąt" -> {
double a = Double.parseDouble(JOptionPane.showInputDialog("Podaj długość 1. boku:"));
double b = Double.parseDouble(JOptionPane.showInputDialog("Podaj długość 2. boku:"));
double pole = Geometria.poleProstokata(a, b);
double obwod = Geometria.obwodProstokata(a, b);
JOptionPane.showMessageDialog(null, "Pole: " + pole + "\nObwód: " + obwod);
}
case "koło" -> {
double r = Double.parseDouble(JOptionPane.showInputDialog("Podaj promień koła:"));
double pole = Geometria.poleKola(r);
double obwod = Geometria.obwodKola(r);
JOptionPane.showMessageDialog(null, "Pole: " + pole + "\nObwód: " + obwod);
}
}
}
}
src/main/java/gotowe/p06_funkcje/przyklady/TestyGeometrii.java 0 → 100644
package gotowe.p06_funkcje.przyklady;
public class TestyGeometrii {
public static void main(String[] args) {
// proste testy polegające na wywołaniu funkcji dla przykładowych wartości i wypisaniu wyniku
System.out.println("pole kwadratu 5 = " + Geometria.poleKwadratu(5));
System.out.println("obwód kwadratu 5 = " + Geometria.obwodKwadratu(5));
System.out.println("pole prostokąta 3x4 = " + Geometria.poleProstokata(3, 4));
System.out.println("obwód prostokąta 3x4 = " + Geometria.obwodProstokata(3, 4));
System.out.println("pole koła 5 = " + Geometria.poleKola(5));
System.out.println("obwód koła 5 = " + Geometria.obwodKola(5));
}
}
src/main/java/gotowe/p06_funkcje/teoria/Funkcje1_Void.java 0 → 100644
package gotowe.p06_funkcje.teoria;
import java.time.LocalTime;
public class Funkcje1_Void {
static void poczatek() {
// Funkcja typu void nie zwraca żadnego wyniku, tylko "coś robi"
System.out.println("To jest funkcja początek");
System.out.println("Funkcja początek kończy się");
}
static void nikt_mnie_nie_chce() {
// Jeśli funkcja nie jest wywoływana z main (bezpośrednio albo pośrednio), to
// jej treść się nie wykona.
System.out.println("To się nigdy nie wypisze");
}
static void ktoraGodzina() {
System.out.println("Godzina " + LocalTime.now());
}
public static void main(String[] args) {
System.out.println("Początek main");
poczatek(); // wywołanie / call / invoke
for(int i = 0; i < 10; i++) {
ktoraGodzina();
}
koniec();
}
// W Javie kolejność definicji metod (funkcji) nie ma znaczenia.
// Funkcja zdefiniowana wcześniej może wywoływać funkcję zdefiniowaną później.
static void koniec() {
System.out.println("Koniec");
System.out.print("Na koniec jest godzina: ");
ktoraGodzina(); // jedna funkcja może wywołać inną funkcję
}
}
src/main/java/gotowe/p06_funkcje/teoria/Funkcje2_Parametry.java 0 → 100644
package gotowe.p06_funkcje.teoria;
public class Funkcje2_Parametry {
// Funkcja może mieć parametry:
static void zaprosNaKurs(String jezyk, int iloscDni) {
System.out.println("Zapraszamy na kurs języka " + jezyk + ", które będzie trwał " + iloscDni + " dni.");
}
static void powtorz(String napis, int ilosc) {
for(int i = 1; i <= ilosc; i++) {
System.out.println(napis);
}
}
public static void main(String[] args) {
// Wywołując funkcję sparametryzowaną musimy przekazać wartości parametrów, czyli "argumenty".
zaprosNaKurs("Java", 10);
zaprosNaKurs("Python", 10);
zaprosNaKurs("SQL", 4);
System.out.println();
// Zadeklarowane w funkcji: parametr, paramter formalny (formal parameter)
// Wartość przekazywana w wywołaniu: argument, parametr aktualny / bieżący (actual parameter)
powtorz("Ala ma kota", 5);
powtorz("Ola ma psa", 3);
}
}
src/main/java/gotowe/p06_funkcje/teoria/Funkcje3_Wynik.java 0 → 100644
package gotowe.p06_funkcje.teoria;
public class Funkcje3_Wynik {
// Funkcja może zwrócić wynik:
static int liczba() {
return 13;
}
static int dodaj(int x, int y) {
return x + y;
}
static String napis() {
return "Hello world";
}
static String powitanie(String imie) {
return "Witaj " + imie + ", miło Cię poznać";
}
// Funkcja może zawierać wiele instrukcji return w różnych miejscach. Np. w zależości od warunku zwróć jedno lub drugie.
// Kompilator Javy sprawdza jednak, czy funkcja zwraca wynik w każdej sytuacji.
static int roznicaBezwzgledna(int x, int y) {
if(x >= y) {
return x - y;
} else {
return y - x;
}
}
public static void main(String[] args) {
liczba();
// Czy liczba 13 wypisze się na ekran? NIE
// To, że funkcja zwraca wynik, oznacza, że np. można ten wynik zapisać na zmienną:
int wynik = liczba();
System.out.println("Funkcja zwróciła wynik " + wynik); // dopiero tutaj
wynik = dodaj(13, 12);
System.out.println("Dodawanie zwróciło wynik " + wynik);
String napis;
napis = powitanie("Ala");
System.out.println("Powitanie 1: " + napis);
napis = powitanie("Karol");
System.out.println("Powitanie 2: " + napis);
String s = "Ola";
napis = powitanie(s);
System.out.println("Powitanie 2: " + napis);
}
}
src/main/java/gotowe/p06_funkcje/teoria/Narnia.java 0 → 100644
package gotowe.p06_funkcje.teoria;
public class Narnia {
public static void main(String[] args) {
System.out.println("Wszyscy są w domu");
System.out.println("Łucja chowa się w pokoju z szafą");
wejdzDoSzafy("Łucja");
System.out.println("Łucja wróciła do domu");
wejdzDoSzafy("Łucja", "Zuzanna", "Piotr", "Edmund");
System.out.println("Po wyeliminowaniu czarownicy wszyscy wrócili do domu.");
String[] kolejneOsoby = { "Ala", "Ola", "Ela" };
wejdzDoSzafy(kolejneOsoby);
}
// varargs - zmienna liczba argumentów
// taki parametr z trzema kropkami może występować tylko 1, na samym końcu listy parametrów
// wewnątrz funkcji on jest widziany jako tablica
// a z zewnątrz można przekazać 1 tablicę albo wiele elementów po przecinku
static void wejdzDoSzafy(String... kto) {
System.out.println();
System.out.println("Do Krainy Narni weszli:");
for(String imie: kto) {
System.out.println(" * " + imie);
}
System.out.println("Mają ciekawe przygody");
System.out.println("I w końcu wracają");
System.out.println();
}
}
src/main/java/gotowe/p10_klasy_podstawy/Osoba.java 0 → 100644
package gotowe.p10_klasy_podstawy;
// Przy definicjach w tym pakiecie nie ma zadeklarowanego poziomu widoczności (public/private).
// W tej sytuacji obowiązuje widoczność domyślna=pakietowa.
class Osoba {
// Zmienna definiowana na poziomie klasy (a nie w metodach) jest określana jako:
// pole (field), atrybut (attribute) lub zmienna instancyjna (instance variable).
// Wartości takich zmiennych (nie-statycznych) przechowywane są oddzielnie w każdym obiekcie.
// W tej wersji klas pozostawiamy pola na poziomie widoczności pakietowej. W praktyce Javy najczęściej pola są prywatne.
String imie, nazwisko;
int wiek;
// Zmienne oznaczone static to: zmienne statyczne / pola statyczne / atrybuty statyczne.
// Wartość jest przechowywana w jednym egzemplarzu w klasie (a nie obiekcie).
// Wszystkie obiekty mają dostęp do jednej, wspólnej wartości zmiennej statycznej.
// Dodatkowo oznaczenie final i wpisanie konkretnej wartości powoduje, że jest to stała (i tak jest traktowana przez kompilator).
static final int WIEK_PELNOLETNIOSCI = 18;
// Konstruktor bezargumentowy, nazywany także "konstruktor domyślny" / default constructor.
// Zostałby automatycznie utworzony, gdyby w klasie nie było innych konstruktorów, ale jeśli są, to musi być zdefiniowany jawnie.
Osoba() {
}
// Dosyć często (ale nie zawsze) definiuje się konstruktor, który inicjalizuje wszystkie pola przekazanymi wartościami.
Osoba(String imie, String nazwisko, int wiek) {
this.imie = imie;
this.nazwisko = nazwisko;
this.wiek = wiek;
}
// Metoda ("nie-statyczna", czyli "instancyjna") to czynność, którą "potrafi" wykonać obiekt.
// Inaczej mówiąc, to funkcja, która jest wywoływana i wykonuje się w kontekście określonego obiektu.
void przedstawSie() {
System.out.println("Nazywam się " + imie + " " + nazwisko + " i mam " + wiek + " lat.");
}
// Metoda może zwracać wynik. Bardzo często wynik zależy od aktualnej wartości pól w obiekcie.
boolean pelnoletnia() {
return wiek >= WIEK_PELNOLETNIOSCI;
}
// Metoda może zmieniać stan obiektu.
void postarzejSie() {
wiek += 1;
}
}
src/main/java/gotowe/p10_klasy_podstawy/Program.java 0 → 100644
package gotowe.p10_klasy_podstawy;
// Jeśli klasa zawiera metodę main, to może pełnić rolę programu - można ją uruchamiać (poleceniem java w wierszu poleceń lub z poziomu środowiska deweloperskiego).
class Program {
public static void main(String[] args) {
// Deklaracja zmiennej typu obiektowego. Uwaga - sam taki zapis nie tworzy obiektu (inaczej niż w C++).
Osoba a;
// System.out.println(a);
// Utworzenie obiektu i wpisanie "referencji do obiektu" do zmiennej:
a = new Osoba();
// W nowoutworzonym obiekcie, o ile konstruktor i inicjalizacje w klasie nie wpiszą czegoś innego,
// pola są inicjowane na wartości 0, false, null w zależności od typu:
System.out.println(a);
System.out.println("Początkowe wartości pól: " + a.imie + " " + a.nazwisko + " " + a.wiek);
// Na polach obiektu (o ile poziom widoczności pozwala) można wykonywać operacje jak na innych zmiennych.
a.imie = "Ala";
a.nazwisko = "Kowalska";
a.wiek = 30;
System.out.println("a wartości pól: " + a.imie + " " + a.nazwisko + " " + a.wiek);
// Najczęściej deklaracja zmiennej i utworenie obiektu są zapisane razem:
Osoba b = new Osoba("Jan", "Kowalski", 30);
System.out.println(b);
System.out.println("b wartości pól: " + b.imie + " " + b.nazwisko + " " + b.wiek);
System.out.println();
// Wywołania metod na obiektach:
a.przedstawSie();
b.przedstawSie();
if(a.pelnoletnia()) {
System.out.println(a.imie + " jest pełnoletnia");
}
System.out.println();
System.out.println("Postarzejemy " + b.imie + "...");
b.postarzejSie();
a.przedstawSie();
b.przedstawSie();
}
}
src/main/java/gotowe/p10_klasy_podstawy/PustaKlasa.java 0 → 100644
package gotowe.p10_klasy_podstawy;
class PustaKlasa {
}
src/main/java/gotowe/p10_klasy_podstawy/PustaKlasaProgram.java 0 → 100644
package gotowe.p10_klasy_podstawy;
class PustaKlasaProgram {
public static void main(String[] args) {
// Nawet jeśli definicja klasy jest pusta, można utworzyć obiekt i jest na nim dostepnych kilka metod:
PustaKlasa obiekt = new PustaKlasa();
System.out.println(obiekt);
System.out.println(obiekt.getClass());
System.out.println(obiekt instanceof PustaKlasa);
System.out.println(obiekt.toString());
System.out.println(obiekt.hashCode());
System.out.println(obiekt.equals(obiekt));
System.out.println(obiekt.equals(null));
}
}
src/main/java/gotowe/p12_dziedziczenie/a_podstawy/Konto.java 0 → 100644
package gotowe.p12_dziedziczenie.a_podstawy;
class Konto {
int numer;
int saldo;
Osoba wlasciciel;
Konto(int numer, int saldo, Osoba wlasciciel) {
this.numer = numer;
this.saldo = saldo;
this.wlasciciel = wlasciciel;
}
@Override
public String toString() {
return "Konto nr " + numer + ", saldo: " + saldo + ", wł.: " + wlasciciel;
}
void wplata(int kwota) {
saldo += kwota;
}
void wyplata(int kwota) {
saldo -= kwota;
}
void przelew(Konto kontoDocelowe, int kwota) {
this.saldo -= kwota;
kontoDocelowe.saldo += kwota;
}
}
src/main/java/gotowe/p12_dziedziczenie/a_podstawy/Osoba.java 0 → 100644
package gotowe.p12_dziedziczenie.a_podstawy;
// Przy definicjach w tym pakiecie nie ma zadeklarowanego poziomu widoczności (public/private).
// W tej sytuacji obowiązuje widoczność domyślna=pakietowa.
class Osoba {
String imie, nazwisko;
int wiek;
static final int WIEK_PELNOLETNIOSCI = 18;
Osoba() {
}
Osoba(String imie, String nazwisko, int wiek) {
this.imie = imie;
this.nazwisko = nazwisko;
this.wiek = wiek;
}
// Ta metoda zostanie nadpisana w podklasach
void przedstawSie() {
System.out.println("Nazywam się " + imie + " " + nazwisko + " i mam " + wiek + " lat.");
}
// Ta metoda nie będzie nadpisywana w podklasach. Można by do niej dopisać final.
boolean pelnoletnia() {
return wiek >= WIEK_PELNOLETNIOSCI;
}
void postarzejSie() {
wiek += 1;
}
@Override
public String toString() {
return imie + " " + nazwisko + " (" + wiek + " lat)";
}
}
src/main/java/gotowe/p12_dziedziczenie/a_podstawy/Polimorfizm1.java 0 → 100644
package gotowe.p12_dziedziczenie.a_podstawy;
public class Polimorfizm1 {
public static void main(String[] args) {
Osoba osoba = new Osoba("Ala", "Kowalska", 30);
System.out.println(osoba);
// Poprzez zmienną typu Osoba można korzystać tylko ze zmiennych (pól) i metod zdefiniowanych w klasie Osoba.
System.out.println(osoba.imie + " " + osoba.nazwisko);
osoba.przedstawSie();
// Nie działają:
// System.out.println(osoba.kierunek);
// System.out.println(osoba.sredniaOcen());
System.out.println();
Student student = new Student("Adam", "Abacki", 22, "geologia", 4);
System.out.println(student);
// Jeśli klasa Student jest rozszerzeniem klasy Osoba,
// to na zmiennej typu Student można wykonać te operacje (i dostać się do tych zmiennych),
// które byłyby dostępne zmiennej typu Osoba...
if(student.pelnoletnia()) {
System.out.println("Student " + student.imie + " jest pełnoletni");
}
// ... a dodatkowo dostępne są zmienne i metody dodane w klasie Student.
student.dodajOcene(5);
student.dodajOcene(4);
System.out.println("Średnia ocen: " + student.sredniaOcen());
System.out.println();
// Dziedziczenie to nie tylko "skopiowanie definicji z istniejącej klasy i dopisanie czegoś jeszcze".
// W dziedziczeniu chodzi też o to, że w każdej sytuacji obiekt podklasy może być użyty zamiast obiektu nadklasy.
// "zasada podstawiania"
// Skoro student posiada wszystkie te cechy, co inne osoby, to obiektu student można użyć w k ązdym miejscu, gdzie możnaby uzyć osoby.
// Przykłady:
// Student może być wpisany do zmiennej typu Osoba.
Osoba ktos = student;
// Osoba ktos = osoba;
ktos.przedstawSie();
// Student może być właścicielem konta:
Konto kontoStudenckie = new Konto(1313, 123, student);
kontoStudenckie.wplata(500);
System.out.println(kontoStudenckie);
System.out.println();
// Student może pójść do urzędu
Urzad urzadMiasta = new Urzad();
urzadMiasta.zalatwSprawe(student);
// itp....
// Czy w zmienne ktos mamy teraz Osobę czy Studenta?
System.out.println(ktos.getClass()); // Student
// Jednak do pól tego obiektu nie można dostać się "oficjalnie":
// System.out.println(ktos.kierunek + " , średnia " + ktos.sredniaOcen());
// Obiekt ze zmiennej typu "nadklasa" można zrzutować na typ "podklasa", jeśli widzimy, że w danym momencie jest to możliwe:
if(ktos instanceof Student) {
System.out.println("To jest Student");
Student zrzutowany = (Student)ktos;
System.out.println(zrzutowany.kierunek + " , średnia " + zrzutowany.sredniaOcen());
// albo tak jeśli czytamy tylko jedną rzecz:
System.out.println(((Student)ktos).rok);
} else {
System.out.println("To nie jest Student");
}
}
}
src/main/java/gotowe/p12_dziedziczenie/a_podstawy/Polimorfizm2.java 0 → 100644
package gotowe.p12_dziedziczenie.a_podstawy;
public class Polimorfizm2 {
public static void main(String[] args) {
Osoba osoba = new Osoba("Ala", "Kowalska", 30);
Student student = new Student("Adam", "Abacki", 20, "prawo", 1);
System.out.println(osoba);
System.out.println(student);
System.out.println();
// 1) Podklasa może nie zmieniać metody z nadklasy - wtedy ta metoda jest "dziedziczona" i działa ta sama implementacja
System.out.println(student.pelnoletnia());
// 2) Podklasa może dodać zupełnie nowe metody
student.dodajOcene(3);
student.dodajOcene(4);
student.dodajOcene(5);
student.dodajOcene(5);
System.out.println(student.sredniaOcen());
// System.out.println(osoba.sredniaOcen());
System.out.println();
// 3) podklasa może też nadpisać (OVERRIDE) metodę, która istniała w nadklasie
// wtedy gdy metoda zostanie wywołana na obiekcie podklasy, zadziała jej zmieniona wersja
System.out.print(" osoba.przedstawSie(): ");
osoba.przedstawSie();
System.out.print("student.przedstawSie(): ");
student.przedstawSie();
System.out.println();
// Java użyje wersji metody z podklasy także wtedy, gdy obiekt podklasy (Student)
// będzie wpisany na zmienną typu nadklasa (Osoba):
Osoba x;
x = osoba;
x.przedstawSie();
x = student;
x.przedstawSie();
// bo w języku Java metody instancyjne są zawsze "wirtualne" (terminologia języka C++)
// Zauważmy, że x.przedstawSie() wypisuje informację o kierunku,
// ale sami bezpośrednio tej informacji nie odczytamy ze zmiennej x, bo jest ona typu Osoba
// System.out.println(x.kierunek);
System.out.println();
// Wpisywanie studenta do zmiennej Osoba x jest nienaturalne.
// Ale do podobnej sytuacji może dojść w zupełnie naturalny sposób.
// 1) Kolekcja może zawierać obiekty różnych klas:
Osoba[] osoby = {
new Osoba("Ala", "Kowalska", 30),
new Student("Adam", "Abacki", 20, "prawo", 1),
new Pracownik("Jan", "Kowalski", 50, "kierowca", 4321),
};
// Wtedy gdy przeglądamy zawartość w pętli element kolekcji widzimy jako obiekt nadklasy (Osoba)
for(Osoba o: osoby) {
o.przedstawSie();
}
System.out.println();
System.out.println("=========================");
System.out.println("Idziemy do urzędu...");
Urzad urzadMiasta = new Urzad();
// Do urzędu jako Osoba może pójść zwykła Osoba, może też pójść Student...
urzadMiasta.zalatwSprawe(osoba);
urzadMiasta.zalatwSprawe(student);
for(Osoba o: osoby) {
urzadMiasta.zalatwSprawe(o);
}
}
}
src/main/java/gotowe/p12_dziedziczenie/a_podstawy/Polimorfizm3.java 0 → 100644
package gotowe.p12_dziedziczenie.a_podstawy;
public class Polimorfizm3 {
public static void main(String[] args) {
// Dzięki temu, że "Student jest Osobą" i "Pracownik jest Osobą",
// można obiekty tych klas umieści w tablicy (kolekcji itp.) osób.
Osoba[] osoby = {
new Osoba("Ala", "Kowalska", 44),
new Osoba("Ola", "Malinowska", 33),
new Student("Adam", "Abacki", 20, "medycyna", 1),
new StudentInformatyki("Karol", "Infobacki", 23, 3),
new Pracownik("Jan", "Kowalski", 40, "kierowca", 3300),
};
// Przeglądają elementy tablicy wiemy na pewno, że są to Osoby,
// ale dodatkowo może się okazać, że niektóre osoby są Student albo Pracownik
// Każda osoba posiada imię, nazwisko i wiek - można te dany odczytać.
// Każda osoba potrafi się przedstawić - można wywołać przedstawSie()
// ale w każdej podklasie ta metoda może mieć inną treść ("overriding").
// Wykona się wersja z właściwej klasy.
for(Osoba osoba: osoby) {
System.out.println("* kolejna osoba to " + osoba.imie + " " + osoba.nazwisko);
System.out.println(" " + osoba);
System.out.print(" ");
// System.out.println(osoba.kierunek); // nie każda osoba jest studentem
osoba.przedstawSie();
System.out.println(" to jest obiekt klasy: " + osoba.getClass().getSimpleName());
// Można jawnie sprawdzić czy zmienna wskazuje na obiekt określonej klasy
// (lub dalszej podklasy - np. StudentInformatyki byłby w tym sensie Studentem)
if(osoba instanceof Student) {
// Jeśli tak jest, to możemy bezpiecznie zrzutować (cast) zmienną na typ Student
Student student = (Student)osoba;
System.out.println(" To jest student kierunku " + student.kierunek
+ ", który ma średnią ocen " + student.sredniaOcen());
}
// natomiast taki if nie byłby prawdziwy dla obiektu klasy StudentInformatyki
if(osoba.getClass() == Student.class) {
System.out.println(" to jest konkretnie klasy Student");
}
System.out.println();
}
}
}
src/main/java/gotowe/p12_dziedziczenie/a_podstawy/Pracownik.java 0 → 100644
package gotowe.p12_dziedziczenie.a_podstawy;
import java.math.BigDecimal;
class Pracownik extends Osoba {
String zawod;
BigDecimal pensja;
Pracownik() {
}
Pracownik(String imie, String nazwisko, int wiek, String zawod, BigDecimal pensja) {
// wywołanie konstruktora z nadklasy
super(imie, nazwisko, wiek);
this.zawod = zawod;
this.pensja = pensja;
}
Pracownik(String imie, String nazwisko, int wiek, String zawod, double pensja) {
// wywołanie innego konstruktora z tej samej klasy
this(imie, nazwisko, wiek, zawod, BigDecimal.valueOf(pensja).setScale(2));
}
Pracownik(String imie, String nazwisko, int wiek, String zawod, int pensja) {
this(imie, nazwisko, wiek, zawod, BigDecimal.valueOf(pensja).setScale(2));
}
Pracownik(String imie, String nazwisko, int wiek, String zawod, String pensja) {
this(imie, nazwisko, wiek, zawod, new BigDecimal(pensja));
}
// tworzenie wielu konstruktorów w tej samej klasie to jest "przeciążanie konstruktorów" / "overloading"
@Override
public void przedstawSie() {
System.out.println("Dzień dobry, tu " + imie + ", pracuję jako " + zawod + " i zarabiam " + pensja + " zł.");
}
}
src/main/java/gotowe/p12_dziedziczenie/a_podstawy/Student.java 0 → 100644
package gotowe.p12_dziedziczenie.a_podstawy;
import java.util.ArrayList;
import java.util.List;
// Klasa Student jest rozszerzeniem klasy Osoba.
// Klasa Student dziedziczy z klasy Osoba (inherits / inheritance).
// Klasa Osoba jest nadklasą (superclass), a klasa Student jest podklasą (subclass).
class Student extends Osoba {
// Obiekt klasy Student będzie posiadał wzystkie pola zdefiniowane w klasie Osoba oraz wszystkie pola zdefiniowane tutaj.
String kierunek;
int rok;
List<Integer> oceny = new ArrayList<>();
Student() {
// Tutaj kompilator wstawia automatycznie wywołanie konstruktora bezargumentowego z nadklasy
// super();
}
Student(String imie, String nazwisko, int wiek, String kierunek, int rok) {
// Jawne wywołanie konstruktora z nadklasy w celu przekazania do niego argumentów.
super(imie, nazwisko, wiek);
this.kierunek = kierunek;
this.rok = rok;
}
// Jeśli chodzi o metody, podklasa może:
// 1) nie zmieniać metod odziedziczonych z nadklasy
// przykłady: pelnoletnia()
// 2) dodać nowe metody, których nie było w nadklasie
void dodajOcene(int ocena) {
oceny.add(ocena);
}
double sredniaOcen() {
int suma = 0;
for(int ocena: oceny) {
suma += ocena;
}
return 1. * suma / oceny.size();
}
// 3) nadpisać (override) metody, które były zdefiniowane w nadklasie
// czyli dla istniejących metoda podać inną treść
// adnotacja @Override jest w takich sytuacjach zalecana, ale nieobowiązkowa - bez niej wszystko też działa
@Override
void przedstawSie() {
System.out.println(
"Hej, tu " + imie + " " + nazwisko + ", studiuję na " + rok + " roku kierunku " + kierunek + ".");
}
@Override
public String toString() {
return super.toString() + ", student " + rok + " roku kierunku " + kierunek;
}
}
src/main/java/gotowe/p12_dziedziczenie/a_podstawy/StudentInformatyki.java 0 → 100644
package gotowe.p12_dziedziczenie.a_podstawy;
class StudentInformatyki extends Student {
// Czasami podklasa nie ma nowych pól ani metod, a jest wprowadzana po to, aby ustalić pewne szczegóły.
// Jest to podklasa / podzbiór w sensie matematycznym (logicznym).
public StudentInformatyki(String imie, String nazwisko, int wiek, int rok) {
// ustalamy, że kierunkiem studiów jest "informatyka" i nie może być inaczej
super(imie, nazwisko, wiek, "informatyka", rok);
}
}
src/main/java/gotowe/p12_dziedziczenie/a_podstawy/Urzad.java 0 → 100644
package gotowe.p12_dziedziczenie.a_podstawy;
public class Urzad {
void zalatwSprawe(Osoba osoba) {
System.out.println("Proszę się przedstawić.");
osoba.przedstawSie();
if(osoba.pelnoletnia()) {
System.out.println("Obywatelu " + osoba.nazwisko + ", sprawa załatwiona, dokumenty do odbioru za 30 dni.");
} else {
System.out.println("Do załatwienia sprawy potrzebna jest zgoda rodzica.");
}
System.out.println();
}
}
src/main/java/gotowe/p12_dziedziczenie/konstruktory_z_nadklasy/ProblemZKonstruktorem.java 0 → 100644
package gotowe.p12_dziedziczenie.konstruktory_z_nadklasy;
class AA {
// klasa posiada konstruktor(y) z parametrami, a nie posiada konstruktora bezparametrowego
AA(String nazwa) {
}
}
/*
// wówczas nie skompiluje się podklasa bez żadnego konstruktora
class BB extends AA {
}
// ponieważ gdy nie napiszemy żadnego własnego konstruktora, automatycznie generowany jest taki:
class CC extends AA {
public CC() {
super();
}
}
// nie można również w podklasach pisać własnych konstruktorów, które nie robią super:
class DD extends AA {
String mojeImie;
DD(String imie) {
mojeImie = imie;
}
// ponieważ gdy nie napiszemy na początrku konstruktora super(...) ani this(...)
// to automatycznie wstawiane jest super() (bez parametrów)
}
class EE extends AA {
EE() {
super("Ala");
// OK
}
}
class FF extends AA {
FF(String arg) {
super(arg);
// OK
}
FF() {
this("Ola"); // wskazanie innego konstruktora z tej samej klasy
}
FF(int x) {
// this lub super muszą być pierwszą instrukcją w konstruktorze
// System.out.println(x); // gdybym odkomentował, to przestanie się kompilować
super(String.valueOf(x));
}
}
public class ProblemZKonstruktorem {
public static void main(String[] args) {
// nie ma konstruktora domyślnego - nie da się w tak prosty sposób utworzyć obiektu
AA a1 = new AA();
}
}
*/
src/main/java/gotowe/p12_dziedziczenie/nadpisywanie/ZasadyNadpisywania.java 0 → 100644
package gotowe.p12_dziedziczenie.nadpisywanie;
import java.io.FileNotFoundException;
import java.io.IOException;
class Nadklasa {
// nadklasa, z której potem będziemy dziedziczyć
int m01() {
return 34;
}
Number m02() {
return 23;
}
Nadklasa m02a() {
return this;
}
Integer m03() {
return 27;
}
String m04() {
return "Ala";
}
public String m05() {
return "Ala";
}
private String m06() {
return "Alicja";
}
public String m07(String arg) {
return "napis " + arg;
}
public void m08() throws IOException {
}
public void m09() throws IOException {
}
public void m10() throws FileNotFoundException {
}
public void m11() {
}
public void m12() {
}
@Override
public Nadklasa clone() throws CloneNotSupportedException {
return (Nadklasa)super.clone();
}
}
class Podklasa extends Nadklasa {
// typ wyniku musi być dokładnie taki sam (jeśli mówimy o typach prostych)
// long m01() {
// return 43;
// }
// short m01() {
// return 43;
// }
int m01() {
return 43;
}
// typ wyniku można "zawęzić"/"ukonkretnić" jeśli mówimy o typie klasowym
// jesli w nadklasie metoda zwraca coś bardziej ogólnego, to w podklasie można zwrócić coś bardziej konkretnego
Long m02() {
return 432L;
}
Podklasa m02a() {
return this;
}
// Number m03() {
// return 27;
// }
// nie mozna zmniejszyć poziomu widoczności
// private String m04() {
// return "Ala";
// }
// ale można zwiększyć
protected String m04() {
return "Ala";
}
// zmiejszenie widczności
// String m05() {
// return "Ala";
// }
// protected String m05() {
// return "Ala";
// }
// tutaj nie mamy do czynienia z nadpisywaniem, bo metody prywatne nie są dziedziczone
// @Override
public int m06() throws IOException {
return 9;
}
// to też nie jest nadpisanie, tylko przeciążanie (to jest inna metoda) - może być dowolna jeśli chodzi o wynik, widocznośc i wyjątki
// @Override
int m07(int arg) throws FileNotFoundException {
return 10 * arg;
}
public void m08() {
}
public void m09() throws FileNotFoundException {
//FileNotFoundException jest podklasą IOException
}
// public void m10() throws IOException {
// }
// dotyczy tylko wyjątków checked
public void m10() {
}
public void m11() throws IllegalArgumentException {
throw new IllegalArgumentException("bla bla");
}
// public void m12() throws Exception {
// }
}
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