Java – start!

www.xsys21.huExpert software systems for the 21th century

Vég Csaba: Java-Start!

Java – start!Minden jog fenntartva. A szerző előzetes írásbeli engedélye nélkül

jelen anyagot vagy annak részleteit más nyelvre lefordítani, reprodukálni és közölni tilos!

Non-profit oktatási intézmények ingyenesen felhasználhatják; más-jellegű felhasználáshoz, így pl.

tanfolyam-tartáshoz az XSys Kft. hozzájárulása szükséges.

A Java a Sun Mictosystems, Inc. bejegyzett védjegye.


2Vég Csaba: Java-start!

1.„Hello”



„Hello!”

Írjuk ki a Hello! szöveget!

// Hello.java// Hello.java

public class Hello {public class Hello {

public static void main(String[] args) {public static void main(String[] args) {

System.out.println("Hello!");System.out.println("Hello!");

}}

}}



Megjegyzés

// 1.1 Hello.java

public class Hello {

public static void main(String[] args) {

System.out.println("Hello!");

}

}

Megjegyzés

A Java figyelmen kívül hagyja a sor // után A Java figyelmen kívül hagyja a sor // után következő részét.következő részét.



Osztály (class)// Hello.java




}

}

Hello: publikus osztály

Objektumorientált nyelvekben a programunkat Objektumorientált nyelvekben a programunkat osztályoknak (class) nevezett zárt egységekből osztályoknak (class) nevezett zárt egységekből építjük felépítjük fel

publikus (mindenki által használható) osztálypublikus (mindenki által használható) osztály



Jellegzetességek

// Hello.java




}

}

jellegzetességek

A nevet követően,kapcsos zárójelek között soroljuk A nevet követően,kapcsos zárójelek között soroljuk fel az osztályhoz tartozó elemeket, melyeket az fel az osztályhoz tartozó elemeket, melyeket az osztály jellegzetességeinek (feature) nevezünkosztály jellegzetességeinek (feature) nevezünk. .



„Hello” osztály definíciója

public class Hello { ...}

…

publikus osztály

az osztály neve

ide kerülnek az osztályjellegzetességei



public static void main(String[] args)

public class Hello { // Hello.java



}

}

main

Ha egy pontosan ilyenHa egy pontosan ilyen ( (main nevű, „publikus és main nevű, „publikus és statikus”, stb.statikus”, stb.)) jellegzetességet jellegzetességet megmegadunk, akkor a adunk, akkor a Java el tudja indítani, futtatni tudja az osztályt. Java el tudja indítani, futtatni tudja az osztályt.

Az osztály futtatásaAz osztály futtatása:: a a kapcsoszárójelek közötti kapcsoszárójelek közötti programrész végrehajtprogramrész végrehajtásaása..



Kiírás

// Hello.java




}

}Kiírás a konzolra

A zárójelek között számérték vagy egy egyszerű A zárójelek között számérték vagy egy egyszerű kifejezés is szerepelhetkifejezés is szerepelhet



Kifejezés kiírása

Írjuk ki a kifejezés értékét!

public class Kiírás {public class Kiírás {


System.out.println( 2.8/3*(1+3) );System.out.println( 2.8/3*(1+3) );

}}

}}

)31(3

8.2



Szövegek összefűzése

Több szöveget a + művelettel fűzhetünk össze, így a megjelenő értéket magyarázó szöveggel is ki tudjuk egészíteni.

public class Kiírás {public class Kiírás {


System.out.println("2.8/3*(1+3) értéke: "+ System.out.println("2.8/3*(1+3) értéke: "+ (2.8/3*(1+3))+".");(2.8/3*(1+3))+".");

}}

}}

összefűzés

összefűzés



JDKJava nyelvű programok készítéséhez (fordításhoz) szükséges egy fejlesztői környezet.

JDK: Java Development Kit A Java nyelvet kifejlesztő SUN által ingyen rendelkezésre

bocsátott „Java fejlesztői csomag” www.javasoft.com címről letölthető

Java programozás: JDK: minimális készlet Integrált fejlesztői környezet (IDE: Integrated

Development Environment)



JDK telepítéseA telepítés részben bizonyos állományok („fájlok”) elhelyezését jelenti.

Fordító, futtató és kiegészítő programok elérhetővé tétele. (PATH).

A Java programok környezetét jelentő állományok helye. CLASSPATH elnevezésű környezeti változó: osztályokat tartalmazó könyvtárakat, több osztályt/könyvtárat tömörítetten tároló jar v. zip

állományok.

A CLASSPATH értékét ki kell egészítenünk azzal a könyvtárral, amelybe elhelyezzük a programjainkat. (esetleg az aktuális könyvtárral)



Fordítás és futtatásHello.java szöveges állomány. Állomány neve = a publikus osztály neve .java kiterjesztés!

Fordítás: Java compiler javac Hello.java eredmény: Hello.class

Futtatás: java Hello (Hello! szöveg)

Hello.java

Hello.classjavac

java

fordítás

futtatás



Fordítás és futtatás

class állomány: bájtkód forma java paranccsal indítható Java virtuális gép (JVM: Java Virtual Machine).

Gépfüggetlen: más gépen is futtatható (hálózat)

Hello.java

Hello.classjavac

java

fordítás

futtatás



MegjegyzésekA megjegyzéseket a fordítóprogram figyelmen kívül hagyja. Megjegyzés: ahova kiegészítő szóközöket is írhatunk.

A Java három fajta megjegyzést ismer. // után a sor végéig tartó rész, /* és */ között: több soros (nem ágyazhatók egymásba), /** és */ között (speciális változat): dokumentációs megjegyzés

valamely definiált elem (pl. osztály vagy jellegzetesség) előtt. javadoc program: html dokumentáció.

(szabványos környezet dokumentációja is így készült)



AzonosítóAzonosító: programelem elnevezése betűvel kezdődik és betűvel vagy számjeggyel folytatódik

A $ és az _ jelek is betűnek számítanak ($ jel a Java céljaira) Unicode szabvány alapján a nemzeti karakterek

(pl. á, é, stb.) kis- és a nagybetűk különbözők

A Java nyelv készítőinek ajánlása: osztályok elnevezését nagybetűvel kezdjük, jellegzetességek nevét kisbetűvel kezdjük Több szavas elnevezés:

pl. a születési dátum => születésiDátum



KulcsszavakKulcsszavak: csak a nyelv által meghatározott jelentésben használhatók (kis- és a nagybetűk!)

abstract, boolean, break, byte, case, catch, char, class, const, continue, default, do, double, else, extends, final, finally, float, for, goto, if, implements, import, instanceof, int, interface, long, native, new, package, private, protected, public, return, short, static, super, switch, synchronize, this, throw, throws, transient, try, void, volatile, while



Applet

Java különlegessége: www dokumentumokba Java nyelvű programokat illeszthetünk be

applet (kisalkalmazás): html-oldalakba ágyazható intelligensebb megjelenítés és működés

A web-lapon az applet kap egy adott méretű grafikus területet, ahova rajzolni lehet.



Applet beágyazásaHelloApplet.html

<HTML><HEAD><TITLE>HelloApplet</TITLE></HEAD>

<BODY>

Kiírás: <applet code="HelloApplet.class" width=80 height=15> </applet>

</BODY>

</HTML>

HelloApplet.class: elhelyezni a megfelelő könyvtárba.

A web-lap megtekintésekor a program automatikusan elindul.

applet-tag futtatandó állomány

grafikus terület

Helyettesítő szöveg



Szöveg kirajzolása appletből

public class HelloApplet extends java.applet.Applet { public void paint(java.awt.Graphics g) { g.drawString("Hello!", 5, 12); }}

Más szerkezetűekRajzolás: paintSzöveg kirajzolása: drawString



appletviewerapplet indítása: rá hivatkozó html oldal

Böngészőappletviewer (JDK) figyelmen kívül hagyja a html-lapon szereplő többi szöveget több applet esetén mindegyiket külön ablakban jeleníti meg

Java alkalmazásból is lehetséges a grafikus megjelenítésAppletből is kiírhatunk szöveget a konzolra a szöveg megtekintéséhez a böngészőben be kell

kapcsolnunk a Java konzol megjelenítését általában diagnosztikai üzenetek



Rajzolás appletből// width=200 height=100

public class RajzApplet extends java.applet.Applet {

public void paint(java.awt.Graphics g) {

g.setColor(java.awt.Color.blue); g.fillRect(10,20,180,60);

g.setColor(java.awt.Color.red); g.fillOval(20,10,100,50);

}

}



2.Egyszerű számítás



Egyszerű számításA téglalap adataiból számítsuk ki a kerületét és a területét!

Téglalap kerülete

Téglalap területe

részfeladatok

Téglalap

kerület

terület

osztály részfeladatai (funkciók)

Téglalap kerület(): double terület(): double

metódusok

Téglalap-a: double-b: double+kerület(): double {2*(a+b)}+terület(): double {a*b}

tulajdonságokTéglalap

-a: double-b: double+ (a': double, b': double)+kerület(): double {2*(a+b)}+terület(): double {a*b}

konstruktor

- saját+publikus

valós érték



Osztály és objektum

Osztály: típus, olyan keret, melyet

konkrét adatokkal tölthetünk fel. pl.: egy Téglalapnak van egy a és egy b tulajdonsága,

illetve egy kerület és egy terület metódusa. Konkrét Téglalap: a két oldalhosszúságnak konkrét

értéke van, így a téglalap a kerület és a terület értékeit is meg tudja adni.

Objektum (vagy példány): a konkrét elem Az osztály az objektumainak a típusa, azaz a

lehetséges objektumok közös jellegzetességeit határozza meg.

Téglalap-a: double-b: double+ (a': double, b': double)+kerület(): double {2*(a+b)}+terület(): double {a*b}



TéglalapKonstrukció (létrehozás): adott osztályú

objektum készítése (példánkban egy konkrét Téglalap felvétele)

Megadása: egy különleges metódus, a konstruktor (constructor) segítségével: az objektumot milyen értékek (esetleg objektumok) alapján és milyen módon készíthetjük el.(a jel arra utal, hogy az objektumot a zárójelek között felsorolt paraméterekből hozzuk létre.)

Konstruktor esetén a + jel azt jelenti, hogy a „külvilág számára” engedélyezzük az objektum létrehozását.




Téglalap -a: double …

... private double a; ...

…

Téglalap

+ (a': double, b': double) …

... public Téglalap(double a_, double b_) { a=a_; b=b_; } ...

Téglalap … +kerület(): double {2*(a+b)} … ...

public double kerület() { return 2*(a+b); } ...

tulajdonságok

konstrukció


metódusokértékadás

visszatérési érték



Téglalap

public class Téglalap {

private double a;

private double b;

public Téglalap(double a_, double b_) {a=a_;b=b_;}

public double kerület() { return 2*(a+b); }

public double terület() { return a*b; }

}




Használatpublic class Téglalap { private double a; private double b; public Téglalap(double a_, double b_) { a=a_; b=b_; } public double kerület() { return 2*(a+b); } public double terület() { return a*b; } public static void main(String[ ] args) { Téglalap t=new Téglalap(10,20); System.out.println("A téglalap kerülete: "+t.kerület()+ ", területe: "+t.terület()+"."); }}



Téglalap t=new Téglalap(10,20);

t.kerület() objektum jellegzetessége: . operátor

... new Téglalap(10,20) ...

a konstruktor paraméterei milyen osztályú

lesz az új objektum

"új"

Téglalap t = ...

változó

kezdőértéke változó neve változó típusa



Változó definíciója

típus név;

típus név = kezdőérték;

Több, azonos típusú változódouble a,b; double x=1,y,z=3*2.54;



VáltozóLokális változó v. paraméter lokális változó: definiálatlan kezdőértékűFordítási hiba: double x; return x;

Jellegzetességként : attribútum, mező, vagy tagváltozó. Alapérték:

számok esetén 0, logikai változó esetén false, karakteres változó esetén a null-karakter ('\0'

„semmilyen” karakter), referencia esetén null (később)



Jellegzetességek elérése

Osztály definícióján belül közvetlenül elérhetők, az objektum határain kívül a . operátort kell használnunk.

Osztály definícióján belül az aktuális objektumra a this kulcsszóval hivatkozhatunk akkor is elérhetjük az objektum jellegzetességeit (pl. this.a), ha

egy paraméter vagy egy lokális változó neve megegyezik az osztály egy jellegzetességének a nevével.



3.Tulajdonságok



Komponensek

Adott módú („szabványos”) programozásJava filozófiája

Nagyobb flexibilitást biztosít

Attribútumok helyett tulajdonságok (property)




Komponensek (adott módú programozás)

Tulajdonságok

Származtatott v. Alap tulajdonság

x: double // csak lekérdezhető, de nem beállítható

y: double< // lekérdezhető és beállítható

z: double<< // csak beállítható, de nem lekérdezhető

Téglalap +a: double +b: double + (a': double, b': double) +kerület(): double {2*(a+b)} +terület(): double {a*b}

Téglalap +a: double +b: double + (a': double, b': double) +/kerület: double {2*(a+b)} +/terület: double {a*b}



Lekérdező/beállító metódusok

private double xx; // ha nem származtatott

public double getXx() { return xx; } // ha lekérdezhető

public void setXx(double xx_) { xx=xx_; } //ha beállítható

public class Téglalap {public class Téglalap { private double a;private double a; private double b;private double b; public Téglalap(double a_, double b_) { a=a_; b=b_; }public Téglalap(double a_, double b_) { a=a_; b=b_; } public double public double getKerületgetKerület() { return 2*(a+b); }() { return 2*(a+b); } public double public double getTerületgetTerület() { return a*b; }() { return a*b; }}}



public class Téglalap { private double a; public double getA() { return a; } public void setA(double a_) { a=a_; } private double b; public double getB() { return b; } public void setB(double b_) { b=b_; } public Téglalap(double a_, double b_){ a=a_;b=b_;} public double getKerület() { return 2*(a+b); } public double getTerület() { return a*b; }}



Kipróbálás

Téglalap t=new Téglalap(10,20);

System.out.println(t.getA()+"x"+t.getB()+" téglalap");

System.out.println(" kerülete: "+t.getKerület());

System.out.println(" területe: "+t.getTerület());



Számított tulajdonság

( értéke: Math.PI )

Kör+sugár: double+ (sugár': double)+/kerület: double {2*sugár*}+/terület: double {sugár2*}



public class Kör public class Kör { private double sugár; public double getSugár () { return sugár; } public void setSugár(double sugár_) { sugár=sugár_; } public Kör(double sugár_) { sugár=sugár_; } public double getKerület() { return 2*sugár*Math.PI; } public double getTerület() { return sugár*sugár*Math.PI; } public static void main(String[] args) { Kör k=new Kör(1); System.out.println(k.getSugár()+" egység sugarú kör"); System.out.println(" kerülete: "+k.getKerület()); System.out.println(" területe: "+k.getTerület()); }}



MathPI: double E: double sin(x: double): double asin(x: double): doublecos(x: double): doubleacos(x: double): doubletan(x: double): doubleatan(x: double): double



Mathabs(a: int): intabs(x: double): doublemin(a: int, b: int): intmax(a: int, b: int): intmin(x: double, y: double): double max(x: double, y: double): doublerint(x: double): double sqrt(x: double): double pow(x: double, a:double): double exp(a: double): doublelog(x: double): doublerandom(): double



Egy másodpercekben megadott időtartam alapján írjuk ki, hogy az hány óra, hány perc és hány másodperc!

Időtartam +óra: int +perc: int +másodperc: int + (összes: int)

Időtartam:

getÓra():int

getPerc():int

getMásodperc():int



public class Időtartam private int óra; public int getÓra() { return óra; } private int perc; public int getPerc() { return perc; } private int másodperc; public int getMásodperc() { return másodperc; } public Időtartam(int összes) { óra=összes/(60*60); perc=összes/60%60; másodperc=összes%60; }

Egészosztás és maradékszámítás



Időtartam

...


Időtartam t=new Időtartam(3823);

System.out.println(t.getÓra()+" óra "+

t.getPerc()+" perc "+

t.getMásodperc()+" másodperc");

}



