杂技演员转型夜场摇滚歌手 日挣千元献艺背后艰辛

Java
A Java kabalafigurája, Duke
Paradigma	objektumorientált
Jellemz? kiterjesztés	.java, .class, .jar, .war, .ear
Megjelent	1995
Tervez?	James Gosling illetve a Sun Microsystems cég
Fejleszt?	James Gosling illetve a Sun Microsystems cég, amit kés?bb megvett az Oracle Corporation
Utolsó kiadás	Java SE 24 (stabil verzió, 2025. március 18.)
Típusosság	statikusan típusos, er?sen típusos, típusbiztos, normatív
Fordítóprogram	Javac
Megvalósítások	OpenJDK, Oracle HotSpot, JRockit, Jikes
Hatással volt rá	C++ C Ada Simula 67 Smalltalk Objective-C Object Pascal Oberon Eiffel Modula-3 Mesa Simula C# UCSD Pascal
Operációs rendszer	platformfüggetlen
Licenc	GNU General Public License / Java Community Process
Weboldal

A Java általános célú, objektumorientált programozási nyelv, amelyet a Sun Microsystems fejlesztett a ’90-es évek elejét?l kezdve egészen 2009-ig, amikor a céget felvásárolta az Oracle.

A Java alkalmazásokat jellemz?en bájtkód formátumra alakítják, de k?zvetlenül natív (gépi) kód is készíthet? Java forráskódból. A bájtkód futtatása a Java virtuális géppel t?rténik, ami vagy interpretálja a bájtkódot, vagy natív gépi kódot készít bel?le, és azt futtatja az adott operációs rendszeren. Létezik k?zvetlenül Java bájtkódot futtató hardver is, az úgynevezett Java processzor.

A Java nyelv a szintaxisát f?leg a C és a C++ nyelvekt?l ?r?k?lte, viszont sokkal egyszer?bb objektummodellel rendelkezik, mint a C++. A JavaScript szintaxisa és neve hasonló ugyan a Javához, de a két nyelv nem áll olyan szoros rokonságban, mint azt ezekb?l a hasonlóságokból gondolhatnánk.

Bár a nyelv neve kezdetben Oak (t?lgyfa) volt (James Gosling, a nyelv atyja nevezte így az irodája el?tt n?v? t?lgyfáról), kés?bb kiderült, hogy ilyen elnevezés? nyelv már létezik, ezért végül Java néven vált ismertté. A Java szó a Oracle védjegye.

általános tudnivalók

A Java nyelvet kávézás k?zben találták ki, innen ered a kávéscsésze ikon. Négy fontos szempontot tartottak szem el?tt, amikor a Javát kifejlesztették:

• objektumorientáltság;
• függetlenség az operációs rendszert?l, amelyen fut (t?bbé-kevésbé);
• olyan kódokat és k?nyvtárakat tartalmazzon, amelyek el?segítik a hálózati programozást;
• távoli gépeken is képes legyen biztonságosan futni.

Objektumorientáltság

A nyelv els? tulajdonsága, az objektumorientáltság (?OO”), a programozási stílusra és a nyelv struktúrájára utal. Az OO fontos szempontja, hogy a szoftvert ?dolgok” (objektumok) alapján csoportosítja, nem az elvégzett feladatok a f? szempont. Ennek alapja, hogy az el?bbi sokkal kevesebbet változik, mint az utóbbi, így az objektumok (az adatokat tartalmazó entitások) jobb alapot biztosítanak egy szoftverrendszer megtervezéséhez. A cél az volt, hogy nagy fejlesztési projekteket k?nnyebben lehessen kezelni, így cs?kken az elhibázott projektek száma.

A Java szerepe

A Java szoftver három igen fontos szerepet t?lt be:

1. mint programozási nyelv;
2. mint k?ztes réteg (middleware);
3. mint platform.

A Java legfontosabb része a Java virtuális gép (Java Virtual Machine – JVM). A JVM mindenütt jelen van (szinte mindenféle berendezés, chip és szoftvercsomag tartalmazza), így a nyelv k?zépszintként és platformként egyaránt m?k?dik. Ugyanakkor a nyelv ?platformfüggetlen” is, mert a Java virtuális gépek interpretálják a szabványos Java bájtkódot. Ez azt jelenti, hogy egy PC-n megírt Java program minimális módosítás után ugyanúgy fog futni egy javás telefonon is. Innen j?n az írd meg egyszer, futtasd bárhol kifejezés. Ez jelent?s k?ltségcs?kkenést eredményez, mert a kódot csak egyszer kell megírni.

Platformfüggetlenség (hordozhatóság)

Ez a tulajdonság azt jelenti, hogy a Java nyelven írt programok a legt?bb hardveren (megk?zelít?leg) ugyanúgy futnak. Ezt úgy érik el, hogy a Java fordítóprogram a forráskódot csak egy úgynevezett Java bájtkódra fordítja le. Ez azután a virtuális gépen fut, ami az illet? hardver gépi kódjára fordítja^[forrás?]. Léteznek továbbá szabványos k?nyvtárcsomagok, amelyek – k?zvetítve a kód és a gép k?z?tt – egységes funkcionalitásként teszik elérhet?vé az illet? hardver sajátosságait (grafika, szálak és hálózat).

