Java - IV. / 1

11. Alapfogalmak

12. Kifejezések, értékadás

13. Szelekciók

14. Iterációk

15. Metódusok írása

Java - IV. / 2

11. Alapfogalmak1. Mintaprogram - Krumpli

2. ASCII és unikód karakterek

3. A program alkotóelemei

4. Változó, típus

5. Primitív típusok

6. A forrásprogram szerkezete

7. Metódushívás (üzenet)

8. Értékadó utasítás

9. Adatok bevitele a konzolról

10. Megjelenítés a konzolon

Java - IV. / 3

Mintaprogram - KrumpliFeladat – Krumpli

Egy cserkésztáborban készül a vacsora, de a konyhafőnök nem tudja, mennyi krumplit vegyen. A fejadagot ismeri, az 0.4 kg, de a szükséges mennyiséget számítógép segítségével szeretné kiszámolni az aktuális létszámtól függően.

Írjuk meg a programot a konyhafőnöknek! A program kérje be a létszámot, majd írja ki a szükséges mennyiséget a következőképpen:Létszám? 20A szükséges mennyiség: 20 * 0.4 kg = 8.0 kg

Java - IV. / 4

A Krumpli osztály UML ábrája

Krumpli

+ main(args: String[])

Java - IV. / 5

import extra.*; // extra egy saját csomag, nem API

public class Krumpli {public static void main(String[ ] args) {

int letszam;double fejadag=0.4, osszesen;

// A letszam változó beolvasása konzolról:letszam = Console.readInt("Letszam? ");

// A szükséges mennyiség kiszámítása és kiírása:osszesen = fejadag*letszam;System.out.print("A szukseges mennyiseg: ");System.out.println(letszam+" * "+fejadag+" kg = "+

osszesen+" kg");}

}

Java - IV. / 6

A Krumpli program fordítása és futtatása

Java - IV. / 7

ASCII és unikód karakterek ASCII karakterkészlet: Szabványos kódrendszer,

mely a karaktereket 1 bájton ábrázolja.

• megjeleníthető karakterek• vezérlő (kontroll, escape) karakterek

Unikód karakterkészlet: Szabványos kódrendszer, mely a karaktereket 2 bájton ábrázolja.

• jelölése: \uhhhh, ahol h hexadecimális számjegy• lehetséges értékek: \u0000 \uffff• első 256 karaktere megegyezik az ASCII

karakterkészlettel

Java - IV. / 10

Fehér szóköz, pl. szóköz, tabulátor, sorvégjel Megjegyzés: //, /*...*/ Azonosító Kulcsszó Literál

• egész, valós, karakter, logikai, szöveg

Szeparátor, pl.:( ) { } . , [ ] Operátor, pl. */+ == <

A program alkotóelemei

A program alapelemei

Java - IV. / 18

Változó, típus

int letszam;

double fejadag=0.4, osszesen;

?

letszam

0.4

fejadag

?

osszesen

Változó = névvel azonosított memóriaterület

4 byte 8 byte 8 byte

Java - IV. / 20

Deklarálás, inicializálás

A Javában a változókat deklarálni kell!

Deklarálás:

<típus> <változó> ;

Például: int letszam;

Deklarálás és inicializálás:

<típus> <változó> = <kifejezés> ;

Például: double fejadag=0.4;

A deklaráció abban a blokkban érvényes, ahol a változót deklaráltuk.

Inicializálás

Java - IV. / 21

Konstans

Változtathatatlan változó

Módosítója: final

Például:final int EVSZAM=1999;

EVSZAM=2000; // fordítási hiba!

konstans literál

Java - IV. / 22

Java típusok

Primitív típusú változó: memóriaterülete oszthatatlan.

Referencia típusú változó: mutató, mely egy objektum hivatkozását tartalmazza.

Prim itív

O sztály típus In terfész típus

O sztály/In terfész

T ípus []

T öm b

R eferencia

Java típus

Java - IV. / 23

Primitív típusok

byte short int long

Egész

char

Karakter

Sorszámozott

float double

Valós

Numerikus