Java elemi típusai

valós típusok

logikai

Java típusai

elemi típusok referencia típusok ...

szám-jellegű (numerikus) típusok

float double

egész-jellegű (integrális) típusok

byte char short int long

boolean



Elemi típusoklogikai típus

boolean false vagy true 1

egész-jellegű típusok

byte -128..127 1

char 65536 féle 2

short -32768..32767 2

int -2147483648..2147483647 4

long -9223372036854775808..9223372036854775807 8

valós típusok

float kb. (1.410-45 .. 3.410+38) 4

double kb. (4.910-324 .. 3.810+308) 8



Elemi típusok és a void

Gyakran használt típusok: egész érték: int, esetleg long

kis ábrázolási tartomány: short, esetleg byte byte: operációs rendszerrel kapcsolatos adatok

feldolgozása. Valós értékek: double, esetleg float

Gépfüggetlen típusok

void: nem típus; a segítségével jelezzük, hogy egy metódus nem ad vissza értéket.



4.Grafikus felület



Adatok grafikus felületen

Az appletek a html-lapon egy grafikus területet kapnak, így a programok a felhasználóval egy grafikus felhasználói felületen (GUI: Graphical User Interface) keresztül kommunikálhatnak.

Készítsünk appletet, amely az oldalhosszúságok alapján megadja a téglalap kerületét és területét!



GUI

a= 12 b= 21 kerület: 66, terület: 252

téglalap.a

téglalap.kerület

téglalap.terület

téglalap.b

TéglalapApplet

-téglalapA: TextField -téglalapB: TextField -téglalapKerület: Label -téglalapTerület: Label +init()

Téglalap +a: double +b: double + (a': double, b': double) +/kerület: double {2*(a+b)} +/terület: double {a*b}

+téglalap



GUI komponens

Az adatcsere általában nem a paint metódussal történik.

A Java elérhetővé tesz olyan előre elkészített felhasználói felület komponenseket, amelyek segítségével felépíthetjük a megtervezett felhasználói felületünket.Pl.: Label (címke): szöveg megjelenítésére TextField (szöveges mező): rövid szöveg bevitelére TextArea (szöveges terület): több soros szöveg bevitelére Button (gomb): parancs elindítása



Kapcsolat

Hasonló a felület egy tulajdonságához, azonban a téglalap részben független a felülettől, míg egy tulajdonság önmagában nem létezhet. Nyílhegy: láthatóság

a TéglalapApplet tud a téglalap-ról, a Téglalap azonban nincs tudomással a felületről.

A TéglalapApplet felület téglalap néven éri el a megfelelő objektumot.

A kapcsolat írható (setTéglalap)

TéglalapApplet

Téglalap

+a: double +b: double + (a': double, b': double) +/kerület: double {2*(a+b)} +/terület: double {a*b}

+téglalap



TéglalapApplet// width=400 height=30

import java.applet.Applet;

import java.awt.*;

import java.awt.event.*;

public class TéglalapApplet

extends Applet implements ActionListener {

private Téglalap téglalap;

private TextField téglalapA = new TextField();

private TextField téglalapB = new TextField();

private Label téglalapKerület = new Label();

private Label téglalapTerület = new Label();



TéglalapApplet

public void init() {

add(new Label("a="));

add(téglalapA); téglalapA.addActionListener(this);

add(new Label("b="));

add(téglalapB); téglalapB.addActionListener(this);

add(téglalapKerület);

add(téglalapTerület);

setTéglalap(new Téglalap(12,21));

}



TéglalapAppletpublic void setTéglalap(Téglalap téglalap_) { téglalap=téglalap_; téglalapA.setText(""+téglalap.getA()); téglalapB.setText(""+téglalap.getB()); téglalapKerület.setText(" kerület: "+téglalap.getKerület()+","); téglalapTerület.setText(" terület: "+téglalap.getTerület()); validate(); } public void actionPerformed(ActionEvent e) { téglalap.setA( Double.parseDouble( téglalapA.getText() ) ); téglalap.setB( Double.parseDouble( téglalapB.getText() ) ); setTéglalap(téglalap); }



Komponensek tulajdonságai

A komponensek alapértelmezett megjelenési formáját módosíthatjuk a tulajdonságaik megváltoztatásával. foreground: Color background: Color font: Font



Komponensek tulajdonságai

Egyetlen komponens tulajdonságának módosítása: init metódusban:

téglalapKerület.setColor(Color.cyan);téglalapTerület.setColor(Color.cyan);

Az applet is egy komponens init metódusban:

setFont(new Font("serif",Font.ITALIC,14));



public void init() { Font vastagDőlt =

new Font("serif",Font.BOLD+Font.ITALIC,16); Font dőlt = new Font("serif", Font.ITALIC,14); Label l1=new Label("a="); add(l1); l1.setFont(vastagDőlt); add(téglalapA); téglalapA.addActionListener(this); Label l2=new Label("b="); add(l2); l2.setFont(vastagDőlt); add(téglalapB); téglalapB.addActionListener(this); add(téglalapKerület); téglalapKerület.setFont(dőlt); add(téglalapTerület); téglalapTerület.setFont(dőlt); setTéglalap(new Téglalap(12,21)); }



CsomagokKönyvtár-jellegű hierarchia

A csomagokon belüli alcsomagok, illetve elemek megadása: a . jelölés A java.awt.Label jelölés a java csomagon belüli awt alcsomag

Label osztályára hivatkozik. A könyvtárrendszerben ez egy java nevű könyvtár awt

alkönyvtárában elhelyezkedő Label.class állományt jelent.

Csomaghierarchia teteje: CLASSPATH

A Java készítőinek konvenciója szerint a csomagok elnevezését kisbetűvel kezdjük.



Fontosabb csomagokjava.applet applet készítésejava.awt felhasználói felület készítése, rajzolásjava.awt.event grafikus felülettel kapcsolatos események java.awt.geom síkban történő rajzolás java.io állományok kezelésejava.lang Java nyelvhez szükséges alapvető osztályokjava.lang.reflect programszerkezet feltérképezésejava.math tetszőleges pontosságú aritmetikajava.net hálózati kommunikáció java.sql adatbázisok kezelése java.util segédosztályokjava.util.jar jar (JAR: Java Archive) állományok kezelésejava.util.zip zip és gzip formátumú tömörített állományok javax. alapvető kiterjesztések



HivatkozásA pontjelöléssel bármely osztály forrásszövegében hivatkozhatunk a CLASSPATH-ból elérhető bármely csomag bármely, korábban már elkészített osztályára

import utasítás: egyetlen osztály elérése:

import java.applet.Applet;

Csomag összes osztálya: import java.awt.*;

Rövidítési lehetőség (egyértelműség)

java.lang: közvetlenül elérhető



package utasítás

Nagyobb programokat célszerű csomagokba szervezni.

A forrásprogram első utasításaként a package utasítással megadhatjuk az osztály csomagját: pl.: package javaStart.példa;

Egy osztálynak soha nem kell importálnia a saját csomagját, így az abban elhelyezkedő többi osztályt közvetlenül is eléri.

A csomagnevek egyediségének biztosítása: Internet címekhez hasonló (fordított sorrendű) hierarchikus csomagnevek, pl. com.sun.java.swing, org.omg.CORBA, stb.



Java forrásállomány alapszerkezete

Legelső utasításként egyetlen, az osztály csomagját meghatározó package utasítás lehet.

Ezután import utasításokat adhatunk meg.

A forrásállomány ezután egy vagy több osztály (vagy interfész, lásd később) definícióját tartalmazza, azonban csak egyetlen osztály lehet publikus, és a nevének meg kell egyeznie a forrásállomány nevével.



5.Feltételes elágazások



Logikai típusú kifejezés

Objektumra vonatkozó eldöntendő kérdés

Logikai típus:boolean lehetséges értékei: true (igaz) és false (hamis).



Szerkeszthető?Három szakasz hossza alapján döntsük el, hogy szerkeszthető-e ilyen oldalakkal háromszög!

Háromszög

+szerkeszthető?

Háromszög-a: double-b: double-c: double+ (a': double, b': double, c': double)+/szerkeszthető? { a+b>c b+c>a c+a>b}



public class Háromszög private double a; private double b; private double c; public Háromszög(double a_, double b_, double c_) { a=a_; b=b_; c=c_; } public boolean isSzerkeszthető() { return a+b>c && b+c>a && c+a>b; } public static void main(String[] args) { Háromszög háromszög=new Háromszög(1,2,3); System.out.println("Szerkeszthető: "+ háromszög.isSzerkeszthető()+"."); }

logikai „és”



Relációs műveletekÖsszehasonlítás (szám-jellegű értékek között):

kifejezés > kifejezéskifejezés >= kifejezéskifejezés < kifejezéskifejezés <= kifejezés

Egyenlőségvizsgálat (logikai értékek között is):kifejezés == kifejezéskifejezés != kifejezés ( )

A relációs műveletek balról jobbra értékelődnek ki. Ekvivalencia és kizáró vagy (pl.: a<0 == b<0)



Logikai műveletektagadás:

! kifejezés

logikai és:kifejezés && kifejezés

logikai vagykifejezés || kifejezés

A logikai műveletek balról jobbra értékelődnek ki. Az && és a || gyengébb az aritmetikai és a relációs műveleteknél

(pl.: 0<=a && a<=5) A jobboldalon álló kifejezés csak szükség esetén értékelődik ki.



Feltételes kifejezés Egy feltételtől függően egy kifejezésben más érték jelenjen meg.

A feltételes kifejezés:feltétel ? kifejezés_true : kifejezés_false

public static void main(String[] args) { Háromszög háromszög=new Háromszög(1,2,3); System.out.println("A háromszög "+ (háromszög.isSzerkeszthető() ? "" : "nem")+ " szerkeszthető." ); }



Szökőév? Egy évről döntsük el, hogy a Gergely-naptár szerint az szökőév-e!

Év

+szökőév?

Év+év: int+ (év': int)+/szökőév? {év%4= 0 (év%100=0) év%400=0}



Feltételes utasítás

Egy kétismeretlenes, két egyenletből álló lineáris egyenletrendszerről döntsük el, hogy az ellentmondásos, határozatlan, vagy határozott, és ez utóbbi esetben adjuk meg a megoldást.

Az egyenletrendszert jelöljük a következő módon:

ax+by=c

dx+ey=f

Lineáris egyenletrendszer

+határozatlan? +ellentmondásos?

+határozott?

+x: double +y: double



Lineáris egyenletrendszer-a,b,c: double-d,e,f: double+ (a': double, b': double, c': double, d': double, e': double, f ': double)-/det: double {a*e-b*d}-/detX: double {c*e-b*f}-/detY: double {a*f-c*d}+/határozott? { det0 }+/határozatlan? { határozott detX=0 }+/ellentmondásos? { határozott detX0 }+/x: double { detX/det }+/y: double { detY/det }



LineárisEgyenletrendszer


LineárisEgyenletrendszer e=

new LineárisEgyenletrendszer(1,2,2, 2,1,-4);

if( e.isHatározott() )

System.out.println("x="+e.getX()+", y="+e.getY()+".");

else

System.out.println("Az egyenletrendszer "+

(e.isHatározatlan() ? "határozatlan" : "ellentmondásos")

+".");

}



Utasítás és utasításblokk Utasításblokk: több utasítás csoportosítása kapcsoszárójelek között tetszőleges számú utasítás vagy

lokális változó deklarációs utasítása üres blokk

Lokális változó deklarációs utasítása: egy pontosvesszővel lezárt deklaráció (pl. int x,y;).

Végrehajtható utasítás, pl.: üres utasítás: ; kifejezés pontosvesszővel lezárva (pl. a=b+1;). összetett utasítások



if és if-else utasítás

if utasítás (opcionális végrehajtás):if( feltétel ) utasítás

if-else utasítás (alternatíva):if( feltétel ) utasítás_true

else utasítás_false



6.Többszörös elágazás



Többszörös leágazásAz Év osztályt egészítsük ki úgy, hogy meg tudja mondani, hogy abban az évben mikor lesz húsvét! közelítő számítás: (1800 és 2099 között)

: ?(e=6 d=28 év%19>10)

49

?(e=6 d=29)

Húsvét: int

50 22+d+e

d (19*(év%19)+24)%30 e (2*(év%4)+4*(év%7)+6*d+5)%7



Többszörös leágazás

if(a) A

else

if(b) B

else C

A

?(a) :

B C

?(b)

?(a) :

: ?(b)

A

B C

if(a) Aif(a) A

else if(b) Belse if(b) B

else Celse C



Húsvét public int getHúsvét() { int d = (19*(év%19)+24)%30; int e = (2*(év%4)+4*(év%7)+6*d+5)%7; if( e==6 && d==28 && év%19>10 ) return 49; else if( e==6 && d==29) return 50 else return 22+d+e; }



Egy másodfokú egyenletről állapítsuk meg, hogy létezik-e valós megoldása, ill. egybeesik-e a két valós megoldás, és ha létezik, akkor írjuk ki a megoldást! Másodfokú

-a,b,c: double+(a': double, b': double, c': double)

-/D: double {b2-4ac}+/valós megoldások száma: int+/nincs valós megoldás? {D<0}

+/x1: ^?nincs valós megoldás, double {a

Db

2

}

+/x2: ^?nincs valós megoldás, double {a

Db

2

}valós megoldások számavalós megoldások száma::

0, ha nincs v0, ha nincs v.. megoldás, megoldás,

1, ha a két v1, ha a két v.. megoldás egybeesik, megoldás egybeesik,

2, egyébként, ha a két valós megoldás különböző.2, egyébként, ha a két valós megoldás különböző.



public class Másodfokú private double a,b,c; public Másodfokú(double a_, double b_, double c_) { a=a_; b=b_; c=c_; } private double getD() { return b*b-4*a*c; } public int getValósMegoldásokSzáma() { double d=getD(); return (d<0) ? 0 : ( d==0 ? 1 : 2 ); } public double getX1() { return (-b+Math.sqrt(getD()))/(2*a); } public double getX2() { return (-b-Math.sqrt(getD()))/(2*a); }



public class Másodfokú...


Másodfokú m=new Másodfokú(-1,2,3);

if(m.getValósMegoldásokSzáma()==0)

System.out.println("nincs valós megoldás");

else if(m.getValósMegoldásokSzáma()==1)

System.out.println("x1,x2="+m.getX1());

else

System.out.println("x1="+m.getX1()+", x2="+m.getX2());

}



Esetszétválasztásswitch( kifejezés ) { case konstansKifejezés1: utasítások1 break; case konstansKifejezés2: case konstansKifejezés3: utasítások23 break; default: utasítások_else

} gépközeli logika!

int típusúvá konvertálható

„érték-címkék”

blokk-végére lép

default-címke



Másodfokú...


Másodfokú m=new Másodfokú(-2,4,-2);

switch( m.getValósMegoldásokSzáma() ) {

case 0: System.out.println("nincs valós megoldás"); break;

case 1: System.out.println("x1,x2="+m.getX1()); break;

default:

System.out.println("x1="+m.getX1()+", x2="+m.getX2());

}

}

kódok



final változókfinal változó: legfeljebb egyszer adható neki érték (leggyakrabban a változó deklarációjában történik) osztály attribútuma lokális változó paraméter: a metódus blokkjában a paraméter értékét nem

változtatjuk meg.

A kódokat final attribútumokként elnevezhetjük. static kulcsszó: az értéket nem kell minden objektumban megismételni, mivel az osztályra (az osztály minden objektumára) érvényes értéket jelöl.Összefoglalva: nevesített konstans: static final kulcsszavakkal megadott változó



Konstansok... public static final int NINCS_VALÓS_MEGOLDÁS = 0, EGYBEESŐ_VALÓS_MEGOLDÁSOK = 1, KÜLÖNBÖZŐ_VALÓS_MEGOLDÁSOK = 2; public int getValósMegoldásokSzáma() { double d=getD(); return (d<0) ?

NINCS_VALÓS_MEGOLDÁS : (d==0 ?

EGYBEESŐ_VALÓS_MEGOLDÁSOK :KÜLÖNBÖZŐ_VALÓS_MEGOLDÁSOK);

}



...public static void main(String[] args) { Másodfokú m=new Másodfokú(1,2,3); switch( m.getValósMegoldásokSzáma() ) { case Másodfokú.NINCS_VALÓS_MEGOLDÁS: System.out.println("nincs valós megoldás"); break; case Másodfokú. EGYBEESŐ_VALÓS_MEGOLDÁSOK: System.out.println("x1,x2="+m.getX1()); break; default: System.out.println("x1="+m.getX1()+", x2="+m.getX2()); } }



LiterálokLogikai (boolean): true és false.Egész literál alapértelmezésben int típusú long: számjegyek után írt l vagy L karakterrel jelölünk.

A literál értékét három számrendszerben is megadhatjuk: decimális: a 0 vagy egy nem nulla számjeggyel kezdődő

természetes szám, pl. 1234567890. oktális: 0 után a számjegyek, pl. 01234567. hexadecimális: 0x után, pl.: 0xa7f.

Valós: egészrész, tizedespont, törtrész, exponens és típusjelölő alapértelmezésként double (d vagy D típusjelölő), pl. 2D. float: f vagy F típusjelző.



LiterálokKarakteres (char típusú): aposztrófok között egyetlen Unicode karakter

vagy escape-szekvencia, pl. 'a'. Szöveges (String típusú) literál: karakterek vagy escape-szekvenciák

idézőjelek közötti sorozata, pl. "abcd". \\ fordított per \b visszafelé törlés (backspace). \t (vízszintes) tabulátorjel \n új sor jele. \r sorvége jele. \f lapdobás (form feed) \" idézőjel \' aposztróf \számjegyek oktálisan (!), a karakter kódja, pl. \0

Unicode kódok a szövegben: \uddddnull: referencia-típusok esetén használható



7.Ciklusok



Elöltesztelő ciklusEgy pozitív egész számlálójú és nevezőjű törtet egyszerűsítsünk! Tört

-a, b: int+ (a': int, b': int)-egyszerűsítés ()-/lnko:int

: ?

(x,y)(y,x%y) b

/lnko: int

y

(x,y)(a,b)

x%y0



public class Tört private int a,b; public int getA() { return a; } public int getB() { return b; } public Tört(int a_, int b_) { a=a_; b=b_; egyszerűsítés(); } private void egyszerűsítés() { int lnko=getLnko();

a=a/lnko; b=b/lnko; } private int getLnko() { int x=a,y=b; while( x%y!=0 ) { int x_=x; x=y; y=x_%y; } return y; } public static void main(String[] args) { Tört q=new Tört(12,18); System.out.println(q.getA()+"/"+q.getB()); }

: ?

(x,y)(y,x%y) b

/lnko: int

y

(x,y)(a,b)

x%y0



Hátultesztelő ciklus

public int getLnko() { int x=a,y=b;

do { int m=x%y; x=y; y=m;

} while( y!=0 );

return x;

}

: y0

?

(x,y)(y,x%y) b

x

(x,y)(a,b)

/lnko: int



Prímtényezők

Egy 1-nél nagyobb egész számnak írjuk ki a prímtényezős felbontását, pl. a 12 szám esetén jelenjen meg a 2 2 3 szöveg! Az egymás után megtalált

prímtényezőket szóközökkel elválasztva egyetlen szöveggé fűzzük össze.

Prímtényezők-n: int+ (n': int)+/prímtényezők: String



Prímtényezőkn' prímtényezői szövegként:

s legyen üres szöveg; i = 2

amíg az n' nagyobb, mint 1

ha i osztja n'-t,

s-hez fűzzük a " "+i szöveget,

n'-t osszuk el i-vel

egyébként vegyük a következő i-t

az eredmény s

? : n'%i=0

s n'n'/i ii+1

ss+" "+i

? n'>1

s""; i2

:

/prímtényezők: String



Értékadó operátorok public String getPrímtényezők() { int n_=n; String prímtényezők=""; int i=2; while( n_>1 ) if( n_%i==0 ) {

prímtényezők=prímtényezők+" "+i; n_=n_/i;

} else i=i+1; return prímtényezők; }

a=a#(b) kifejezés az a#=b módon rövidíthető, ha létezik a #= operátor

pprímtényezőkrímtényezők+=" "+i+=" "+i

n_/=in_/=i

i+=1i+=1



Növelő/csökkentő operátorok

public String getPrímtényezők() {

int n_=n; String prímtényezők=""; int i=2;

while( n_>1 )

if( n_%i==0 ) {

prímtényezők+=" "+i;

n_/=i;

} else i=i+1;

return prímtényezők;

}

++i++i



A ++i és az i++ megnöveli az i értékét 1-gyel, a --i és az i-- pedig csökkenti 1-gyel.

Prefix: a műveletben a továbbiakban a módosított értéket használja fel.

Postfix: művelet is módosítja a változó értékét, azonban a kifejezésben az eredeti értéket használja fel.

Ha az i értéke 2, j=++i esetén j értéke 3 lesz, j=i++ esetén azonban 2, mindkét esetben az i értéke a kifejezés után 3.



8.For, break és continue



Prímtényezős felbontás

Egy 1-nél nagyobb egész számnak a prímtényezős felbontását írjuk ki hatványalakban, pl. a 24 szám esetén jelenjen meg a 2^3 3 szöveg! megszámoljuk, hogy a belső ciklus hányszor hajtódik végre.



? :

s

n'/=i

?

n'=n; s""; i2

:

/prímtényezők: String

++i

j0

n'>1

n'%i=0

?(j=1)

?(j=0) ?(j>1)

s+=" "+i s+=" "+i+"^"+j

++j

kezdő beállítás

ismétlés feltétele

léptetés



for utasításfor( kifLista_kezdőBeállítás; feltétel; kifLista_léptetés ) utasítás

kifLista_kezdőBeállítás; while( feltétel ) { utasítás kifLista_léptetés; }

for( lokálisVáltozó_dekl; feltétel; kifLista_léptetés ) utasítás

végtelenciklus:for( ; ; )



for - inicializálással public String getPrímtényezők() { int n_=n; String prímtényezők=""; int i,j; for( i=2; n_>1; ++i ) { for( j=0; n_%i==0; ++j ) n_/=i; switch(j) { case 0: break; case 1: prímtényezők+=" "+i; break; default: prímtényezők+=" "+i+"^"+j; } } return prímtényezők; }



for - deklarációval public String getPrímtényezők() { int n_=n; String prímtényezők=""; for(int i=2; n_>1; ++i ) { int j; for(j=0; n_%i==0; ++j ) n_/=i; switch(j) { case 0: break; case 1: prímtényezők+=" "+i; break; default: prímtényezők+=" "+i+"^"+j; } } return prímtényezők; }



Megadott lépésszámú ciklus

1-től 10-ig terjedő egész számoknak írjuk ki a négyzetét és a köbét!

public class NégyzetÉsKöbTáblázat {public class NégyzetÉsKöbTáblázat {


System.out.println( "x: \tx^2, \tx^3");System.out.println( "x: \tx^2, \tx^3");

for(int i=1; i<=10; ++i) for(int i=1; i<=10; ++i)

System.out.println( i+": \t"+(i*i)+", \t"+(i*i*i) );System.out.println( i+": \t"+(i*i)+", \t"+(i*i*i) );

} }

}}



