Függvények, metóduok¶

Ahogyan a Python anyagrészben már megtanultuk, természetesen a Java nyelvben is lehetőségünk van különbőző függvényeket, metódusokat létrehozni.

Beépített függvények¶

A beépített függvényeknek az előnye, hogy nem szükséges semmit importálnunk, alapból tartalmazza a fordító

Matematikai¶

Főbb matematikai függvények:

Függvény	Példa	Leírás
Math.abs(x)	`Math.abs(-5)`	Egy szám abszolútértéke
Math.max(x, y)	`Math.max(5, 6)`	Két szám maximuma
Math.min(x, y)	`Math.min(5, 6)`	Két szám minimuma
Math.sqrt(x)	`Math.sqrt(25)`	Egy szám négyzetgyöke
Math.random()	`Math.random()`	Véletlen szám 0 és 1 között
Math.pow(x, y)	`Math.pow(2, 3)`	Egy szám hatványa
Math.sin(x)	`Math.sin(0)`	Egy szám szinusz értéke
Math.cos(x)	`Math.cos(0)`	Egy szám koszinusz értéke
Math.tan(x)	`Math.tan(0)`	Egy szám tangens értéke
Math.log(x)	`Math.log(1)`	Egy szám logaritmus értéke
Math.log10(x)	`Math.log10(1)`	Egy szám 10-es logaritmus értéke
Math.round(x)	`Math.round(1.5)`	Egy szám matematikai kerekítése
Math.floor(x)	`Math.floor(1.5)`	Egy szám lefelé kerekítése
Math.ceil(x)	`Math.ceil(1.5)`	Egy szám felfelé kerekítése
Math.PI	`Math.PI`	PI értéke

String¶

A beépített String függvények lehetőséget biztosítanak a szövegek manipulálására.

Az alábbi példák teszteléséhez hozzunk létre egy változót:

String example = "Példa szöveg";

A változó neve után tegyünk . karaktert, majd adjuk meg a függvény nevét, majd zárójelek között a paramétereket.

Főbb String függvények:

Függvény	Példa	Leírás
length()	`example.length()`	Szöveg hosszának lekérdezése
toUpperCase()	`example.toUpperCase()`	Szöveg nagybetűssé alakítása
toLowerCase()	`example.toLowerCase()`	Szöveg kisbetűssé alakítása
replace(x, y)	`example.replace("Példa", "Másik")`	Szövegben x szöveg y szövegre cserélése
substring(x, y)	`example.substring(0, 5)`	Szöveg x és y közötti részének kivágása
indexOf(x)	`example.indexOf("P")`	Szövegben x szöveg első előfordulásának indexe
split(x)	`example.split(" ")`	Szöveg x szöveg mentén történő szétválasztása
trim()	`example.trim()`	Szöveg elején és végén lévő felesleges szóközök eltávolítása
startsWith(x)	`example.startsWith("P")`	Szöveg x szöveggel kezdődik-e
endsWith(x)	`example.endsWith("g")`	Szöveg x szöveggel végződik-e
contains(x)	`example.contains("P")`	Szöveg x szöveget tartalmazza-e
equals(x)	`example.equals("Példa szöveg")`	Szöveg x szöveggel megegyezik-e
repeat(x)	`example.repeat(2)`	Szöveg x számú ismétlése
charAt(x)	`example.charAt(0)`	Szöveg x indexű karaktere

Szám kerekítése¶

A Java-ban a legegyszerűbb módszer egy szám két tizedesjegyre történő kerekítésére a String.format() metódus használata.

double number = 1.677777778;
String formattedNumber = String.format("%.2f", number);

Karakter¶

A beépített karakter függvények lehetőséget biztosítanak a karakterek manipulálására.

Az alábbi példák teszteléséhez hozzunk létre egy változót:

char betu = 'a';

Figyelem