boolean

Logikai

Primitív

Java - IV. / 24

Típusneve

Foglaltmemória

Legkisebb értékLegnagyobb érték Pontosság

float 4 bájt (32 bit) 1.40129846432481707e-453.40282346638528860e+38

6-7 jegy

double 8 bájt (64 bit) 4.94065645841246544e-3241.79769313486231570e+308

14-15 jegy

Valós típusok

Típusneve

Foglaltmemória Legkisebb érték Legnagyobb érték

byte 1 bájt (8 bit) -27 = -128 2

7-1 = 127

short 2 bájt (16 bit) -215

= -32768 215

-1 = 32767

int 4 bájt (32 bit) -231

= -2147483648 231

-1= 2147483647long 8 bájt (64 bit) -2

63 ~ -10

192

63-1 ~ 10

19

Egész típusok

Java - IV. / 25

Logikai típus

Típus neve Foglalt memória Igaz érték Hamis érték

boolean nem definiált true false

Típusneve

Foglaltmemória

Legkisebbérték

Legnagyobbérték

char 2 bájt (16 bit) '\u0000' (0) '\uffff' (65535)

Karakter típus

Java - IV. / 26

A forrásprogram szerkezete

App

…

C1

...

CN

...

v1, ...vN

+main+m1...+mN

Java - IV. / 27

// App.java forrásprogramja

import java.util.*;

import extra.*;

// osztálydeklarációk(sorrend mindegy):

class C1 {

...

}

...

class CN {

...

}

Csomagok importálása

osztály feje

osztály blokkja

Java - IV. / 28

public class App {

v1, ... vN

public static void main(String[ ] args) {

// metódus blokkja: deklarációk,utasítások

}

void m1() {...

}...void mN() {

...}

}

App a fordítási egység egyetlen publikus osztálya

osztály feje

metódus feje

Java - IV. / 29

Blokk, utasítás

Blokk (összetett utasítás): { ... }

Mindaz, amit abban a blokkban adunk meg, pontosan

arra a blokkra érvényes!

Ahol egy utasítást megadhatunk, ott egy blokkot is.

Egy blokk utasításokból áll.

Minden utasítást pontosvessző zár le.

Java - IV. / 30

Utasítások fajtái

Deklaráló utasítás (Memóriahelyek foglalása):int letszam;

Értékadó utasítás: letszam=45; Postfix és prefix növelő és csökkentő utasítások:

letszam++; --letszam; Metódushívás: System.out.println("Hello"); Példányosítás (Új objektum létrehozása):

aDatum = new Datum(2000,11,05); Programvezérlő utasítás: if (i==0) ... Üres utasítás: ; (csak egy pontosvessző)

Java - IV. / 31

Kivétel (Exception)

// Kivetel.javaimport extra.*;

public class Kivetel {public static void main(String[] args) {

int narancsokSzama = 56;int letszam = Console.readInt("Letszam: ");System.out.println("Fejadag: "+narancsokSzama/letszam);System.out.println("Finom a narancs!");

}}

Java - IV. / 32

Futási hiba (kivétel) keletkezése

Java - IV. / 33

Metódushívás (üzenet)

Osztálymetódus hívása: Osztály.metódus(paraméterek)Például: letszam = Console.readInt("...");

Példánymetódus hívása: objektum.metódus(paraméterek)Például: System.out.print("...");

Ha a metódust a saját osztályából hívjuk, akkor nem kell minősíteni:metódus(paraméterek)

Java - IV. / 35

Adatok bevitele a konzolrólextra::Console

+readInt(str: String): int +readInt(): int +readLong(str: String): long +readLong(): long +readDouble(str: String): double+readDouble(): double +readChar(str: String): char+readChar(): char +readLine(str: String): String+readLine(): String +pressEnter()

Java - IV. / 36

Megjelenítés a konzolon

Konzolra a következő metódusokkal írhatunk:

• System.out.print(paraméter)

• System.out.println(paraméter)

• System.out.println()

számok, szövegek igazítása:

extra.Format osztály

Java - IV. / 37

extra::Format