Valós értékek

Készítsünk táblázatot a -2 és 2 radián közötti szögértékek szinuszával és koszinuszával fél radiánonként.

public class SinCosTáblázat {public class SinCosTáblázat {


for(double rad=-2*Math.PI; rad<=2*Math.PI;for(double rad=-2*Math.PI; rad<=2*Math.PI; rad+=0.5) rad+=0.5)

System.out.println(rad+": \t"+Math.sin(rad)+System.out.println(rad+": \t"+Math.sin(rad)+", \t"+Math.cos(rad));", \t"+Math.cos(rad));

} }

}}



Prímtényezők public String getPrímtényezők() { int n_=n; String prímtényezők=""; for(int i=2; n_>1; ++i ) { int j; for(j=0; n_%i==0; ++j ) n_/=i; switch(j) { case 0: break; case 1: prímtényezők+=" "+i; break; default: prímtényezők+=" "+i+"^"+j; } } return prímtényezők; }

i+= 1, majd 2i+= 1, majd 2



Jelző public String getPrímtényezők() { int n_=n; String prímtényezők=""; int f=1; for(int i=2; n_>1; i+=f, f=2 ) { int j; for(j=0; n_%i==0; ++j ) n_/=i; switch(j) { case 0: break; case 1: prímtényezők+=" "+i; break; default: prímtényezők+=" "+i+"^"+j; } } return prímtényezők; }



UtasításcímkeUtasításcímke:

címke: utasítás

címke: azonosító, mely nem kulcsszó és csak akkor egyezhet meg egy másik utasítás címkéjével, ha egyik utasítás sem tartalmazza a másikat.

goto: nincs goto utasítás a goto kulcsszó

(nem deklarálhatunk ilyen nevű változót vagy metódust)



break és continue utasításbreak: break;

legbelső switch, while, do vagy for utasításból lép ki; a végrehajtás az adott utasítás után folytatódik.

break címke; a program végrehajtása az adott címkéjű tetszőleges összetett

utasítás után folytatódik. (Pl.: egy ciklusból egy switch utasításon belül kiléphetünk)

continue: kizárólag egy while, do vagy for utasításon belül continue;

a ciklusmag végére lép (for: léptetés!) continue címke;

az adott címkéjű ciklusutasítás következő iterációja



Konverzió adott típusú érték más típusú értékké való átalakítása.

Bővítő (widening) konverzió: a kiindulási értéket egy bővebb tartományú típusba alakítjuk, pl.: egész értéket valós típusúvá. Ekkor az érték nem sérülhet meg.

Szűkítő (narrowing) konverzió: az eredménytípus kisebb tartományú, így a tartományon kívüli értékek megsérülnek.

Identikus konverzió is, ha egy értéket a vele azonos típusúvá alakítunk (elvi jelentőségű).

Konkatenáció műveletben tetszőleges típusú érték szöveges, azaz String típusúvá alakítódik



Elemi típusok alapkonverziói

Alapkonverzióval elemi típusok esetén csak a szám-jellegű értékek konvertálhatók;Sorrend:

byte char/short int long float double

A short típusból char típusba és vissza történő konverzió egyaránt szűkítő!

A char típusú érték a konverzió során számként a Unicode kódrendszer szerinti kódjával jelenik meg.



Automatikus identikus és bővítő konverzió

A Java a következő három esetben megengedi és automatikusan végre is hajtja az identikus és a bővítő konverziót: Értékadás esetén, a változó típusává történő konverziókor, Metódushívás paramétereként az értéknek a paraméter

típusává történő konverziókor, Aritmetikai műveletekben

pl. 3+4.5 a művelet így azonos típusú értékek között hajtódik végre.



Konverziós operátor

Típuskonverziós (type cast) operátor:érték típusának módosításanem csak bővítő és identikus, hanem szűkítő

konverziót is előírhatunk.

(típus) érték

Pl.: (byte)'x' magas precedenciájú: pl. ((float)(2+3)).



KonkatenációAutomatikus szöveges konverzió konkatenáció (+ művelet) esetén. A nem szöveges érték elhelyezkedhet az operátor bal- vagy a jobboldalán is (pl. ""+a).

Szöveggé történő automatikus konverzió értéke: logikai érték esetén a true vagy false szöveg, egész vagy valós számtípus esetén a számérték szövegként, karakteres típus esetén a karakter. Objektum esetén:

+toString(): String metódus eredménye

Mi a különbség: ""+a (String)a



9.Metódusok



AlprogramokAlprogram: függvény eljárás (void)

érték szerinti paraméterátadás

Hívásból történő visszatérés: Eljárás esetén: automatikusan a metódus blokkjának

utolsó utasítását követően. return utasítás: visszatérés kiváltása Eljárás esetén

return; Függvény esetén

return kifejezés;



Statikus (osztály-) attribútumEgy osztály két objektumának az attribútumai különböző értékűek lehetnek. Ezek az attribútumok így az objektumhoz (a példányhoz) kötődnek.static kulcsszó: statikus, az osztályra vonatkozó jellegzetességek megadásaOsztályattribútum: osztályra vonatkozó érték, az osztály minden objektuma számára

közös és elérhető. lehet publikus minősített névvel (pont-jelölés) az osztály vagy egy objektuma

alapján is elérhető. Általában: összetett konstansok

pl. Math.PI vagy Color.black. java.lang.System osztály osztályattribútuma az out



Statikus metódus

Osztálymetódus: osztályra vonatkozó alprogram az osztály minden objektuma számára elérhető, osztálymetódus közvetlenül nem ér el példányváltozókat és

példányműveleteket (csak közvetve, pl. ha készít egy új objektumot vagy azt paraméterként veszi át)

Legtöbbször a példányoktól független számítási és megoldási módszereket, „trükköket” adunk meg. Pl. a Math osztály sin, cos, stb. metódusai.

main osztálymetódus: a programot indító metódus



Egyszerűsítés

Egy a/b alakú racionális számot lehetőség szerint egyszerűsítsünk, és írjuk ki vegyestört formában (pl. 14/4 esetén: 3 1/2, ill. 14/7 esetén: 2)!

Tört-a: int-b: int+$lnko(a:int, b:int): int-egyszerűsítés ()+ (a':int, b':int)+vegyestört(): String

statikusstatikus



public class Tört private int a,b; public Tört(int a_, int b_) { a=a_; b=b_; egyszerűsítés(); } public static int lnko(int a, int b) { do { int m=a%b; a=b; b=m; } while( b!=0 ); return a; } private void egyszerűsítés() { if(b<0) { a=-a; b=-b; } if(a==0) b=1; else { int o=lnko(Math.abs(a),b); a/=o; b/=o; } } public String vegyestört(){ return (b==1) ? ""+a : (a/b)+" "+(a%b)+"/"+b; } public static void main(String[] args) { System.out.println("Tört: "+ new Tört(18,12).vegyestört()); }



A Tört osztályt egészítsük ki a négy alapművelettel (add: összeadás, sub: kivonás, mul: szorzás, div: osztás).

Tört -a: int -b: int +$lnko(a:int, b:int): int -egyszerűsítés() + (a':int, b':int) +vegyestört(): String +add(t:Tört):Tört +sub(t:Tört):Tört +mul(t:Tört): Tört +div(t:Tört): Tört

public Tört add(Tört t) { public Tört add(Tört t) {

return new Tört(a*t.b+t.a*b,b*t.b); } return new Tört(a*t.b+t.a*b,b*t.b); }

public Tört sub(Tört t) { public Tört sub(Tört t) {

return new Tört(a*t.b-t.a*b,b*t.b); } return new Tört(a*t.b-t.a*b,b*t.b); }

public Tört mul(Tört t) { public Tört mul(Tört t) {

return new Tört(a*t.a,b*t.b); } return new Tört(a*t.a,b*t.b); }

public Tört div(Tört t) { public Tört div(Tört t) {

return new Tört(b*t.b,a*t.a); } return new Tört(b*t.b,a*t.a); }



Túlterhelés (overloading)

A Tört osztály alapműveleteit egészekre is készítsük el (pl. mul(i:int): Tört).Metódusnevek túlterhelése: a metódusokat nem csak a nevük azonosítja,

hanem az átvett paraméterek száma és típusa isEzek együttesen:

a metódus specifikációja vagy szignatúrája.Több, azonos nevű metódus is létezhet, amelyek

különböző számú vagy típusú paramétereket kapnak.



Túlterhelés

public Tört add(Tört t) { return new Tört(a*t.b+t.a*b,b*t.b); }

