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

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

A fejezet osztályainak rendszerezése Java API: kb. 2000 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

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()

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

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

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

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ó)

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ó!

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

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!

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>);

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

É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!

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

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

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

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ó

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

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

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

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

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 }

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

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

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

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

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

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 }

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

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 }

É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!

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!

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!

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”

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

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);

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)

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 }

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:");

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

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

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()

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 }

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());

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

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 (-)

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

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)

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)

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!

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)

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

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

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;

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();

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

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()

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!

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(...)

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

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

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

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

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

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

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

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

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");

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());

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

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()

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

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 }

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; }

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

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

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

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)