+left(num: int, len: int): String +right(num: int, len: int): String

+left(num: double, len: int, frac: int ): String +right(num: double, len: int, frac: int ): String

+left(str: String, len: int): String+right(str: String, len: int): String

Java - IV. / 38

12. Kifejezések, értékadás1. A kifejezés alkotóelemei

2. Operátorok

3. Típuskonverziók

4. Értékadás

5. Kifejezések kiértékelése – példák

6. Feltétel

7. Paraméterátadás, túlterhelt metódusok

8. java.lang.Math osztály

Java - IV. / 40

Kifejezések kiértékelése

Kiértékelési sorrend:

• Zárójelek (belülről kifelé)

• Előbb a nagyobb prioritású operátor

• Egyforma prioritás esetén az operátor

asszociativitásától függően

jobbról balra () vagy balról jobbra ()

Java - IV. / 41

Példák

alfa

Math.sin(alfa) + 5

-98E4

(j<5) || (j>10)

!(Math.sqrt((n+3)/2)==0)

Java - IV. / 42

Az operandus típusa

Változó és függvény típusa a deklarált típus

Literálok alapértelmezett típusai:

• Egész: int. De: 45L

• Valós: double. De: 7.8F

• Logikai: boolean

• Karakter: char

• Szöveg: String

Java - IV. / 43

Java operátorokPrior. Operátor Elnevezés Asszoc.

[] . (<param>) ++ -- unáris postfixoperátorok

++ -- + - ~ ! unáris prefixoperátorok

new (<típus>)<kif> példányosítás,típuskényszerítés

* / % multiplikatívoperátorok

+ - additív operátorok

<< >> >>> bitenkénti léptetőoperátorok

Java - IV. / 44

Java operátorok(folyt)

Prior. Operátor Elnevezés Asszoc.

< <= > >= instanceof hasonlítóoperátorok

== != egyenlőségvizsgálóoperátorok

& logikai/bitenkéntiÉS

^ logikai/bitenkéntiKIZÁRÓ VAGY

| logikai/bitenkéntiVAGY

Java - IV. / 45

Java operátorok(folyt.)

Prior. Operátor Elnevezés Asszoc.

&& logikai rövid ÉS

|| logikai rövid VAGY

?: feltételeskiértékelés

= += -= *= /= %= &=|= ^= <<= >>= >>>=

értékadóoperátorok

Java - IV. / 46

Példák

int i; long lon; float f; double d;

char c; boolean bool;

Unáris postfix és prefix operátorok (előjel, léptetés)i=3; i=-i; // i==-3

i=3; lon=3+ i++; // lon==6, i==4

i=3; lon=3+ ++i; // lon==7, i==4

Multiplikatív operátoroki=22; i=i/5; // i==4f=20.5F; f=f/5; // f==4.1f=20.5F%5; // f==0.5

Java - IV. / 47

Additív operátoroki=3; f=i+600; // f==603.0

Hasonlító és egyenlőségvizsgáló operátorok

i=3; bool=i==5; // bool==false