Vannak olyan Java-fordítóprogramok, amelyek a forráskódot natív gépi kódra fordítják le – ilyen például a GCJ –, ezzel valamelyest felgyorsítva annak futtatását. Cserébe a lefordított program elveszíti hordozhatóságát.

A Sun Microsystems licence ragaszkodik a kül?nb?z? Java kivitelezések egymással való ?sszeférhet?ségéhez (felcserélhet?ségéhez?)^[forrás?]. Egyes cégek, mint például a Microsoft, mégis platformfügg? sajátságokat adtak a nyelvhez, amire a Sun keményen reagált: beperelte a Microsoftot (az amerikai bíróság 20 millió dollár kártérítésre és a sajátos tulajdonságok visszavonására k?telezte a céget).

Válaszként a Microsoft kihagyta a Java rendszert a j?v?beli termékekb?l és Windows-változatokból. Ez azt jelenti, hogy az Internet Explorer webb?ngész? alapváltozataiból hiányzik a Java. így abban az olyan weboldalak, amelyek Javát használnak, nem fognak helyesen megjelenni. A Windows-felhasználók e problémáját megoldva a Sun és más cégek ingyenesen let?lthet?vé tették a JVM rendszert azon Windows-változatok számára, amelyekb?l a virtuális gép hiányzik.

A hordozhatóság megvalósítása technikailag nagyon bonyolult. E k?zben a Java esetében is sok vita volt. Az ?írd meg egyszer, futtasd bárhol” szlogenb?l ?írd meg egyszer, keress hibát mindenhol” lett. 2016-ra a hordozhatóság nem okoz tovább problémát, mivel maga a Java is nyílt szabványokra épül, pl. openGL v. Open POSIX vagy az RFC-k, a Java minden jelent?sebb platformon elérhet? (Linux, Unix, Windows, más rendszerek pl. AS/400).

Java 2016-ban is sikeres a szerver oldalon a servlet, a JSP és Enterprise JavaBeans, JDBC technológiákkal, integrációs lehet?ségeivel, nyelvi eszk?zeivel, jvm nyelveivel és a nyílt forráskódú k?z?sség tudására is építve.

Biztonságos távoli futtatás

A Java rendszer volt az els?, amely lehet?vé tette a távoli gépeken való futtatást sandboxban (homokozóban). Egy kisalkalmazás futtatható a felhasználó gépén (let?ltve a Java kódot egy HTTP kiszolgálóról). A kód egy biztonságos k?rnyezetben fut, amely nem engedi meg "rossz szándékú" kód futtatását^[forrás?]. A gyártók kiadhatnak olyan tanúsítványokat, amelyeket digitálisan aláírnak, ezzel a nevüket adva ahhoz, hogy a kisalkalmazás biztonságos. így azok a felhasználó felügyelete alatt léphetnek ki a biztonságos k?rnyezetb?l.

A nyelv

A klasszikus ?Helló Világ!” Javában

A k?vetkez? egyszer? program kiírja azt, hogy ?Helló Világ!” az alapértelmezett kimeneti eszk?zre (ami általában a konzol, de lehet egy fájl vagy bármi más is).

 public class HelloVilag {
     public static void main(String[] args) {
         System.out.println("Helló Világ!");
     }
 }

Vezérlés

Ciklusok

while

A while egy olyan ciklus, amely a belsejében lév? utasításokat mindaddig ismétl?d?en végrehajtja, ameddig a megadott feltétel igaz.

 while (logikai kifejezés) {
     utasítás(ok)
 }

do – while

A do…while ciklus hasonlóan a while ciklushoz, addig hajtja végre a belsejében lév? utasításokat, ameddig a feltétel igaz. A while és a do…while k?z?tt annyi a kül?nbség, hogy a while az utasítások lefuttatása el?tt kiértékeli feltételt, így ha már az els? alkalommal a feltétel hamis, a belsejében lév? utasítások egyszer sem futnak le. A do…while ezzel ellentétben viszont csak az utasítások lefuttatása után értékeli ki a kifejezést, tehát ebben az esetben egyszer mindenképpen végrehajtja a belsejében lév? utasításokat.

 do {
     utasítás(ok)
 } while (logikai kifejezés);

for

A for ciklus általános alakja a k?vetkez?:

 for (inicializáló kifejezés(ek) ; ciklusfeltétel(ek) ; léptet? kifejezés(ek) ) {
     utasítás(ok)
 }

for – each

A Java 1.5 verziótól kezdve for ciklussal iterálhatóak a t?mb?k és a java.lang.Iteratable interfész implementációi a k?vetkez? szintaxissal:

 for (elem : t?mb) {
     utasítás(ok)
 }

Például:

 for (String s : new String[]{"1","2","3"}) {
     System.out.println(s);
 }

Feltételes utasítások

 if (logikai kifejezés) {
     utasítás(ok)
 }

 if (logikai kifejezés) {
     utasítás(ok)
 } else {
     utasítás(ok)
 }

Elegend? else if utasításokkal bármilyen komplex ha-akkor szerkezetet ki lehet építeni.

 if (logikai kifejezés) {
     utasítás(ok)
 } else if (logikai kifejezés) {
     utasítás(ok)
 } else if (logikai kifejezés) {
     utasítás(ok)
 } else {
     utasítás(ok)
 }

