Transcript 5Osztalyok_Java

16. Objektumok, karakterláncok,
csomagolók
17. Osztály készítése
Java - V. / 1
16. Objektumok, karakterláncok,
csomagolók
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
A fejezet osztályainak rendszerezése
Primitív típus - referenciatípus
Objektum létrehozása, deklarálása
Értékadás az objektumok körében
Az objektum élete, automatikus szemétgyűjtés
String osztály
StringBuffer osztály
Objektum átadása paraméterként
Primitív típusok csomagolása
StringTokenizer osztály
Java - V. / 2
A fejezet osztályainak rendszerezése
 Java API: kb. 2000 osztály
 A java.lang csomag legfontosabb osztályai:
java.lang
Object
Boolean Character Number Math System String StringBuffer
Byte Short Integer Long Float Double
Java - V. / 3
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()
Java - V. / 4
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
Java - V. / 5
Primitív típus – referenciatípus
Primitív tí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
Java - V. / 6
Közvetlen (direkt) címzés
byte eletkor=12;
52145.
eletkor 52144.
12
Itt az adat!
52143.
52142.
Memóriacímek
Memória
Java - V. / 7
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ó)
Java - V. / 8
Közvetett (indirekt) címzés
Ember ember = new Ember("Erika",1953);
"Erika",1953
82345.
ember objektum címe
ember 35284.
82345
35283.
ember.megy();
Automatikus indirekció!
35282.
Memóriacímek
Memória
Java - V. / 9
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
Java - V. / 10
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!
Java - V. / 11
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>);
Java - V. / 12
Példa: String objektum létrehozása
String
+String(value: String)
+toUpperCase(): String
+toString(): String
...
szöveg: String new String("Pirkadat")
"Pirkadat"
toUpperCase()
String szoveg;
szoveg = new String("Pirkadat");
System.out.println(szoveg.toUpperCase()); // PIRKADAT
System.out.println(szoveg);
// Pirkadat
Java - V. / 13
Értékadás az objektumok körében
String ember1 = new String("Timea");
String ember2 = new String("Roland");
Object obj;
String ember3;
ember1 = ember2;
obj = ember1;
// ember1 = obj; Szintaktikai hiba! obj általánosabb!
// ember1 = ember3; Szintaktikai hiba! ember3-nak
// nincs értéke!
//1
//2
//3
//4
Java - V. / 14
Object
ember1
//1
:String
ember3
"Timea"
//3
String
ember2
:String
//2
//4
obj
"Roland"
Java - V. / 15
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
Java - V. / 16
Az objektum élete,
automatikus szemétgyűjtés
ember1 = new String("Gábor");
ember1 = new String("Anikó");
:String
ember1
"Gábor"
:String
"Anikó"
Java - V. / 17
String osztály
0
1
2
3
4
K
é
s
z
!
 Értéke egész élete során állandó
 Unikód karakterek sorozata
String szoveg=new String(”Kész!");
String szoveg=”Kész!";
// optimalizáció
Java - V. / 18
String osztály (folyt.)
 Konstruktorok
• String()
• String(value: String)
• String(buffer: StringBuffer)
 Hossz, index
• length(): int
• charAt(index: int): char
Java - V. / 19
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
Java - V. / 20
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
Java - V. / 21
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
Java - V. / 22
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
}
}
Java - V. / 23
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
Java - V. / 24
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
Java - V. / 25
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
Java - V. / 26
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
Java - V. / 27
StringBuffer hegy1 = new StringBuffer("Machu");
StringBuffer hegy2 = hegy1.append(" Picchu");
hegy2.insert(0,"Ez is ");
//1
hegy1
:StringBuffer
"Machu"
hegy1
hegy2
hegy1
hegy2
//1
//2
//3
//2
:StringBuffer
"Machu Picchu"
//3
:StringBuffer
"Ez is Machu Picchu"
Java - V. / 28
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
}
}
Java - V. / 29
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
Java - V. / 30
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
}
Java - V. / 31
static void szethuz(StringBuffer str) {
for (int i=str.length()-1; i>0; i--)
Értékadás szerinti
kompatibilitás!
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);
Csak a referencia másolódik át!
System.out.println("*"+sb+"*");
//  "*P e a c e*"
}
Java - V. / 32
A metódusba való
belépéskor:
A metódusból való kilépés
előtt:
null
str
sb
:StringBuffer
"Peace"
str
sb
:StringBuffer
"P e a c e"
A metódus csak a mutatott objektumot
változtathatja meg, a referenciát nem!
Java - V. / 33
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!
Java - V. / 34
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”
Java - V. / 35
Példánymetódusok (folyt.)
 <type> <type>Value()