Logikai operátorokboolean vanA;vanA=Console.readChar(”Betű:")=='A' || Console.readChar("Még egy:")=='A';

Feltételes kiértékelésint teljesitmeny = 60;int premium = (teljesitmeny>50)?10000:0;

Java - IV. / 48

Típuskonverziók

A Java erősen típusos nyelv

(a fordító ellenőrzi a kompatibilitást)

Bizonyos műveletek előtt konvertálni kell.

A típuskonverzió fajtái (kétféle osztályzás):

• automatikus (implicit) vagy

kényszerített (explicit)

• konverzió iránya: szűkítő vagy bővítő

Java - IV. / 49

Implicit és explicit típuskonverzió

Típuskényszerítés

(<típus>) <kifejezés>

Példák:

double d; int i=5;

d=i; // int double, implicit bővítő

d=79.4;

i=(int)d; // double int, explicit szűkítő, i==79

// i=d; // Szintaktikai hiba!!!

Java - IV. / 50

A bővítő konverzió iránya

byte

char

long floatintshort

double

bővítő konverzió: nincs információvesztés szűkítő konverzió: információvesztés lehetséges

Példák:

int i = 'A'; // implicit bővítő, char int

char c = (char)65; // explicit szűkítő, int char

Szűkítő és bővítő konverziók

Java - IV. / 51

Numerikus operátorok típuskonverziói

Minden operandus minimum int típusú lesz Az eredmény típusa a közös, konvertált típus lesz

Példák:

double d = 21/2*3; // d==30.0

double d = 21.0/2*3; // d==31.5

int i = ’A’+1; // i==66

Java - IV. / 52

Értékadás

<változó> = <kifejezés>

precedenciája a legkisebb

visszaadja a jobb oldali kifejezés értékét

Többszörös értékadás

<v1> = <v2> = ... <vN> = <kifejezés>

(jobb asszociativitás)

Java - IV. / 53

Értékadási kompatibilitás

Az értékadás kiértékelésének szabályai: Bal és jobb oldal típusai megegyeznek

nincs típuskonverzió

byte b=(byte)128; // b==-128 Jobb oldal szűkebb implicit bővítő konverzió

int i=50; long lon;

lon = i; // int long Bal oldal byte, short vagy char, és belefér

implicit szűkítő konverzió

byte b=127; // int bytechar c=65; // int char

Java - IV. / 54

Kifejezések kiértékelése - példák

int i=5; double d=1;

i / 2 * d d * i / 2

1

2

3

5 (int)2 (int)eredmény: 2.0(double) 1.0(double)5.0(double)eredmény: 2.5(double)

1

2

3

Java - IV. / 55

Kifejezések kiértékelése - példákbyte b=1; int i=3;(b + 2 * i++) % 2 == 0 | i == 3

1

2

6

3

4

5

7

3 (int)6 (int)7 (int)1 (int)false(boolean)false(boolean)

eredmény: false(boolean)

Java - IV. / 59

Metódusok túlterhelése

int min(int a, int b)long min(long a, long b)float min(float a, float b)double min(double a, double b)

metódus szignatúrája:

• azonosítja a metódust• metódus neve + a paraméterek száma +

paraméterek típusa (például min,int,int) túlterhelt (overloaded) metódus: ugyanolyan

nevű, de más paraméterezésű metódus

Java - IV. / 60

java.lang.Math osztály

matematikai függvények és konstansok gyűjteménye nem példányosítható, kizárólag statikus

deklarációkat tartalmaz

final double E a természetes alap

final double PI Pi értéke

Adatok (konstansok)

Java - IV. / 61

double max(double a, double b)float max(float a, float b)int max(int a, int b)long max(long a, long b)

Metódusok

double min(double a, double b) float min(float a, float b)int min(int a, int b)long min(long a, long b)

double abs(double a)float abs(float a)int abs(int a)long abs(long a)

Java - IV. / 62

double ceil(double a) // legközelebbi >= egész double floor(double a) // legközelebbi <= egész double rint(double a) // legközelebbi egész long round(double a) // legközelebbi long értékint round(float a) // legközelebbi int érték

Metódusok (folyt.)

double exp(double a) // ea

double log(double a) // e alapú logaritmusdouble sqrt(double a) // négyzetgyök adouble pow(double a, double b) // ab

double random() // véletlenszám, // 0.0 <= … <1.0.

Java - IV. / 63

double sin(double a) // a radián!double cos(double a)double tan(double a)

Metódusok (folyt.)

double toDegrees(double radian) // radián fokdouble toRadians(double degree) // fok radián

Java - IV. / 64

13. Szelekciók1. Egyágú szelekció – if

2. Kétágú szelekció – if..else

3. Egymásba ágyazott szelekciók

4. Többágú szelekciók – else if és switch

5. Független feltételek vizsgálata

Java - IV. / 65

Egyágú szelekció - if

if (feltétel)

utasítás;

if (feltétel) {

utasítás1;

utasítás2;

...

utasításN;

}A Javában minden feltételt

zárójelbe kell tenni!

[feltétel]

utasítás

[else]

Java - IV. / 66

Feladat – Következő karakterKérjünk be konzolról egy karaktert! Ha a karakter 'A' és 'Z' közé esik, akkor írjuk ki az unikód táblában őt követő karaktert, egyébként ne írjunk ki semmit!

import extra.*;public class KovKarakter {

public static void main(String[] args) {char karakter = Console.readChar("Karakter? ");if (karakter >= 'A' && karakter <= 'Z') {

karakter++;System.out.println(karakter);

}}

}

Java - IV. / 67

Kétágú szelekció - if..else

[feltétel] [else]

utasítás1 utasítás2

Java - IV. / 68

Java kód

if (feltétel)

utasítás1;

else

utasítás2;

if (feltétel) {

utasítás;

...

}

else {

utasítás;

...

}

Java - IV. / 69

Feladat – Jó szám

Kérjünk be konzolról egy valós számot! A szám akkor jó, ha 1000 és 2000 közötti páros egész (a határokat is bele-értve). Írjuk ki, hogy a szám jó, vagy nem jó!

import extra.*;public class JoSzam {

public static void main(String[] args) {double szam = Console.readDouble(”Szam: ");if (szam>=1000 && szam<=2000 &&

Math.floor(szam)==szam && szam%2==0)System.out.println("Jo szam");

elseSystem.out.println("Nem jo szam");

}}

Java - IV. / 70

Többágú szelekciók

[feltétel2] [else][feltétel1]

utasítás1 utasításNutasítás2 ...

Java - IV. / 71

Java kód: else if és switch

if (feltétel1)

utasítás1;

else if (feltétel2)

utasítás2;

...

else

utasításN;

switch (kifejezés) { case érték1: utasítások; break; case érték2: utasítások; break; ... default: utasítások;}

Java - IV. / 74

Feladat – KockaDobjunk egyet a kockával! A dobás értékétől függően a következő üzeneteket írjuk ki:1..3: Gyenge! 4: Nem rossz! 5: Egész jó! 6: Fantasztikus!Ha a dobás nem 1 és 6 között van, írjuk ki, hogy Érvénytelen dobás!

import extra.*;

public class Kocka {

… // következő dián

}

Java - IV. / 75

public static void main(String[] args) {

int dobas = Console.readInt("Dobj! 1-6: ");

switch (dobas) {

case 1:

case 2:

case 3:System.out.println("Gyenge!"); break;

case 4:System.out.println("Nem rossz!"); break;

case 5:System.out.println("Egész jó!"); break;

case 6:System.out.println("Fantasztikus!"); break;

default:System.out.println(”Érvénytelen dobás!");

}

}

Java - IV. / 78

14. Iterációk1. Elöltesztelő ciklus – while

2. Hátultesztelő ciklus – do while

3. Léptető ciklus – for

4. Ciklusok egymásba ágyazása, kiugrás a ciklusból

5. Adatok feldolgozása végjelig

6. Megszámlálás

7. Összegzés, átlagszámítás

8. Minimum- és maximumkiválasztás

9. Menükészítés

Java - IV. / 79

Elöltesztelő ciklus - while

while (feltétel)

utasítás;

while (feltétel) {

utasítás1;

utasítás2;

...

utasításN;

}[feltétel]

utasítás

Java - IV. / 80

Feladat – Bank

Van egy kis megtakarított pénzem. Arra vagyok kíváncsi,

hány hónap múlva éri el ez az összeg a bankban a 100

ezer Ft-ot, ha havi 2%-os kamatos kamattal számolhatok?

import extra.Console;

public class Bank {

… // következő dián

}

Java - IV. / 81

public static void main (String args[]) {

final int ALOMEGYENLEG = 100000;

int egyenleg = Console.readInt("Mennyi penzed van? ");

short honap = 0;

while (egyenleg < ALOMEGYENLEG) {

honap++;

egyenleg *=1.02; // ft-ra kerekités!

}

System.out.println("Tartsd bent "+honap+" honapig");

System.out.println("Utana kivehetsz "+egyenleg+" ft-ot");

}

Java - IV. / 82

Hátultesztelő ciklus - do while

do

utasítás;

while (feltétel);

do {

utasítás1;

utasítás2;

...

utasításN;

} while (feltétel);

[feltétel]

utasítás

Java - IV. / 83

Feladat – SzámbekérésKérjünk be terminálról egy számot. A számot csak akkor fogadjuk el, ha az egy naptári nap értéke, vagyis 1 és 31 közé esik! Írjuk ki minden esetben, ha a szám nem jó. (Feltételezzük, hogy a felhasználó számot üt be.)

import extra.Console;

public class SzamBeker {

… // következő dián

}

Java - IV. / 84

public static void main (String args[]) {

int szam;

boolean ok;

System.out.println("Szam (1..31)");

do {

szam = Console.readInt();

ok = szam>=1 && szam<=31; // a szám vizsgálata

if (!ok)

System.out.println("Nem jo");

} while (!ok);

System.out.println("Jo");

}

Java - IV. / 85

Léptető ciklus - for

[feltétel]

utasítás

inicializálás

léptetés

Egy vagy több ciklusváltozó minden egyes ciklus végrehajtásakor automatikusan lép egyet.

belépési feltétel elöltesztelő ciklus

Java - IV. / 86

Java kód

for (inicializálás; feltétel; léptetés)

utasítás;

for (inicializálás; feltétel; léptetés) {

utasítás1;

utasítás2;

...

utasításN;

}

Java - IV. / 88

Feladat – Angol ábécéÍrjuk ki az angol ábécé nagybetűit a konzolra szóközökkel elválasztva!

public class AngolABC {

public static void main (String args[]) {

for (char betu='A'; betu<='Z'; betu++)

System.out.print(betu+" ");

}

}

Java - IV. / 89

Feladat – Első ötÍrjuk ki 200-tól kezdve 17-esével az első 5 számot!

public class ElsoOt {

public static void main (String args[]) {

for (int i=0, szam=200; i<5; i++, szam+=17)

System.out.print(szam+" ");

}

}

Java - IV. / 92

Kiugrás a ciklusból

break kiugrás az aktuális utasításblokkból

A ciklusból való kiugrást csak nagy

elővigyázatossággal szabad alkalmazni! Fontos,

hogy a program továbbra is áttekinthető legyen!

continue ugrás az aktuális utasításblokk (ciklus) végére

Java - IV. / 93

break (kiugrás az aktuális blokkból)

for (int i=0; i<10; i++) {

for (int j=0; j<20; j++) {

if (ok)

break; // kiugrás a belső ciklusból

…

}

System.out.println("Vége a belső ciklusnak");

}

System.out.println("Vége a külső ciklusnak ");

Java - IV. / 94

break (kiugrás több blokkból egyszerre)

for (int i=0; i<10; i++) {

for (int j=0; j<20; j++) {

if (ok)

break tovabb;// kiugrás a ciklusból a tovabb cimkére

…

}

System.out.println("Vége a belső ciklusnak");

}

tovabb:

System.out.println("Vége a külső ciklusnak ");

Java - IV. / 95

continue (ugrás az aktuális ciklus végére)

for (int i=0; i<10; i++) {

for (int j=0; j<20; j++) {

if (ok)

continue; // folytatás a ciklusváltozó köv. értékével

…

}

System.out.println("Vége a belső ciklusnak");

}

System.out.println("Vége a külső ciklusnak ");

Java - IV. / 113

15. Metódusok írása1. A metódus fogalma, szintaktikája

2. Paraméterátadás

3. Visszatérés a metódusból

4. Metódusok túlterhelése

5. Lokális változók

6. Néhány példa

7. Hogyan tervezzük meg metódusainkat?

Java - IV. / 114

A metódus fogalma, szintaktikája

Feladat – MetódusmintaKérjünk be számokat a konzolról 0 végjelig! Minden egyes számról állapítsuk meg, hogy az hány jegyű! A program elején és végén, valamint az egyes eredmények kiírása után húzzunk egy-egy 20 hosszúságú vonalat!

Java - IV. / 115

Nagyvonalú terv (pszeudokód)

adatok: szám, jegyek száma

vonalhúzás

in: szám

while szam != 0

jegyek számának kiszámítása és kiírása

vonalhúzás

in: szám

end while

vonalhúzás

Java - IV. / 116

import extra.*;

public class MetodusMinta {

public static void main(String[ ] args) {

vonalhuz();

int szam;

while ((szam=Console.readInt("Szam: ")) != 0) {

System.out.println("Jegyek szama:

"+jegyekSzama(szam));

vonalhuz();

}

vonalhuz();

}

A metódus utasítások összessége,melyet meghívhatunk a nevére valóhivatkozással.

Java - IV. / 117

függvény

eljárásstatic void vonalhuz() {

for (int i=1; i<=20; i++)System.out.print('-');

System.out.println(); }

static int jegyekSzama(int n) {int result = 0; do {

n /= 10; result++;

} while (n !=0); return result;

}}

A metódusok deklarálási sorrendje tetszőleges!

Java - IV. / 118

A MetodusMinta osztály UML ábrája

MetodusMinta

+main(args: String[])

vonalhuz()

jegyekSzama(n: int): int

Java - IV. / 119

Metódusfej

A metódus általános szintaxisa

[<módosítók>] <visszatérési típus> <metódus neve>

( [<formális paraméterlista>] ) [<throws ...>]

{

<metódusblokk>

}A szögletes zárójelek közötti részeket nem kötelező megadni. A Javában csak érték szerinti paraméterátadás van. Fordítási hibák:

• függvénynél: van return nélküli ág• lokális változó nincs inicializálva

Java - IV. / 120

Példák

Módosítók Visszat. típus Név Paraméterek

public void print (float f)

public static int min (int a, int b)

void vonalhuz()

private int minChar(char c1,char c2)

Módosítók:

• public, protected vagy private: láthatóság• abstract: absztrakt metódus• final: végleges metódus• static: statikus, vagyis osztálymetódus

Java - IV. / 121

Aktuális paraméter

Formális paraméter

static int jegyekSzama( int n ) {int result = 0; do {

n /= 10; result++;

} while (n !=0); return result ;

}…

System.out.println("Jegyek szama:"+jegyekSzama(szam));…

Értékadás szerintikompatibilitás!

n=szam

Paraméter, lokális változó, visszatérés

lokális változó

Java - IV. / 124

Metódusok túlterhelése

int min(int a, int b)long min(long a, long b)

Metódus szignatúrája:

• azonosítja a metódust• metódus neve + a paraméterek száma +

paraméterek típusa (például min,int,int)• a visszatérési típus nem tartozik a szignatúrához!

Túlterhelt (overloaded) metódus: ugyanolyan nevű, de más paraméterezésű metódus

Java - IV. / 125

Feladat – Metódusminta2Kérjünk be számokat a konzolról 0 végjelig! Minden egyes számról állapítsuk meg, hogy az hány jegyű! Húzzunk

a program elején egy 50 hosszú és @ karakterekből álló,

a program végén egy 50 hosszú és nevető fejecskékből álló, valamint

az egyes eredmények kiírása után egy-egy 20 hosszúságú és mínusz karakterekből álló vonalat!

Java - IV. / 126

import extra.*;public class MetodusMinta2 {

static void vonalhuz() {vonalhuz(20,'-');

}

static void vonalhuz(int hossz) {vonalhuz(hossz,'-');

}

static void vonalhuz(int hossz, char ch) {for (int i=1; i<=hossz; i++)

System.out.print(ch);System.out.println();

}

Java - IV. / 127

static int jegyekSzama(int n) {

// …

}

public static void main(String[] args) {

vonalhuz(50,'@');

int szam;

while ((szam=Console.readInt("Szam: ")) != 0) {

System.out.println("Jegyek szama: ” + jegyekSzama(szam));

vonalhuz();

}

vonalhuz(50,'\u0002'); // nevető fejecskék

}

}

Az a metódus fog futni, melynekformális paraméterezésemegfelel a hívásnak!