Az el?bbi szerkezet kiváltható, ha ugyanazt az egész, felsorolható ill. string típusú (Java 1.7 óta) kifejezést kell kiértékelni t?bb esetben is. így kevesebb karakter felhasználásával (r?videbb a kód), átláthatóbb megvalósítást kapunk.

 switch (egész kifejezés) {
     case konstans egész kifejezés:
          utasítás(ok)
          break;
     …
     default:
          utasítás(ok)
          break;
 }

Java 14-t?l elérhet? egy r?videbb, break nélküli szintaxis, továbbá használható kifejezésként is, nem csak utasításként.

// R?videbb szintaxis
switch (egész kifejezés) {
    case konstans egész kifejezés -> { utasítás(ok) }
    …
    default -> { utasítás(ok) }
}

// Kifejezés
var változó = switch (egész kifejezés) {
    case konstans egész kifejezés:
        opcionális utasítás(ok)
        yield érték;
    …
    default:
        opcionális utasítás(ok)
        yield érték;
};

// Kifejezés és r?videbb szintaxis
var változó = switch (egész kifejezés) {
    case konstans egész kifejezés -> érték;
    …
    default -> érték;
};

Java 21-t?l mintaillesztést is lehet végezni vele, és kezelhet? a null érték is (ha nincs kül?n kezelve, akkor továbbra is kivételt okoz a null). Például:

Boolean logikaiértékFeldolgozás(Object érték) {
    return switch (érték) {
        // Egyszer? mintaillesztés: illesztés a típusra
        case Boolean b -> b;
        // ?rfeltételes mintaillesztés
        case String s when s.equalsIgnoreCase("igaz") -> true;
        case String s when s.equalsIgnoreCase("hamis") -> false;
        // null érték kezelése
        case null -> null;
        default -> null;
    }
}

Kivételkezelés

 try {
     utasítás(ok)
 } catch (kivételtípus) {
     utasítás(ok)
 } catch (kivételtípus) {
     utasítás(ok)
 } finally {
     utasítás(ok)
 }

A Java nyelvben a kivételtípusok osztályok, és k?z?ttük is fennáll típushierarchia. éppen ezért, ha t?bb catch ágat használunk egy blokkban, akkor mindig a speciálisabb típust kell korábban feltüntetni, mert a catch ágak kiértékelése fentr?l lefelé halad.

Egy try után k?telez? legalább egy catch vagy egy finally ágat tenni (az egyetlen kivételt lásd alább). A catch ágakból t?bb is lehet, de egy try blokk végén csak egy finally lehet.

Ha két catch ág tartalma azonos, akkor ezek Java 1.7 óta ?sszevonhatók, a típusokat | jellel elválasztva (ez magyar billenty?zeten az Alt Gr+W billenty?kombinációval vihet? be):

try {
    utasítás(ok)
} catch (kivételtípus | kivételtípus) {
    utasítás(ok)
}

Szintén 1.7-es Java óta használható a try er?forrásokkal (angolul try-with-resources) konstrukció. Ez egy kényelmes megoldást kínál a használt er?források (megnyitott fájlok, hálózati kapcsolatok stb.) bezárására kivétel fellépése esetén is: az er?forrás close metódusa lefut k?zvetlenül a try blokk elhagyása el?tt, akár a blokk végét elérve hagyja el a vezérlés a blokkot, akár kivétellel. Ez az egyetlen típusú try blokk, aminél a catch és finally ágnak opcionálisak.

try (BufferedReader br = new BufferedReader(new FileReader("fájl.txt"))) {
    br.readLine();
}

Feltétel nélküli ugróutasítások

A Java nem támogatja a goto utasítást, mivel ennek használata spagettikódot eredményezhet. Nagyon ritkán mégis szükség van a goto-ra, a Java lehet?vé tesz alternatív megoldásokat, ami a címkézhet? continue és break utasítás. A goto fenntartott szó és nem használható azonosítóként.

Korai kilépés a ciklusokból

A Java nyelv két utasítást is ad a ciklusból való kilépéshez. A

 continue;

utasítás megszakítja a folyamatban lev? ismételgetést és egy újabbat kezd (ugyanúgy viselkedik, mint a ciklus elejére ugró goto).

Hasonlóan, a

 break;

utasítás teljesen kilép a ciklusból, és t?bb ismételgetést nem hajt végre. A hatás ugyanaz, mint egy goto utasítás a cikluson kívülre.

A Java break és continue utasításai sokkal hatásosabbak, mint a C és C++ hasonló nev? utasításai, mert képesek egy t?bbszint? ciklusból is kilépni. (Csak annyi a teend?, hogy megcímkézzük a ciklust és hozzátoldjuk a break vagy continue utasításokhoz. Ugyanezt csak goto utasítással lehet elérni C-ben és C++-ban.)

Példa:

  kulso: while (true) {
     belso: while (true) {
         break;             // kilépés a legbels? ciklusból
         break belso;       // ugyancsak kilépés a legbels? ciklusból
         break kulso;       // kilépés a legküls? ciklusból
     }
 }

Korai kilépés az eljárásokból

A

 return;

utasítás befejez egy eljárást.

A

 return aErtek;

visszaad a hívó eljárásnak egy értéket (aErtek) is visszatéréskor.

