Gotowe przykłady funkcji

src/main/java/gotowe/p08_funkcje/gdyby_nie_bylo_static/Geometria.java

+package gotowe.p08_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/p08_funkcje/gdyby_nie_bylo_static/TestyGeometrii.java

+package gotowe.p08_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/p08_funkcje/importowanie/V1_BrakImportow.java

+package gotowe.p08_funkcje.importowanie;
+
+public class V1_BrakImportow {
+
+	public static void main(String[] args) {
+		System.out.println("Pole kwadratu 5 = " + gotowe.p08_funkcje.przyklady.Geometria.poleKwadratu(5.0));
+		System.out.println("Pole koła 5 = " + gotowe.p08_funkcje.przyklady.Geometria.poleKola(5.0));
+		System.out.println("Pole prostokąta 3×5 = " + gotowe.p08_funkcje.przyklady.Geometria.poleProstokata(3.0, 5.0));
+		System.out.println("100 mil = " + gotowe.p08_funkcje.przyklady.JednostkiMiary.mileNaKm(100) + " km");
+		System.out.println("100 km = " + gotowe.p08_funkcje.przyklady.JednostkiMiary.kmNaMile(100) + " mil");
+	}
+
+}

src/main/java/gotowe/p08_funkcje/importowanie/V2_ImportKlas.java

+package gotowe.p08_funkcje.importowanie;
+
+import gotowe.p08_funkcje.przyklady.Geometria;
+import gotowe.p08_funkcje.przyklady.JednostkiMiary;
+
+public class V2_ImportKlas {
+
+	public static void main(String[] args) {
+		System.out.println("Pole kwadratu 5 = " + Geometria.poleKwadratu(5.0));
+		System.out.println("Pole koła 5 = " + Geometria.poleKola(5.0));
+		System.out.println("Pole prostokąta 3×5 = " + Geometria.poleProstokata(3.0, 5.0));
+		System.out.println("100 mil = " + JednostkiMiary.mileNaKm(100) + " km");
+		System.out.println("100 km = " + JednostkiMiary.kmNaMile(100) + " mil");
+	}
+
+}

src/main/java/gotowe/p08_funkcje/importowanie/V3_ImportGwiazdka.java

+package gotowe.p08_funkcje.importowanie;
+
+import gotowe.p08_funkcje.przyklady.*;
+
+// Import wszystkich klas publicznych z podanego pakietu.
+// Jeśli w programie użyjemy nazwy, która znajduje się w różnych pakietach, to mamy konfokt nazw i to się skompiluje.
+// Podczas ustalania skąd się wzięła jakaś nazwa kompilator stosuje taką kolejność:
+// 1) Klasy zaimportowane wprost (jak w v2)
+// 2) Klasy z bieżącego pakietu
+// 3) Klasy zaimportowane z * , wśród nich klasy z pakietu java.lang oraz klasy z pakietu domyślnego (którego nie należy używać)
+public class V3_ImportGwiazdka {
+
+	public static void main(String[] args) {
+		System.out.println("Pole kwadratu 5 = " + Geometria.poleKwadratu(5.0));
+		System.out.println("Pole koła 5 = " + Geometria.poleKola(5.0));
+		System.out.println("Pole prostokąta 3×5 = " + Geometria.poleProstokata(3.0, 5.0));
+		System.out.println("100 mil = " + JednostkiMiary.mileNaKm(100) + " km");
+		System.out.println("100 km = " + JednostkiMiary.kmNaMile(100) + " mil");
+	}
+
+}

src/main/java/gotowe/p08_funkcje/importowanie/V4_ImportStatic.java

+package gotowe.p08_funkcje.importowanie;
+
+import static gotowe.p08_funkcje.przyklady.Geometria.poleKola;
+import static gotowe.p08_funkcje.przyklady.Geometria.poleKwadratu;
+import static gotowe.p08_funkcje.przyklady.Geometria.poleProstokata;
+import static gotowe.p08_funkcje.przyklady.JednostkiMiary.kmNaMile;
+import static gotowe.p08_funkcje.przyklady.JednostkiMiary.mileNaKm;
+
+public class V4_ImportStatic {
+
+	public static void main(String[] args) {
+		System.out.println("Pole kwadratu 5 = " + poleKwadratu(5.0));
+		System.out.println("Pole koła 5 = " + poleKola(5.0));
+		System.out.println("Pole prostokąta 3×5 = " + poleProstokata(3.0, 5.0));
+		System.out.println("100 mil = " + mileNaKm(100) + " km");
+		System.out.println("100 km = " + kmNaMile(100) + " mil");
+	}
+
+}

src/main/java/gotowe/p08_funkcje/importowanie/V5_ImportStaticGwiazdka.java

