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 és elindítja a main függvényt. Mivel még nincs ilyen objektum a main szükségképpen statikus
This document is posted to help you gain knowledge. Please leave a comment to let me know what you think about it! Share it to your friends and learn new things together.
Transcript
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) {
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 !!!
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)