Alapvet? adattípusok

A nyelv egyszer? adattípusai, más szóval primitív típusai a k?vetkez?k:

Változó típusa	Leírás	Példa
byte	8 bites el?jeles egész	byte largestByte = 127;
short	16 bites el?jeles egész	short largestShort = 32767;
int	32 bites el?jeles egész	int largestInteger = 2147483647;
long	64 bites el?jeles egész	long largestLong = 9223372036854775807L;
float	32 bites egyszeres lebeg?pontosságú (IEEE 754 szabvány)	float largestFloat = 3.4028235E38f; //(E38 = $10^{38}$)
double	64 bites kétszeres lebeg?pontosságú (IEEE 754 szabvány)	double largestDouble = 1.7976931348623157E308; //(E308 = $10^{308}$)
char	16 bites Unicode-karakter	char aChar = 'S';
boolean	logikai érték (igaz / hamis)	boolean aBoolean = true;

A t?mb és a karakterlánc nem egyszer? típusok, hanem objektumok. A long és float változók inicializálásánál kül?n meg kell adni, hogy a begépelt szám melyik típusba tartozik: az egész szám literál végére L vagy f bet?t írunk. A forráskódba begépelt, ilyen megjel?lés nélküli egész számokat integer-ként, a lebeg?pontos számokat pedig double-ként kezeli.

Karakterek

A Java a 16 bites Unicode kódolást (az UTF-16-ot) használja. Ez tartalmazza a szabványos ASCII-karaktereket, de ugyanakkor tartalmazza más nyelvek karakterkészletét is (pl: g?r?g, cirill, kínai, arab stb.). A Java programok mindezeket a karakterkészleteket képesek használni, habár a legt?bb szerkeszt?program csak a hagyományos ASCII karakterkészletet támogatja.

Interfészek és osztályok

A Java egyik fontos tulajdonsága, hogy lehet?vé teszi interfészek létrehozását, amiket az osztályok megvalósíthatnak. Példa egy interfészre:

 public interface Torolheto {
    public void torol();
 }

Ez az interfész csak annyit határoz meg, hogy minden, ami t?r?lhet?, biztosan rendelkezik torol() eljárással. Ennek a fogalomnak t?bb haszna is van, mint például:

 public class Fred implements Torolheto {
     @Override
     public void torol() {
         //Itt k?telez? megvalósítani a torol() eljárást
     }
 }

Más osztályban lehetséges a k?vetkez?:

 public void torolMindent(Torolheto[] lista) {
      for (int i = 0; i < lista.length; i++)
           lista[i].torol();
 }

Léteznek továbbá jel?l? interfészek, amelyeknek az implementálása nem jár metódus megvalósításával, csak egy bizonyos tulajdonsággal ruházzák fel az ?ket implementáló osztályt. Ilyen pl. a Serializable interfész. Az interfészek k?z?tt is fennállhat ?r?kl?dési reláció. Ilyenkor ugyanúgy minden át?r?kl?dik, ahogyan az osztályok esetében.

Egy absztraktként megjel?lt osztálynak lehet nem megvalósított (csak deklarált, de nem implementált) metódusa. Példa:

 // K?telez? kulcsszó az abstract, ekkor az osztálynak lehet absztrakt metódusa, de nem lehet példánya
 public abstract class Elvont {
     private int adat;
     public Elvont(int adat) {
         this.adat = adat;
     }
     public int getAdat() {
         return adat;
     }
     // K?telez? kulcsszó az abstract, ekkor nem szabad implementálni a metódust
     public abstract void manipulal();
 }

Ennek értelmében az interfész egy olyan osztály, amely teljesen absztrakt, mert nem lehet megvalósított metódusa (ez alól kivételt képeznek a Java 8-ban bevezetett default metódusok). Egy absztrakt osztálynak, illetve egy interfésznek nem létezhetnek példányai, mert akkor futásid?ben nem lenne adott a konkrét viselkedése (a hívott metódus t?rzse) – példányosítani csak az absztrakt osztályból leszármazó, illetve az interfészt megvalósító, konkrét (nem absztrakt) osztályt lehet. Ez a konkrét osztály lehet nevesített (hagyományos) vagy névtelen. Az utóbbi az absztrakt osztály (típus) egyszeri példányosítása, az absztrakt részének a példányosítás helyén t?rtén? k?telez? megvalósításával. Példa:

 ...
 Torolheto obj = new Torolheto() {
     @Override
     public void torol() {
         //Itt k?telez? megvalósítani a torol() eljárást
     }
 };
 ...
 obj.torol(); // Ez itt így már érvényes
 ...

Ha egy interfésznek egyetlen absztrakt (nem default) metódusa van, akkor az Java 8 óta funkcionális interfésznek min?sül, és lambda kifejezéssel vagy metódusreferenciával is megvalósítható:

...
Torolheto obj = () -> { /* Itt kell megvalósítani a torol() eljárást */ };
Torolheto obj2 = System::gc;
...