A karaktereket a char típusú változókban tároljuk, és a karaktereket aposztrófok (') között adjuk meg.

Főbb karakter függvények:

Függvény	Példa	Leírás
isDigit	`Character.isDigit('a')`	Karakter szám-e
isLetter	`Character.isLetter('a')`	Karakter betű-e
isLowerCase	`Character.isLowerCase('a')`	Karakter kisbetű-e
isUpperCase	`Character.isUpperCase('A')`	Karakter nagybetű-e
toLowerCase	`Character.toLowerCase('A')`	Karakter kisbetűvé alakítása
toUpperCase	`Character.toUpperCase('a')`	Karakter nagybetűvé alakítása
isWhitespace	`Character.isWhitespace(' ')`	Karakter szóköz-e
getNumericValue	`Character.getNumericValue('1')`	Karakter számértéke

Példa

char betu = 'a';

System.out.println(Character.isDigit(betu)); // false
System.out.println(Character.isLetter(betu)); // true
System.out.println(Character.isLowerCase(betu)); // true
System.out.println(Character.isUpperCase(betu)); // false
System.out.println(Character.toLowerCase(betu)); // a
System.out.println(Character.toUpperCase(betu)); // A
System.out.println(Character.isWhitespace(betu)); // false
System.out.println(Character.getNumericValue(betu)); // -1

Dátum és idő¶

Java nyelven a dátum- és időkezelés elengedhetetlen része a modern alkalmazásoknak. Az alábbiakban a Java dátumkezelésének legfontosabb aspektusait mutatom be röviden.

A java.time csomag részeként bevezetett LocalDate, LocalTime, és LocalDateTime osztályok a dátum és idő kezelésének modern megközelítését biztosítják.

Dátum¶

A LocalDate osztály segítségével tudunk dátumokat kezelni. Ebben az osztályban csak a dátumot tároljuk, azaz az évet, a hónapot és a napot.

Példa

Dátum létrehozása általunk megadott értékek alapján:

LocalDate date = LocalDate.of(2021, 10, 10);

Aktuális dátum lekérdezése:

LocalDate date = LocalDate.now();

Nincs mindig szükségünk a teljes dátumra, ilyenkor használhatjuk a beépített függvényeket. A fenti date változó alábbi részeit tudjuk lekérdezni:

Metódus	Leírás	Példakód
getYear()	Az év lekérdezése	`date.getYear()`
getMonth()	A hónap lekérdezése	`date.getMonth()`
getMonthValue()	A hónap számmal kifejezve	`date.getMonthValue()`
getDayOfMonth()	A hónap napjának lekérdezése	`date.getDayOfMonth()`
getDayOfWeek()	A hét napjának lekérdezése	`date.getDayOfWeek()`
getDayOfYear()	Az év napjának lekérdezése	`date.getDayOfYear()`

Példa

Kérjük ki az aktuális évet és írjuk ki a konzolra!

LocalDate date = LocalDate.now();
System.out.println("Aktuális év: " + date.getYear());

Vannak esetek amikor módosítanunk kell a dátumot, ezt az alábbi függvények segítségével tehetjük meg:

Metódus	Leírás	Példakód
plusYears()	Évek hozzáadása	`date.plusYears(2)`
plusMonths()	Hónapok hozzáadása	`date.plusMonths(3)`
plusDays()	Napok hozzáadása	`date.plusDays(7)`
minusYears()	Évek levonása	`date.minusYears(1)`
minusMonths()	Hónapok levonása	`date.minusMonths(6)`
minusDays()	Napok levonása	`date.minusDays(10)`

Ezekkel a metódusokkal egyszerűen módosíthatod a LocalDate objektum dátumát, attól függően, hogy szükséges-e előre vagy hátra lépni az időben. Az évek, hónapok és napok hozzáadása vagy levonása segítségével a programozók finoman szabályozhatják a dátumokat a különféle alkalmazásokban.

Példa

LocalDate date = LocalDate.now();
LocalDate newDate = date.plusYears(1).plusMonths(2).plusDays(3); // Aktuális dátumhoz 1 évet, 2 hónapot és 3 napot adunk hozzá
System.out.println("Új dátum: " + newDate);

Idő¶

A LocalTime osztály segítségével tudunk időpontokat kezelni. Ebben az osztályban csak az időpontot tároljuk, azaz az órát, a percet, a másodpercet és a nanoszekundumokat.

Példa

Időpont létrehozása általunk megadott értékek alapján:

LocalTime time = LocalTime.of(12, 30, 0);
System.out.println("time = " + time);

Aktuális idő lekérdezése a rendszeróra alapján:

LocalTime time = LocalTime.now();
System.out.println("time = " + time);

Nincs mindig szükségünk a teljes időre, ilyenkor használhatjuk a beépített függvényeket. A fenti time változó alábbi részeit tudjuk lekérdezni:

Metódus	Leírás	Példakód
getHour()	Az óra	`time.getHour()`
getMinute()	A perc	`time.getMinute()`
getSecond()	A másodperc	`time.getSecond()`
getNano()	A másodperc nanoszekundumai	`time.getNano()`
toSecondOfDay()	Éjféltől számított másodpercek	`time.toSecondOfDay()`

Példa

Kérjük ki az aktuális órát és írjuk ki a konzolra!

LocalTime time = LocalTime.now();
System.out.println("Aktuális óra" + time.getHour());

Vannak esetek amikor módosítanunk kell az időt, ezt az alábbi függvények segítségével tehetjük meg:

Metódus	Leírás	Példakód
plusHours()	Órák hozzáadása	`time.plusHours(2)`
plusMinutes()	Percek hozzáadása	`time.plusMinutes(30)`
plusSeconds()	Másodpercek hozzáadása	`time.plusSeconds(45)`
plusNanos()	Nanoszekundumok hozzáadása	`time.plusNanos(1000000)`
minusHours()	Órák levonása	`time.minusHours(1)`
minusMinutes()	Percek levonása	`time.minusMinutes(15)`
minusSeconds()	Másodpercek levonása	`time.minusSeconds(30)`
minusNanos()	Nanoszekundumok levonása	`time.minusNanos(500000)`

Példa

LocalTime time = LocalTime.now();
LocalTime newTime = time.plusHours(1).plusMinutes(30); // Aktuális időhöz 1 órát és 30 percet adunk hozzá
System.out.println("Új idő: " + newTime);

Dátum és idő¶

A LocalDateTime osztály segítségével tudunk dátumokat és időpontokat kezelni. Ebben az osztályban a dátumot és az időpontot is tároljuk, tehát ötvözi a LocalDate és a LocalTime osztályokat.

Dátum és idő létrehozása¶

A LocalDateTime osztály of() metódusával tudunk dátumot és időpontot létrehozni.

LocalDateTime dateTime = LocalDateTime.of(2021, 10, 10, 12, 30, 0);

Aktuális dátum és idő lekérdezése:

LocalDateTime dateTime = LocalDateTime.now();

Dátum és idő lekérdezése¶

A LocalDateTime osztály get() metódusával tudjuk lekérdezni a dátum és idő részeit.

int year = dateTime.getYear();
int month = dateTime.getMonthValue();
int day = dateTime.getDayOfMonth();
int hour = dateTime.getHour();
int minute = dateTime.getMinute();
int second = dateTime.getSecond();

Dátum és idő módosítása¶

A LocalDateTime osztály plus() és minus() metódusaival tudjuk módosítani a dátumot és időpontot.

LocalDateTime newDateTime = dateTime.plusDays(1);

Feladatok¶

Olvassunk be a standard inputról neveket vesszővel elválasztva, majd írjuk ki őket egymás alá!

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.print("Add meg a neveket vesszővel elválasztva: ");
        String nevek = scanner.nextLine();

        String[] nevekTomb = nevek.split(",");

        for (String nev : nevekTomb) {
            System.out.println(nev);
        }
    }
}

Output

Add meg a neveket vesszővel elválasztva: Jani,Pisti,Levente,Kata
Jani
Pisti
Levente
Kata

Saját függvények¶

Saját függvények létrehozásához a következő szintaxist kell használnunk:

Szintaxis

<láthatóság> static <visszatérési típus> <függvény neve>(<paraméterek>) {
    // Függvény törzse
}

Figyelem

A függvényeket a main függvényen kívül kell létrehozni.

Példa

public static void helloWorld() {
    System.out.println("Hello World!");
}

public static void main(String[] args) {
    helloWorld();
}