+package gotowe.p08_funkcje.importowanie;
+
+import static gotowe.p08_funkcje.przyklady.Geometria.*;
+import static gotowe.p08_funkcje.przyklady.JednostkiMiary.*;
+
+//NK import static alx.p06_funkcje.przyklady.*.*;
+
+public class V5_ImportStaticGwiazdka {
+
+	public static void main(String[] args) {
+		System.out.println("Pole kwadratu 5 = " + poleKwadratu(5.0));
+		System.out.println("Pole koła 5 = " + poleKola(5.0));
+		System.out.println("Pole prostokąta 3×5 = " + poleProstokata(3.0, 5.0));
+		System.out.println("100 mil = " + mileNaKm(100) + " km");
+		System.out.println("100 km = " + kmNaMile(100) + " mil");
+	}
+
+}

src/main/java/gotowe/p08_funkcje/przyklady/FunkcjeZWarunkami.java

+package gotowe.p08_funkcje.przyklady;
+
+import java.util.Random;
+
+public class FunkcjeZWarunkami {
+	// Funkcje, które zwracają wyniki za pomocą return, mogą posiadać bardziej złożoną treść,
+	// np. używać if-ów, switch-ów, pętli...
+	// return nie musi być wtedy ostatnią instrukcją, może występować w kilku miejscach,
+	// a kompilator będzie sprawdzał "czy w każdej sytuacji na pewno funkcja zwróci jakiś wynik"
+	
+	static int wieksza(int x, int y) {
+		if(x > y) {
+			return x;
+		} else {
+			return y;
+		}
+	}
+	
+	// jeszcze bardziej zwięzła wersja, z wykorzystaniem wyrażenia warunkowego ?:
+	static int wieksza_v2(int x, int y) {
+		return x > y ? x : y;
+	}
+
+	public static void main(String[] args) {
+		Random random = new Random();
+		int x = random.nextInt(10);
+		int y = random.nextInt(10);
+		
+		System.out.println(" x = " + x);
+		System.out.println(" y = " + y);
+		
+		int wieksza = wieksza(x, y);
+		System.out.println("większą z nich jest: " + wieksza);
+	}
+
+}

src/main/java/gotowe/p08_funkcje/przyklady/Geometria.java

+package gotowe.p08_funkcje.przyklady;
+
+import java.util.Scanner;
+
+public class Geometria {
+	private Geometria() {
+		// aby nikt nie tworzył instancji tej klasy, bo to jest "utility class"
+	}
+
+	public static double poleKwadratu(double a) {
+		return a * a;  // ew. Math.pow(a, 2)
+	}
+	
+	public static double poleKola(double r) {
+		//JOptionPane.showMessageDialog(null, "Właśnie zabieram się za obliczanie pola koła o promieniu " + r);
+		return Math.PI * Math.pow(r, 2);
+	}
+	
+	public static double poleProstokata(double a, double b) {
+		return a * b;
+	}
+	
+	public static double obwodKwadratu(double a) {
+		return 4*a;
+	}
+
+	public static double obwodProstokata(double a, double b) {
+		return 2*a + 2*b;
+	}
+
+	public static double obwodKola(double r) {
+		return 2 * Math.PI * r;
+	}
+
+	// W tej wersji main jest w tej samej klasie, co definicje funkcji,
+	// dzięki temu można łatwo te funkcje (statyczne) wywoływać.
+	// Ale dla przejrzystości kodu lepiej funkcje definiować w jednej klasie, a program (main) pisać w innej - zob. ProgramGeometryczny)
+	public static void main(String[] args) {
+		Scanner sc = new Scanner(System.in);
+		
+		System.out.print("Podaj pierwszą liczbę: ");
+		double x = sc.nextDouble();
+
+		System.out.print("Podaj drugą liczbę: ");
+		double y = sc.nextDouble();
+		
+		double wynik;
+		wynik = poleKwadratu(x);
+		System.out.println("Pole kwadratu o boku " + x + " wynosi " + wynik);
+		wynik = poleKwadratu(y);
+		System.out.println("Pole kwadratu o boku " + y + " wynosi " + wynik);
+		
+		wynik = poleProstokata(x, y);
+		System.out.println("Pole prostokąta " + x + " × " + y + " wynosi " + wynik);
+		
+		wynik = poleKola(x);
+		System.out.println("Pole koła o promieniu " + x + " wynosi " + wynik);
+		wynik = poleKola(y);
+		System.out.println("Pole koła o promieniu " + y + " wynosi " + wynik);
+
+		wynik = obwodKwadratu(x);
+		System.out.println("Obwód kwadratu o boku " + x + " wynosi " + wynik);
+		wynik = obwodKwadratu(y);
+		System.out.println("Obwód kwadratu o boku " + y + " wynosi " + wynik);
+		
+		// tak też można pisać, ale po co?...
+		wynik = Geometria.obwodProstokata(x, y);
+		System.out.println("Obwód prostokąta " + x + " × " + y + " wynosi " + wynik);
+	}
+
+}

src/main/java/gotowe/p08_funkcje/przyklady/JednostkiMiary.java

+package gotowe.p08_funkcje.przyklady;
+
+public class JednostkiMiary {
+	
+	public static double kmNaMile(double km) {
+		return km / 1.609344;
+	}
+	
+	public static double mileNaKm(double mile) {
+		return 1.609344 * mile;
+	}
+	
+	public static double farNaCel(double far) {
+		return 5. / 9. * (far - 32d);
+	}
+	
+	public static double celNaFar(double cel) {
+		return 32.0 + (9.0 / 5.0 * cel);  // 32 + 1.8*cel
+	}
+
+}