Ha egy osztály implementál egy vagy t?bb interfészt, akkor az az(ok) által el?írt (deklarált) minden metódust k?telez?en meg kell valósítania (implementálnia kell), kivéve, ha az illet? osztály absztrakt. Ekkor a meg?r?k?lt, de nem implementált metódusok az osztály meg nem valósított részét képezik. Példa:

 public abstract class TorolhetoElvont extends Elvont implements Torolheto {
     // A k?vetkez? kikommentezett rész mind meg?r?kl?dik
     /*
     private int adat;
     public Elvont(int adat) {
         this.adat = adat;
     }
     public int getAdat() {
         return adat;
     }
     // K?telez? kulcsszó az abstract, ekkor nem szabad implementálni a metódust
     public abstract void manipulal();
     public abstract void torol();
     */

     // Célszer? létrehozni konstruktort, amely lehet?vé teszi a meg?r?k?lt adat inicializálását
     public TorolhetoElvont(int adat) {
         super(adat);
     }
 }

Lehetséges az ?r?klési lánc megszakítása; azaz egy osztály mondhatja magáról, hogy végleges. Ekkor bel?le nem lehet ?r?k?ltetni. Példa:

 public final class Vegleges {
    ...
 }

Java 17-t?l lehetséges egy k?ztes állapot is: egy osztály vagy interfész meghatározhatja magáról, hogy mely osztályok/interfészek származhatnak le bel?le, illetve valósíthatják meg. A szül?osztály/-interfész a sealed kulcsszóval és a permits záradékkal határozhatja meg az engedélyezett altípusok k?rét, az altípusoknak pedig a final, sealed és non-sealed kulcsszavak egyikével kell rendelkezniük az engedélyezett további altípusokról; a non-sealed kulcsszó az adott altípus tekintetében megszünteti a korlátokat (tehát ugyanazok a szabályok érvényesek az ?r?kl?désre, mintha nem lenne semmilyen kulcsszó, a non-sealed csak azt szolgálja, hogy ez a szándék explicit legyen). Például:

sealed class Síkidom permits K?r, Soksz?g, EgyébSíkidom { … }

final class K?r extends Síkidom { … }
sealed class Soksz?g extends Síkidom permits Háromsz?g, Négysz?g { … }
final class Háromsz?g extends Soksz?g { … }
final class Négysz?g extends Soksz?g { … }
non-sealed class EgyébSíkidom extends Síkidom { … }

Ki- és bemenet

A k?vetkez? kódrészlet bemutatja egy karakter beolvasását a felhasználótól, majd ennek kiíratását:

 public static void main(String[] args) throws java.io.IOException {
    char a;
    System.out.println("üdv?zl?m! Kérem írjon be egy bet?t.");
    a = (char) System.in.read();
    System.out.println("A beüt?tt bet?: " + a);
 }

Objektumorientált programozás megvalósítása

A származtatott osztály megadása extends segítségével:

 public class Alaposztaly {
    protected int i;
    public void eljaras(){
       i++;
    }
 }

 public class Szarmaztatott extends Alaposztaly {
    //eljaras felulirasa
    @Override
    public void eljaras() {
        i+=2;
    }
 }

A származtatáskor az alaposztály minden elemét átvette a származtatott osztály, de az eljaras() metódusát felüldefiniáltuk.

Alaposztály konstruktor meghívása a super segítségével

 public class Szarmaztatott extends Alaposztaly {
    private int masikValtozo;
    //Konstruktor
    public Szarmaztatott(int i){
        //Alaposztaly konstruktoranak atadjuk a parametert
        super(i);
        masikValtozo = i;
    }
 }

Származtatáskor kizárólag egyetlen ?sosztályt adhatunk meg, viszont tetsz?leges számú interfészt implementálhatunk. így elkerülhet? egyrészt a leszármazási láncban a k?r (egy osztály tranzitívan ?nmagától származzon), illetve a megvalósított részek ütk?zése. C++-ban egy osztálynak t?bb k?zvetlen ?se is lehet, de ekkor egyértelm?en jel?lni kell, hogy melyik k?zvetlen ?s melyik megvalósított részét használjuk fel, viszont a k?r ott sem lehetséges.

Láthatósági k?r?k

A Java nyelv négyféle láthatóságot támogat a típusok, adattagok és tagfüggvények k?rében. A felsorolás a legszigorúbbtól halad a legmegenged?bb felé:

• private – privát, azaz csak a definiáló osztály belsejében látható;
• nincs kulcsszó – (angolul default vagy package-private) félnyilvános, azaz a definiáló csomag belsejében látható;
• protected – védett, azaz a definiáló osztály leszármazottaiból látható;
• public – nyilvános, azaz mindenhol látható.

Generikus osztályok

A Java 5-t?l kezdve megjelent az osztályok paraméterezhet?vé tétele. A szintaxis hasonlít a C++ nyelv sablonjaihoz, bár a m?k?dése jelent?sen eltér: míg a C++ a sablonokat fordítási id?ben ?kit?lti”, és a lefordított programban már konkrét, nem paraméteres típusok vannak, addig a Java generikus típusaiból kompatibilitási okokból a fordítóprogram – a fordítási idej? típusellen?rzést k?vet?en – egyszer?en eltávolítja a típusinformációkat.

List<Integer> list = new ArrayList<Integer>();

A generikus paraméter nem csak konkrét típus lehet, hanem alsó vagy fels? korlát, illetve teljesen k?tetlen is. A paraméter teljes elhagyásával nyers típust kapunk, ami sok tekintetben hasonlít a k?tetlen paraméter? típushoz, azonban kompatibilitási okokból (a nyers típus szintaxisa azonos a generikus típusok bevezetése el?tti szintaxissal) bizonyos veszélyes m?veleteket el lehet végezni velük, amiket a k?tetlen paraméterrel nem.

