2009.10.01.

1

Java programozás alapjai

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’

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

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

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)

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

2009.10.01.

2

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

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

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

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

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;

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

2009.10.01.

3

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

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!

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

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

É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];

Visszatérés objektummal

C++ Java

class Vector class Vector{ {… …Vector Add(const Vector& v) public Vector Add(Vector v){ {return Vector(x + v.x, y + v.y); return newVector(x + v.x, y + v.y);

} }… …

}; }

2009.10.01.

4

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;

Példa: generikus tár

C++ Java

1. Template nincs2. 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) ); ☺

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ú

Tömbök

� a tömb is objektumként viselkedik

• new-val kell inicializálhatjuk• int tomb[] = new int[1];

• létrehozáskor is inicializálhatjuk• int tomb[] = { 1, 2, 300000 };

Tömbök

� mérete konstans

� a length attribútum tartalmazza a hosszát• int meret = tomb.length;

• az elemek a [ ] operátorral érhető ela 0.. length -1 tartományban

Tömb elemek bejárása

� while

int tomb[] = new int[10];

int i = 0;

while(i < tomb.length){

tomb[++i] = i*i;

}

2009.10.01.

5

Tömb elemek bejárása

� for

int tomb[] = new int[10];

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

tomb[i] = i * i;

}

Tömb elemek bejárása

� for each

int tomb[] = { 1, 3, 2, 5, 4 };

for( int i : tomb ){

System.out.println(i);

}

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

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

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 tagjaif (A instanceof B) { ... }

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

2009.10.01.

6

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

}

}

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)

Java osztályok specialitásai

Az osztályoknak nincs:

� másoló konstruktora (helyette más mechanizmus)� = operátora� destruktora (helyette finalize)

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

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

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

2009.10.01.

7

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

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

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

Statikus változók inicializálása

Konstans é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álytinicializálja

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

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

2009.10.01.

8

Polimorfizmus

� a paraméterek típusától függően másként viselkedő 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ő

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

Ö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

Ö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

Ö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( ) { … }}

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

2009.10.01.

9

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

Interfészek többszörös öröklés helyett

Employee

név, fizetésSet( )

Manager

csoportAssign( )

Temporary

időSetTime( )

TempMan

Employee

név, fizetésSet( )

Manager

csoportAssign( )

Temporary

időSetTime( )

TempMan

TempLike

SetTime( )

időSetTime( )

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

}

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

}

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)

}

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;

}

}

2009.10.01.

10

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

}

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

...}

}

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

CLASSPATH �

graphics/Circle.class

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

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