src/main/java/gotowe/p08_funkcje/przyklady/ProgramGeometryczny.java

+package gotowe.p08_funkcje.przyklady;
+
+import java.util.Locale;
+import java.util.Scanner;
+
+public class ProgramGeometryczny {
+
+	public static void main(String[] args) {
+		Scanner sc = new Scanner(System.in);
+		sc.useLocale(Locale.US);
+		
+		glownaPetla:
+		while(true) {
+			System.out.println("Wybierz figurę:\n Q - zakończ,\n K - kwadrat,\n P - prostokąt,\n O - koło");
+			String wybor = sc.nextLine().trim().toUpperCase();
+			switch(wybor) {
+				case "Q": {
+					break glownaPetla; // etykieta / label
+				}
+				case "K": {
+					System.out.print("Podaj długość boku kwadratu: ");
+					double a = sc.nextDouble();
+					double pole = Geometria.poleKwadratu(a);
+					double obwod = Geometria.obwodKwadratu(a);
+					System.out.println("Pole kwadratu wynosi: " + pole);
+					System.out.println("Obwód kwadratu wynosi: " + obwod);
+					break;
+				}
+				case "P": {
+					System.out.print("Podaj długość dwóch boków prostokąta: ");
+					double a = sc.nextDouble();
+					double b = sc.nextDouble();
+					double pole = Geometria.poleProstokata(a, b);
+					double obwod = Geometria.obwodProstokata(a, b);
+					System.out.println("Pole prostokąta wynosi: " + pole);
+					System.out.println("Obwód prostokąta wynosi: " + obwod);
+					break;
+				}
+				case "O": {
+					System.out.print("Podaj promień koła: ");
+					double r = sc.nextDouble();
+					double pole = Geometria.poleKola(r);
+					double obwod = Geometria.obwodKola(r);
+					System.out.println("Pole koła wynosi: " + pole);
+					System.out.println("Obwód koła wynosi: " + obwod);
+					break;
+				}
+				default: {
+					System.out.println("Nieznane polecenie");
+					continue glownaPetla;
+				}
+			}
+			sc.nextLine(); // żeby Scanner wczytał wszystkie pozostałości i przeszedł do nast. linii
+		}
+	}
+}
+
+/*
+użycie if zamiast switch wyglądałoby tak:
+if("K".equals(wybor)) {
+	System.out.println("Wybrano kwadrat");
+} else if("O".equals(wybor)) {
+	System.out.println("Wybrano koło");
+}
+*/

src/main/java/gotowe/p08_funkcje/przyklady/TestyGeometrii.java

+package gotowe.p08_funkcje.przyklady;
+
+public class TestyGeometrii {
+	// Będąc w jednej klasie, można wywoływać metody zdefiniowane w innej klasie,
+	// zgodnie z ograniczeniami widoczności (private/public)
+	// Jeśli metoda nie jest prywatna, to można jej używać w tym samym pakiecie,
+	// a jeśli jest publiczna, to można używać wszędzie.
+	
+	public static void main(String[] args) {
+		System.out.println("Pole kwadratu 5 = " + Geometria.poleKwadratu(5.0));
+		System.out.println("Pole kwadratu 6.5 = " + Geometria.poleKwadratu(6.5));
+		System.out.println("Pole koła 5 = " + Geometria.poleKola(5.0));
+		System.out.println("Pole prostokąta 3×5 = " + Geometria.poleProstokata(3.0, 5.0));
+		System.out.println();
+
+		// Testy preliczania jednstek też przeniosłem do tej klasy, żeby pokazać, że w klasie JednostkiMiary może nie być main, tylko same funkcje.
+		System.out.println("100 mil = " + JednostkiMiary.mileNaKm(100) + " km");
+		System.out.println("100 km = " + JednostkiMiary.kmNaMile(100) + " mil");
+		System.out.println("160 km = " + JednostkiMiary.kmNaMile(160) + " mil");
+		System.out.println();
+
+		System.out.println("0 F = " + JednostkiMiary.farNaCel(0) + " C");
+		System.out.println("100 F = " + JednostkiMiary.farNaCel(100) + " C"); // ok 37
+		System.out.println("0 C = " + JednostkiMiary.celNaFar(0) + " F");
+		System.out.println("37 C = " + JednostkiMiary.celNaFar(37) + " F"); // ok 100
+		System.out.println("100 C = " + JednostkiMiary.celNaFar(100) + " F"); // 212 ?
+	}
+
+}

src/main/java/gotowe/p08_funkcje/teoria/Funkcje1_Void.java

+package gotowe.p08_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 / 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/p08_funkcje/teoria/Funkcje2_Parametry.java

+package gotowe.p08_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/p08_funkcje/teoria/Funkcje3_Wynik.java

+package gotowe.p08_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/p08_funkcje/teoria/Narnia.java

+package gotowe.p08_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();
+	}
+
+}