public Tört add(int i) { return new Tört(a+i*b,b); }

Tört -a: int -b: int +$lnko(a:int, b:int): int -egyszerűsítés() + (a':int, b':int) +vegyestört(): String +add(i: int):Tört +add(t:Tört):Tört +sub(i: int):Tört +sub(t:Tört):Tört +mul(i:int): Tört +mul(t:Tört): Tört +div(i:int): Tört +div(t:Tört): Tört



Túlterhelés

public Tört add(Tört t) { return new Tört(a*t.b+t.a*b,b*t.b); }

public Tört add(int i) { return new Tört(a+i*b,b); } public Tört sub(Tört t) {

return new Tört(a*t.b-t.a*b,b*t.b); } public Tört sub(int i) { return new Tört(a-i*b,b); } public Tört mul(Tört t) { return new Tört(a*t.a,b*t.b); } public Tört mul(int i) { return new Tört(a*i,b); } public Tört div(Tört t) { return new Tört(b*t.b,a*t.a); } public Tört div(int i) { return new Tört(a,b*i); }



Konstruktor túlterhelése

public class Tört {

private int a,b;

public Tört(int a_, int b_) {

a=a_; b=b_; egyszerűsítés(); }

public Tört(int a_) { a=a_; b=1; }

public Tört() { a=0; b=1; }

public Tört(Tört t) { a=t.a; b=t.b; }

...

}