Például:
Integer iObj = new Integer(30);
int i = iObj.intValue();
double d = iObj.doubleValue();
// i==30
// d==30.0
 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
Java - V. / 36
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);
Java - V. / 37
Character osztály
 static final char MIN_VALUE = '\u0000';
static final char MAX_VALUE = '\uffff';
 static
static
static
static
static
static
boolean
boolean
boolean
boolean
boolean
boolean
isUpperCase(char ch)
isLowerCase(char ch)
isDigit(char ch)
isLetter(char ch)
isSpaceChar(char ch)
isWhitespace(char ch)
 static char toUpperCase(char ch)
static char toLowerCase(char ch)
Java - V. / 38
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
}
}
Java - V. / 39
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:");
}
Java - V. / 40
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
Java - V. / 41
17. Osztály készítése
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
OO paradigma - Emlékeztető
Első mintaprogram - Raktárprogram
Második mintaprogram - Bank és a “Jószerencse”
Az osztály felépítése, az osztály deklarációi
Osztálytag, példánytag
Azonosító, hivatkozási kör, takarás
Változók alapértelmezés szerinti kezdeti értékei
A this objektumreferencia
Konstruktorok
Inicializálók
Java - V. / 46
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 (-)
Java - V. / 47
Az Osztály felépítése
[<módosítók>] class <OsztályAzon>
[extends <OsztályAzon>]
[implements <InterfészAzon>[, <InterfészAzon> ... ]]
{
<osztály blokk (az osztály deklarációi)> Osztály feje
}
Példák
public class JoSzerencse
Módosítók
• public
public class Bank
• abstract
public final class String implements
• final
java.io.Serializable,Comparable
Java - V. / 48
Az osztály deklarációi
Osztály szintű deklaráció
Osztálytag
Példánytag Konstruktor
Osztályváltozó Példányváltozó
Osztálymetódus
Példánymetódus
Osztály- Példány- Belső
inicializáló inicializáló osztály
blokk
blokk
Ajánlott deklarálási sorrend:
• változók, kapcsolatok
• konstruktorok
• metódusok (get/set/main)
Java - V. / 49
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)
Java - V. / 50
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!
Java - V. / 51
Együttműködési diagram
1: main(args)
2: RaktarProgram()
4: akciok()
RaktarProgram
3: Aru(aNev,aEgysegar)
5: hozzatesz(aMenny)
6: elvesz(aMenny)
7: setEgysegar(aEgysegar)
program:
RaktarProgram
aru:Aru
Java - V. / 52
Osztálydiagram
RaktarProgram
+RaktarProgram()
+akciok()
+main(args)
Aru
-nev: String
-egysegar: double
-menny: double
+Aru(aNev:String,aEgysegar:double)
-aru +getNev(): String
+getEgysegar(): double
+setEgysegar(aEgysegar:double)
+getMenny(): double
+getAr(): double
+hozzatesz(aMenny:double)
+elvesz(aMenny:double)
+toString(): String
Java - V. / 53
class Aru {
private String nev;
private double egysegar;
private double menny;
Példányváltozók
public Aru(String aNev, double aEgysegar) {
nev = aNev;
egysegar = aEgysegar;
menny = 0;
}
Konstruktor
public String getNev() {
return nev;
}
Java - V. / 54
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;
}
Java - V. / 55
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();
}
}
Java - V. / 56
public class RaktarProgram {
private Aru aru;
Kapcsolat
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);
}
Java - V. / 57
public static void main(String[] args) {
RaktarProgram program = new RaktarProgram();
program.akciok();
}
Objektum létrehozása
}
saját osztályából
main()
RaktarProgram
RaktarProgram()
akciok()
program:
RaktarProgram
Java - V. / 58
Hivatkozási kör
class JoSzerencse {
int joSzerencse;
int joSzerencse() {
int joSzerencse = this.joSzerencse;
return joSzerencse;
Példányváltozó
}
…
Lokális változó
}
Java - V. / 73
Takarás
class Proba {
int szam=1;
static char kar='A';
void proba() {
int szam=2; char kar='B';
System.out.println(szam);
System.out.println(this.szam);
System.out.println(kar);
System.out.println(Proba.kar);
}
}
//  2
//  1
//  B
//  A
Java - V. / 74
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;
}
Java - V. / 75
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
Java - V. / 76
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
Java - V. / 77
Inicializálók
class Tanulo2 {
static int alapTandij;
double atlag; int tandij; Osztályinicializáló blokk
static {
alapTandij = 2000;
Inicializáló kifejezés
}
{
atlag = Console.readDouble("Atlag: ");
tandij = alapTandij +
(int)Math.round(3000*(5-atlag));
} // …
Példányinicializáló blokk
}
Java - V. / 78
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)
Java - V. / 79