Embed Size (px)
Citation preview
Java programozás alapjai
2 / 59
A Java nyelv
� C++ szintaktikára épít, számos különbséggel� Hello, World (alkalmazás, parancssorból indítható):
A HelloWorldApp.java fájl:
class HelloWorldApp {public static void main(String[] args) {
System.out.println("Hello World!");}
}
A főosztály: neve = fájlnév, van benne main A program belépési pontja:
statikus metódus
cout << … << ‘\n’
3 / 59
Hello world futtatása
class HelloWorldApp {public static void main(String[] args) {
System.out.println("Hello World!");}
}
HelloWorldApp.java
HelloWorldApp.class Szimbólumtábla:main: public, static, void …...
javac HelloWorldApp.java
java HelloWorldApp
Belölti a HelloWorldApp.class fájlt éselindítja a main függvényt. Mivel még nincsilyen objektum a main szükségképpen statikus
4 / 59
Java adattípusok
� Egyszerű adattípusok (int, float)
� Osztályokkal objektumok
� Nincs külön mutató, referencia, címe operátor,
• helyette: objektumok csak dinamikusan hozhatok létre és csak referenciával hivatkozhatunk rájuk
� Egyszerű adattípusoknak van csomagolóobjektuma
� Tömbök (is objektumok)
� Sztringek
5 / 59
Egyszerű adattípusok
Egyszerű alaptípusok:
� Az egész típusok szélessége nem függ a platformtól� Előjel nélküli (unsigned ) egész nincs!� Az == operátor alkalmatlan két double egyenlőségének
vizsgálatára!
byte 8-bites előjeles egészshort 16-bites előjeles egészint 32-bites előjeles egészlong 64-bites előjeles egészfloat 32-bites lebegőpontos (IEEE 754)double 64-bites lebegőpontos (IEEE 754)char 16-bites Unicode karakterboolean Bool-érték (igaz v. hamis)
6 / 59
“Unsigned” egészek
� byte unsigned értékének kiolvasása:
byte b;int i = b & 0xff;
� 32-bites int unsigned értékének kiolvasása:
int i;long l = i & 0xffffffffL ;
7 / 59
Implicit típuskonverzió� Implicit konverziót csak bővítésnél (widening primitive
conversion) lehet használni :byte -> short -> int -> long -> float -> double char -> int -> long -> float -> double
� Egész típusok bővítő konverziója esetén az eredeti pontos értéket megőrizzük
� A byte -> char, illetve short -> charkonverziók nem tekinthetőek bővítésnek, mivel a charunsigned:
byte b = 126; short s = 1000; char c; c = b; // compile error: possible loss of precision c = s; // compile error: possible loss of precision
� Az int -> float, long -> float, long -> doublekonverziók csökkenthetik a számábrázolás precizitását, ilyenkor az eredeti egész értékeket kerekítjük
8 / 59
Explicit típuskonverzió
� Szűkítésnél (narrowing primitive conversion) kötelező explicit konverziót (cast operatort) használni:double -> float -> long -> int > char -> short > byte
pl.: int i = 32; byte b = (byte)i;
� Szűkítés esetén az alsó biteket őrizzük meg, így előfordulhat, hogy az eredeti érték nagyságrendjét is elveszítjük
9 / 59
Explicit típuskonverzió
� Példák implicit/explicit konverzióra• int a = 1; // a == 1• float a = (float)1; // a == 1.0• float a = 1/2; // a == 0.0• float a = (float)1/2; // a == 0.5• int a = 3.14; // a == 3
10 / 59
Típuskonverzió függvényekkel
� Primitív és összetett típusok között nincs implicit/explicit konverzió• int → String
• String egy = Integer.toString(1);• String egy = “” + 1;
• String → int• int a = Integer.parseInt(“1”);
11 / 59
Egyszerű adattípusok specialitásai
Változó létrehozása default (zérus) kezdőértékkel:int i;
Változó létrehozása kezdőértékkel:int i = 5;
Egyszerű adattípusok deklarációja és definíciója (memória foglalás) egyszerre történik
Konstans változó a final kulcsszóval (C++ const):final double pi = 3.14159286;
12 / 59
Osztályok
Minden adatstruktúra osztály (class ) típusúnincs struct , union
public class Employee {
String name;
private long salary = 100;
public Employee(String n, long sal) {
name = n; salary = sal;
}
}
Változókhoz kezdőértéket rendelhetünk vagy alapért.
A törzs csak az osztályon belül lehet
Nem kell a végén pontosvessző
Az osztálymás csomagból is
csomagból
osztályból
bárhonnan
13 / 59
Osztályok
� objektumok prototípusa
� összefüggő adatok és metódusok gyűjteménye• pl. String objektum:
karakterek tömbje és a rajtuk végezhető műveletek
14 / 59
Osztály példány = objektum
� példányt mindig a new operátorral hozunk létre� nem lehet objektumot lokális változóként létrehozni� a változónk mindig hivatkozást tartalmaz
Student s1; // deklaráció
s1 = new Student(“Ubul”, 3.5);// definíció
� az = a hivatkozást másolja, az objektumot NEM!
Student s2 = s1; // s2 ugyanaz az objektum
// lesz, mint s1!
15 / 59
Minden objektum dinamikus
C++ Java
class Vector { class Vector {int x, y; int x, y;
}; }…. ….
Vector v; // stack-en Vector v = new Vector( );Vector *pvnull = NULL; Vector pvnull;Vector *pv = &v; Vector pv = v;Vector& rv = v; Vector rv = v;Vector *pvd = new Vector(); Vector pvd = new Vector( );
delete pvd; szemétgyűjtés
16 / 59
Érték versus Referencia típusok: C++
Dinamikus memóriából allokáltDeklaráció és helyfoglalás különLehet null “=” referenciát másol nem adatot
A tömbjeiben referenciák vannakNem úgy viselkedik, mint a beépítetttípusok
Globális memóriában vagy a vermenDeklaráció és helyfoglalás egyszerreSohasem null= adatot másol nem referenciát
A tömbjeiben elemek vannakAkárcsak a beépített típusok
int i, j=3;
i = j;
int array[10];
int * pi; Class* c;...pi = new int; c = new Class;*pi = 3; c->f( );
int * pj = pi; Class* c1 = c;
Class c;c.f( );
Class c1 = c;
17 / 59
Érték versus Referencia típusok: Java
Dinamikus memóriából allokáltLehet null = referenciát másol nem adatotA tömbjeiben referenciák vannak
OBJEKTUMOK
Globális memóriában vagy a vermenSohasem null= adatot másol nem referenciátA tömbjeiben elemek vannak
BEÉPÍTETT TÍPUSOK
int i, j=3;
i = j;
int array[10];
Class c;c.f( );
Class c1 = c;
int * pi; Class c;...pi = new int; c = new Class;*pi = 3; c.f( );
int * pj = pi; Class c1 = c;
int array[];array = new int[10];
18 / 59
Visszatérés objektummal
C++ Java
class Vector class Vector{ {… …Vector Add(const Vector& v) public Vector Add(Vectorv){ {return Vector(x + v.x, y + v.y); return newVector(x + v.x, y + v.y);
} }… …
}; }
19 / 59
Egyszerű adattípusok osztályba csomagolása
Minden egyszerű adattípusnak létezik egy osztály típusúmegfelelője, pl. int és Integer
� konverziós függvények
� típusra jellemző konstansok
int i1 = 5;
Integer io = new Integer(i1);
Integer ios = new Integer(“135”);
int i2 = io.intValue();
float f = io.floatValue();
String s = io.toString();
i1 = Integer.MAX_VALUE;
20 / 59
Példa: generikus tár
C++ Java
1. Template nincs (1.5.0 Generics)2. void pointer nincs pointer3. Alaposztályra Mi az alaposztály: Object !!!
mutató pointervagy referencia class Tar {
Object obj;void Put(Object o) { obj = o; }Object Get() { return obj; }
}….Tar tar = new Tar();
tar.Put( 3 ); �
tar.Put( new Integer(3) ); ☺
21 / 59
Tömbök
� értékek indexelt listája
� bármilyen típusból létrehozhatunk tömböt a [ ] operátorral• int[] tomb; // üres tömb• int tomb[]; // üres tömb
� a tömb minden eleme azonos típusú
22 / 59
Tömbök
� a tömb is objektumként viselkedik
• new-val kell inicializálni• int tomb[] = new int[1];
• létrehozáskor is inicializálhatjuk• int tomb[] = { 1, 2, 300000 };
23 / 59
Tömbök
� mérete konstans
� a length attribútum tartalmazza a hosszát• int meret = tomb.length;
• az elemek a [ ] operátorral érhetőek ela 0.. length -1 tartományban
24 / 59
Tömb elemek bejárása
� while
int tomb[] = new int[10];
int i = 0;
while(i < tomb.length){
tomb[++i] = i*i;
}
25 / 59
Tömb elemek bejárása
� for
int tomb[] = new int[10];
for( int i = 0; i < tomb.length; ++i ){
tomb[i] = i * i;
}
26 / 59
Tömb elemek bejárása
� for each
int tomb[] = { 1, 3, 2, 5, 4 };
for( int i : tomb ){
System.out.println(i);
}
27 / 59
Tömbök
int[] intArray = new int[5];// vagy int intArray[] = new int[5];int i = intArray[2];int l = intArray.length ;
deklaráció és inicializálás egy lépésben:int[] intArray = { 1, 3, 2, 4, 7 };
korábban deklarált tömb átdefiniálása:intArray = new int[] { 3, 2, 4, 8, 7, 5 };
28 / 59
Sztringek
String osztály:� Tartalma a létrehozás után nem módosítható,
� Idézőjelek közé tett szövegből mindig String lesz, pl.String s = “abc”;
System.out.println(“Hello”);
� Példák:String s = “abc”;
int i = s.compareTo(“cde”);
System.out.println(String.valueOf(i)+ s.subString(1,2) + “ef”);
int l = s.length();
29 / 59
Operátorok
A legtöbb művelet a C++-hoz hasonlóan működik+ - * / % >> <<
&& || ! & | ^
> >= < <= == !=
?: () (típus) new
Leglényegesebb különbségek:� nincs operator overloading� nincs -> operátor: mindig pontot használunk� nincs :: operátor (aminek a bal oldalán nem példány,
hanem osztály áll): ehelyett is pontot használunk
� instanceof operátor: igaz, ha az A objektum a B osztály vagy B-ből származó osztály tagja
if (A instanceof B) { ... }
30 / 59
Vezérlőszerkezetek
A legtöbb a C++-ban megszokott módon működik:for while do..while if...else
switch..case..default
break continue return
Leglényegesebb különbségek:� az if után álló feltétel mindig boolean típusú, azaz:
int value;
if (value) { ... } // Hiba!
if (0 != value) { ... } // Így jó!
� (nincs goto !!! )
31 / 59
Goto helyett címkézett ciklusok
outer: while (true)
{
inner: while (true)
{
break; // kilép a belső ciklusból
break inner; // kilép a belső ciklusból
break outer; // kilép a külső ciklusból
}
}
32 / 59
Java osztályok specialitásai
Minden osztálynak van:� Konstruktora
• feladata az objektum inicializálása
• több konstruktor is tartozhat egy osztályhoz
• minden alkalommal meghívódik amikor létrehozunk egy objektumot
� közös őse: minden osztály az Object -ből származik (nem kell feltüntetni)
33 / 59
Java osztályok specialitásai
Az osztályoknak nincs:
� másoló konstruktora (helyette más mechanizmus)� = operátora� destruktora (helyette finalize)
34 / 59
Tagok
class Group {private Employee employees[];int n_emp = 0;Group( ) {
employees = new Employee[10];}
void Add(Employee e) {employees[n_emp++] = e;}void Doctor( ) {
for(int i = 0; i < n_emp; i++) {employees[i].name =
new String(”Dr. ” + employees[i].name);}
}
Beágyazott objektum
Kezdeti érték
Minősített elérés más objektumbólnév belülről
Explicit helyfoglalás
35 / 59
MetódusokVirtuális metódusok:� nincs virtual kulcsszó, minden függvény virtuális� ha mégsem akarjuk, hogy egy leszármazott felüldefiniálja,
akkor a final kulcsszót használhatjuk
Absztrakt metódus: az abstract kulcsszóvalabstract class Shape {
public abstract void draw();
// nincs törzs
public final void move(int newX, int newY ) { … }
}
� abstract metódusa csak abstract osztálynak lehet� abstract osztály nem példányosodhat
36 / 59
Osztályváltozók
C++ Java
class Dolgozo { class Dolgozo {int kor; int kor;static int nygdjkrhtr; static int nygdjkrhtr =65;int hatra() { int hatra() {
return (nygdrkrhtr-kor); return(nygdrkrhtr-kor);} }
}; }
int Dolgozo::nygdjkorhtr=65;
Az osztály minden példányához tartozik,
Külön kell inicializálni
37 / 59
Osztálymetódusok
C++ Java
class Window { class Dolgozo {static void WndProc(); static int nygdjkrhtr =65;
}; static void NyEmel( ) {… nygdjkrhtr++;wnd.lpfnWndProc =WndProc ; }… }RegisterClass( &wnd ) …
Dolgozo.NyEmel();
Windows Alkalmazásesemény
lpfnWndProc
WndProc()C,PASCALfüggvény
38 / 59
Osztály változó és metódus
A static kulcsszóval deklarált változók és metódusok nem egy objektumhoz tartoznak, hanem az egész osztályra közösek.
� statikus függvények
• csak statikus függvényeket és változókat használhatnak (nincs implicit this az argumentumok között)
• meghívásukkor a pont elé nem egy objektum, hanem az osztály nevét kell írni:Dolgozo.NyEmel();
39 / 59
A main függvény
� Először a main függvény indul, az objektumokat ettől kezdve hozzuk létre
� Nincs még objektum (nem üzenhetünk senkinek)A main csak statikus lehet
public static void main(String args[]) { ... }
� A main new-val létrehozhat lokális objektumokat, azokon kívül csak a statikus objektumokat érheti el
40 / 59
Statikus változók inicializálásaKonstans értékadás:
class Dolgozo{static int nygdjkrhtr = 65;
}
A statikus változóknak a static initializer adhat kezdőértéket:class AClass {
static { // Nincs név, visszatérő érték, semmi// Itt csinálhatunk bármit
}
...
}
� Hasonlít a konstruktorhoz, de nem egy példányt, hanem az osztályt inicializálja
41 / 59
Statikus változók/metódusok jelentősége
Statikus változó = „Objektum Orientált” globális változó
Statikus függvény = „Objektum Orientált” globális függvény
int i = Integer.MAX_VALUE;
float rnd = Math.random();
float sinpi = Math.sin( Math.PI );
String s = String.valueOf( 123 );
System.out.println(“Az eredmeny”);
42 / 59
Adatrejtés
� felesleges részletek és belső állapotok elrejtése
� különböző hozzáférési szintek
• public mindenki számára hozzáférhető
• package az adott package-be tartozóosztályok számára érhető el (alapértelmezett)
• private csak az osztályon belülről érhető el
� legyen minden private , amíg nem indokolt publikussá tenni
43 / 59
Polimorfizmus
� a paraméterek típusától függően máskéntviselkedő függvények
void szamol(int ertek);
void szamol(Complex ertek);
� felüldefiniált függvény
• a leszármazott osztályban ugyanazzal a névvel és paraméterekkel definiált függvény
• @Override jelölő
44 / 59
Szemétgyűjtés
Java-ban a létrehozott objektumokat nem kell a programnak explicit megsemmisítenie
� nincs destruktor� nincs delete operátor
� van finalize() metódus: a szemétgyűjtő hívja a megsemmisítés előtt
A felesleges objektumok eltüntetéséről a szemétgyűjtő(garbage collector ) gondoskodik
� alacsony prioritással állandóan fut a háttérben� figyeli, hogy mely objektumokra nincs már érvényes
hivatkozás
45 / 59
Öröklődés Java módra
� minden osztály az Object-ből származik
� egy osztálynak csak egy ősosztálya lehet(többszörös öröklődés nincs)
� a leszármazott osztály örökli a paraméter nélküli konstruktort
� a paraméteres konstruktorokat NEM!
� az ősosztály konstruktorát a super() segítségével hívhatjuk meg
46 / 59
Öröklődés Java módra
� az osztály (class ) mellett bevezeti az interface -t ez majdnem olyan, mint egy osztály, de:
• csak publikus, absztrakt függvényeket tartalmaz• csak final változókat tartamaz• nem lehet példányosítani• az interfacet implementáló osztálynak az
interface minden függvényét meg kell valósítani
� „ős-interface”-ből több is lehet egy osztálynak az őstípus mellett
47 / 59
Öröklődésabstract class shape {
protected int x, y, col;void move(int dx, int dy) {
int c = col; col = 0; draw(); x += dx; y += dy; col = c; draw();
}abstract void draw( );shape( int x0, int y0, int c0 ) {
x = x0; y = y0; col = c0;}
}class line extends shape {
private int xe, ye;line( int x1, int y1, int x2, int y2, int c ) {
super ( x1, y1, c );xe = x2; ye = y2;
}void draw( ) { … }
}
48 / 59
Öröklés szerepei C++ -ban
� Kód, változó átörökítés
� Közös interfész megvalósítása: pl. heterogén szerk.
class Shape {int x, y, col;void SetColor( int c ) { col = c; }
}
class Line : public Shape {} class Rect : public Shape {}
class Shape { virtual void Draw()=0; }class Line : public Shape {
virtual void Draw();}class Rect : public Shape {
virtual void Draw();}
Shape * shapes[10];shapes[0] = new Line();shapes[1] = new Rect();
for(int i = 0; i < 2; i++)shapes[i] -> Draw( );
49 / 59
A második funkció interfésszel
interface ShapeLike { void Draw ( );
}
class Line implements ShapeLike {void Draw();
}class Rect implements ShapeLike {
void Draw();}... void Display( ShapeLike s ) {
s.Draw( );}... Display( new Rect() );... Display( new Line() );
50 / 59
Interface megvalósításclass Employee { … }class Manager extends Employee { … }
interface TempLike {int GetTime ( );void SetTime ( int t );
}class Temporary extends Employee implements TempLik e {
int emp_time;Temporary( String nam, long sal, int time ) {
super(nam, sal); // for base class constructoremp_time = time;
}public void Show( ) {
super.Show( );System.out.print(”Until "+String.valueOf(emp_time)) ;
}public int GetTime ( ) { return emp_time; }public void SetTime ( int t ) { emp_time = t; }
}
51 / 59
TempMan
class TempMan extends Manager implements TempLike {int emp_time;
TempMan( String nam, long sal, int time, int level ) {super(nam, sal, level); //for base class construct oremp_time = time;
}public void Show( ) {
super.Show( );System.out.print(”Until "+String.valueOf(emp_time)) ;
}public int GetTime ( ) { return emp_time; }public void SetTime ( int t ) { emp_time = t; }
}
52 / 59
Az ősök őse: Object
public class Object {public Object( ) { … }protected Object clone ( ) { … }
// “copy constructor”, ha nem definiáljuk át// csak belülről működik
protected void finalize ( ) { … }// “destruktor”, protected
public boolean equals ( Object o ) { … }// összehasonlítás
public final Class getClass ( ) { … }// melyik osztályból definiáltuk ezt: végleges
public String toString ( ) { … }// konverzió string-re (kiíráshoz)
}
53 / 59
Példa: heterogén tömb
public class MyArray {
protected Object[] elements;
MyArray(int size) {
elements = new Object[size];
}
Object getItem(int idx) {
return elements[idx]; }
void putItem( int idx, Object o ) {
elements[idx] = o;
}
}
54 / 59
Öröklődés: Klónozható tömb
public class MyCloneableArray extends MyArray{MyCloneableArray(int size) {super(size);// Őstípus konstruktora, először ezt kell hívni
}
public Object clone(){ MyCloneableArray newArray = new
MyCloneableArray(elements.length);for (int i = 0; i < elements.length; i++)
newArray.elements[i] = elements[i];return newArray;
}}
55 / 59
Besorolás a klónozhatók csoportjába
// public interface Cloneable {// public Object clone();// };public class MyCloneableArray extends MyArray
implements Cloneable{
MyCloneableArray(int size) { … }public Object clone(){ MyCloneableArray newArray = new
MyCloneableArray(elements.length);...}
}
56 / 59
Import, package-ek
� Package : Java osztályok és al-package -ek halmazapackage graphics;
public class Circle {
...
}
� Package vagy class importálása:import graphics.*;
import java.lang.*;
import java.applet.Applet;
� Azonos packageben levő osztályokat nem kell importálni� Minden Java osztály egy package tagja
CLASSPATH �
graphics/Circle.class
57 / 59
Fontos beépített package-ek
� java.appletAz Applet osztály és egyéb, appletekkel kapcsolatos
eszközök� java.awt (Abstract Windowing Toolkit)GUI osztályok: ablakok, ablak elemek� java.awt.eventEseménykezeléssel kapcsolatos osztályok és interface-ek
� java.awt.imageKépek megjelenítése, feldolgozása� java.ioFile és más adatfolyamok kezelése
58 / 59
Fontos beépített package-ek II.
� java.langEgyszerű adattípusok osztály megfelelői (Integer )Szálak (Thread ) kezeléseStringek kezelése (String és StringBuffer )� java.netHálózatkezelés: Socket , URL, HTTP kapcsolat, stb.� java.rmi (Remote Method Invocation)Távoli eljárások hívása (CORBA-szerű)� java.utilKollekciók, naptár, helyi információk, stb.
És még nagyon sokan mások
