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!