V. Osztályok használata, készítése

Az előadások a következő témára: "V. Osztályok használata, készítése"— Előadás másolata:

1 V. Osztályok használata, készítése
16. Objektumok, karakterláncok, csomagolók 17. Osztály készítése

2 V. Osztályok használata, készítése
16. Objektumok, karakterláncok, csomagolók 1. A fejezet osztályainak rendszerezése 2. Primitív típus - referenciatípus 3. Objektum létrehozása, deklarálása 4. Értékadás az objektumok körében 5. Az objektum élete, automatikus szemétgyűjtés 6. String osztály 7. StringBuffer osztály 8. Objektum átadása paraméterként 9. Primitív típusok csomagolása 10. StringTokenizer osztály

3 A fejezet osztályainak rendszerezése
Java API: kb osztály A java.lang csomag legfontosabb osztályai: java.lang Byte Short Integer Long Float Double Object Boolean Character Number Math System String StringBuffer

4 Az Object osztály Minden osztály közös őse
Bármely osztályból létrehozott példány “az egy” objektum A Java minden objektumára jellemző metódusokat tartalmaz. Például: boolean equals(Object obj) String toString() Class getClass()

5 Az Object osztály leszármazottai
Csomagoló osztályok Boolean, Character, Byte, Short, Integer, Long, Float, Double Math osztály Matematikai konstansok és függvények System osztály exit() in, out objektumok String, StringBuffer

6 Primitív típus – referenciatípus
8 primitív típus: boolean, char, byte, short, int, long, float, double A változó azonosítójával közvetlenül hivatkozunk a változó memóriahelyére A deklaráló utasítás végrehajtása: memória foglalás A programozó nem definiálhat primitív típust

7 Közvetlen (direkt) címzés
Memória 52142. 52143. 52144. 52145. eletkor 12 Memóriacímek byte eletkor=12; Itt az adat!

8 Referenciatípus Objektumra mutat
A változó azonosítójával az objektum memóriahelyére közvetve hivatkozunk egy referencián (hivatkozáson) keresztül A hivatkozás rejtve marad (automatikus indirekció)

9 Közvetett (indirekt) címzés
Ember ember = new Ember("Erika",1953); Memória 35282. 35283. 35284. ember Memóriacímek 82345. 82345 "Erika",1953 ember objektum címe ember.megy(); Automatikus indirekció!

10 A null referencia Referencia típusú konstans Foglalt szó
Értéke: a nulla cím Nem mutat semmire, nem hivatkozik objektumra Például: ember = null; ember null

11 new <OsztályAzonosító>(<aktuális paraméterlista>)
Objektum létrehozása new <OsztályAzonosító>(<aktuális paraméterlista>) Példányosítás Memóriafoglalás Konstruktorhívás (a megfelelő szignatúrájú)  Beállítja az objektum kezdeti állapotát adatok kapcsolatok Visszaadja az új objektum referenciáját A létrehozásnak nem feltétele a deklarálás!

12 Objektum deklarálása <OsztályAzonosító> objektum;
Az objektum egy referencia típusú változó Memóriafoglalás: csak a referencia részére Az objektum létrehozása a programozó feladata <OsztályAzonosító> objektum; objektum=new <OsztályAzonosító>(<aktuális paraméterlista>); <OsztályAzonosító> objektum = new <OsztályAzonosító>(<aktuális paraméterlista>);

13 Példa: String objektum létrehozása
new String("Pirkadat") String +String(value: String) +toUpperCase(): String +toString(): String ... szöveg: String "Pirkadat" toUpperCase() String szoveg; szoveg = new String("Pirkadat"); System.out.println(szoveg.toUpperCase()); // PIRKADAT System.out.println(szoveg); // Pirkadat