List<?> l1; // k?tetlen: értékül kaphat List<String>-et, List<Integer>-t, List<Object>-et stb.
List<? extends Number> l2; // fels? korlát: értékül kaphat List<Number>-t, List<Integer>-t stb.
List<? super Integer> l3; // alsó korlát: értékül kaphat List<Integer>-t, List<Number>-t vagy List<Object>-et
List l4; // nyers típus

A Java 7-ben megjelent a diamond operátor, amely egyszer?síti a szintaxist. Az értékadás jobb oldalán nem kell újból megismételni az osztály paraméterezését.

Map<String,Integer> map = new HashMap<>();

Felsorolásos típusok

A Java 5-ben jelentek meg a felsorolásos típusok (enums), amikkel egy korlátozott, konstans értékhalmaz tárolható, fordítási idej? ellen?rzésekkel. Más nyelvekt?l (pl. C, C++, C#) eltér?en a típus értékei nem egész számok, hanem objektumok, így lehetnek adattagjaik, metódusaik, megvalósíthatnak interfészeket stb. általában az egyes konstansok az enumosztály példányai, de amennyiben a kívánt viselkedés megvalósításához szükséges, lehet minden konstans egy-egy alosztály is. Például:

enum évszak { TAVASZ, NYáR, ?SZ, TéL }

enum Hónap {
    JANUáR(évszak.TéL), FEBRUáR(évszak.TéL), MáRCIUS(évszak.TAVASZ),
    áPRILIS(évszak.TAVASZ), MáJUS(évszak.TAVASZ), JúNIUS(évszak.NYáR),
    JúLIUS(évszak.NYáR), AUGUSZTUS(évszak.NYáR), SZEPTEMBER(évszak.?SZ),
    OKTóBER(évszak.?SZ), NOVEMBER(évszak.?SZ), DECEMBER(évszak.TéL);

    private final évszak évszak;
    Hónap(évszak évszak) { this.évszak = évszak; }
    public évszak getévszak() { return this.évszak; }
}

enum Hónap2 {
    JANUáR { int napokSzáma(int év) { return 31; } },
    FEBRUáR { int napokSzáma(int év) { return év % 4 == 0 && (év % 100 != 0 || év % 400 == 0) ? 29 : 28; } },
    …
    DECEMBER { int napokSzáma(int év) { return 31; } };

    abstract int napokSzáma(int év);
}

Annotációk

Szintén a Java 5-ben jelentek meg az annotációk. Ezekkel kül?nb?z? deklarációkhoz (típus, metódus, adattag, paraméter stb.) rendelhet?k metaadatok, amelyek aztán visszanyerhet?k – a @Retention metaannotációtól függ?en – fordítási vagy akár futási id?ben, amik felhasználhatók például kódgenerálásra vagy futás k?zben az annotált deklarációk kigy?jtésére. Például:

// Egy fordítási idej? kódgenerálót megkér egy ?builder” osztály generálására
@GenerateBuilderClass
class Teszt {
    // Fordítási hibát okoz, ha nem írja felül a szül?osztály (Object) egy metódusát, például elgépelés miatt
    @Override
    public String toString() { … }

    // Fordítási figyelmeztetést okoz, azt is dokumentálva, hogy mióta számít elavultnak
    @Deprecated(since = "1.1")
    public String stringify() { … }

    // Statikus ellen?rz?knek jelzi, hogy a metódus visszaadhat null értéket
    @Nullable
    public Object getValue() { … }
}

Rekordok

A Java 16-ban jelentek meg a rekordok, amik lényegesen egyszer?sítik a nem módosítható adatok ?sszességét reprezentáló típusok létrehozását. Például:

// Java 15
class Pont {
    private final int x, y;
    public Pont(int x, int y) { this.x = x; this.y = y; }
    public int x() { return x; }
    public int y() { return y; }
    public String toString() { return String.format("Pont[x=%d, y=%d]", x, y); }
    public int hashCode() { return Objects.hash(x, y); }
    public boolean equals(Object other) {
        if (other instanceof Pont) {
            Pont p = (Pont)other;
            return x == p.x && y == p.y;
        } else {
            return false;
        }
    }
}

// Java 16
record Pont(int x, int y) {}

Java class fájl verziók

Minden lefordított class fájl a k?vetkez? bájt sorozattal kezd?dik: CAFEBABE, a 7-8. bájt pedig a class fájl verzióját adja meg. A k?vetkez? táblázat az adott java verziókhoz tartozó class fájlok verzióit foglaljuk ?ssze:

• Java 1.1 f? verzió szám: 45
• Java 1.2 f? verzió szám: 46
• Java 1.3 f? verzió szám: 47
• Java 1.4 f? verzió szám: 48
• Java 5 f? verzió szám: 49
• Java 6 f? verzió szám: 50
• Java 7 f? verzió szám: 51
• Java 8 f? verzió szám: 52
• Java 9 f? verzió szám: 53
• Java 10 f? verzió szám: 54
• Java 11 f? verzió szám: 55
• ...
• Java 19 f? verzió szám: 63

A Java t?rténete

A Java nyelv t?rténete ?sszeforrt a Sun Microsystems Java fordítójával és virtuális gépével és az ezekhez kapcsolódó fejleszt?i programcsomaggal (Java SDK vagy újabban JDK – Java Development Kit), amely a Java nyelv és ahhoz kapcsolódó szabványok standard implementációjának tekinthet?. A nyílt szabványt képvisel?, de zárt forráskódú Java eszk?z?k miatt sok kritikát kapott a Sun a Free Software Foundationtól. Valószín?leg ennek is k?sz?nhet?, hogy a Sun Microsystems 2007-ben a Java SE (Standard Edition), Java ME (Micro Edition) és a Java EE (Enterprise Edition) GPL licenc alatt nyílt forráskódúvá, azaz szabad szoftverré teszi, ahogy ez már részben meg is t?rtént a Java EE esetében, nem GPL-kompatibilis licenccel.

Java FX

2006-ban megjelent egy változata a Java-nak JavaFX néven, ami egy szkriptnyelvet takar. Gyorsan egyszer?en tudunk vele asztali alkalmazásokat készíteni.

A JavaFX drasztikusan ler?vidült termelési ciklust kínál a Java-fejleszt?k és a webfejleszt?k számára egyaránt, valamint megk?nnyíti a grafikát, videót, audiót, animációt és gazdag sz?vegfunkciókat tartalmazó alkalmazások létrehozását. A JavaFX abból a szempontból egyedülálló, hogy egységesített fejlesztési és telepítési modellt kínál kifejezésteli, gazdag internetes alkalmazások (RIA) asztali számítógépen, b?ngész?n és mobilon t?rtén? kiépítéséhez. Ráadásul az új JavaFX mobil emulátor használata mellett a fejleszt?k el?zetesen megtekinthetik alkalmazásaikat a k?zelj?v?ben bevezetett JavaFX mobilplatformon, amely 2009 tavaszától lesz elérhet? a Sun mobilpartnerei számára.

Java Development Kit

A Java Development Kit (JDK) egy Oracle termék Java fejleszt?k számára, amely tartalmazza a Java fordítót (javac), egy teljes érték? Java Runtime Environment (JRE)-t, azaz Java futtató k?rnyezetet, és egyéb más fejleszt? eszk?z?ket.

A JDK nyílt let?ltése megsz?nt 2019. április 16-án új licenc bevezetése miatt. Innent?l kezdve egy Oracle fiók létezése szükséges a let?ltéshez. Az Oracle az eddig openJDK-t tette meg java f? ágának és az Oracle JDK ennek egy leágazás, ami a nem nyílt kódú eszk?z?ket is tartalmazza. Ezek k?re fokozatosan cs?kken, az Oracle mind t?bb java-s eszk?zének forráskódját tette át az openJdk kód bázisba.

Az OpenJDK, azaz a Java nyílt változatát, továbbra is lehet személyes adatok megadása nélkül használni, bármilyen célra.

A Java 19-t?l az Oracle Jdk-t megint le lehet t?lteni szabadon és fel lehet használni ingyenesen bármilyen célra. 2023-t?l az Oracle Jdk subscription díjai megint változnak.

JDK verziók

• 1.0 (1996) – kódneve Oak (t?lgy), ez volt az els? verziója a Java virtuális gépnek és az osztályk?nyvtáraknak. Ez a k?vetkez? f?bb eszk?z?ket jelentette: jvm a java programok futtatásához, java plugin b?ngész?h?z, java fordító, debugger, applet viewer. F?bb k?nyvtárak léteztek már a grafikus megjelenítéshez (AWT), audio-hoz, animációhoz, és a hálózat kezeléshez. Nyelvi szinten a nyelvet jellemezték a k?vetkez?k: Objektum Orientáltság, C/C++-hoz hasonló szintaxis, 1 fájl 1 osztály elve, interface-ek, absztrakt osztályok. Továbbá jellemz? volt még az interpretált végrehajtás is.
• 1.1 (1997) – itt jelent meg el?sz?r a bels? osztály fogalom – ami lehet?vé teszi t?bb osztály egymásba ágyazását –, valamint a JDBC az adatbázis kezeléshez, RMI a távoli metódus hívásokhoz, a Reflection API az osztály/példány elemzéshez, dinamikus példányosításhoz/metódus híváshoz.
• 1.2 (1998) – kódneve Playground (játszótér), ez a verzió számottev? mérf?ldk? volt a nyelv evolúciójában. Azért, hogy ezt kihangsúlyozza, a Sun hivatalosan Java 2-nek nevezte el. Nyelvi szint? változások: megjelent a strictfp kulcsszó. API szint? változások: része lett a Swing grafikus API, a JVM-be belekerült a JIT-compiler, Java plugin, Java IDL-egy IDL fordító a CORBA alkalmazásokhoz, Collection framework.
• 1.3 (2000) – kódneve Kestrel, csak néhány kisebb változtatást végeztek el rajta: ekkor került be a Hotspot JVM a rendszerbe, a Java Sound, a JNDI API is hivatalos része lett a bels? rendszernek.Hozzáadtak egy új JPDA API-t a debuggoláshoz és a szintetikus proxy osztályokat.
• 1.4 (2002) – kódneve Merlin. Nyelvi b?vítés: assert kulcsszó a teszteléshez (ala JUnit). API változások: új API a reguláris kifejezések kezelésére (RegExp a Perl-b?l), kivétel láncolás, NIO, Java logging API, Image IO, JAXP- XSLT és XML feldolgozáshoz, JCE, JSSE, JAAS – java biztonság, részévé vált a Java Web Start a vastag kliensek k?nnyebb webes futtatásához, update-eléséhez, Preferences API.
• 5 (2004) – bels? számozás szerint 1.5, kódneve Tiger, újdonságai nyelvi szinten a generic-ek, a megszámlálható elemet tartalmazó t?mb?n való automatikus végighaladó ciklus, az adattípusok automatikus objektummá alakítása (autoboxing), típusbiztos enum, metódus argumetruma lehet változó számú (varargs C-szer?en), static import, metaadatok kezelése forrásfájlban (annotation), System.out.printf C-b?l áthozása. Továbbá számos API b?vítés, hozzáadás, és JVM változás is volt.
• 6 (2006) – bels? számozás szerint 1.6.0, kódneve Mustang. Decemberben jelent meg a végleges változat kiterjesztett nyomk?vetési és felügyeleti megoldásokkal, Java Scripting API: szkriptnyelvek támogatása (JVM-en belül ill. azon kívül), grafikusfelület-tervezést támogató kiegészítésekkel, Java Compiler API megjelenése, JDBC 4.0 – Apache Derby el?recsomagolva a JDK-ba, pluggable annotációk, Swing GUI elemek b?vítése pl. rendezhet? / sz?rhet? táblázatok, szinkronizáció és fordítás optimalizálása, Swing felület jelent?s gyorsítása / optimalizálása, JAXWS,JAXB.
• 7 (2011) – kódneve Dolphin. 2011. július 28-ától érhet? el hivatalosan. F?bb újdonságai a teljesség igénye nélkül: JVM támogatás a dinamikus nyelvekhez, nyelvi b?vítések: Diamond operátor, String-ek engedélyezése switch utasításban,t?bb kivétel kezelése egyszerre, automatikus er?forrás kezelés,egész számokban '_' használata a k?nnyebb tagolásért, új NIO2 k?nyvtár, GPU-t kihasználni képes XRender API a Java 2D-hez, Fork és Join keretrendszer a k?nnyebb párhuzamosság használatához.
• 8 (LTS)(2014 április): Lambda kalkulus beépítése nyelvi szinten a Lambda projekt keretében, valamint a 7-be még nem beépített Coin projekt részek. Nashorn projekt egy Javascript motor beépítése, Date and Time API (Jodatime szer? megoldás), permanent generation eltávolítása.

Gyors verziókiadás (félévente):

• 9 (2017 szeptember): JDK modularizáció, amit a Jigsaw projekt keretében dolgoztak ki, Money and Currency API, nagyobb integráció a Java FX-szel, automatikus párhuzamosítás az OpenCL-lel.
• 10: Err?l egyel?re viszonylag kevés tudható, várható pl. a primitív típusok teljes eltávolítása, és a 64 biten címezhet? t?mb?k bevezetése, a nagy adathalmazok támogatásához.
• 11 (LTS): A var típus bevezetése
• 12: új switch utasítás, Shenandoah GC bevezetése nagyon r?vid GC felfüggesztési id?kkel (10-500 ms),Microbenchmark suite hozzáadása,JVM constants API hozzáadása, AArch64 esetén 1 port használat a korábbi kett? helyett, G1 kiugrás kevert gy?jtések esetén, nem használt memória azonnali visszaadása G1 esetén
• 13 (2019 szeptember 17): dinamikus Class Data Sharing (CDS) archív listával,ZGC azonnal nem használt memória visszaadása, legacy Socket API újraírása, új switch utasítás b?vítése yield-del, új sz?veg blokkok bevezetése, ahol nem kell escape-elni, as-is használat
• 17 (LTS)

A 17-es verziótól az Oracle gyorsítja az LTS-esek piacra kerülését. Az eredeti tervek szerinti 3 éves ciklus 2 évesre módosul. A k?vetkez? LTS a 21-es lesz, ami 2023-ban fog érkezni.

Kapcsolódó szabad szoftverek

• GCJ – Nyílt forrású Java fordítóprogram, amely a GNU Compiler Collection része, képes Java bájtkódot vagy natív gépi kódot generálni számos géptípusra
• A Jakarta projekt szabad Java szoftvert készít, f?leg webes programok írásához szükséges eszk?z?ket
• Eclipse – ingyenes integrált fejleszt?i k?rnyezet
• NetBeans – ingyenes integrált fejleszt?i k?rnyezet
• IntelliJ IDEA – integrált fejleszt?i k?rnyezet kereskedelmi és ingyenes változattal
• JUnit – egységteszt segédeszk?z

További információk

• A Java hivatalos webhelye
• Az OpenJDK hivatalos weboldala
• Sun oktatói weboldalak
• Java Standard Edition 16 dokumentációja
• Szabad szoftverek Java nyelven Archiválva 2009. március 15-i dátummal a Wayback Machine-ben
• Javafórum wiki

Kapcsolódó szócikkek

• Java API-k listája