Tört -a: int -b: int + (a':int, b':int) + (a':int) + () + (t: Tört) …



this(...)

public class Tört { private int a,b; public Tört(int a_, int b_) { a=a_; b=b_; egyszerűsítés(); } public Tört(int a_) { this(a_,1); } public Tört() { this(0,1); } public Tört(Tört q) { this(q.a,q.b); } ...}




Alapértelmezett és másoló konstruktor

Két speciális:Alapértelmezett konstruktor:

nincsenek paraméterei, így az objektumot egy alapértelmezett módon állítja be.

Ha egyáltalán nem adunk meg konstruktort, akkor a Java automatikusan felvesz egy alapértelmezett konstruktort, melynek a láthatósága megegyezik az osztály láthatóságával.

Másoló konstruktor: a létrehozandó osztállyal azonos típusú objektum alapján készít egy új objektumot.



Alapértelmezett paraméterértékek

Tört -a: int -b: int + (a': int =0, b': int =1) + (t: Tört) …




Lekérdezés és módosítóMódosítás: az objektum kívülről látható, megfigyelhető állapotának változása. Nem tekintjük módosításnak, ha csak a művelet

megvalósításának technikája miatt változtatunk az objektumon, de logikailag az ugyanolyan marad.

Lekérdezés: nem változtat a megfigyelhető állapoton. több lekérdezés tetszőleges sorrendben végrehajtható.

Módosító: megváltozhat a megfigyelhető állapot. több, egymás után végrehajtott módosító metódus

felcserélése más eredményre vezethet.



public class Tört public Tört add(Tört t) { return new Tört(a*t.b+t.a*b,b*t.b); } public Tört Add(Tört t) { a=a*t.b+t.a*b; b*=t.b;

egyszerűsítés(); return this; } public Tört add(int i) { return new Tört(a+i*b,b); } public Tört Add(int i) { a+=i*b; egyszerűsítés(); return this; }

Tört -a: int -b: int +$lnko(a:int, b:int): int -egyszerűsítés() + (a': int =0, b': int =1) + (t: Tört) +/vegyestört(): String +/add(i: int):Tört +/add(t:Tört):Tört +Add(i: int):Tört +Add(t:Tört):Tört …

p=q.add(r.Add(new Tört(1,2)));p=q.add(r.Add(new Tört(1,2)));



Vizsgáljuk meg, hogy egy y=ax+b formában megadott egyenesre illeszkedik-e egy (x,y) pont!

Egyenes-a: double-b: double+ (a': double, b': double)+/illeszkedik(p: Pont)?

Pont+x: double+y: double+ (x': double, y': double)



public class Pont

public class Pont {

private double x;

public double getX() { return x; }

private double y;

public double getY() { return y; }

public Pont(double x_, double y_) { x=x_; y=y_; }

public String toString() { return "("+x+","+y+") pont"; }

}

Egyenes-a: double-b: double+ (a': double, b': double)+/illeszkedik(p: Pont)?

Pont+x: double+y: double+ (x': double, y': double)



public class Egyenespublic class Egyenes { private double a, b; public Egyenes(double a_, double b_) { a=a_; b=b_; } public String toString() { return "y=" + a + "x" + (b>=0 ? "+" : "") + b + " egyenes"; } public boolean illeszkedik(Pont p) {

return p.getY() == a*p.getX()+b; } public static void main(String[] args) { Pont p = new Pont(2,3); Egyenes e = new Egyenes(1,1); System.out.println("A "+p+" az "+e+"re "+ ( e.illeszkedik(p) ? "" : "nem " )+"illeszkedik."); }}



10.Öröklés



Határozzuk meg egy R->R y=f(x) függvény határozott integráljának közelítését a trapéz-formula segítségével (n osztópont esetén)!Függvény:

x értékhez megadja a megfelelő y=f(x) értéket.

-f

HatározottIntegrál -a: double -b: double -n: int + (f': Függvény, a':double, b':double, n': int) +/integrál: double

Függvény +/y(x: double): double



Először: konkrét fv.

public class LineárisFüggvény { private double a, b; public LineárisFüggvény(double a_, double b_) { a=a_;

b=b_; } public double y(double x) { return a*x+b; } public String toString() { return

"LineárisFüggvény("+a+"x+"+b+")"; }}

LineárisFüggvény +/y(x: double): double

Integrál -a: double -b: double -n: int + (f: LineárisFüggvény, a':double, b':double, n': int) +/integrál: double



public class HatározottIntegrál

private LineárisFüggvény f;

private double a,b; private int n; private double integrál; public double getIntegrál() { return integrál; } public HatározottIntegrál(LineárisFüggvény f_, double a_, double b_, int n_) { f=f_; a=a_; b=b_; n=n_; double h=(b-a)/n, s=(f.y(a)+f.y(b))/2, x=a; for(int i=1; i<=n-1; i++) { x+=h; s+=f.y(x); } integrál = s*h; } public String toString() { return

"HatározottIntegrál( ["+a+";"+b+"] "+n+" osztópont, "+ "függvény: "+f+")"; }



Általánosítás/pontosítás

OO nyelvek: új típusok (osztályok) készítésekor az adatokhoz hozzákapcsolhatjuk az azokat kezelő alprogramokat (a metódusokat).

Osztályt általánosan definiálunk, majd további speciális (pontosított) változatokat készítünk.

Az osztály pontosítása, specializálása: felvehetünk újabb attribútumokat, illetve tulajdonságokat, felvehetünk újabb műveleteket, a már definiált műveleteket átdefiniálhatjuk.



Öröklés

A pontosított alosztály átveszi, örökli az alaposztály, az ős jellegzetességeit (azokat nem kell újra leírnunk). A műveletek átdefiniálásával az alaposztály viselkedési

módját, működését a specializált osztályokban módosíthatjuk.

Öröklés technikája lehetővé teszi a helyettesíthetőséget: egy alosztály objektuma bárhol felhasználható, ahol az ősosztály objektumára hivatkozunk. Egy változatra bizonyos helyeken általános módon is

hivatkozhatnunk.



Pontosítás

public class LineárisFüggvény extends Függvény { … }


Integrál -a: double -b: double -n: int + (f: Függvény, a':double, b':double, n': int) +/integrál: double

LineárisFüggvény :Függvény -a,b: double + (a': double, b':double) +/y(x: double): double



public class Függvény { public double y(double x) { return 0; } public String toString() { return "KonstansFüggvény( 0 )"; }}

public class LineárisFüggvény extends Függvény {

private double a, b; public LineárisFüggvény(double a_, double b_) {

a=a_; b=b_; } public double y(double x) { return a*x+b; } public String toString() { return

"LineárisFüggvény("+a+"x+"+b+")"; }}


LineárisFüggvény :Függvény -a,b: double + (a': double, b':double) +/y(x: double): double



Őstípus felhasználása... public HatározottIntegrál(Függvény f_, double a_,

double b_, int n_) { a=a_; b=b_; n=n_; f=f_; double h=(b-a)/n, s=(f.y(a)+f.y(b))/2,

x=a; for(int i=1; i<=n-1; i++) { x+=h; s+=f.y(x); } integrál = s*h; } ...public class SinusFüggvény extends Függvény { public double y(double x) { return Math.sin(x); } public String toString() { return "SinusFüggvény()"; }}



Konverzió

Egy objektumnak az ősosztály típusává való átalakítása bővítő konverziónak számít (!), bizonyos helyeken automatikusan végrehajtódik. Pl. a HatározottIntegrál osztály konstruktorában Függvény

típusként bármely alosztály objektumát is átvehetjük.

A konverzió ellenére az alosztálynak megfelelő metódusok hajtódnak végre, azaz minden objektum „tudja”, hogy a metódust milyen utasítássorozattal kell végrehajtania.



Polimorfizmus

Adott osztályúként tekintett objektum azonos szignatúrájú metódusához más utasítássorozat is tartozhat.

Polimorfizmus (többalakúság): egy általánosként tekintett objektum (például egy Személy) több változatban, alakban is megjelenhet. A változatok az általánosként tekintett objektum eltérő működésével figyelhetők meg.



Absztrakt osztály/metódusLogikai hiba: általános függvény nem létezikabsztrakt osztály: általános keretet határoz meg, de konkrét esetben

objektumként csak valamely speciális alváltozat jelenhet meg. absztrakt osztályú objektumot közvetlenül nem készíthetünk,

csak közvetve, valamely (már nem absztrakt) alosztályán keresztül.

ellentéte a konkrét osztály amely példányosítható.

absztrakt metódus: a metódusnak csak az alosztályokban való létezését jelentjük

ki, de ahhoz nem rendelünk alapértelmezett műveletsorozatot



Absztrakt osztály/metódus

public abstract class Függvény {

public abstract double y(double x);

}

Integrál -a: double -b: double -n: int + (f: Függvény, a':double, b':double, n': int) +/integrál: double


KonstansFüggvény -a: double + (a': double) +/y(x: double): double

LineárisFüggvény -a,b: double + (a': double, b':double) +/y(x: double): double



OO – kompozíciós lehetőségpublic class FüggvényÖsszeg extends Függvény {

private Függvény f,g;

public FüggvényÖsszeg(Függvény f_,Függvény g_) { f=f_; g=g_; }

public double y(double x) { return f.y(x)+g.y(x); }

public String toString() { return "ÖsszegFüggvény("+f+" + "+g+")"; }

}

public class ÖsszetettFüggvény extends Függvény {

private Függvény f,g;

public ÖsszetettFüggvény(Függvény f_,Függvény g_) { f=f_;g=g_; }

public double y(double x) { return f.y(g.y(x)); }

public String toString() { return "ÖsszetettFüggvény("+f+" o "+g+")"; }

}



Kompozíciós lehetőség... HatározottIntegrál i= new HatározottIntegrál( new FüggvényÖsszeg( new ÖsszetettFüggvény( new LineárisFüggvény(2,3), new SinusFüggvény() ), new KonstansFüggvény(3) ), -1, 1, 100); System.out.println(i+"="+i.getIntegrál());...



Láthatóságpublic (publikus, nyilvános): bárhonnan elérhetők, ha az objektum vagy az osztály (osztály-

jellegzetesség esetén) is elérhető.protected (védett): csak a definiáló osztály határain belül érhetők el. A pontosított

változatok még a határon belül vannak, így az alosztályok is elérik a védett jellegzetességeket.

A nem pontosított osztályból azonban rejtve maradnak.jelöletlen: csomag-láthatóságú (package visibility) azonos csomagból a jellegzetességek elérhetők, a csomagon kívül

azonban rejtettek.private (saját, privát): nem érhetőek el más osztályokból, még a pontosított alosztályokból

sem.



Láthatóság

Kívülről is elérhető/használható jellegzetesség: publikus

A megvalósítással kapcsolatos részletek: általában saját (private), esetleg, ha a csomag

több osztálya is érintett, akkor csomag-láthatóságú

Osztály logikájához kapcsolódó (absztrakt modell szintű), de nem publikus: védett (protected)



Láthatóság

Lineáris egyenletrendszer -a,b,c: double -d,e,f: double + (a': double, b': double, c': double, d': double, e': double, f ': double) #/det: double {a*e-b*d} #/detX: double {b*f-c*e} #/detY: double {c*d-a*f} +/határozott? { det0 } +/határozatlan? { határozott detX=0 } +/ellentmondásos? { határozott detX0 } +/x: double { detX/det } +/y: double { detY/det }



Átdefiniálás / finalPontosítás során a saját metódusok nem definiálhatók át.

Átdefiniáláskor legfeljebb bővíthetjük, de nem szűkíthetjük a láthatóságot. csomag-láthatóságról védettre vagy publikusra, védettről pedig publikusra változtathatjuk.

final metódus: megtiltjuk a metódus átdefiniálását. (pl. biztonsági ok miatt) adott osztály metódusa még az alosztályokban is mindig az elvárt

módon működjön.

final osztály: megtilthatjuk, hogy az osztályt pontosítsák a jelölés részben azt is eredményezi, mintha az összes metódust

final-ként jelölnénk.



11.Interfész



Interfész

Integrálás: ha ismerjük a primitívfüggvényét, akkor egyszerűen kiszámítható ( F(b)-F(a) )

Primitívfüggvény: olyan lehetőség, amely segítségével hatékonyabban hajthatjuk végre a határozott integrál kiszámításának műveletét.

OO szemlélet: a lehetőségeket interfészekként (interface), más néven kapcsolódási felületként adhatjuk meg.



Interfésza publikus metódusoknak a csoportját definiálja, mely így az objektum elérésének egy lehetséges módját határozza meg.

hasonlít az absztrakt osztályhoz, azonban minden metódusa absztrakt és publikus, illetve attribútumként csak statikus és final adatokat (azaz konstansokat) definiálhatunk.

logikailag eltér az osztálytól, egy interfész valamely más osztályra vonatkozó lehetőségeket,

annak egy használati módját jelenti, így önmagában nem is értelmezhető.




PrimitívFüggvényű +/primitívFüggvény: Függvény

KonstansFüggvény -a: double + (a': double) +/y(x: double): double +/integrálFüggvény :Függvény

Interfész

public interface PrimitívFüggvényű {

public Függvény getPrimitívFüggvény();

}



public class KonstansFüggvény extends Függvény implements PrimitívFüggvényű { private double a; public KonstansFüggvény(double a_) { a=a_; } public double y(double x) { return a; } public Függvény getPrimitívFüggvény() { return new LineárisFüggvény(a,0); } public String toString() {

return "KonstansFüggvény( "+a+" )"; }}



public HatározottIntegrál(Függvény f_, double a_, double b_, int n_) {

a=a_; b=b_; n=n_; f=f_;

double h=(b-a)/n, s=(f.y(a)+f.y(b))/2, x=a;

for(int i=1; i<=n-1; i++) { x+=h; s+=f.y(x); }

integrál = s*h;

}

ha PrimitívFüggvényűha PrimitívFüggvényű



instanceofpublic HatározottIntegrál(Függvény f_, double a_, double b_, int n_) { f=f_; a=a_; b=b_; n=n_; if(f instanceof PrimitívFüggvényű) { pontos=true; Függvény

F=((PrimitívFüggvényű)f).getPrimitívFüggvény(); integrál=F.y(b)-F.y(a); } else { double h=(b-a)/n, s=(f.y(a)+f.y(b))/2, x=a; for(int i=1; i<=n-1; i++) { x+=h; s+=f.y(x); } integrál=s*h; } }



PontosításEgy osztály legfeljebb egyetlen ősosztályt pontosíthat, egy interfésznek azonban több „ősinterfésze” is lehet. Az alaptípust az extends kulcsszó után adjuk meg.

Interfész esetén több ősinterfészt vesszővel választunk el egymástól.

Egy osztály több interfészt is implementálhat (!), azaz több interfésszel leírt lehetőséget is megvalósíthat. A megvalósított interfészeket az implements kulcsszó

után, vesszővel elválasztva soroljuk fel.



Pontosítás

Interfész megvalósításakor definiálni kell az abban megadott metódusokat, különben az osztályt az abstract jelzővel kell ellátni.

Ha egy osztály implementál egy interfészt, azaz rendelkezik az elérésnek ezzel a lehetőségével, akkor természetesen annak a leszármazott osztályai is mind rendelkeznek ezzel a lehetőséggel.



Konverzió

Egy objektum mindig „ismeri” a saját osztályát, azt, amely alapján a new operátorral létrehoztuk.

Objektum tekinthető az osztálya vagy bármely ősosztálya objektumaként, az osztály vagy valamely ősosztály által megvalósított

bármely interfészű objektumként.



Konverzió

Bővítő-konverzió: adott osztályúként tekintett objektumot az osztály ősosztályába vagy valamely implementált interfészébe konvertálunk (pontosabb változatból általánosabb típusúvá alakítunk.

Szűkítő-konverzió típuskonverziós operátorral: a többi (tényleges) osztályába vagy másik implementált interfészébe is alakítható A Java a szűkítő-konverzió során ellenőrzi, hogy a megadott

osztály valóban az objektum osztálya vagy ősosztálya-e, illetve, hogy interfész esetén az objektum ténylegesen implementálja-e az interfészt.



Belső osztály

A primitívfüggvény képzésének a lehetősége logikailag szorosan kapcsolódik a Függvény osztályhoz.

Egy osztályt vagy egy interfészt egy másik osztályon, illetve bizonyos esetekben egy másik interfészen belül, annak egy jellegzetességeként is definiálhatunk

A belső osztály (inner class) egy osztályon vagy interfészen belül definiált másik osztály vagy interfész.



Belső osztályA belső osztály (inner class) egy osztályon vagy interfészen belül definiált másik osztály vagy interfész. van láthatósága, pl. a publikus belső osztály kívülről is

elérhető, ill. publikus konstruktor esetén példányosítható. a befogadó osztály definícióján kívül minősített névvel

érhetjük el. Például a Függvény osztályon belüli PrimitívFüggvényű interfészre a Függvény.PrimitívFüggvényű módon hivatkozhatunk.

a belső osztály a befogadó osztály „határain” belül helyezkedik el, ezért a befogadó osztály objektumainak a privát jellegzetességeit is eléri (!).

A belső osztály statikus is lehet, ami azt jelenti, hogy a definíciója független a befogadó osztály objektumától.



Belső osztály

public abstract class Függvény { public static interface PrimitívFüggvényű { public Függvény getPrimitívFüggvény(); } public abstract double y(double x); }

Függvény+/y(x: double): double

+$PrimitívFüggvényű+/integrálFüggvény: Függvény



public class KonstansFüggvény extends Függvény implements Függvény.PrimitívFüggvényű { private double a; protected class PrimitívFüggvény extends Függvény { public double y(double x) { return a*x; } public String toString() { return "PrimitívFüggvény( "+KonstansFüggvény.this+" )"; } } public KonstansFüggvény(double a_) { a=a_; } public double y(double x) { return a; } public Függvény getPrimitívFüggvény() { return new PrimitívFüggvény(); } public String toString() { return "KonstansFüggvény( "+a+" )"; }}



osztálynév.this

osztálynév.this közvetlenül hivatkozhatunk az adott osztályú külső

objektumra, illetve a jellegzetességeire, pl. KonstansFüggvény.this.a.

a belső osztályban a külső jellegzetességgel azonos nevű jellegzetesség elérése

Belső osztály objektumának létrehozása f.new PrimitívFüggvény()



Lokális osztály

utasításblokkon belül definiált

csak az utasításblokkon belül látható

nem lehet statikus.

a befogadó objektum jellegzetességei mellett a lokális osztály objektuma eléri az utasításblokk final módon deklarált paramétereit és lokális változóit is(!).



public class KonstansFüggvény extends Függvény implements Függvény.PrimitívFüggvényű { private double a; public KonstansFüggvény(double a_) { a=a_; } public double y(double x) { return a; } public Függvény getPrimitívFüggvény() { class PrimitívFüggvény extends Függvény { public double y(double x) { return a*x; } public String toString() { return "PrimitívFüggvény( "+KonstansFüggvény.this+" )"; } } return new PrimitívFüggvény(); } public String toString() { return "KonstansFüggvény( "+a+" )"; }}



Névtelen osztályok

A programozás során gyakran előfordul, hogy bizonyos osztályokat csak egyetlen egy helyen példányosítunk. Egyetlen helyen példányosított osztályokat definiálhatunk

elnevezés nélkül, a példányosítás helyén.

A névtelen osztály (anonymous class) hasonló a lokális osztályhoz konstruktort nem adhatunk meg (csak inicializáló blokkot,

lásd később)



public class KonstansFüggvény extends Függvény implements Függvény.PrimitívFüggvényű { private double a; public KonstansFüggvény(double a_) { a=a_; } public double y(double x) { return a; } public Függvény getPrimitívFüggvény() { return new Függvény() { public double y(double x) { return a*x; } public String toString() { return "PrimitívFüggvény( "+KonstansFüggvény.this+" )"; } }; } public String toString() { return "KonstansFüggvény( "+a+" )"; }}



Névtelen osztály

...

HatározottIntegrál i= new HatározottIntegrál(

new Függvény() {

public double y(double x) {

return Math.sin(x)+2*Math.cos(x);

}

}

, -1, 1, 100);

System.out.println(i+"="+i.getIntegrál());

...



Object

Java nyelven csak egyetlen osztályt adhatunk meg ősosztályként.Ha nem adunk meg ősosztályt, akkor a Java

automatikusan a java.lang.Object osztályát veszi ősosztályként.

Object definiálja a +toString():String metódust, ezért bármely objektum szöveggé alakítható, mivel mindegyik rendelkezik ezzel a metódussal.



super

osztály definícióján belül az ősosztály jellegzetességét a super kulcsszóval érhetjük el.

az ősosztály attribútumára akkor is hivatkozhatunk, ha az osztályban felveszünk egy azonos nevű attribútumot.

az ősosztály metódusát akkor is meghívhatjuk, ha a metódust az osztályban átdefiniáljuk.



super(...)

osztály konstruktorából az ősosztály konstruktorát a blokk legelső utasításaként szereplő super(paraméterek); utasítással hívhatjuk meg.Ha nincs this(paraméterek); vagy super(paraméterek); akkor a Java oda automatikusan a super(); utasítást szúrja be

Ha nem adunk konstruktort: automatikusan felvesz egy alapértelmezett konstruktort. hibalehetőség...



12.Kivételkezelés



Kivételes helyzetek

Hibalehetőségek: negatív oldalhosszúságú téglalap, 0 nevezőjű tört, prímtényezős felbontásban 2-nél kisebb szám, stb.

Hibakód visszaadása: a kódot minden egyes hívás után tesztelnünk kellene körülményes, nehezebben áttekinthető

Pl.:téglalap.setA( Double.parseDouble( téglalapA.getText() ) );

Hibakódos megoldás esetén a parseDouble metódus egy hibakódot is visszaadna, amit mindig vizsgálnunk kellene.



KivételekKivételek: a kivételes eseményeket kivételes módon figyeljük és kezeljük

le. a programot a normális (értsd: „nem kivételes”) működésnek

megfelelően írjuk le a hiba helyén a program „szól” a hiba felléptéről a fellépő hibákat egy-egy gyűjtőhelyen kezelhetjük

A kivételes helyzet bekövetkezéséről egy kivétellel (exception) üzenhetünk. Java nyelven a kivételek is objektumok a kivételek típusát osztályként kell megadnunk kivételként a Throwable osztály alosztálya használható



Kivétel-osztályokThrowable: Error: a rendszer olyan alapvető hibáit jelölik

gyakorlatilag le sem kezelhetők (pl. nincs több szabad memória)

Exception: kezelhetők. RuntimeException (Exception alosztálya)

futási idejű kivételes esemény (pl. nullával való osztás vagy helytelen konverzió)

átgondolt és helyes programokban gyakorlatilag soha nem jelentkezik.

Kivétel-osztály általában az Exception alosztálya, egyes ritka esetekben a RuntimeException alosztálya



Kivételes helyzetekLineáris egyenletrendszer

-a,b,c: double-d,e,f: double+ (a': double, b': double, c': double, d': double, e': double, f ': double)-/det: double {a*e-b*d}-/detX: double {c*e-b*f}-/detY: double {a*f-c*d}+/határozott? { det0 }+/határozatlan? { határozott detX=0 }+/ellentmondásos? { határozott detX0 }+/x: double { detX/det }+/y: double { detY/det } hibalehetőséghibalehetőség



Kivételekpublic class HatározatlanEgyenletrendszer extends Exception { public String toString() {return "Határozatlan egyenletrendszer"; }} public class EllentmondásosEgyenletrendszer extends Exception { public String toString() { return "Ellentmondásos egyenletrendszer"; }}

public double getX() throws HatározatlanEgyenletrendszer, EllentmondásosEgyenletrendszer { if(!isHatározott()) { if(isHatározatlan()) throw new HatározatlanEgyenletrendszer(); else throw new EllentmondásosEgyenletrendszer(); } else return getDetX()/getDet(); }



...public double getX() throws

HatározatlanEgyenletrendszer,EllentmondásosEgyenletrendszer{ if(!isHatározott()) {

if(isHatározatlan()) throw new HatározatlanEgyenletrendszer();

else throw new EllentmondásosEgyenletrendszer(); } return getDetX()/getDet(); }



^: „okozhat”

Lineáris egyenletrendszer -a,b,c: double -d,e,f: double + (a': double, b': double, c': double, d': double, e': double, f ': double) #/det: double {a*e-b*d} #/detX: double {c*e-b*f} #/detY: double {a*f-c*d} +/határozott? { det0 } +/határozatlan? { határozottEgyenletrendszer detX=0 } +/ellentmondásos? { határozottEgyenletrendszer detX0 } +/x: ^Határozatlan, Êllentmondásos, double {detX/det} +/y: ^Határozatlan, Êllentmondásos, double {detY/det}



catch

public static void main(String[] args) { LineárisEgyenletrendszer e= new LineárisEgyenletrendszer(1,2,2, 2,1,-4); try { System.out.println("x="+e.getX()+", y="+e.getY()+"."); } catch(HatározatlanEgyenletrendszer x) { System.out.println("Határozatlan egyenletrendszer"); } catch(EllentmondásosEgyenletrendszer x) { System.out.println("Ellentmondásos egyenletrendszer"); } }



Kivétel-ősosztályprivate abstract class NemHatározottEgyenletrendszer extends

Exception{ } public class HatározatlanEgyenletrendszer extends NemHatározottEgyenletrendszer { public String toString() { return "Határozatlan

egyenletrendszer"; }} public class EllentmondásosEgyenletrendszer extends NemHatározottEgyenletrendszer { public String toString() { return "Ellentmondásos

egyenletrendszer"; }}



Kivétel-ősosztály...

public double getX() throws NemHatározottEgyenletrendszer {

if(!isHatározott()) {

if(isHatározatlan())

throw new HatározatlanEgyenletrendszer();

else

throw new EllentmondásosEgyenletrendszer();

}

return getDetX()/getDet();

}



Kivétel-ősosztály

public static void main(String[] args) { LineárisEgyenletrendszer e= new LineárisEgyenletrendszer(1,2,2, 2,1,-4); try { System.out.println("x="+e.getX()+","+ "y="+e.getY()

+"."); } catch(NemHatározottEgyenletrendszer x) { System.out.println(x); } }



Exception

Összes kivétel elkapása:

try { ...

} catch(Exception e) {

System.out.println(e.getMessage()); e.printStackTrace();

}



message

public abstract class NemHatározottEgyenletrendszer extends Exception {

private NemHatározottEgyenletrendszer(String msg_) { super(msg_); }

private LineárisEgyenletrendszer source; public LineárisEgyenletrendszer getSource() {

return source; } public String toString() { return getMessage()+": "+ getSource()

+"."; }}

Célszerű felvenni egy source tulajdonságot is



Kivétel belső osztálykéntHa a kivétel alapvetően csak egyetlen osztályra vonatkozik: belső osztályként definiálva automatikusan rendelkezésre áll a létrehozás alapobjektuma.

public class LineárisEgyenletrendszer { public abstract class NemHatározott extends Exception { private NemHatározott(String message_) { super(message_); } public LineárisEgyenletrendszer getSource() { return LineárisEgyenletrendszer.this; } public String toString() { return getMessage()+": "+ getSource()+"."; } }...



^?: („kivéve, ha”)

Lineáris egyenletrendszer -a,b,c: double -d,e,f: double + (a': double, b': double, c': double, d': double, e': double, f ': double) #/det: double {a*e-b*d} #/detX: double {c*e-b*f} #/detY: double {a*f-c*d} +/határozott? { det0 } +/határozatlan? { határozott detX=0 } +/ellentmondásos? { határozott detX0 } +/x: ^?határozatlan, ^?ellentmondásos, double { detX/det } +/y: ^?határozatlan, ^?ellentmondásos, double { detY/det }



^?: („kivéve, ha”)

public double getX() throws Határozatlan,Ellentmondásos {

if(isHatározatlan()) throw new Határozatlan(); if(isEllentmondásos()) throw new

Ellentmondásos(); return getDetX()/getDet(); }

a vázlat mindig csak az elvet jeleníti meg, így azt hatékonyabb módon (alosztályok, stb.) is megvalósíthatjuk.



A kivétel kezelésének áthárítása

...

public static void main(String[] args)

throws Határozatlan,Ellentmondásos {

LineárisEgyenletrendszer e=

new LineárisEgyenletrendszer(1,2,2, 2,1,-4);

System.out.println("x="+e.getX()+", y="+e.getY()+".");

}



finally

blokk utasítássorozatának félbeszakadása: kivételes esemény hatására. break, ill. continue.

Zárótevékenység: valamely megkezdett tevékenységet mindenképpen be akarunk fejezni pl. használt erőforrásokat lezárása

Kivételkezeléshez hasonló megadás. try-blokkot követő catch-szerkezet(ek) után a finally („végül”)

kulcsszó után a zárás-jellegű tevékenységek.



try {...} catch(E1 e1) { …} catch(E2 e2) { …} finally { …}

Mindenképpen végrehajtódik normál végrehajtás esetén is kivétel esetén is, függetlenül, hogy egy catch kezeli-e

Olyan try-blokkot is megadhatunk, amelyben csak egy finally-ág szerepel.



Objektumok megszüntetése

Nincs közvetlen lehetőség a már nem használt objektumok megszüntetéséreJVM szemétgyűjtés (garbage collection) eljárása sorra veszi a már nem használt objektumokat és

felszabadítja az azok által elfoglalt területeket.

A gc automatikusan elindul, ha elfogyott a rendelkezésre álló memória. System.gc(); hívással elindítható

#finalize(): a terület felszabadítása előtt meghívódik, így az objektum lebontása (destrukciója) előtt még végrehajthatunk műveleteket.



13.Tömb



Összetett adatok Elemi típus: az érték közvetlenül a befogadó-területen helyezkedik el.

Referencia-típus: az érték külön területet foglal el, a befogadó-területre pedig csak egy hivatkozás (referencia)A referencia segítségével ugyanazt az adatot az

érték másolása nélkül, több helyről is elérhetjük int | | double

…

int | int | int |



Összetett adatokOsztály: előre megadott számú adatot (attribútumot) tartalmaz az adatok különböző típusúak lehetnek. adatelemeket a pont-jelölés segítségével érjük el.

Tömb: létrehozáskor egy számérték adja meg az adatelemek

számát. az adatok azonos típusúak lehetnek. adatelemeket az indexnek nevezett sorszámukkal érjük el

a sorszámozás nullától kezdődik a[i]



Készítsünk egy Dátum osztályt, amely meg tudja mondani, hogy az adott hónapban hány nap van!

Dátum-év: int-hó: int-nap: int+ (év':int, hó':int, nap':int)+/szökőév?+/hónapNapjai: int



public class Dátum private int év, hó, nap;

public Dátum(int év_,int hó_,int nap_) { év=év_; hó=hó_; nap=nap_; } public boolean isSzökőév() { return év%4==0&&!(év%100==0)||év

%400==0;} public int getHónapNapjai() { switch(hó) { case 1: case 3: case 5: case 7: case 8: case 10: case 12: return 31; case 4: case 6: case 9: case 11:

return 30; case 2: return isSzökőév() ? 29 : 28; } return 0; }



public class Dátum private int év, hó, nap;

public static final int HónapNapjai[ ] = {

0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31,

};

public Dátum(int év_,int hó_,int nap_) { év=év_; hó=hó_; nap=nap_; }

public boolean isSzökőév() { return év%4==0&&!(év%100==0)||év%400==0; }

public int getHónapNapjai() {

return (hó==2 && isSzökőév()) ? 29 : HónapNapjai[hó];

}

public String toString() { return év+"-"+hó+"-"+nap; }


Dátum d =new Dátum(1999,8,11);

System.out.println(d+" hónapjában a napok száma: "+

d.getHónapNapjai()+".");

}



Tömb-változó

double a[] adott alaptípusú tömböt és adott típusú változó

pl.: double a[],x

double[] a az összes változót tömbként definiálja,

pl. double[] a, x



Tömb létrehozása

Létrehozás:new double[10]

Elemek száma:tömbKifejezés.length

Kezdőérték:a = new double[ ] { 4,5,6 }



Többdimenziós tömb

kétdimenziós tömbváltozó:double a[][]

létrehozásaa = new double[2][3]

kezdőértéka = new double[][] { { 1,2,3 }, {4,5,6} }

hivatkozása[i][j]



Többdimenziós tömb

Létrehozás:a = new double[2][]

Különböző méretű altömbök:a[0] = new double[3];

a[1] = new double[5];



public class Dátum

private int év, hó, nap; public static final int HónapNapjai[] [] = { { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }, { 0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 } }; public Dátum(int év_,int hó_,int nap_) {év=év_;hó=hó_;nap=nap_;} public boolean isSzökőév() { return év%4==0&&!(év%100==0)||év

%400==0; } public int getHónapNapjai() { return HónapNapjai[isSzökőév() ? 1 : 0][hó]; }...



Egyszerű leképezés A Dátum osztályt egészítsük ki a hétNapja tulajdonsággal, amely megadja, hogy a dátum a hét melyik napjára esik (hétfő, kedd, stb.)!

public static final String HétNapjai[] = {

"vasárnap","hétfő","kedd","szerda","csütörtök","péntek","szombat"

};

public String getHétNapja() {

int e=év, h=hó; // másolat az értékekről

if(h<=2) { --e; h+=10; } else h-=2; // római naptár

int c=e/100, x=e%100; // Százévek és az azon belüli évek

return HétNapjai[(c/4-2*c+x+x/4+(int)(2.6*h-0.199)+nap)%7];

}



Konverzió (referencia-típus)bővítő (widening) konverziók: adott osztályúként tekintett objektum az osztály ősosztályának

objektumaként, ill. interfészre is adott osztályúként tekintett objektumot az osztály által

implementált bármely interfészű objektumként, bármely referencia-érték tekinthető Object-ként, null konvertálható bármely referencia-típusúvá. referencia-értékek tömbje esetén az alaptípus konverzióját veszi

figyelembe

általános típusként tekintett referencia-érték az eredeti típusúvá visszaalakítható, mely szűkítő-konverziónak számít. a Java ellenőrzi, hogy a konverzió megfelelő-e ClassCastException (ami egy RuntimeException)



14.Számlálás, összegzés



Számlálás

Egy cég havi bontásban megadott bevételei közül számláljuk meg azokat a hónapokat, melyekben nem volt bevétel!

Statisztika-adatok[]: double+ (adatok'[]: double)+/hónapokSzáma :int+/bevételnélküliHónapokSzáma: int



public class Statisztika private double adatok[]; public Statisztika(double adatok_[]) { adatok=adatok_; } public int getHónapokSzáma() { return adatok.length; } public int getBevételnélküliHónapokSzáma() { int n=0; for(int i=0; i<adatok.length; ++i) if(adatok[i]==0) ++n; return n; } public static void main(String[] args) { Statisztika s =new Statisztika( new double[] { 2, 0, 4, 0, 1 } ); System.out.println(s.getHónapokSzáma()+" hónapból " +s.getBevételnélküliHónapokSzáma()+" hónapban " +"nem volt bevétel."); }



Összeg és átlag A statisztikát egészítsük ki úgy, hogy az összesített bevételt és a havi átlagot is megadja!

...... public double getÖsszesBevétel() { double s=0;public double getÖsszesBevétel() { double s=0; for(int i=0; i<adatok.length; ++i)for(int i=0; i<adatok.length; ++i) s+=adatok[i];s+=adatok[i]; return s;return s; }} public static void main(String[] args) {public static void main(String[] args) { Statisztika s =new Statisztika( new double[] { 2, 0, 4, 0, 1 } );Statisztika s =new Statisztika( new double[] { 2, 0, 4, 0, 1 } ); double összes=s.getÖsszesBevétel();double összes=s.getÖsszesBevétel(); System.out.println("Összes bevétel: "+összes+", ");System.out.println("Összes bevétel: "+összes+", "); System.out.println(" havi átlag: "+összes/s.getHónapokSzáma()+".");System.out.println(" havi átlag: "+összes/s.getHónapokSzáma()+"."); } }



Iterátor

Adatsorozat elemeit veszik sorra. pl. egy X típusú elemeket felsoroló iterátor:

+/empty()? kiürült-e az adatsorozat+/current(): X megadja az aktuális elemet+next() következő elemre lép

Egy i iterátorral felsorolt adatelemek feldolgozása: for( ; !i.empty(); i.next())

A ciklusmagban az aktuális elemre az i.current() módon hivatkozunk.



Iterátorpublic interface DoubleIterator { public boolean empty(); public double current(); public void next();}

public class DoubleArrayIterator implements DoubleIterator { private double array[]; private int i=0; public DoubleArrayIterator(double array_[]) { array=array_; } public double current() { return array[i]; } public void next() { ++i; } public boolean empty() { return i>=array.length; }}



Adatelemek feldolgozása

Iterátor segítségével tetszőleges, double típusú elemekből álló adatsorozatot feldolgozhatunk

Összegzés:

double s=0;

for(DoubleIterator i=new DoubleArrayIterator(adatok);

!i.empty(); i.next()) {

s+=i.current();

}



Összetett iterátor

Iterátor alapján újabb iterátort is készíthetünk. Pl. a következő névtelen-osztály egy i sorozat minden elemét megszoroz a sorszámával:

new DoubleIterator() { int j=1; public double current() { return i.current()*j; } public boolean empty() { return i.empty(); } public void next() { ++j; i.next(); } }



Összetett iterátorTömbben megadott iterátorok adatait egyetlen, összefüggő adatsorozattá kapcsolja:

public class DoubleJoinIterator implements DoubleIterator { private DoubleIterator a[]; private int i=-1; public DoubleJoinIterator(DoubleIterator a_[]) {a_=a;validate();} protected void validate() { while(a[++i].empty()) if(i>=a.length) {i=-1; break;} } public double current() { return a[i].current(); } public void next() { a[i].next(); validate(); } public boolean empty() { return i==-1; }}



Feldolgozó

public abstract class DoubleOperation { protected double result =0; public abstract void process(double v); public double result() { return result; } public double process(DoubleIterator i) { for( ; !i.empty(); i.next()) process(i.current()); return result(); }}



Összegzés/maximumpublic class DoubleSum extends DoubleOperation { public void process(double v) { result+=v; }}

public class DoubleMaximum extends DoubleOperation { boolean f =true; public DoubleMaximum() { } public DoubleMaximum(double v_) { result=v_; } public void process(double v) { if(f || result<v) {f=false; result=v;} }}



Feldolgozó

...

public static DoubleOperation[] process(

DoubleIterator i, DoubleOperation F[]) {

for( ; !i.empty(); i.next())

for(int j=0; j<F.length; ++j)

F[j].process(i.current());

return F;

}

...



Valós számokat tartalmazó tömb elemeinek határozzuk meg az összegét, a minimumát, a maximumát, a negatív, nulla és a pozitív értékek számát!



Feldolgozók alkalmazásaDoubleOperation F[]= DoubleOperation.process( new DoubleArrayIterator(new double[] {-1,0,1,-2,3,7,-2} ), new DoubleOperation[] { new DoubleSum(), new DoubleMinimum(), new DoubleMaximum(), new DoubleOperation() { public void process(double v) { if(v<0) ++result; } }, new DoubleOperation() { public void process(double v) { if(v==0) ++result; } }, new DoubleOperation() { public void process(double v) { if(v>0) ++result; } }, });



A Dátum osztályt egészítsük ki egy +/évNapja: int tulajdonsággal, amely megadja hogy az adott dátum az év hányadik napja!

......

public static final int HónapNapjai[][] = {public static final int HónapNapjai[][] = {

{ 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }, { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 },

{ 0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }{ 0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }

};};

public int getÉvNapja() { int s=0;public int getÉvNapja() { int s=0;

for(int i=1; i<hó; ++i) s+=HónapNapjai[isSzökőév() ? 1 : 0][i];for(int i=1; i<hó; ++i) s+=HónapNapjai[isSzökőév() ? 1 : 0][i];

return s+nap; return s+nap;

}}

......



Inicializáló blokkstatikus – nem statikus

public static final int HónapNapjai[][] = new int[][] { { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }, { 0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 } }; public static final int együttesNapok[] = new int[13]; static { int s=0; for(int i=1; i<=12; ++i) { együttesNapok[i]=s; s+=HónapNapjai[0][i]; } }



Számítsuk ki egy valós együtthatós polinom x helyen felvett helyettesítési értékét!

Polinom+/fok: int+együttható[i:int]: double+/helyettesítésiÉrték: double



Tömb-jellegű tulajdonság

private double együttható[]; // ha nem számított

public double getEgyütthatóAt(int i) // ha olvasható

public void setEgyütthatóAt(int i, double együttható_) // ha írható

Polinom+/fok: int+együttható[i:int]: double+/helyettesítésiÉrték: double



public class Polinom private double együttható[]; public int getFokszám() { return együttható.length-1; } public double getEgyütthatóAt(int i) { return i<=getFokszám() ? együttható[i] : 0; } public Polinom(double együttható_[]) { együttható=együttható_; } public Polinom() { this(new double[1]); } public double helyettesítésiÉrték(double x) { double y=0; for(int i=getFokszám(); i>=0; i--) y=y*x+getEgyütthatóAt(i); return y; } public static void main(String[] args) { System.out.println("P(2.5)=" +new Polinom(new double[]{7,4,3,2}).helyettesítésiÉrték(2.5)); }



15.Karakter és szöveg



Karakter

char: egyetlen karakter tárolására alkalmasUnicode-kódolás (65536-féle karakter)karakteres literál: aposztrófok között, pl. 'a'.

egész-jellegű típus egy karakter egész-értékké alakítható, egy egész-

érték pedig karakterré. konverzió során a karakter a kódjaként jelenik meg.



Szöveg (String)

Szövegek ábrázolása: String-osztály nyelvi kiegészítések:

String-literál (pl. "a"), konkatenáció operátor

Szöveg karaktereinek tárolása: karakter-tömbben

A String-objektumok konstansok: az eredeti szövegen nem módosíthatunk, a módosítás-jellegű műveletek újabb String-et képeznek. a szöveg egy részét (substring) az eredeti szöveg alapján is

képezhetünk.

String: karakteres-tömb, kezdőpozíció és az utolsó karakter utáni pozíciót tárol.



String: adott kezelési módú karaktertömb, amelyet alapvetően konstans szövegek tárolására készítettek.

String-osztály funkciócsoportjai: String készítés, ill. String-ből karakter- vagy bájttömböt. String adott karaktere, a szöveg hossza, részszöveg, a

szöveg elejéről és végéről a szóközök eltávolítása (trim). összehasonlítás, adott szöveggel kezdődik, végződik hozzáfűzés, nagybetűssé vagy kisbetűssé alakítás, adott

karaktert másik karakterre cserélhetünk. · A szövegben kereshetünk egy karaktert vagy egy

részszöveget.



Konstrukció/konverzió()

// üres-szöveg

(s: String) // szöveg alapján új String készítése

(tömb: char[]) // karaktertömbből szöveg készítése

/toCharArray():char[] // szövegből karaktertömb készítése

$valueOf(v: *): String // szöveg létrehozása adott, elemi típusú értékből.

$valueOf(o: Object): String// szöveg létrehozása egy objektum alapján.



Lekérdezés+/charAt(index: int): char

// az index pozíción található karakter

+/length():int

// a szöveg hossza, azaz a karaktereinek a száma

+/substring(kezdés: int, vége: int): String

// a kezdőpozíciótól a vége-1 pozícióig a részszöveg

+/substring(kezdés: int): String

// a kezdőpozíciótól a végéig terjedő részszöveg

+/trim():String

// a szöveg elejéről és végéről elhagyja a szóközöket



Hasonlítás+/compareTo(s:String): int

// összehasonlítja a szövegeket. +/equals(o:Object)?

// megegyezik-e a két szöveg +/equalsIgnoreCase(s:String)?

// a kis/nagybetűk megkülönböztetése nélkül +/startsWith(elején:String, kezdés:int =0)?

// a pozíciótól ez a szöveg kezdődik? +/endsWith(végén:String)?

// ezzel a szöveggel végződik? +/regionMatches(k:int,s:String,sK:int,h:int)?

// rész egyezése +/regionMatches(i?,k:int,s:String,sK:int,h:int)?



Átalakított szöveg

+/concat(s:String):String // a szöveghez hozzáfűzi a másik szöveget

+/toLowerCase(): String

// a nagybetűket kisbetűvé konvertálja +/toUpperCase (): String

// a kisbetűket nagybetűvé konvertálja +/replace(régi:char, új:char): String

// a „régi” karaktereket „újra” cseréli



Keresés

+/indexOf(c:char, kezdés:int=0 ):int

// a karakter első előfordulásának a helye

+/lastIndexOf(c:char):int

// a karakter utolsó előfordulásának a helye

+/lastIndexOf(c:char, vége:int):int

// utolsó előfordulás a helye

+/lastIndexOf(s:String):int

// a szöveg utolsó előfordulásának a helye

+/lastIndexOf(s:String, vége:int):int

// a szöveg utolsó előfordulásának a helye



String karakterei

Karakterek sorravétele:for(int i=0; i<s.length(); ++i)

A cikluson belül az aktuális karakterre az s.charAt(i) módon hivatkozhatunk.

Egy szövegben számoljuk meg a szóközöket!



public class Szóközök

private String string; public int getSzóközökSzáma() { int s=0; for(int i=0; i<string.length(); ++i) if(string.charAt(i)==' ') ++s; return s; } public Szóközök(String string_) { string=string_; } public static void main(String[] args) { System.out.println("Szóközök száma: "+ new Szóközök(" to be or not to be"). getSzóközökSzáma()); }



Szöveg karakterei

Egy szövegben ellenőrizzük, hogy minden nyitózárójelhez tartozik egy záró zárójel is. Ügyeljünk arra, hogy a "3)+(4" nem megfelelően zárójelezett! A nem megfelelő zárójelezés hiba, azaz különleges

esemény, ezért megtehetjük, hogy az ellenőrzés a megtalált hibáról kivétellel értesíti a hívót.

Zárójelezés-string: String+ (string': String)+/teszt(): ^váratlanZárójel, ^hiányzóZárójel



StringBuffer

String: nem változtatható.

StringBuffer: szöveg további szövegrészletekkel való kiegészítése.



StringBuffer funkciói

StringBuffer objektumot String objektummá (toString()) és vissza (konstruktor) alakíthatunk.

Elemi- vagy referencia-érték szöveges változatát egy StringBuffer objektum végéhez fűzhetjük (append) vagy egy adott pozícióra beszúrhatjuk (insert).

Szöveg adott pozícióján a karaktert módosíthatjuk (setCharAt(i:int)).

Szöveg hosszának módosítása (setLength), a szöveg rövidítése, vagy növelése a \u0000 karakterekkel történő feltöltéssel.



A Szóközök osztályt egészítsük ki egy olyan metódussal, ami a szövegnek azt a megfelelőjét adja eredményül, amelyben az egymást követő szóközök helyén csak egyetlen szóköz szerepel, ill. a szöveg elejéről és végéről is eltávolítjuk a szóközöket!



public class Szóközök

public String getTöbbszörösSzóközökNélkül() {

StringBuffer b=new StringBuffer(); int m=' ';

for(int i=0; i<string.length(); ++i) {

if(!(m==' '&&string.charAt(i)==' '))

b.append(string.charAt(i));

m=string.charAt(i);

}

if(m==‘ ‘ && b.length()>0) b.setLength(b.length()-1);

return b.toString();

}



Referencia-típusú paraméter

Paraméterátadás:elemi típusú paraméter esetén a teljes érték

lemásolódik.összetett típusú paraméter (objektum vagy tömb)

esetén csak az értékre vonatkozó hivatkozás („referencia”) adódik át.

ha a metódus belsejében az összetett értéken (pl. objektumon vagy a tömb egy elemén) módosítunk, akkor a hívó az általa elért objektumon is észleli a változást.



16.Keresés és rendezés



KeresésEgy String-ként megadott Java azonosítóról állapítsuk meg, hogy az Java kulcsszó-e!

public class Elemzés {public class Elemzés {

public static final String kulcsszó[] = {"abstract", ...};public static final String kulcsszó[] = {"abstract", ...};

public static boolean isKulcsszó(String string) { public static boolean isKulcsszó(String string) {

for(int i=0; i<kulcsszó.length; ++i)for(int i=0; i<kulcsszó.length; ++i)

if(kulcsszó[i].equals(string)) return true;if(kulcsszó[i].equals(string)) return true;

return false;return false;

} }

public static void main(String[] args) { public static void main(String[] args) {

System.out.println("kulcsszó a main: "+Elemzés.isKulcsszó("main"));System.out.println("kulcsszó a main: "+Elemzés.isKulcsszó("main"));

}}

} }



Sorrend kihasználásapublic class Elemzés { public static final String kulcsszó[] = {"abstract", ...}; public static boolean isKulcsszó(String string) { for(int i=0; i<kulcsszó.length; ++i) if(kulcsszó[i].compareTo(string)==0) return true; else if(kulcsszó[i].compareTo(string)>0) break; return false; } public static void main(String[] args) { System.out.println("main kulcsszó: "+ Elemzés.isKulcsszó("main")); }}



Objektumok egyenlősége

Az == és a != operátorok nem csak elemi adatok, hanem referenciák esetén is alkalmazhatók (<, <=, >, >= nem). DE: referenciák esetén az azonosságot vizsgálja

Egyenlőség vizsgálata: Object osztály +/equals(o:Object)? Metódusa alapértelmezésként az == művelet átdefiniálható



java.util.Vector (összetett adatok) +/size(): int

// az elemek száma +/elementAt(i:int):Object

// az i indexű helyen álló elem +setElementAt(i:int, o:Object)

// az i helyen álló elem beállítása +/isEmpty()?

// üres a vektor (nincs benne elem)? +/elements():Enumeration

// a vektor elemeinek felsorolása +/contains(o:Object)?

// szerepel benne az elem? +/indexOf(o:Object):int

// hol található az elem (-1, ha az elem nem szerepel)



java.util.Vector +addElement(o:Object)

// a Vector végéhez fűz egy elemet +insertElementAt(i:int,o:Object)

// beszúr egy elemet az adott pozícióra+removeElement(o:Object)

// törli az elemet +removeAllElements()

// törli az összes elemet +trimToSize()

// az aktuális elemszámnak megfelelő méretűre állítja a tárolás tömbjét



Vector

Vector objektum Object típusú elemek, azaz tetszőleges referencia-típusú értékek tárolására alkalmas.

Vector: dinamikusan változtat a méretét elem hozzáadása (addElement) vagy beszúrása

(insertElement) esetén a tároló tömb automatikusan nagyobb méretűre cserélődik.



Vector alkalmazásaimport java.util.Vector;public class Elemzés { public static final Hashtable kulcsszó = new Hashtable(); static { String T[] = {"abstract", ... }; for(int i=0; i<T.length; ++i) kulcsszó.put(T[i], T[i]); } public static boolean isKulcsszó(String string) { return kulcsszó.containsKey(string); } public static void main(String[] args) { System.out.println("kulcsszó a main: "+ Elemzés.isKulcsszó("main")); }}



Vector elemeinek sorravétele

Tömb-jellegű módon:for(int i=0; i<v.size(); ++i)

aktuális elem: v.elementAt(i)

elements(): java.util.Enumeration objektummal



java.util.Enumeration

+/hasMoreElements()? // a felsorolás tartalmaz-e még több elemet?

+nextElement(): Object // a felsorolás következő elemét adja meg

Az első elem elé lép!while( e.hasMoreElements() )

System.out.println(e.nextElement());

Általában konverzió: (típus)e.nextElement()



java.util.Hashtable

Tömb: tekinthető a 0 és n közötti egészeken értelmezett leképezésként. Tömb-jellegű tulajdonság: valamely indexszerepű

érték (vagy értékek) alapján határozunk meg vagy állíthatunk be egy értéket.

Az indexszerepű értéket kulcsnak (key) nevezzük.

Hashtable: referencia-típusú kulcsok esetén alkalmazható



java.util.Dictionary +/size():int

// a táblában lévő elemek száma+/isEmpty()?

// üres (nincs benne elem)?+/keys():Enumeration

// a kulcsok felsorolása+/elements():Enumeration

// az értékek felsorolása+/get(key:Object):Object

// kulcsnak megfelelő érték lekérdezése+put(key:Object, value:Object)

// kulcsnak megfelelő érték beállítása+remove(key:Object) // kulcsnak megfelelő érték kivétele



Hashtable+clear()

// a táblában lévő összes elem kivétele

+/containsKey(key:Object)? // szerepel a táblában a kulcs?

+/contains(value:Object)? // szerepel a táblában az adott érték?

Object osztály +/hashCode():int metódusabármely referencia-típusú értékAlapértelmezésként egyediÉrték alapján célszerű beállítani



Csomagoló-osztályok

Vector, Hashtable, Enumeration stb., Object típusú elemek: objektumok és tömbök esetén használhatók

Elemi típusú értékek:elkészítjük az elemi típusra specializált változatot

(például IntVector, DoubleVector, stb.). csomagoló-osztályok



csomagoló-osztály (wrapper-class)

Minden elemi típushoz rendelkezésre áll:Boolean, Byte, Character, Short, Integer, Long, Float, Double

Elemi érték -> objektum: konstruktor (pl. new Integer(-1))

Objektum -> elemi értékmegfelelő metódus,

pl.: booleanValue(), byteValue(), charValue(), stb.



Szövegből/szöveggé alakítás

Szövegből: Konstruktorral objektum parseByte(s:String): byte statikus metódusok

(Hibás forma esetén NumberFormatException) Egész típusok esetén: adott számrendszer

Szöveggé alakítás: a csomagoló osztály +/toString():String metódusával, elemi értékeknél pedig a megfelelő, például Byte esetén a +

$/toString(byte:Byte):String metódussal történhet.



Konstansok

Elemi típusra vonatkozó konstansok és statikus metódusok pl. az alapértéknek megfelelő típusú (byte, char,

short, stb.) MAX_VALUE és MIN_VALUE statikus konstansok (static final).



Character +$/isDigit(c:char)?

// számjegy?+$/isLetter(c:char)?

// betű?+$/isLetterOrDigit(c:char)?

// betű vagy számjegy?+$/isLowerCase(c:char)?

// kisbetű?+$/isUpperCase(c:char)?

// nagybetű?+$/toLowerCase(c:char):char

// kisbetűvé alakít+$/toUpperCase(c:char):char

// nagybetűvé alakít



Character+$/isLetterOrDigit(c:char)?

// betű vagy számjegy?+$/isJavaIdentifierStart(c:char)?

// lehet-e egy Java azonosító első karaktere?+$/isJavaIdentifierStart(c:char)?

// lehet-e egy Java azonosító folytató (nem első) karaktere?+$/isUnicodeIdentifierStart(c:char)?

// lehet-e egy Unicode-azonosító első karaktere?+$/isUnicodeIdentifierStart(c:char)?

// lehet-e egy Unicode-azonosító folytató (nem első) karaktere?+$/isWhiteSpace(c:char)?

// szóköz-jellegű (szóköz, tabulátor vagy újsor)?



Number

A Byte, Short, Integer, Long, Float és Double őse

Number definiálja a byteValue, shortValue, stb. metódusokat az előző csomagoló osztályok objektumai mind

használhatók a Number-osztály objektumaként mindegyiktől lekérdezhető adott formában a számérték.



17.Szöveges állomány



ÁllományokÁllománykezelés: java.io csomag

Szöveges állomány: az adatokat karakter-sorozatok ábrázolják. alapvetően emberek számára készülnek, általuk is olvasható vagy

létrehozható — például egy egyszerű szövegszerkesztő programmal.

Adatállomány: az adatok a gép belső kódolása alapján vannak tárolva, így azok

az ember számára csak közvetetten, valamely program által feldolgozva érhetők el és kezelhetők.

java.io.IOException



Állományokszöveges-állomány adatállomány

olvasása Reader InputStreamírása Writer OutputStream

Karakterek ábrázolása: Unicode-kódolás alapján szöveges állományban egy karakter 1 bájton van ábrázolva

adott (például valamely nemzeti karakterkészletnek megfelelő) kódolás alapján

szöveges állományok esetén a Java elrejti a kódolást, azt elegendő csak a konstruktorban megadnunk.

az állomány olvasásakor vagy írásakor a kódkonverziót a megfelelő író- vagy olvasó-objektum automatikusan hajtja végre.



Reader osztályok

Reader

InputStreamReader

FileReader

StringReader

CharArrayReader

BufferedReader

LineNumberReader

FilterReader

PipedReader Tárolás

Szolgáltatás

PushBackReader



Reader - tárolásInputStreamReader // InputStream-ből olvas

(in: InputStream) // alapértelmezett kódolás alapján

(in: InputStream, k: String)

// a k kódolás alapján olvas

FileReader // állományból (alapértelmezett kódolás)

(név: String) // adott nevű állományból olvas

(f: File) // egy File állományból olvas



Reader - tárolás

StringReader // Egy String objektumból olvas

(s: String) // adott szövegből olvas

CharArrayReader // char tömbből olvas

(T[]: char) // adott karakter-tömbből olvas

(T[]: char, kezd:int, hossz:int) // résztömbből olvas



Reader két legalapvetőbb metódusa

+read(): int // beolvassa a következő karaktert (a kódját), // ha elértük az állomány végét, akkor -1 kódot ad

vissza. +close() // lezárja az állományt; ezzel kell jeleznünk, hogy

befejeztük // az állománnyal kapcsolatos munkát.



Reader - szolgáltatás

BufferedReader

// pufferezést tesz lehetővé, így visszaállhatunk egy

// korábban beolvasott helyre, ill. beolvashatunk egy sort.

LineNumberReader

// számlálja az állomány sorait, valamint, ha a sor végét több

// karakter jelzi, azokat egyetlen \n karakterré konvertálja.

PushBackReader

// egy karaktert vissza tudunk tenni (push back) az

// állományba, a következő olvasás így azt olvassa.



Sorszámlálás

Számoljuk meg, hogy egy állomány hány karakterből és hány sorból áll. A sorvége jeleket is karaktereknek tekintjük, azonban logikai sorokat számolunk, így az utolsó sor végén lehet, de hiányozhat is az újsor karakter!

Számláló+karakterekSzáma: int =0+sorokSzáma: int =0+ (in: Reader)+toString():String



Számlálóimport java.io.*;

public class Számláló { private int karakterekSzáma=0; public int getKarakterekSzáma() { return karakterekSzáma; } private int sorokSzáma=0; public int getSorokSzáma() { return sorokSzáma; } public Számláló(Reader in) throws IOException { int c; while((c=in.read())!=-1) { ++karakterekSzáma; if(c=='\n') ++sorokSzáma; } in.close(); }



public String toString() { return getKarakterekSzáma()+ " karakter, "+getSorokSzáma()+" sor."; } public static void main(String[] args) throws IOException { System.out.println(new Számláló( new StringReader("abcdef\ngehij\nklmn\nopqrst") )); System.out.println(new Számláló(

new FileReader("c:\\autoexec.bat")));

}



Egy szöveges állományt írjunk ki a konzolra úgy, hogy minden sor előtt jelenjen meg a sorszáma!

sor beolvasása: BufferedReader osztály, sorok számlálása: LineNumberReader

readLine(): sor beolvasása, állomány végén null



import java.io.*;

public class KiegészítésASorokSzámával { public static void main(String[] args) throws IOException { LineNumberReader in = new LineNumberReader( new FileReader("c:\\autoexec.bat") ); String line; while( (line= in.readLine())!=null ) { System.out.println((in.getLineNumber()-1)+" "+line); } }}



Writer

Writer

OutputStreamWriter

FileWriter

StringWriter

CharArrayWriter

BufferedWriter

FilterWriter

PrintWriter

PipedWriter Tárolás

Szolgáltatás



Writer - tárolás

CharArrayWriter toCharArray(): char[] toString():String writeTo(w:Writer) // pl. állományba

StringWriter (StringBuffer objektumba)getBuffer():StringBuffer toString():String



Writer - szolgáltatás

BufferedWriter: korábbi megjegyzett pozícióra visszaléphetünk

PrintWriter:nem csak egyetlen karakter, hanem más típusú

érték szöveges kiírására is alkalmas. print(v: *) println(v: *) println()

közvetlenül, egy OutputStream-ből is létrehozható



System.out

System.out: PrintStream

PrintWriter-hez hasonló a rendszer alapértelmezett kódolását használja

PrintWriter out =new PrintWriter(System.out);



Készítsünk olyan osztályt, amely egy metódusával egy szöveges-állomány alapján egy olyan új szöveges állományt készítünk, amelyben a nem üres sorok elé kiírunk egy (a konstruktorban) megadott számú szóközt!



Szűrők

SzűrőkBemeneti állomány tartalmán átalakítást kell

végeznünk, vagy a kezelését kiegészítő funkciókkal szeretnénk segíteni

Kimeneti állomány esetén a kiírás előtt kell bizonyos műveleteket végrehajtanunk vagy az adott módú kiírást újabb funkciókkal szeretnénk segíteni.

Szűrők esetén az eredmény ugyancsak állományként jelenik meg.



FilterReader / FilterWriter

Egy Reader / Writer állomány alapján hozzuk létre

Rendelkeznek az alaposztály műveleteivel alapértelmezésként az alapul szolgáló állomány megfelelő

metódusának a meghívása pontosított osztályt készítünk, amelyben átdefiniáljuk a

megfelelő műveleteket. a pontosított osztályt újabb metódusokkal egészítjük ki:

megkönnyíthetjük az állomány tartalmának a szükséges módon történő feldolgozását vagy előállítását.



Készítsünk olyan szűrőt, amely egy bemeneti szöveges állományban előforduló tabulátor ('\t') karaktereket a (konstruktorban) megadott számú szóközre helyettesíti!



public class TabSzóközzé extends FilterReader { private int szóközökSzáma, n=0; public int read() throws IOException { if(n>0) { --n; return ' '; } int c=in.read(); if(c=='\t') { n=szóközökSzáma-1; return ' '; } return c; } public TabSzóközzé(Reader in_, int szóközökSzáma_) { super(in_); szóközökSzáma=szóközökSzáma_; } public static void main(String[] args) throws IOException { Reader in = new TabSzóközzé( new StringReader("jan :\t12\nfebr:\t31\nmarc:\t20"), 4 ); Writer out=new OutputStreamWriter(System.out); int c; while((c=in.read())!=-1) out.write(c); in.close(); out.close(); }



18.StreamTokenizer



Tokenekre bontás

Reader: karakterenként

BufferedReader: soronként

PrintWriter: szöveggé alakított adatok kiírása

StreamTokenizer: a bemenetet nagyobb egységenként (tokenenként) dolgozhatjuk fel.



Karaktertípusok

Szóköz-jellegű: a tokenizáló kihagyjaSzámjegy típusú: szám (szám előtt - is lehet)Betűvel kezdődik és betűvel vagy számjeggyel folytatódik: azonosító.Idézőjel típusú karakterek között szöveges konstans, belül escape-szekvenciákat (pl. \n) is megadhatunk.

Megjegyzés-jellegű karakterek után a sorvégéig kihagyja a karaktereket. // utáni, illetve a /* és */ közötti karaktereket kihagyhatjuk

Normál karakter: önmagában jelenti a tokent.



Létrehozás

a tokenizálót nem InputStream-ből, hanem egy Reader-ből célszerű létrehozni (a bemenet megfelelő kódolása miatt)

Konzol-bemenet olvasása:StreamTokenizer tokenizer = new StreamTokenizer(

new InputStreamReader(System.in)

);



Tokenek olvasása

nextToken():int kihagyja a szóközöket és a megjegyzéseket. normál karakterek: a visszaadott érték a karakter kódja, különleges karakterek esetén:

TT_EOF=-1 // állomány végeTT_EOL='\n' // sorvégeTT_NUMBER=-2 // szám-jellegű tokenTT_WORD=-3 // azonosító-jellegű token

Tokenek olvasása (a t int típusú):while( (t=tokenizer.nextToken())!=tokenizer.TT_EOF ) ...



Token jellemzői

+ttype: int // a beolvasott token kódja (a nextToken() eredménye)

+sval: String

// a beolvasott azonosító vagy szöveges konstans +nval: double

// a beolvasott szám értéke +/lineno(): int

// az aktuális sor száma



Karaktertípusok+resetSyntax()

// az összes karakter normál-típusú lesz+wordChars(tól:int, ig:int)

// a tartomány karakterei betű-jellegűek+whitespaceChars(tól:int, ig:int)

// szóköz-jellegűek+ordinaryChars(tól:int, ig:int)

// normál karakterek+ordinaryChar(k: int)

// megfelel a következőnek: ordinaryChars(k,k)+commentChar(k: int)

// megjegyzésjel-jellegű+quoteChar(k: int)

// idézőjel-jellegű



Karaktertípusok+parseNumbers()

// a 0-9 közötti karakterek szám-jellegűek+eolIsSignificant(f?)

// tokenként értelmezze-e a sorvége jeleket+slashStarComments(f?)

// kihagyja-e a /* megjegyzéseket +slashSlashComments(f?)

// kihagyja-e a // megjegyzéseket +lowerCaseMode(f?)

// kisbetűssé konvertálja-e az azonosítókat?



Alapértelmezett beállítás

latin-betűk és a 0xa0-tól 0xff-ig terjedő kódok (ezek nemzeti karakterek) betű-típusúak,

'0' és '9' közöttiek számjegy-típusúak, '\0' és ' ' közötti karakterek szóközök, '"' és '\'' idézőjelek, a '/' megjegyzésjel (!), a sorvégét átugorja és nem hagyja ki a //utáni és a /* és */ közötti

karaktereket.



A bemeneti szöveges állományban a tanulók nevei, majd kettőspont után a jegyei szerepelnek. Eredményként írjuk ki a tanulók neveit és átlagukat, majd végül az átlagok átlagát!



A bemeneti szöveges állományban egy Java nyelvű program van. Egy tömbben felsorolt azonosítók alapján írjunk ki egy referenciatáblázatot, melyben az azonosítók után felsoroljuk, hogy az a program hányadik sorában szerepel!



ReferenciaSzámláló -referenciák: Referenciák + (azonosítók':Vector, in: Reader) +/print(out: PrintWriter) Referenciák

-referencia: Vector<Referencia> + (azonosítók: String[]) +/referenciák: Enumeration<Referencia> +előfordulás(azonosító:String, sorszám:int) +/print(out: PrintWriter)

Referencia +azonosító: String -előfordulás: Vector<Integer> +/előfordulások: Enumeration<Integer> + (azonosító':String) +előfordulás(sorszám:int) +/print(out: PrintWriter)



File (útvonal:String)

// létrehozás szövegesen megadott útvonalból (útvonal:String, név:String)

// létrehozás útvonalból és névből (útvonal:File, név:String)

// létrehozás útvonalból és névből +/getName(): String

// elérési út név-része +/getPath(): String

// a megadott elérési út +/getAbsolutePath(): String

// elérési utat abszolút útvonallá egészíti ki



File +/getParent(): String

// a szülő könyvtár elérési útja vagy null +/isAbsolute()?

// abszolút módon van megadva az elérési út? +/isExists()?

// létezik a bejegyzés? +/canRead()?

// létezik és olvasható? +/canWrite()?

// létezik és írható?+/isFile()?

// a bejegyzés egy állomány? +/isDirectory?

// a bejegyzés egy könyvtár?



File+/lastModified():long // utolsó módosítás kódja (csak összehasonlításra) +/length():long // állomány hossza +/mkdir()? // a szülő könyvtárban megkísérli létrehozni az elérési út

könyvtárát +/mkdirs()? // a szülőkben megkísérli létrehozni a teljes elérési utat+/list():String[] // könyvtár esetén a benne található állományok neve



File +renameTo(újÁllomány: File)

// átnevezés +delete()?

// megkísérli törölni az bejegyzést (állományt vagy könyvtárat) +/equals()?

// ugyanazt az állományt jelöli? +/toString()

// elérési útvonalként jelenik meg

+$separator:String, +$separatorChar:charútvonal elemeinek elválasztása



19.Adatállományok



InputStream - tárolás

FileInputStream // adathordozón tárolt állományból

(név: String) // adott nevű állományból olvas

(f: File) // File állományból olvas

ByteArrayInputStream // Egy byte tömbből olvas

(T[]: char) // adott tömbből olvas




InputStream – alapvető metódusok

+read(): int

// beolvassa a következő bájtot;

// ha elértük az állomány végét, akkor -1 értéket ad.

+close()

// lezárja az állományt; ezzel kell jeleznünk, hogy

// befejeztük az állománnyal kapcsolatos munkát



InputStream

InputStream FileInputStream

ByteArrayInputStream

BufferedInputStream

PipedInputStream

Tárolás Szolgáltatás

DataInput

DataInputStream

ObjectInputStream

SequenceInputStream

PushBackInputStream FilterInputStream

ObjectInput



InputStream - szolgáltatásBufferedInputStream: az állományt nagyobb egységekben olvassa, korábbi (megjegyzett) pozícióra visszaállhatunk.

PushBackInputStream: egyetlen bájtot (unread(b:int)) vagy egy tömbbel (esetleg

résztömbbel) megadott bájtokat visszahelyezhetünk az InputStream-be

PipedInputStream: párhuzamosan végrehajtott programrészek közötti kommunikációSequenceInputStream segítségével több InputStream-et egyetlen bemenetté kapcsolhatunk össze.DataInputStream, ObjectOutputStream: a bementről a gép belső tárolásaként ábrázolt adatokat (pl. int vagy double típusúakat) olvassunk be



OutputStream - tárolás

FileOutputStream // adathordozón tárolt állomány(név: String) // adott nevű állományba ír

(f: File) // File állományba ír (f: File, hozzáfűzés?) ByteArrayOutputStream // Egy byte tömböt

készít (T[]: char) // adott tömbből olvas




OutputStream

OutputStream FileOutputStream

ByteArrayOutputStream

PipedOutputStream

Tárolás Szolgáltatás

DataOutput

ObjectOutput

DataOutputStream

BufferedOutputStream

ObjectOutputStream

FilterOutputStream



OutputStream – alapvető metódusok

+write(b:int)

// bájt kiírása

+close()

// lezárja az állományt

BufferedOutputStream: a kiírásokat nagyobb egységekbe gyűjthetjük, így ritkábban fordulunk az operációs rendszerhez.



Bájtok olvasása

Egy adatállomány bájtjait írjuk ki szövegesen hexadecimális formában (16-os számrendszerben). Egy sorban megadott számú bájt jelenjen meg!



DataInput DataOutputread():int write(v:int)readBoolean(): boolean writeBoolean(v: boolean)readByte(): byte writeByte(v: int)readUnsignedByte(): int writeUnsignedByte(v: int)readFully(t:byte[]) write(t:byte[])readFully(t:byte[],i:int,h:int) write(t:byte[],i:int,h:int)readShort(): short writeShort(v: int)readUnsignedShort(): int writeUnsignedShort(v: int)readChar(): char writeChar(v: int)

writeChars(v: String)readInt(): int writeInt(v: int)readLong(): long writeLong(v: long)readFloat(): float writeFloat(v: double)readDouble(): double writeDouble(v: double)readUTF(): String writeUTF(v: String)skipBytes(n:int)



Elemi adatok írása/olvasása

DataInputStream / DataOutputStream: az állományokat nem csak bájtonként érhetjük el, hanem gépi formában tárolt elemi adatokat is elhelyezhetünk benne, ill. visszaolvashatunk belőle.



Készítsünk egy osztályt, ami a Java kulcsszavait egy tömbben tárolja. Az osztály egy metódusa tárolja, egy másik metódusa pedig egy alapállományból töltse be a kulcsszavakat. Az adatállomány elején az elemek száma int-ként, a String-ek pedig UTF-ben legyenek tárolva!



Szerializáció

Összetett adatok szerializációja: az adatállományokkal nem csak elemi értékeket, hanem tetszőleges („referencia-”) típusú összetett adatokat, így tömböket és objektumokat is írhatunk/olvashatunk.

Szerializáció alapeszközei: ObjectInputStream és ObjectOutputStream



ObjectInputStreamObjectInputStream: InputStream ObjectInput interfészt is implementálja.

DataInput pontosítása

readObject(): Object

Létrehozás: InputStream alapján hozhatunk létre.

(f: InputStream) // ObjectInputStream létrehozása



ObjectOutputStreamObjectOutputStream: OutputStream ObjectOutput interfészt is implementálja.

DataOutput pontosítása

writeObject(o: Object)

Létrehozás: OutputStream alapján hozhatunk létre.

(f: OutputStream) // ObjectOutputStream létrehozása



Szerializáció

... public void read(ObjectInputStream in) throws IOException,ClassNotFoundException { kulcsszavak=(String[])in.readObject(); } public void write(ObjectOutputStream out) throws

IOException { out.writeObject(kulcsszavak); }...



Biztonsági probléma: megoldás: csak azoknak az objektumoknak a kiírása

engedélyezett, amelyek osztálya implementálja a java.io csomagban megtalálható Serializable („szerializálható”) „jelző”-interfészt.

transient kulcsszó: ha egy attribútum külső tárolása nem szükséges (betöltés után alapérték)

Externalizable: a Serializable pontosításareadExternal(in:ObjectInput):

ÎOException, ^ClassNotFoundExceptionwriteExternal(in:ObjectInput): ÎOException



20.Véletlen elérés



Véletlen elérésű állományLétrehozás: (név:String, mód:String)

// adott nevű állomány

(f:File, mód:String) // File objektummal megadott állomány

Mód: "r": csak olvasásni szeretnénk "rw": írni és módosítani is

RandomAccessFile: implementálja a DataInput és DataOutput interfészeket

elemi adatok olvasása és írására lehetséges összetett adatok írása/olvasása nem lehetséges



Véletlen elérés metódusai

+/length(): long // az állomány mérete bájtokban

+/getFilePointer():long

// hol áll a mutató +/seek(pozíció:long)

// adott helyre lépés



Egy állományt az @ jelek alapján bontsunk oldalakra. Először az első oldalt mutassuk meg, majd + jelre a következő, - jel esetén az előző oldalt, e esetén az első, u esetén az utolsó oldalt, illetve v esetén fejezzük be az állomány megtekintését! ReadMe

+ (állományNév:String)+show()+aktuálisOldalMegjelenítése()+elsőOldal()+előzőOldal()+adottOldal(i:int)+következőOldal()+utolsóOldal()



Index-alapján történő elérés

Adott tanfolyamon részt vett diákok nevét és legfeljebb 10 eredményét tartalmazó adatállomány alapján írjuk ki a neveket és az eredményeket az átlagok szerinti növekvő sorrendben!



Logikai modell

tanfolyam.removeAllDiák(); tanfolyam.addDiák(new Diák("Kiss A.", new double[]{ 5,5,5 })); tanfolyam.addDiák(new Diák("Kovács Á.", new double[]{ 4,5 })); tanfolyam.addDiák(new Diák("Fekete L.", new double[]{ 4,4,5 }));

*

Tanfolyam +addDiák(d:Diák) +removeAllDiák() +/everyDiák():Enumeration<Diák> +/everyDiákÁtlagAlapján():Enumeration<Diák>

Diák +név: NChars<25> +eredmények[i:int]: double + (név':String, eredmények':double[]) +/átlag: double +/print(out: PrintStream)



Logikai modell

Enumeration e;

for(e=tanfolyam.everyDiák(); e.hasMoreElements(); )

((Diák)e.nextElement()).print(System.out);

System.out.println("****");

for(e=tanfolyam.everyDiákÁtlagAlapján(); e.hasMoreElements(); )

((Diák)e.nextElement()).print(System.out);

*

Tanfolyam +addDiák(d:Diák) +removeAllDiák() +/everyDiák():Enumeration<Diák> +/everyDiákÁtlagAlapján():Enumeration<Diák>

Diák +név: NChars<25> +eredmények[i:int]: double + (név':String, eredmények':double[]) +/átlag: double +/print(out: PrintStream)



Állományban tárolásTanfolyam

data:RandomAccessFile+ (filename: String)+close()+addDiák(d:Diák)+removeAllDiák()+/everyDiák():Enumeration<Diák>+/everyDiákÁtlagAlapján():Enumeration<Diák>

Diák+filePos: long+név: NChars<25>+eredmények[i:int]: double+ (név':String, eredmények':double[])+/átlag: double+/print(out: PrintStream)+$/read(f:RandomAccessFile):Diák+/write(f:RandomAccessFile)

NChars+size: int+string: String+/toString(): String+$/read(in:DataInput, size:int):NChars+/write(out:DataOutput)



Tanfolyam data:RandomAccessFile + (filename: String) +close() +addDiák(d:Diák) +removeAllDiák() +/everyDiák():Enumeration<Diák> +/everyDiákÁtlagAlapján():Enumeration<Diák>

Diák +filePos: long +név: NChars<25> +eredmények[i:int]: double + (név':String, eredmények':double[]) +/átlag: double +/print(out: PrintStream) +$/read(f:RandomAccessFile):Diák +/write(f:RandomAccessFile)

DiákIndex +filePos: long +átlag: double + (diák:Diák) +/getDiák(f:RandomAccessFile)

*

DiákIndexek -filename:String -index: Vector -rendezett? + (filename':String, tanfolyam':Tanfolyam) +close() +setIndex() +setRendezett() +/addDiák(d:Diák) +/removeAllDiák() +/everyDiák():Enumeration<Diák>

-indexek

-

Documents

Java – start!