14 Értékadás az objektumok körében
String ember1 = new String("Timea"); //1 String ember2 = new String("Roland"); //2 Object obj; String ember3; ember1 = ember2; //3 obj = ember1; //4 // ember1 = obj; Szintaktikai hiba! obj általánosabb! // ember1 = ember3; Szintaktikai hiba! ember3-nak // nincs értéke!

15 ember1 :String "Timea" "Roland" ember2 ember3 obj String Object //1 //2 //3 //4

16 Objektumok egyenlőségvizsgálata
String s1 = new String("Hello"), s2 = new String("Hello"); System.out.println((s1==s2)?"Azonosak":"Nem azonosak"); System.out.println((s1.equals(s2))?"Egyenlok":"Nem egyenlok"); Nem azonosak Egyenlok

17 Az objektum élete, automatikus szemétgyűjtés
ember1 = new String("Gábor"); ember1 = new String("Anikó"); ember1 :String "Anikó" "Gábor"

18 String osztály K é z s ! 1 3 2 4 Értéke egész élete során állandó
1 3 2 4 Értéke egész élete során állandó Unikód karakterek sorozata String szoveg=new String(”Kész!"); String szoveg=”Kész!"; // optimalizáció

19 String osztály (folyt.)
Konstruktorok String() String(value: String) String(buffer: StringBuffer) Hossz, index length(): int charAt(index: int): char

20 String osztály (folyt.)
Manipulált karakterláncok toLowerCase(): String toUpperCase(): String toString(): String trim(): String replace(oldChar: char, newChar: char): String substring(beginIndex: int): String substring(beginIndex: int, endIndex: int): String

21 String osztály (folyt.)
Egyenlőségvizsgálat, hasonlítás equals(anObject: Object): boolean equalsIgnoreCase(anotherString: String): boolean compareTo(o: Object): int compareTo(str: String): int compareToIgnoreCase(str: String): int Konkatenálás concat(str: String): String

22 String osztály (folyt.)
Keresések indexOf(ch: int): int indexOf(ch: int, fromIndex: int): int indexOf(str: String): int indexOf(str: String, fromIndex: int): int Karakterláncformák valueOf(value: Type): String valueOf(value: type): String Kivételek StringIndexOutOfBoundsException NullPointerException

23 public class StringTeszt { public static void main(String[] args) {
Feladat – StringTeszt Kérjünk be terminálról egy szöveget, majd: 1) Írjuk ki fordítva! 2) Írjuk ki csupa nagybetűvel, aztán csupa kisbetűvel! 3) Írjuk ki az első 9 karakterét és az utolsó 3 karakterét! 4) Cseréljük ki az összes szóközt kötőjelre! import extra.*; public class StringTeszt { public static void main(String[] args) { // következő dián }

24 String szoveg = Console.readLine("Szöveg: ");
for (int i=szoveg.length()-1; i>=0; i--) //1 System.out.print(szoveg.charAt(i)); System.out.println(); System.out.println(szoveg.toUpperCase()); //2 System.out.println(szoveg.toLowerCase()); if (szoveg.length()>=9) //3 System.out.println(szoveg.substring(0,9)); if (szoveg.length()>=3) System.out.println(szoveg.substring(szoveg.length()-3)); System.out.println(szoveg.replace(' ','-')); //4

25 StringBuffer osztály Konstruktorok Kapacitás, hossz, index
StringBuffer(length: int) StringBuffer(str: String) Manipulálható szöveg Kapacitás, hossz, index capacity(): int length(): int ensureCapacity(minimumCapacity: int) setLength(newLength: int) charAt(index: int): char

26 StringBuffer osztály (folyt.)
Bővítés append (value: <Type>): StringBuffer append (value: <type>): StringBuffer insert (offset: int, value: <Type>): StringBuffer insert (offset: int, value: <type>): StringBuffer Törlés deleteCharAt(index: int): StringBuffer delete(start: int, end: int): StringBuffer

27 StringBuffer osztály (folyt.)
Egyéb setCharAt(index: int, ch: char) replace(start: int, end: int, str: String): StringBuffer reverse(): StringBuffer substring(start: int): String substring(start: int, end: int): String toString(): String

28 StringBuffer hegy1 = new StringBuffer("Machu"); //1
StringBuffer hegy2 = hegy1.append(" Picchu"); //2 hegy2.insert(0,"Ez is "); //3 hegy1 :StringBuffer "Machu" //1 hegy1 hegy2 :StringBuffer "Machu Picchu" //2 hegy1 hegy2 :StringBuffer "Ez is Machu Picchu" //3

29 Feladat – Csere Olvassunk be egy szöveget, majd cseréljük ki az összes & jelet az and szóra! import extra.*; public class Csere { public static void main(String[] args) { // következő dián }

30 StringBuffer szoveg = new StringBuffer(Console.readLine("Szoveg: ")); //1 int poz = szoveg.toString().indexOf('&'); //2 while (poz!=-1) { szoveg.replace(poz,poz+1,"and"); //3 poz = szoveg.toString().indexOf('&'); //4 } System.out.println(szoveg); //5

31 Objektum átadása paraméterként
Feladat – Objektum paraméter Írjunk egy olyan eljárást, amely a paraméterként megkapott szöveget széthúzza, vagyis minden karaktere után beszúr egy szóközt! import extra.*; public class ObjektumParameter { //következő dián }

32 Értékadás szerinti kompatibilitás!
static void szethuz(StringBuffer str) { for (int i=str.length()-1; i>0; i--) str.insert(i,' '); str = null; // csak demonstrációs célú utasítás } public static void main(String[] args) { StringBuffer sb = new StringBuffer("Peace"); szethuz(sb); System.out.println("*"+sb+"*"); //  "*P e a c e*" Értékadás szerinti kompatibilitás! Csak a referencia másolódik át!

33 A metódusba való belépéskor: A metódusból való kilépés előtt:
:StringBuffer "Peace" str sb "P e a c e" null A metódusba való belépéskor: A metódusból való kilépés előtt: A metódus csak a mutatott objektumot változtathatja meg, a referenciát nem!

34 Primitív típusok csomagolása
Célok: Primitív típusú változók objektumként kezelése Primitív típusokkal kapcsolatos információk lekérdezése Minden primitív típushoz tartozik egy csomagoló osztály: Character, Boolean, Byte, Short, Integer, Long, Float, Double A csomagoló osztályok példányai változtathatatlanok!

35 Konstruktorok Példánymetódusok
<Type> (<type> value) Például: Character cObj = new Character('A'); <Type> (String s) Például: Boolean bObj = new Boolean("True"); Példánymetódusok String toString() Például: Double dObj = new Double(6099.8); String s = dObj.toString(); //s=="6099.8”

36 Példánymetódusok (folyt.)
<type> <type>Value() Például: Integer iObj = new Integer(30); int i = iObj.intValue(); // i==30 double d = iObj.doubleValue(); // d==30.0 Példánymetódusok (folyt.) boolean equals(Object obj) Például: Integer iObj = new Integer(30), jObj = new Integer(30); if (iObj.equals(jObj)) … // true if (iObj.equals("30")) … // false, más osztály

37 Statikus metódusok Boolean osztály
static <Type> valueOf(String s) Például: Integer iObj, jObj; iObj = Integer.valueOf("30"); jObj = Integer.valueOf("45D"); //NumberFormatException! Boolean osztály static final Boolean TRUE = new Boolean(true); static final Boolean FALSE = new Boolean(false);

38 Character osztály static final char MIN_VALUE = '\u0000'; static final char MAX_VALUE = '\uffff'; static boolean isUpperCase(char ch) static boolean isLowerCase(char ch) static boolean isDigit(char ch) static boolean isLetter(char ch) static boolean isSpaceChar(char ch) static boolean isWhitespace(char ch) static char toUpperCase(char ch) static char toLowerCase(char ch)

39 Feladat – Milyen karakter?
Kérjünk be karaktereket '-' végjelig! Állapítsuk meg minden egyes karakterről, hogy az szám, betű (azon belül kisbetű vagy nagybetű), szóköz, fehér szóköz vagy egyéb! import extra.*; public class MilyenKarakter { public static void main(String[] args) { //következő dián }

40 char kar = Console.readChar("Karakter:");
while (kar != '-') { if (Character.isDigit(kar)) System.out.println("szam"); else if (Character.isLetter(kar)) { if (Character.isUpperCase(kar)) System.out.println("nagybetu"); else System.out.println("kisbetu"); } else if (Character.isSpaceChar(kar)) System.out.println("szokoz"); else if (Character.isWhitespace(kar)) System.out.println("fehér szokoz"); System.out.println("egyeb"); kar = Console.readChar("Karakter:");

41 Numerikus csomagoló osztályok
static final <type> MIN_VALUE = <a típusnak megfelelő érték>; static final <type> MAX_VALUE = <a típusnak megfelelő érték>; Például: System.out.println(Byte.MIN_VALUE); static <type> parse<Type>(String s) Például: int i = Integer.parseInt("50"); // i==50

42 StringTokenizer osztály
Cél: szöveg egységekre bontása elválasztó karakterekkel Egység = token Elválasztó karakterek = delimiterek alapértelmezés: fehér szóközök megadható java.util java.lang::Object StringTokenizer delimiterek 2 * 3 a z n é h 5 ! tokenek

43 Konstruktorok Metódusok
StringTokenizer(String str, String delim, boolean returnTokens) StringTokenizer(String str, String delim) StringTokenizer(String str) Metódusok boolean hasMoreTokens() String nextToken() String nextToken(String delim) int countTokens()

44 Feladat – Szavak Kérjünk be egy mondatot! Írjuk ki, hány szó van benne, majd írjuk ki a szavakat is természetes sorszámmal ellátva (1-től), mindegyiket külön sorba! import extra.*; import java.util.*; public class Szavak { public static void main(String[] args) { //következő dián }

45 String mondat = Console.readLine("Mondat: ");
StringTokenizer st = new StringTokenizer(mondat); System.out.println("Szavak szama: "+st.countTokens()); int sorszam = 0; while (st.hasMoreTokens()) System.out.println(++sorszam+": "+st.nextToken());

46 V. Osztályok használata, készítése
17. Osztály készítése 1. OO paradigma - Emlékeztető 2. Első mintaprogram - Raktárprogram 3. Második mintaprogram - Bank és a “Jószerencse” 4. Az osztály felépítése, az osztály deklarációi 5. Osztálytag, példánytag 6. Azonosító, hivatkozási kör, takarás 7. Változók alapértelmezés szerinti kezdeti értékei 8. A this objektumreferencia 9. Konstruktorok 10. Inicializálók

47 OO paradigma - Emlékeztető
Példánydeklaráció: példányváltozó, példánymetódus Osztálydeklaráció: osztályváltozó, osztálymetódus Objektumok, osztályok sztereotípusai: információhordozó, határ, kontroll, konténer Objektumdiagram, osztálydiagram, együttműködési diagram Két osztály közötti egy-egy kapcsolat Láthatóság: nyilvános (+), védett (#), privát (-)

48 Az Osztály felépítése [<módosítók>] class <OsztályAzon>
Osztály feje [<módosítók>] class <OsztályAzon> [extends <OsztályAzon>] [implements <InterfészAzon>[, <InterfészAzon> ... ]] { <osztály blokk (az osztály deklarációi)> } Példák public class JoSzerencse public class Bank public final class String implements java.io.Serializable,Comparable Módosítók public abstract final

49 Az osztály deklarációi
Osztályváltozó Osztálymetódus Példányváltozó Példánymetódus Osztálytag Példánytag Osztály- inicializáló blokk Konstruktor Példány- inicializáló Belső osztály Osztály szintű deklaráció Ajánlott deklarálási sorrend: változók, kapcsolatok konstruktorok metódusok (get/set/main)

50 A tagok módosítói Hozzáférési módosítók public protected private
alapértelmezés: csomag Egyéb módosítók static final abstract (metódus)

51 Feladat – Raktárprogram
Adott egy zöldségraktár, melyben pillanatnyilag egyetlen árut, paradicsomot raktározunk. A raktárba gyakran teszünk be, illetve veszünk ki onnan paradicsomot. A paradicsom pillanatnyi egységára 300 Ft, de ez változhat. Készítsünk olyan programot, mely segítségével rögzíteni tudjuk a megfelelő adatokat, és bármikor jelentést tudunk adni a paradicsom aktuális mennyiségéről, egységáráról és értékéről! Végezzük el a következő akciókat: Tegyünk a raktárba 125 kg paradicsomot, aztán vegyünk ki 25 kg-ot, majd szállítsuk le a paradicsom egységárát 210 Ft-ra! Mindhárom akció után írjuk ki, mennyi paradicsom van raktáron és milyen értékben!

52 7: setEgysegar(aEgysegar)
Együttműködési diagram RaktarProgram aru:Aru program: 2: RaktarProgram() 4: akciok() 3: Aru(aNev,aEgysegar) 5: hozzatesz(aMenny) 6: elvesz(aMenny) 7: setEgysegar(aEgysegar) 1: main(args)

53 Osztálydiagram Aru -nev: String -egysegar: double -menny: double
RaktarProgram +RaktarProgram() +akciok() +main(args) -aru -nev: String -egysegar: double -menny: double Aru +Aru(aNev:String,aEgysegar:double) +getNev(): String +getEgysegar(): double +setEgysegar(aEgysegar:double) +getMenny(): double +getAr(): double +hozzatesz(aMenny:double) +elvesz(aMenny:double) +toString(): String

54 Példányváltozók Konstruktor class Aru { private String nev;
private double egysegar; private double menny; public Aru(String aNev, double aEgysegar) { nev = aNev; egysegar = aEgysegar; menny = 0; } public String getNev() { return nev; Példányváltozók Konstruktor

55 public double getEgysegar() {
return egysegar; } public void setEgysegar(double aEgysegar) { if (aEgysegar >= 0) egysegar = aEgysegar; public double getMenny() { return menny; public double getAr() { return menny*egysegar;

56 public void hozzatesz(double aMenny) {
if (aMenny>0) menny += aMenny; } public void elvesz(double aMenny) { if (aMenny>0 && aMenny<=menny) menny -= aMenny; public String toString() { return nev+"\tEgysegar: "+egysegar+ "\tMenny: "+menny+"\tAr: "+getAr();

57 Kapcsolat public class RaktarProgram { private Aru aru;
public RaktarProgram() { aru = new Aru("Paradicsom",300); } public void akciok() { aru.hozzatesz(125); System.out.println(aru); aru.elvesz(25); aru.setEgysegar(210); Kapcsolat

58 Objektum létrehozása saját osztályából
public static void main(String[] args) { RaktarProgram program = new RaktarProgram(); program.akciok(); } Objektum létrehozása saját osztályából program: RaktarProgram main() RaktarProgram RaktarProgram() akciok()

59 Feladat – Bank Az OTP bank “Jószerencse” fantázianevű befektetési jegyeket forgalmaz. Egy ügyfél számlát nyithat ehhez a befektetési formához, majd vásárolhat vagy eladhat befektetési jegyeket. A számla nyitásakor meg kell adni a számlatulajdonos nevét, és megadható a kedvezményezett neve is (azé, aki örökli a számlát). Az induló összeg a számla nyitásakor nulla. A befektetési jegynek árfolyama van; a vásárlás és az eladás mindig az aktuális árfolyamon történik. Vásárláskor 200 Ft, eladáskor 400 Ft kezelési költséget kell fizetni. Készítsünk olyan programot, amely a bank “Jószerencse” befektetési jegyeinek forgalmazását szimulálja! Két ügyfél nyisson számlát, majd menüből választhatóan vásároljanak és adjanak el az ügyfelek befektetési jegyeket, és lehessen az árfolyamot is változtatni!

60 Együttműködési diagram
Bank() menu() JoSzerencse("Arany Dániel") vasarlas(10000) eladas(50000) main() Bank :JoSzerencse szamla1 otp:Bank :JoSzerencse ügyfél szamla2 ugyfelKiszolgalas(szamla) jelentes() getArfolyam() setArfolyam(...) JoSzerencse jegyDb(...) ertek(...)

61 Osztálydiagram JoSzerencse -utolsoSzamlaSzam: long = 10000
2 <<Információhordozó>> JoSzerencse -utolsoSzamlaSzam: long = 10000 -arfolyam: double = 1.03 -vasarKezKoltseg, eladKezKoltseg: int -szamlaSzam: long -tulajdonos, kedvezmenyezett: String -jegyDb: long +JoSzerencse (tulajdonos, kedvezmenyezett) +JoSzerencse (tulajdonos) +getArfolyam(): double +setArfolyam(arf) +jegyDb(ertek): long +ertek(jegyDb): long +getJegyDb(): long +ertek(): long +vasarlas(osszeg): long +eladas(osszeg): long +toString(): String <<Kontroll>> Bank +Bank() +ugyfelKiszolgalas(jo) +jelentes() +menu() +main(...) Osztálydiagram

62 Osztály- változók Példány- változók import extra.*;
class JoSzerencse { private static long utolsoSzamlaSzam = 10000; private static double arfolyam = 1.03; private static int vasarKezKoltseg = 200; private static int eladKezKoltseg = 400; private long szamlaSzam; private String tulajdonos, kedvezmenyezett; private long jegyDb; Osztály- változók Példány- változók

63 Konstruktor túlterhelése
public JoSzerencse(String tulajdonos,String kedvezmenyezett) { szamlaSzam = ++utolsoSzamlaSzam; this.tulajdonos = tulajdonos; this.kedvezmenyezett = kedvezmenyezett; jegyDb = 0; } public JoSzerencse(String tulajdonos) { this(tulajdonos,""); Konstruktor túlterhelése másik konstruktor hívása

64 Osztály- metódusok public static double getArfolyam() {
return arfolyam; } public static void setArfolyam(double arf) { if (arf >= 0) arfolyam = arf; Osztály- metódusok

65 Osztálymetódusok Példánymetódusok
public static long jegyDb(long ertek) { return (long)(ertek/arfolyam); } public static long ertek(long jegyDb) { return (long)(jegyDb*arfolyam); public long getJegyDb() { return jegyDb; public long ertek() { return ertek(jegyDb) ; Osztálymetódusok Példánymetódusok

66 Példánymetódus osztályváltozóra hivatkozik
public long vasarlas(long osszeg) { long db = jegyDb(osszeg); jegyDb += db; return ertek(db)+vasarKezKoltseg; // a befizetendõ összeg } public long eladas(long osszeg) { jegyDb -= db; return ertek(db)-eladKezKoltseg; // a kifizetendõ összeg Példánymetódus osztályváltozóra hivatkozik

67 public String toString() {
return "Szamlaszam: "+szamlaSzam+ " Tulajd.: "+Format.left(tulajdonos,15)+ " Kedv.: "+Format.left(kedvezmenyezett,15)+ " Jegyszam: "+Format.right(jegyDb,8)+ " Ertek: "+Format.right(ertek(),8); } } // JoSzerencse

68 Kapcsolatok public class Bank { JoSzerencse szamla1, szamla2;
public Bank() { szamla1 = new JoSzerencse("Arany Daniel", "Ezust Hajnalka"); szamla2 = new JoSzerencse("Fejer Lipot"); } Kapcsolatok

69 public void ugyfelKiszolgalas(JoSzerencse szamla) {
long osszeg; System.out.println("\n"+szamla); char valasz; do { valasz = Character.toUpperCase (Console.readChar("V(asarlas)/E(ladas)")); } while (valasz!='V' && valasz != 'E'); if (valasz == 'V') { osszeg=szamla.vasarlas(Console.readInt("Mennyiert vasarol?")); System.out.println("Befizetendo: "+osszeg+" ft"); } else { osszeg = szamla.eladas(Console.readInt("Mennyiert ad el? ")); System.out.println("Kifizetendo: "+osszeg+" ft");

70 public void jelentes() {
System.out.println("\n* - * - * - JELENTES - * - * - *"); System.out.println("Arfolyam: "+JoSzerencse.getArfolyam()); System.out.println(szamla1); System.out.println(szamla2); } public void menu() { char valasz; do { jelentes(); System.out.println("\n1. ugyfel kiszolgalasa"); System.out.println("2. ugyfel kiszolgalasa"); System.out.println("3: Arfolyam modositas "); System.out.print ("V: Vege "); valasz = Character.toUpperCase(Console.readChar());

71 switch (valasz) { case '1': { ugyfelKiszolgalas(szamla1); break; } case '2': { ugyfelKiszolgalas(szamla2); case '3': { JoSzerencse.setArfolyam( Console.readDouble("Uj arfolyam:")); } while (valasz!='V');

72 Objektum létrehozása saját osztályából
public static void main(String[] args) { Bank otp = new Bank(); otp.menu(); } } // Bank Objektum létrehozása saját osztályából otp:Bank main() Bank Bank() menu()

73 Hivatkozási kör class JoSzerencse { int joSzerencse;
int joSzerencse = this.joSzerencse; return joSzerencse; } … Példányváltozó Lokális változó

74 Takarás class Proba { int szam=1; static char kar='A'; void proba() {
int szam=2; char kar='B'; System.out.println(szam); //  2 System.out.println(this.szam); //  1 System.out.println(kar); //  B System.out.println(Proba.kar); //  A }

75 A this objektumreferencia
Példánymetódusok utolsó, rejtett paramétere A megszólított objektum referenciája public long vasarlas(long osszeg, JoSzerence this) { long db = jegyDb(osszeg); this.jegyDb += db; return ertek(db)+vasarKezKoltseg; }

76 Konstruktor Beállítja az objektum kezdeti állapotát adatok kapcsolatok
Hasonlít a metódushoz, de nincs visszatérési értéke Neve megegyezik az osztály nevével Csak a new-val hívható Csak a hozzáférési módosítók használhatók Túlterhelhető Nem öröklődik

77 Alapértelmezés szerinti konstruktor
Nincs (explicit) konstruktor  egy alapértelmezés szerinti (implicit) konstruktor fut le paraméter nélküli adatok, kapcsolatok alapértelmezések  nullaszerű kezdőértékek: false, ’\u0000’, 0, null Van legalább 1 (explicit) konstruktor  nincs alapértelmezés szerinti konstruktor

78 Inicializálók class Tanulo2 { static int alapTandij;
double atlag; int tandij; static { alapTandij = 2000; } { atlag = Console.readDouble("Atlag: "); tandij = alapTandij (int)Math.round(3000*(5-atlag)); } // … Osztályinicializáló blokk Inicializáló kifejezés Példányinicializáló blokk

79 Az inicializálás sorrendje
Osztályadatok (osztály betöltésekor) alapértelmezés szerinti értékek osztályinicializáló kifejezések osztályinicializáló blokkok Objektum adatai (objektum születésekor) alapértelmezés szerinti értékek példányinicializáló kifejezések példányinicializáló blokkok konstruktor(ok)