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

Gábor Dénes Főiskola (IAI)

A programozás alapjai (Java) - V. / 1

16. Objektumok, karakterláncok,

csomagolók

17. Osztály készítése



16. Objektumok, karakterláncok, csomagolók

1. A fejezet osztályainak rendszerezése2. Primitív típus - referenciatípus3. Objektum létrehozása, deklarálása4. Értékadás az objektumok körében5. Az objektum élete, automatikus szemétgyűjtés6. String osztály7. StringBuffer osztály8. Objektum átadása paraméterként9. Primitív típusok csomagolása10. 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

Primitív típus

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!



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

Referenciatípus



Közvetett (indirekt) címzés

Memória

35282.

35283.

35284.ember

Memóriacímek

82345.

82345

"Erika",1953

ember objektum címe

ember.megy();Automatikus indirekció!

Ember ember = new Ember("Erika",1953);



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



Objektum létrehozása

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

new <OsztályAzonosító>(<aktuális paraméterlista>)

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



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

Példa: String objektum létrehozása



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

:String

"Roland"

ember2

ember3

objString

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 azonosakEgyenlok



ember1 = new String("Gábor");

ember1 = new String("Anikó");

ember1

:String

"Anikó"

:String

"Gábor"

Az objektum élete,automatikus szemétgyűjtés



String osztály

Értéke egész élete során állandó Unikód karakterek sorozata

String szoveg=new String("Kész!");

String szoveg="Kész!"; // optimalizáció

K é zs !

0 1 32 4



String osztály (folyt.)

Konstruktorok

• String()

• String(value: String)

• String(buffer: StringBuffer)

Hossz, index

• length(): int

• charAt(index: int): char




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




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



Feladat – StringTesztKé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

• StringBuffer()• 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 – CsereOlvassunk be egy szöveget, majd cseréljük ki az összes & jelet az and szóra!

import extra.*;

public class Csere {


// 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

}



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

}


StringBuffer sb = new StringBuffer("Peace");

szethuz(sb);

System.out.println("*"+sb+"*"); // "*P e a c e*"

}

Értékadás szerintikompatibilitás!

Csak a referencia másolódik át!



:StringBuffer

"Peace"

str

sb

:StringBuffer

"P e a c e"

str

sb

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



<type> <type>Value()Például:Integer iObj = new Integer(30);int i = iObj.intValue(); // i==30double d = iObj.doubleValue(); // d==30.0

boolean equals(Object obj)Például:Integer iObj = new Integer(30), jObj = new Integer(30);if (iObj.equals(jObj)) … // trueif (iObj.equals("30")) … // false, más osztály

Példánymetódusok (folyt.)



Statikus metódusok 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 {


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

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



17. Osztály készítése1. OO paradigma - Emlékeztető2. Első mintaprogram - Raktárprogram3. Második mintaprogram - Bank és a “Jószerencse”4. Az osztály felépítése, az osztály deklarációi5. Osztálytag, példánytag6. Azonosító, hivatkozási kör, takarás7. Változók alapértelmezés szerinti kezdeti értékei8. A this objektumreferencia9. Konstruktorok10. 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 (-)



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

}

Az osztály felépítése

Módosítók• public• abstract• final

Példákpublic class JoSzerencsepublic class Bankpublic final class String implements

java.io.Serializable,Comparable



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ó

blokk

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árprogramAdott 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!



Együttműködési diagram

RaktarProgram aru:Aruprogram:

RaktarProgram

2: RaktarProgram()4: akciok()

3: Aru(aNev,aEgysegar)5: hozzatesz(aMenny)

6: elvesz(aMenny)7: setEgysegar(aEgysegar)

1: main(args)



Osztálydiagram

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



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



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); System.out.println(aru); aru.setEgysegar(210); System.out.println(aru); }

Kapcsolat



public static void main(String[] args) { RaktarProgram program = new RaktarProgram(); program.akciok(); }}

Objektum létrehozásasaját osztályából

program:RaktarProgram

main()RaktarProgram

RaktarProgram() akciok()



Feladat – BankAz 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

:JoSzerencse

otp:Bank

JoSzerencse("Arany Dániel") vasarlas(10000)eladas(50000)

main()

:JoSzerencse

szamla1

szamla2ugyfelKiszolgalas(szamla)jelentes()

ügyfél

Bank

JoSzerencse

Bank() menu()

getArfolyam()setArfolyam(...)

jegyDb(...)ertek(...)



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



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;

Példány-változók

Osztály-változók



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



public static double getArfolyam() {

return arfolyam;

}

public static void setArfolyam(double arf) {

if (arf >= 0)

arfolyam = arf;

}

Osztály-metó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ódusosztá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

}



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



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

}case '3': {

JoSzerencse.setArfolyam(Console.readDouble("Uj arfolyam:"));

break;}

}} while (valasz!='V');

}




Bank otp = new Bank();

otp.menu();

}

} // Bank

Objektum létrehozásasaját osztályából

otp:Bankmain()

Bank

Bank() menu()



class JoSzerencse {

int joSzerencse;

int joSzerencse() {

int joSzerencse = this.joSzerencse;

return joSzerencse;

}

…

}

Hivatkozási kör

Lokális változó

Példányváltozó



Takarás

class Proba {int szam=1;static char kar='A';void proba() {

int szam=2; char kar='B';System.out.println(szam); // 2System.out.println(this.szam); // 1System.out.println(kar); // BSystem.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) {


this.jegyDb += db;

return ertek(db)+vasarKezKoltseg;

}



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

Konstruktor



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



Példányinicializáló blokk

Inicializáló kifejezés

Osztályinicializáló blokk

class Tanulo2 {static int alapTandij;double atlag; int tandij;static {

alapTandij = 2000;}{

atlag = Console.readDouble("Atlag: ");tandij = alapTandij +

(int)Math.round(3000*(5-atlag));} // …

}

Inicializálók



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)

Documents

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