Skip to content

2
20250520
Commit 68c2d2b3 by Patryk Czarnik
Options

PRzykłady na tablice i funkcje

parent 5383878d
Showing with 1866 additions and 1 deletions
src/p02_scanner/KlasaScanner.java
package p02_scanner;
import java.util.Locale;
import java.util.Scanner;
public class KlasaScanner {
......
src/p04_petle/Parkomat.java 0 → 100644
package p04_petle;
import java.util.Scanner;
/* Godzina parkowania kosztuje 4 zł.
* Użytkownik podaje liczbę godzin parkowania.
* Program oblicza kwotę do zapłaty,
* a następnie W PĘTLI pobiera kolejne "monety" od klienta
* (po prostu wczytuje liczby całkowite z terminala)
* tak długo, aż zostanie opłacona cała suma.
*
* Program może wypisywać na bieżąco "status", np. ile pozostało do zapłaty.
* Jeśli wpłacono zbyt dużo, automat "wydaje resztę".
*/
public class Parkomat {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("Za ile godzin parkowania płacisz? ");
int ileGodzin = scanner.nextInt();
int doZaplaty = ileGodzin * 4;
int suma = 0;
while(suma < doZaplaty) {
System.out.printf("Do tej pory wpłacono %d, pozostało jeszcze %d\n", suma, doZaplaty-suma);
System.out.print("wrzuć monetę: ");
int moneta = scanner.nextInt();
suma += moneta;
}
if(suma > doZaplaty) {
System.out.printf("Wydaję %d reszty\n", suma-doZaplaty);
}
System.out.println("Do widzenia");
}
}
src/p04_petle/Przerwania.java 0 → 100644
package p04_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/p06_tablice/A_Wstep.java 0 → 100644
package p06_tablice;
import java.util.Arrays;
import java.util.stream.Stream;
public class A_Wstep {
public static void main(String[] args) {
// Zamiast tworzyć oddzielną zmienną dla każdej wartości:
String imie1, imie2, imie3;
imie1 = "Ala";
imie2 = "Ola";
imie3 = "Ula";
System.out.println(imie1 + " " + imie2 + " " + imie3);
// można utworzyć tablicę, która od razu zawiera wiele pól
// (każde pole to tak jakby zmienna na pojedynczą wartość)
String[] tablica = new String[5];
tablica[1] = "Adam";
tablica[2] = "Ludwik";
tablica[3] = "Xawery";
System.out.println(tablica[1] + " " + tablica[2] + " " + tablica[3]);
// Możemy teraz używać operacji dotyczących całej tablicy łącznie:
System.out.println(tablica);
System.out.println(Arrays.toString(tablica));
// okazuje się, że elementy tablic są numerowane od 0.
// Ta tablica ma 5 elementów, więc poprawne indeksy (numery miejsc)
// w tej tablicy to liczby od 0 do 4
tablica[0] = "Andrzej";
tablica[4] = "Zenon";
System.out.println(Arrays.toString(tablica));
System.out.println();
// Można też używając pętli wykonywać czynności "dla każdego elementu tablicy"
// pętla for z "licznikiem" - stary styl, ale na dużo pozwala
for(int i=0; i < tablica.length; i++) {
System.out.println("Osoba nr " + i + " ma imię " + tablica[i]);
}
System.out.println();
// Od Java 5 mamy też pętlę for-each - najprostszy sposób odczytania wszystkich wartości
for(String imie : tablica) {
System.out.println("Witaj " + imie);
}
System.out.println();
// Od Java 8 mamy też metodę forEach, do której przekazuje się wyrażenie lambda lub referencję do metody
// (to by miało większy sens dla listy, a nie dla tablicy)
Stream.of(tablica).forEach(imie -> System.out.println("Żegnaj " + imie));
}
}
src/p06_tablice/B_Tworzenie.java 0 → 100644
package p06_tablice;
import java.math.BigDecimal;
import java.util.Arrays;
public class B_Tworzenie {
public static void main(String[] args) {
// Gdy tworzymy tablicę podając jej rozmiar,
// to jest ona automatycznie wypełniania wartościami:
// - 0 dla prostych typów liczbowych (int, long, double)
int[] liczby = new int[10];
System.out.println(Arrays.toString(liczby));
// łatwo wypełnić tablicę jednakowymi elementami
Arrays.fill(liczby, 13);
System.out.println(Arrays.toString(liczby));
// - false dla typu boolean
// - null dla wszystkich typów obiektowych, w tym String, Integer, BigDecimal, List ...
String[] napisy = new String[5];
BigDecimal[] ceny = new BigDecimal[3];
System.out.println(napisy);
System.out.println(ceny);
System.out.println();
double x = 55.55;
// Można też od razu podać listę wartości w nawiasach klamrowych (podczas deklaracji zmiennej tablicowej)
// Kompilator Javy sam policzy jaki ma być rozmiar tablicy
double[] d = {1.0, 3.14, Math.sqrt(2), liczby[2], x};
System.out.println("Tablica d ma rozmiar " + d.length);
System.out.println(Arrays.toString(d));
String[] miasta = {"Warszawa", "Kraków", "Wrocław", "Łódź", "Poznań"};
System.out.println("Lizba miast: " + miasta.length);
System.out.println(Arrays.toString(miasta));
// uwaga - tego zapisu można używać tylko podczas deklarownaia nowej zmiennej
// miasta = {"Praga", "Berlin"};
// ale można tak:
miasta = new String[] {"Paryż", "Londyn"};
System.out.println(Arrays.toString(miasta));
}
}
src/p06_tablice/C_Petle.java 0 → 100644
package p06_tablice;
import java.util.Arrays;
public class C_Petle {
public static void main(String[] args) {
String[] miasta = {"Warszawa", "Kraków", "Łódź", "Wrocław", "Poznań"};
int[] liczby = {0, 10, 20, 30, 40, 50, 60, 70, 80, 90};
System.out.println(Arrays.toString(miasta));
System.out.println(Arrays.toString(liczby));
System.out.println();
// Są dwa sposoby wykonywania czynności dla wszystkich elementów tablicy:
// 1) Tradycyjna pętla for / for z licznikiem
for(int i = 0; i < miasta.length; i++) {
System.out.println("! " + miasta[i]);
}
System.out.println();
for(int i = 0; i < liczby.length; i++) {
System.out.print(liczby[i] + "; ");
}
System.out.println();
System.out.println();
// 2) Pętla "for-each" / "enhanced for loop"
// Bezpośrednio przeglądamy elementy tablicy/kolekcji. Są one po kolei wpisywane na nową zmienną.
for(String miasto : miasta) {
System.out.println("* " + miasto);
}
System.out.println();
// zwróćmy uwagę, że to są elementy tablicy, a nie indeksy (pozycje)
for(int liczba : liczby) {
System.out.print(liczba + ", ");
}
System.out.println();
System.out.println();
// Od Java 10 można nie pisać typu przed zmienną, tylko zamiast tego "var"
for(var miasto : miasta) {
System.out.println("* pozdrawiamy " + miasto);
}
System.out.println();
System.out.println();
// Pętla for-each nie nadaje się do modyfikowania zawartości tablicy.
System.out.println(Arrays.toString(liczby));
System.out.println();
System.out.println("w pętli for-each próbuję zmieniać wartości...");
for(int x : liczby) {
x++;
// modyfikowanie zmiennej w for-each nie wpływa na zawartość tablicy
// w x mamy kopię wartości, a nie "referencję do miejsca w tablicy"
}
System.out.println();
System.out.println(Arrays.toString(liczby)); // liczby się nie zmieniły
System.out.println();
// Jeśli chcemy modyfikować elementy tablicy, to w praktyce uzywamy tradycyjnej pętli for
System.out.println("w zwykłym for zmieniam wartości");
for(int i = 0; i < liczby.length; i++) {
System.out.println(liczby[i] + " -> " + (liczby[i]+1));
liczby[i]++;
}
System.out.println(Arrays.toString(liczby));
// Zwykłe pętli for używamy też wtedy, gdy algorytm wymaga jednoczesnego dostępu do różnych elementów.
}
}
src/p06_tablice/D_Dwuwymiarowe.java 0 → 100644
package p06_tablice;
import java.util.Arrays;
public class D_Dwuwymiarowe {
public static void main(String[] args) {
// Tablice wielowymiarowe... To tak naprawdę tablice tablic.
// Tutaj powstanie 3-elementowa tablica, której elementami są tablice typu int[]
// z których każda ma 5 elementów int.
int[][] a = new int[3][5];
//NK int[][] a2 = new int[3,5];
System.out.println(a.length); // 3
System.out.println(a[0].length); // 5
System.out.println();
// regularna macierz
a[0][4] = 44;
a[1][2] = 22;
System.out.println(a[0][4]);
System.out.println("a: " + a + " , zawartość: " + Arrays.toString(a));
System.out.println("a[0]: " + a[0]+ " , zawartość: " + Arrays.toString(a[0]));
System.out.println();
System.out.println(Arrays.toString(a));
System.out.println(Arrays.deepToString(a));
System.out.println();
// dwa sposoby pisania pętli, która przejrzy całą tablicę dwywymiarową
// for(int i = 0; i < 3; i++) {
// for(int j = 0; j < 5; j++) {
// System.out.print(a[i][j] + ", ");
// }
// System.out.println();
// }
// System.out.println();
for(int i = 0; i < a.length; i++) {
for(int j = 0; j < a[i].length; j++) {
System.out.print(a[i][j] + ", ");
}
System.out.println();
}
System.out.println();
for(int[] row: a) {
for(int x: row) {
System.out.print(x + "; ");
}
System.out.println();
}
System.out.println();
// Można nie wypełniać od razu wierszy jednakowymi tablicami,
// ale początkowo zostawić null-e i dopiero potem wpisać poszczególne wiersz.
// Wtedy mogą być one nawet różnej długości.
int[][] b = new int[4][];
System.out.println(Arrays.toString(b));
// inicjujemy poszczególne wiersze
b[0] = new int[7];
Arrays.fill(b[0], 9);
b[1] = new int[] {3, 4, 5};
b[2] = null;
b[3] = new int[0]; // pusta tablica i null to są różne rzeczy
System.out.println(Arrays.deepToString(b));
// Można użyć notacji {} także do wypełniania tablic wielowymiarowych.
String[][] c = {
{"Ala", "Ola", "Ela"},
{"Jacek", "Placek"},
null,
{},
};
System.out.println(Arrays.deepToString(c));
}
}
src/p06_tablice/Kopiowanie1.java 0 → 100644
package p06_tablice;
import java.util.Arrays;
public class Kopiowanie1 {
public static void main(String[] args) {
int[] a = {1,2,3,4,5,6,7,8,9};
// clone(), copyOf(), copyOfRange() - tworzą nową tablicę wypełnioną takimi samymi danymi (lub fragment)
int[] b = a.clone();
int[] c = Arrays.copyOf(a, 5);
int[] d = Arrays.copyOf(a, 12);
int[] e = Arrays.copyOfRange(a, 4, 8);
int[] f = Arrays.copyOfRange(a, 4, 12);
// arraycopy: Docelowa tablica musi istnieć
int[] g = new int[8];
System.arraycopy(a, 2, g, 1, 5);
// Referencja do tej samej tablicy (do tego samego obiektu)
// Zmiany w tablicy a będą widziane przez zmienną r i vice versa
int[] r = a;
System.out.println("a: " + Arrays.toString(a));
System.out.println("b: " + Arrays.toString(b));
System.out.println("c: " + Arrays.toString(c));
System.out.println("d: " + Arrays.toString(d));
System.out.println("e: " + Arrays.toString(e));
System.out.println("f: " + Arrays.toString(f));
System.out.println("g: " + Arrays.toString(g));
System.out.println("r: " + Arrays.toString(r));
System.out.println();
System.out.println("Zmieniam a w środku");
a[0]=13;
a[1]++;
a[2]+=10;
a[3]*=5;
System.out.println("a: " + Arrays.toString(a));
System.out.println("b: " + Arrays.toString(b));
System.out.println("c: " + Arrays.toString(c));
System.out.println("d: " + Arrays.toString(d));
System.out.println("e: " + Arrays.toString(e));
System.out.println("f: " + Arrays.toString(f));
System.out.println("g: " + Arrays.toString(g));
System.out.println("r: " + Arrays.toString(r));
System.out.println();
System.out.println("Na a wpisuję nową tablicę");
a = new int[] {77,88,99};
System.out.println("a: " + Arrays.toString(a));
System.out.println("b: " + Arrays.toString(b));
System.out.println("r: " + Arrays.toString(r));
}
}
src/p06_tablice/Srednia1.java 0 → 100644
package p06_tablice;
public class Srednia1 {
public static void main(String[] args) {
double[] dane = {8.0, 7.5, 3.3, -2, 0, 4.4, 7.5};
// (pisząc odpowiednią pętlę...) oblicz średnią arytmetyczną z liczb, które są w tablicy...
// przy okazji: biorąc fragment kodu w {nawiasy klamrowe}
// ograniczamy zasięg zmiennych
{ // wersja 1:
double suma = 0;
for(int i = 0; i < dane.length; i++) {
suma += dane[i];
}
double srednia = suma / dane.length;
System.out.println(srednia);
}
{ // wersja 2:
double suma = 0;
for(double x : dane) {
suma += x;
}
double srednia = suma / dane.length;
System.out.println(srednia);
}
}
}
src/p06_tablice/WypiszWInnejKolejnosci.java 0 → 100644
package p06_tablice;
public class WypiszWInnejKolejnosci {
public static void main(String[] args) {
int[] t = {100, 110, 120, 130, 140, 150, 160, 170, 180, 190};
// normalna kolejność wersja foreach
for(int x : t) {
System.out.print(x + " ");
}
System.out.println();
// normalna kolejność - wersja z licznikiem
for(int i = 0; i < t.length; i++) {
System.out.print(t[i] + " ");
}
System.out.println();
// wypisz elementy w odwróconej kolejności:
for(int i = t.length-1; i >= 0; i--) {
System.out.print(t[i] + " ");
}
System.out.println();
// alternatywny zapis:
{
int i = t.length;
while(i > 0) {
System.out.print(t[--i] + " ");
}
}
System.out.println();
// wypisz elementy w takiej kolejności:
// - pierwszy, ostatni, drugi, przedostatni, ...
// aż do momentu, gdy dojdziesz do środka tablicy
// każdy element ma pojawić się tylko raz
// 100, 190, 110, 180, 120, 170, 130, 160, 140, 150
// wersja 1:
for(int i = 0; i < t.length / 2; i++) {
System.out.print(t[i] + " ");
System.out.print(t[t.length - i - 1] + " ");
}
if(t.length % 2 != 0) {
System.out.print(t[t.length/2] + " ");
}
System.out.println();
// wersja 2:
for(int i = 0, j = t.length-1; i <= j; i++, j--) {
System.out.print(t[i] + " ");
if(i < j) {
System.out.print(t[j] + " ");
}
}
}
}
src/p08_funkcje/A_Wprowadzenie.java 0 → 100644
package p08_funkcje;
public class A_Wprowadzenie {
// Funkcja to jest fragment programu, któremu nadajemy jakąś nazwę
// i używamy w programie wtedy, gdy nam jest potrzebny.
static void aaa() {
System.out.println("aaa, kotki dwa");
System.out.println("szaro-bure obydwa");
}
// Funkcja może mieć zadeklarowane parametry
// (w Javie musimy określić typy parametrów)
// Funkcja widzi te parametry jako zmienne, którym nadane są początkowe wartości w momencie wywołania.
static void powitaj(String imie, String miasto) {
System.out.println("Witaj " + imie + " z miasta " + miasto);
}
// Funkcje typu void nie zwracają żadnego wyniku.
// Jeśli funkcja ma inny typ, to MUSI zwrócić (return) wartość tego typu.
static int stukrotnosc(int x) {
return 100*x;
}
// Funkcja może mieć więcej niż 1 return. Ważne jednak, aby w każdym przebiegu zwróciła jakiś wynik.
static String zgadnijPlec(String imie) {
if(imie.endsWith("a")) {
return "kobieta";
} else {
return "mężczyzna";
}
}
public static void main(String[] args) {
System.out.println("Początek programu");
aaa();
aaa();
System.out.println();
powitaj("Ala", "Wrocław");
powitaj("Łukasz", "Gdańsk");
// wartości parametrów mogą pochodzić ze zmiennych, być obliczane itd.
String osoba = "Ola Malinowska";
String[] miasta = {"Gliwice", "Zabrze", "Katowice"};
powitaj(osoba, miasta[1]);
powitaj(osoba.split(" ")[0], miasta[2].toUpperCase());
System.out.println();
int wynik = stukrotnosc(7);
System.out.println("Wynikiem funkcji stukrotnosc z parametrem 7 jest: " + wynik);
// Gdy wywołamy funkcję, ale nie odbierzemy jej wyniku, to ten wynik nigdzie się nie pojawi; nigdzie się nie zapisze
stukrotnosc(5);
// Można bezpośrednio wypisać wynik:
System.out.println(stukrotnosc(4));
// Można użyć funkcji w wyrażeniach
wynik = stukrotnosc(13) + stukrotnosc(4*2) * 2;
System.out.println("Wynik wyrażenia: " + wynik);
System.out.println();
System.out.println(zgadnijPlec("Dominika"));
System.out.println(zgadnijPlec("Patryk"));
System.out.println("Koniec programu");
}
}
src/p08_funkcje/FunkcjaPowtorz.java 0 → 100644
package p08_funkcje;
public class FunkcjaPowtorz {
// Napisz funkcję, która jako parametry przyjmuje String oraz int
// i wypisuje na ekran podany napis tyle razy, ile wynosi przekazana liczba.
// Uruchom funkcję kilka razy w main na przykładowych parametrach.
static void powtorz(String napis, int ileRazy) {
for(int i=0; i<ileRazy; i++) {
System.out.println(napis);
}
}
static void powtorz2(String napis, int ileRazy) {
while(ileRazy-- > 0)
System.out.println(napis);
}
public static void main(String[] args) {
powtorz("Ala ma kota", 5);
powtorz("Ola ma psa", 2);
}
}
src/p08_funkcje/FunkcjeNaTablicach.java 0 → 100644
package p08_funkcje;
public class FunkcjeNaTablicach {
static int suma(int[] t) {
int suma = 0;
for(int x : t) {
suma += x;
}
return suma;
}
static int sumaParzystych(int[] t) {
int suma = 0;
for(int x : t) {
if(x % 2 == 0) {
suma += x;
}
}
return suma;
}
// Zwraca największą z liczb w tablicy (nie używaj sortowania)
static int max(int[] t) {
// dwa podejścia do wpisania wartości początkowej:
int wynik = Integer.MIN_VALUE;
// int wynik = t[0];
for(int el : t) {
if(el > wynik) {
wynik = el;
}
}
return wynik;
}
public static void main(String[] args) {
int[] a = {5, 10, 15, 1, 20, 4, 8, 0};
int[] u = {-10, -5, -8, -10};
int[] e = {};
System.out.println("suma: " + suma(a));
System.out.println("sumaP: " + sumaParzystych(a));
System.out.println("max a: " + max(a));
System.out.println("max u: " + max(u));
System.out.println("max e: " + max(e));
}
}
src/p08_funkcje/Geometria.java 0 → 100644
package p08_funkcje;
// Ta klasa zawiera wyłącznie metody statyczne.
// Na takie klasy mówi się często "klasa narzędziowa" / "utility class".
// Odpowiada to modułowi zawierającemu funkcje z innych języków (C, Python, PHP itp).
// Po prostu w Javie funkcje definiuje się zawsze wewnątrz klasy.
public class Geometria {
// blok statyczny zostanie wykonany, gdy maszyna wirtualna załaduje klasę do pamięci
static {
System.out.println("Klasa Geometria się załadowała");
}
public static double poleKwadratu(double a) {
return a*a;
}
public static double obwodKwadratu(double a) {
return 4*a;
}
public static double poleProstokata(double a, double b) {
return a*b;
}
public static double obwodProstokata(double a, double b) {
return 2*a + 2*b;
}
public static double poleKola(double r) {
return Math.PI * r*r;
}
public static double obwodKola(double r) {
return Math.PI * 2*r;
}
public static boolean warunekTrojkata(double a, double b, double c) {
return a < b + c && b < a + c && c < a + b;
}
public static double poleTrojkata(double a, double b, double c) {
double p = obwodTrojkata(a, b, c) / 2;
return Math.sqrt(p*(p-a)*(p-b)*(p-c));
}
public static double obwodTrojkata(double a, double b, double c) {
return a + b + c;
}
}
src/p08_funkcje/GeometriaProgram.java 0 → 100644
package p08_funkcje;
import java.util.Scanner;
public class GeometriaProgram {
public static void main(String[] args) {
@SuppressWarnings("resource")
Scanner scanner = new Scanner(System.in);
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");
petla:
while(true) {
System.out.println("\nWybierz figurę lub operację:");
String wybor = scanner.next().toUpperCase();
switch(wybor) {
case "Q" -> {
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 dwie długości boków prostokąta: ");
double a = scanner.nextDouble();
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 "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 "T" -> {
System.out.print("Podaj trzy długości boków trójkąta: ");
double a = scanner.nextDouble();
double b = scanner.nextDouble();
double c = scanner.nextDouble();
if(Geometria.warunekTrojkata(a, b, c)) {
double pole = Geometria.poleTrojkata(a, b, c);
double obwod = Geometria.obwodTrojkata(a, b, c);
System.out.printf("Dla prostokąta o bokach %.3f %.3f %.3f pole wynosi %.3f, a obwód %.3f\n", a, b, c, pole, obwod);
} else {
System.out.println("Z tych liczb nie da się złożyć trójkąta");
}
}
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.f_na_c(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.c_na_f(c);
System.out.printf("%.3f °C = %.3f °F\n", c, wynik);
} default -> {
System.out.println("Nieznane polecenie " + wybor);
}
}
}
System.out.println("Dzięki, miłego dnia!");
}
}
\ No newline at end of file
src/p08_funkcje/GeometriaTesty.java 0 → 100644
package p08_funkcje;
public class GeometriaTesty {
// W tej klasie, w main, są testowe wywołania metod zdefiniowanych w klasie Geometria.
// Jeśli klasa znajduje się w tym samym pakiecie, to nie trzeba jej importować; po prostu używamy.
// Metodę statyczną wywołuje się pisząc Klasa.metoda
public static void main(String[] args) {
System.out.println(Geometria.poleKwadratu(5));
System.out.println(Geometria.obwodKwadratu(5));
System.out.println(Geometria.poleProstokata(3, 4));
System.out.println(Geometria.obwodProstokata(3, 4));
System.out.println();
// inne podejście:
double[] testoweLiczby = {0, 1, 2, 5, 7.5, 12};
for (var bok : testoweLiczby) {
var pole = Geometria.poleKwadratu(bok);
var obwod = Geometria.obwodKwadratu(bok);
System.out.printf("Kwadrat o boku %.3f ma pole %.3f i obwód %.3f\n", bok, pole, obwod);
}
}
}
src/p08_funkcje/JednostkiMiary.java 0 → 100644
package p08_funkcje;
public class JednostkiMiary {
private static final double PRZELICZNIK_KM_MILE = 1.609344;
// https://pl.wikipedia.org/wiki/Mila_mi%C4%99dzynarodowa
public static double mile_na_km(double mile) {
return mile * PRZELICZNIK_KM_MILE;
}
public static double km_na_mile(double km) {
return km / PRZELICZNIK_KM_MILE;
}
// Stopnie Celsjusza na Fahrenheita i odwrotnie
// https://pl.wikipedia.org/wiki/Skala_Fahrenheita
public static double c_na_f(double c) {
// To jest źle, bo dzielenie 9/5 daje wynik 1
// return 32 + 9/5 * c;
// Poprawne zapisy:
// return c * 9 / 5 + 32;
// return 32.0 + 9.0 / 5.0 * c;
// return 32 + 9. / 5. * c;
return 32 + 1.8 * c;
}
public static double f_na_c(double f) {
// Niepoprawne, bo 5/9 daje wynik 0
// return 5/9 * (f - 32);
// Poprawne zapisy:
// return 5./9. * (f - 32.);
return (f - 32) / 1.8;
}
public static void main(String[] args) {
// Tutaj w main wpiszemy tylko przykładowe wywołania funkcji,
// aby sprawdzić, czy one dobrze działają.
// To nie jest "praktyczny program" dla użytkownika.
System.out.println("100 mil = " + mile_na_km(100) + " km");
System.out.println("300 mil = " + mile_na_km(300) + " km");
System.out.println("100 km = " + km_na_mile(100) + " mil");
System.out.println("160 km = " + km_na_mile(160) + " mil");
System.out.printf("%.1f km = %.1f mil\n", 160.0, km_na_mile(160));
System.out.println();
System.out.println(" 0 C = " + c_na_f(0) + " F");
System.out.println(" 37 C = " + c_na_f(37) + " F");
System.out.println("100 C = " + c_na_f(100) + " F");
System.out.println();
System.out.println(" 0 F = " + f_na_c(0) + " C");
System.out.println(" 50 F = " + f_na_c(50) + " C");
System.out.println("100 F = " + f_na_c(100) + " C");
}
}
src/p08_funkcje/Max.java 0 → 100644
package p08_funkcje;
import java.util.Arrays;
public class Max {
/** Funkcja zwraca większą z dwóch liczb */
static int max(int a, int b) {
if(a >= b) {
return a;
} else {
return b;
}
}
// alternatywne zapisy:
static int max_v2(int a, int b) {
if(a >= b)
return a;
return b;
}
static int max_v3(int a, int b) {
return a >= b ? a : b;
}
static int max_v1(int a, int b, int c) {
if(a >= b) {
if(a >= c) {
return a;
} else {
return c;
}
} else {
if(b >= c) {
return b;
} else {
return c;
}
}
}
/** Funkcja zwraca największą z trzech liczb */
static int max(int a, int b, int c) {
if(a >= b && a >= c) return a;
if(b >= c) return b;
return c;
}
static int max_v3(int a, int b, int c) {
return (a >= b && a >= c) ? a : (b >= c) ? b: c;
}
static int max_v4(int a, int b, int c) {
return max(max(a, b), c);
}
static int max(int a, int b, int c, int d) {
return max(max(a, b), max(c, d));
}
static int max_uniwerslany(int... args) {
if(args == null || args.length == 0) {
throw new IllegalArgumentException("tablica powinna mieć elementy");
}
// uwaga - to nie jest optymalne wydajnościowo. sortowanie nie jest potrzebny, aby znaleźć max
Arrays.sort(args);
return args[args.length-1];
}
// btw, w Javie istnieje "przeciążanie metod" (overloading), tzn. można definiować
// wiele metod o tej samej nazwie pod warunkiem, że różnią się liczbą lub typem parametrów
public static void main(String[] args) {
System.out.println(max(5, 7)); // 7
System.out.println(max(13, -17)); // 13
System.out.println(max(9, 9)); // 9
System.out.println();
System.out.println(max(5, 9, 6)); // 9
System.out.println(max(9, 9, 7)); // 9
System.out.println(max(9, 8, 7)); // 9
System.out.println(max(5, 4, 9)); // 9
System.out.println(max_uniwerslany(5, 3, 7, 3, 5));
}
}
src/p08_funkcje/Silnia.java 0 → 100644
package p08_funkcje;
import java.math.BigInteger;
import java.util.Scanner;
import java.util.stream.LongStream;
public class Silnia {
// Funkcja zwraca silnię z podanej liczby.
// silnia to jest iloczyn liczb naturalnych od 1 do n włącznie
// np. silnia(5) = 1*2*3*4*5 = 120
// silnia(0) = 1
static long silnia(int n) {
long iloczyn = 1;
for(int i=2; i <= n; i++) {
iloczyn = iloczyn * i; // albo iloczyn *= i;
}
return iloczyn;
}
static BigInteger silniaBig(int n) {
BigInteger iloczyn = BigInteger.ONE;
for(int i=2; i <= n; i++) {
iloczyn = iloczyn.multiply(BigInteger.valueOf(i));
}
return iloczyn;
}
// wersja rekurencyjna
// rekurencja (recursion) to technika, w której funkcja wywołuje samą siebie
// w praktyce rekurencji używa się rzadko, ale jest ona ważna w teorii programowania
static long silniaR(int n) {
if(n <= 1) return 1;
return silniaR(n-1) * n;
}
// Od Java 8 można też zastosować "techniki funkcyjne"
// a dokładnie schemat z redukcją elementów strumienia
static long silniaFun(int n) {
return LongStream.rangeClosed(1, n).reduce(1, (a,b) -> a*b);
}
static BigInteger silniaBigFun(int n) {
return LongStream.rangeClosed(1, n)
.mapToObj(BigInteger::valueOf)
.reduce(BigInteger.ONE, BigInteger::multiply);
}
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("Podawaj liczby, a ja będę liczyć silnię.");
System.out.println("Aby zakończyć, wpisz liczbę ujemną.");
while(true) {
System.out.print("Podaj argument: ");
int arg = scanner.nextInt();
if(arg < 0) break;
var wynik = silniaBigFun(arg);
System.out.printf("silnia(%s) = %s%n", arg, wynik);
}
}
}
src/p08_funkcje/WartosciOpcjonalne.java 0 → 100644
package p08_funkcje;
import java.util.Optional;
import java.util.OptionalInt;
public class WartosciOpcjonalne {
// Gdy funkcja czasami ma określony wynik, ale czasami nie
// (typowe dla wyszukiwania...)
// to istnieje kilka sposobów zwracania takiego wyniku.
// Przykładowe funkcje:
// - zwracanie pierwszego znalezionego elementu parzystego (może żadnego nie być)
// - max - co zrobić, gdy tablica jest zupełnie pusta?
// Podejście 1 - zwracamy umówioną wartość specjalną
// Ewentualny problem - jak odróżnić wartość specjalną od "normalnego wyniku"
// Dla pierwszej parzystej jest to oczywiste, ale dla max już nie - tablica może naprawdę zawierać MIN_INT
static int pierwszaParzysta_v1(int[] t) {
for(int e : t) {
if(e % 2 == 0) {
return e;
}
}
return -1; // to znaczy że nie znaleźliśmy
}
static int max_v1(int[] t) {
int wynik = Integer.MIN_VALUE;
for(int el : t) {
if(el > wynik) {
wynik = el;
}
}
return wynik;
}
// Podejście drugie: null jako informacja o tym, że wyniku brak
// nulla można użyć tylko, gdy typ jest typem obiektowym, a nie typem prostym
// W przypadku liczb musimy zatem przejść na typy Integer, Double itp.
// W dodatku "z nullami są problemy..."
static Integer pierwszaParzysta_v2(int[] t) {
for(int e : t) {
if(e % 2 == 0) {
return e;
}
}
return null;
}
static Integer max_v2(int[] t) {
if(t == null || t.length == 0) {
return null;
}
int wynik = t[0];
for(int el : t) {
if(el > wynik) {
wynik = el;
}
}
return wynik;
}
// Od Java 8 pojawiły się typy "Optional".
// Optional<T> to jest typ generyczny dobry dla wszystkich typów obiektowych.
// Dla liczb dostępne są OptionalInt, OptionalLong, OptionDouble.
// Funkcja, która "czasami zwraca wynik, a czasami nie" powinna być typu opcjonalnego
// Od Javy 8 jest to zalecane.
static OptionalInt pierwszaParzysta_v3(int[] t) {
for(int e : t) {
if(e % 2 == 0) {
return OptionalInt.of(e);
}
}
return OptionalInt.empty();
}
static OptionalInt max_v3(int[] t) {
if(t == null || t.length == 0) {
return OptionalInt.empty();
}
int wynik = t[0];
for(int el : t) {
if(el > wynik) {
wynik = el;
}
}
return OptionalInt.of(wynik);
}
static Optional<String> najdluzszyNapis(String[] t) {
if(t == null || t.length == 0) {
return Optional.empty();
}
String wynik = "";
for(String s : t) {
if(s != null && s.length() > wynik.length()) {
wynik = s;
}
}
return Optional.of(wynik);
}
// Informacyjnie: można jeszcze wyrzucać wyjątek, jeśli funkcja nie jest w stanie dać wyniku
public static void main(String[] args) {
int[] a = {5, 10, 15, 20};
int[] b = {5, 3, 15};
int[] e = {};
String[] imiona = {"Ala", "Natalia", "Edward", "Zenon", "Agnieszka", "Jan"};
String[] brakNapisow = {};
System.out.println("pp_v1:");
System.out.println(pierwszaParzysta_v1(a));
System.out.println(pierwszaParzysta_v1(b));
System.out.println(pierwszaParzysta_v1(e));
System.out.println("\nmax_v1:");
System.out.println(max_v1(a));
System.out.println(max_v1(b));
System.out.println(max_v1(e));
System.out.println("\npp_v2:");
System.out.println(pierwszaParzysta_v2(a));
System.out.println(pierwszaParzysta_v2(b));
System.out.println(pierwszaParzysta_v2(e));
System.out.println("\nmax_v2:");
System.out.println(max_v2(a));
System.out.println(max_v2(b));
System.out.println(max_v2(e));
System.out.println("\npp_v3:");
System.out.println(pierwszaParzysta_v3(a));
System.out.println(pierwszaParzysta_v3(b));
System.out.println(pierwszaParzysta_v3(e));
System.out.println("\nmax_v3:");
System.out.println(max_v3(a));
System.out.println(max_v3(b));
System.out.println(max_v3(e));
System.out.println();
System.out.println(najdluzszyNapis(imiona));
System.out.println(najdluzszyNapis(brakNapisow));
// sprawdzanie, czy Optional jest niepusty
Optional<String> imie = najdluzszyNapis(imiona);
if(imie.isPresent()) {
System.out.println("Najdłuższe imię to " + imie.get());
} else {
System.out.println("Brak imion");
}
Optional<String> napis = najdluzszyNapis(brakNapisow);
if(napis.isPresent()) {
System.out.println("Najdłuższy napis to " + napis.get());
} else {
System.out.println("Brak napisów");
}
System.out.println();
// można też stosować zapisy "funkcyjne"
najdluzszyNapis(imiona).ifPresent(im -> System.out.println("Znalazłem imię " + im));
najdluzszyNapis(imiona)
.map(String::toUpperCase)
.ifPresent(System.out::println);
// wersja z else:
pierwszaParzysta_v3(b).ifPresentOrElse(
y -> System.out.println("Pierwsza parzysta to " + y),
() -> System.out.println("Nie znaleziono parzystej"));
}
}
src/p09_importowanie/Imporcik1.java 0 → 100644
package p09_importowanie;
import java.util.List;
public class Imporcik1 {
public static void main(String[] args) {
// W tej wersji wprost importuję java.util.List
// Wówczas List oznacza oryginalną listę z pakietu java.util.
List<String> list = List.of("Ala", "Ela", "Ola", "Ula");
System.out.println(list.getClass());
System.out.println(list);
// do własnej listy z bieżącego pakietu muszę odwołać się nazwą kwalifikowaną
p09_importowanie.List<String> patrykList = p09_importowanie.List.of("Patryk", "Tomek", "Wiktor");
System.out.println(patrykList);
// do prawdziwej listy też zawsze mogę się nazwą kwalifikowaną
java.util.List<String> utilList = java.util.List.of("java", "util", "list");
System.out.println(utilList);
}
}
src/p09_importowanie/Imporcik2.java 0 → 100644
package p09_importowanie;
import java.util.*;
public class Imporcik2 {
public static void main(String[] args) {
// W tej wersji importuję java.util.*
// Wówczas List oznacza lokalna listę z bieżącego pakietu.
List<String> list = List.of("Ala", "Ela", "Ola", "Ula");
System.out.println(list.getClass());
System.out.println(list);
// mogę też odwołać się nazwą kwalifikowaną
p09_importowanie.List<String> patrykList = p09_importowanie.List.of("Patryk", "Tomek", "Wiktor");
System.out.println(patrykList);
// do prawdziwej listy muszę się nazwą kwalifikowaną
java.util.List<String> utilList = java.util.List.of("java", "util", "list");
System.out.println(utilList);
}
}
src/p09_importowanie/List.java 0 → 100644
package p09_importowanie;
import java.util.Arrays;
import java.util.stream.Collectors;
import java.util.stream.Stream;
/* To jest fejkowa wersja listy, którą tworzę, aby w programach Imporcik1 i Imporcik2
* pokazać, która klasa jest używana przez kompilator w zależności od sytuacji.
*/
public class List<T> {
private final Object[] tablica;
private List(T[] elems) {
tablica = Arrays.copyOf(elems, elems.length);
}
public static <T> List<T> of(T... elems) {
return new List<>(elems);
}
@Override
public String toString() {
return Stream.of(tablica)
.map(Object::toString)
.collect(Collectors.joining(", ", "ListaPatryka{", "}"));
}
public T get(int i) {
if(i < 0 || i >= tablica.length) {
throw new IndexOutOfBoundsException(i);
}
return (T)tablica[i];
}
}
src/p09_importowanie/Program1.java 0 → 100644
package p09_importowanie;
/* W tej wersji programu nie ma żadnych importów, a wszystkie odwołania do klas Geometria, JednostkiMiary
* oraz standardowej klasy Scanner są poprzedzone nazwą pakietu.
* Pełna nazwa łącznie z pakietem to jest "nazwa kwalifikowana" / "qualified name".
*
* W języku Java ZAWSZE da się napisać program bez użycia import.
*/
public class Program1 {
public static void main(String[] args) {
java.util.Locale.setDefault(java.util.Locale.US);
java.util.Scanner scanner = new java.util.Scanner(System.in);
System.out.println("Dostępne polecenia:");
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");
petla:
while(true) {
System.out.println("\nWybierz figurę lub operację:");
String wybor = scanner.next().toUpperCase();
switch(wybor) {
case "Q" -> {
break petla;
}
case "K" -> {
System.out.print("Podaj długość boku kwadratu: ");
double a = scanner.nextDouble();
double pole = p08_funkcje.Geometria.poleKwadratu(a);
double obwod = p08_funkcje.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 dwie długości boków prostokąta: ");
double a = scanner.nextDouble();
double b = scanner.nextDouble();
double pole = p08_funkcje.Geometria.poleProstokata(a, b);
double obwod = p08_funkcje.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 "O" -> {
System.out.print("Podaj promień koła: ");
double r = scanner.nextDouble();
double pole = p08_funkcje.Geometria.poleKola(r);
double obwod = p08_funkcje.Geometria.obwodKola(r);
System.out.printf("Dla koła o promieniu %.3f pole wynosi %.3f, a obwód %.3f\n", r, pole, obwod);
}
case "T" -> {
System.out.print("Podaj trzy długości boków trójkąta: ");
double a = scanner.nextDouble();
double b = scanner.nextDouble();
double c = scanner.nextDouble();
if(p08_funkcje.Geometria.warunekTrojkata(a, b, c)) {
double pole = p08_funkcje.Geometria.poleTrojkata(a, b, c);
double obwod = p08_funkcje.Geometria.obwodTrojkata(a, b, c);
System.out.printf("Dla prostokąta o bokach %.3f %.3f %.3f pole wynosi %.3f, a obwód %.3f\n", a, b, c, pole, obwod);
} else {
System.out.println("Z tych liczb nie da się złożyć trójkąta");
}
}
case "KM" -> {
System.out.print("Podaj odległość w kilometrach: ");
double km = scanner.nextDouble();
double wynik = p08_funkcje.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 = p08_funkcje.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 = p08_funkcje.JednostkiMiary.f_na_c(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 = p08_funkcje.JednostkiMiary.c_na_f(c);
System.out.printf("%.3f °C = %.3f °F\n", c, wynik);
}
default -> {
System.out.println("Nieznane polecenie " + wybor);
}
}
}
System.out.println("Dzięki, miłego dnia!");
}
}
\ No newline at end of file
src/p09_importowanie/Program2.java 0 → 100644
package p09_importowanie;
import java.util.Locale;
import java.util.Scanner;
import p08_funkcje.Geometria;
import p08_funkcje.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 Program2 {
public static void main(String[] args) {
Locale.setDefault(Locale.US);
@SuppressWarnings("resource")
Scanner scanner = new Scanner(System.in);
System.out.println("Dostępne polecenia:");
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");
petla:
while(true) {
System.out.println("\nWybierz figurę lub operację:");
String wybor = scanner.next().toUpperCase();
switch(wybor) {
case "Q" -> {
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 dwie długości boków prostokąta: ");
double a = scanner.nextDouble();
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 "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 "T" -> {
System.out.print("Podaj trzy długości boków trójkąta: ");
double a = scanner.nextDouble();
double b = scanner.nextDouble();
double c = scanner.nextDouble();
if(Geometria.warunekTrojkata(a, b, c)) {
double pole = Geometria.poleTrojkata(a, b, c);
double obwod = Geometria.obwodTrojkata(a, b, c);
System.out.printf("Dla prostokąta o bokach %.3f %.3f %.3f pole wynosi %.3f, a obwód %.3f\n", a, b, c, pole, obwod);
} else {
System.out.println("Z tych liczb nie da się złożyć trójkąta");
}
}
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.f_na_c(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.c_na_f(c);
System.out.printf("%.3f °C = %.3f °F\n", c, wynik);
}
default -> {
System.out.println("Nieznane polecenie " + wybor);
}
}
}
System.out.println("Dzięki, miłego dnia!");
}
}
\ No newline at end of file
src/p09_importowanie/Program3.java 0 → 100644
package p09_importowanie;
import java.util.*;
import p08_funkcje.*;
/* 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.
* Jest to dodatkowo wyjaśnione w przykładach Imporcik1 i Imporcik2.
*
* Gdy w programie pojawia się jakaś nazwa, to kompilator szuka klasy w takiej kolejności:
* 1. rzeczy zaimportowane bezpośrednio (tak jak w Program2)
* 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 Program3 {
public static void main(String[] args) {
Locale.setDefault(Locale.US);
Scanner scanner = new Scanner(System.in);
System.out.println("Dostępne polecenia:");
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");
petla:
while(true) {
System.out.println("\nWybierz figurę lub operację:");
String wybor = scanner.next().toUpperCase();
switch(wybor) {
case "Q" -> {
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 dwie długości boków prostokąta: ");
double a = scanner.nextDouble();
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 "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 "T" -> {
System.out.print("Podaj trzy długości boków trójkąta: ");
double a = scanner.nextDouble();
double b = scanner.nextDouble();
double c = scanner.nextDouble();
if(Geometria.warunekTrojkata(a, b, c)) {
double pole = Geometria.poleTrojkata(a, b, c);
double obwod = Geometria.obwodTrojkata(a, b, c);
System.out.printf("Dla prostokąta o bokach %.3f %.3f %.3f pole wynosi %.3f, a obwód %.3f\n", a, b, c, pole, obwod);
} else {
System.out.println("Z tych liczb nie da się złożyć trójkąta");
}
}
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.f_na_c(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.c_na_f(c);
System.out.printf("%.3f °C = %.3f °F\n", c, wynik);
}
default -> {
System.out.println("Nieznane polecenie " + wybor);
}
}
}
System.out.println("Dzięki, miłego dnia!");
}
}
\ No newline at end of file
src/p09_importowanie/Program4.java 0 → 100644
package p09_importowanie;
import static p08_funkcje.Geometria.obwodKola;
import static p08_funkcje.Geometria.obwodKwadratu;
import static p08_funkcje.Geometria.obwodProstokata;
import static p08_funkcje.Geometria.obwodTrojkata;
import static p08_funkcje.Geometria.poleKola;
import static p08_funkcje.Geometria.poleKwadratu;
import static p08_funkcje.Geometria.poleProstokata;
import static p08_funkcje.Geometria.poleTrojkata;
import static p08_funkcje.Geometria.warunekTrojkata;
import static p08_funkcje.JednostkiMiary.c_na_f;
import static p08_funkcje.JednostkiMiary.f_na_c;
import static p08_funkcje.JednostkiMiary.km_na_mile;
import static p08_funkcje.JednostkiMiary.mile_na_km;
import java.util.Locale;
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 Program4 {
public static void main(String[] args) {
Locale.setDefault(Locale.US);
Scanner scanner = new Scanner(System.in);
System.out.println("Dostępne polecenia:");
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");
petla:
while(true) {
System.out.println("\nWybierz figurę lub operację:");
String wybor = scanner.next().toUpperCase();
switch(wybor) {
case "Q" -> {
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 dwie długości boków prostokąta: ");
double a = scanner.nextDouble();
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 "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 "T" -> {
System.out.print("Podaj trzy długości boków trójkąta: ");
double a = scanner.nextDouble();
double b = scanner.nextDouble();
double c = scanner.nextDouble();
if(warunekTrojkata(a, b, c)) {
double pole = poleTrojkata(a, b, c);
double obwod = obwodTrojkata(a, b, c);
System.out.printf("Dla prostokąta o bokach %.3f %.3f %.3f pole wynosi %.3f, a obwód %.3f\n", a, b, c, pole, obwod);
} else {
System.out.println("Z tych liczb nie da się złożyć trójkąta");
}
}
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 = f_na_c(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 = c_na_f(c);
System.out.printf("%.3f °C = %.3f °F\n", c, wynik);
}
default -> {
System.out.println("Nieznane polecenie " + wybor);
}
}
}
System.out.println("Dzięki, miłego dnia!");
}
}
\ No newline at end of file
src/p09_importowanie/Program5.java 0 → 100644
package p09_importowanie;
import static java.lang.Math.*;
import static p08_funkcje.Geometria.*;
import static p08_funkcje.JednostkiMiary.*;
import java.util.Locale;
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 p09_funkcje.*.*;
*/
public class Program5 {
public static void main(String[] args) {
// Tylko, żeby pokazać dizałanie Math.*
System.out.println("pi: " + PI);
System.out.println("pierwiastek z 2 " + sqrt(2));
Locale.setDefault(Locale.US);
Scanner scanner = new Scanner(System.in);
System.out.println("Dostępne polecenia:");
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");
petla:
while(true) {
System.out.println("\nWybierz figurę lub operację:");
String wybor = scanner.next().toUpperCase();
switch(wybor) {
case "Q" -> {
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 dwie długości boków prostokąta: ");
double a = scanner.nextDouble();
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 "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 "T" -> {
System.out.print("Podaj trzy długości boków trójkąta: ");
double a = scanner.nextDouble();
double b = scanner.nextDouble();
double c = scanner.nextDouble();
if(warunekTrojkata(a, b, c)) {
double pole = poleTrojkata(a, b, c);
double obwod = obwodTrojkata(a, b, c);
System.out.printf("Dla prostokąta o bokach %.3f %.3f %.3f pole wynosi %.3f, a obwód %.3f\n", a, b, c, pole, obwod);
} else {
System.out.println("Z tych liczb nie da się złożyć trójkąta");
}
}
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 = f_na_c(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 = c_na_f(c);
System.out.printf("%.3f °C = %.3f °F\n", c, wynik);
}
default -> {
System.out.println("Nieznane polecenie " + wybor);
}
}
}
System.out.println("Dzięki, miłego dnia!");
}
}
\ No newline at end of file
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment