Java (programozási nyelv)

A Wikipédiából, a szabad enciklopédiából
Java
Java logo and wordmark.svg

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 Standard Edition 8 Update 5 (1.8.5) (2014. április 15.)
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
Operációs rendszer platformfüggetlen
Licenc GNU General Public License / Java Community Process
Weboldal
A Java kabalafigurája, Duke

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 addig, amíg a céget fel nem vásárolta az Oracle 2009-ben. 2011-ben a Java 1.7-es verzióját az Oracle gondozásában adták ki.

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 szintaxisát főleg a C és a C++ nyelvektől örökölte, viszont a Java sokkal egyszerűbb objektummodellel rendelkezik, mint a C++. A JavaScript szintaxisa és neve hasonló ugyan a Javahoz, de nincs közvetlen köze egymáshoz a két nyelvnek.

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), de 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 Sun Microsystems védjegye. Ennélfogva engedélye nélkül más nem használhatja más által kifejlesztett termékek megjelölésére még például Java-szerű stb. összetételekben sem, mert ez a védjegyjogosult jogaiba ütközik.

Általános tudnivalók[szerkesztés | forrásszöveg szerkesztése]

A Java nyelvet kávézás közben találták ki, innen ered a kávéscsésze ikon.[1] 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[szerkesztés | forrásszöveg szerkesztése]

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 szerepei[szerkesztés | forrásszöveg szerkesztése]

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

  1. mint programozási nyelv;
  2. mint középszint (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)[szerkesztés | forrásszöveg szerkesztése]

A második tulajdonság, a platformfüggetlenség azt jelenti, hogy a Javában íródott programok hasonlóan fognak futni különböző hardvereken. Ezt úgy lehet megvalósítani, hogy a Java fordítóprogram csak egy úgynevezett Java bájtkódra fordítja le a forráskódot, ami aztán futtatva lesz a virtuális gépben, amely lefordítja az illető hardver gépi kódjára. Továbbá, szabványos könyvtárcsomagok léteznek, amelyek elérhetővé teszik az illető hardver sajátságosságait (grafika, szálak és hálózat) egységes módon.

Vannak olyan Java fordítóprogramok, amelyek natív gépi kódra fordítják le a forráskódot, ilyen például a GCJ, így valamelyest felgyorsítják a futtatást, de ugyanakkor a lefordított program elveszti hordozhatóságát.

A Sun Microsystems licence ragaszkodik a különböző Java kivitelezések összeférhetőségéhez. 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 az olyan weboldalak, amelyek Javát használnak, nem fognak helyesen megjelenni. 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, 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.

Ennek ellenére a Java sikeres lett a servlet, a JSP és Enterprise JavaBeans kiszolgálóoldali technológiákkal.

Biztonságos távoli futtatás[szerkesztés | forrásszöveg szerkesztése]

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 teszi lehetővé a "rossz szándékú" kód futtatását; a gyártók kiadhatnak olyan tanúsítványokat, amelyeket digitálisan aláírnak, tanúsítva, hogy a kisalkalmazás biztonságos, lehetővé téve ennek kilépését a biztonságos környezetből (ugyancsak a felhasználó felügyelete alatt).

A nyelv[szerkesztés | forrásszöveg szerkesztése]

A klasszikus „Helló Világ!” Javában[szerkesztés | forrásszöveg szerkesztése]

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[szerkesztés | forrásszöveg szerkesztése]

Ciklusok[szerkesztés | forrásszöveg szerkesztése]

while[szerkesztés | forrásszöveg szerkesztése]

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[szerkesztés | forrásszöveg szerkesztése]

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[szerkesztés | forrásszöveg szerkesztése]

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 - in[szerkesztés | forrásszöveg szerkesztése]

A Java 1.5 verziótól kezdve for ciklussal iterálhatóak a tömbök és a java.lang.Iteratable interface 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[szerkesztés | forrásszöveg szerkesztése]

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

Kivételkezelés[szerkesztés | forrásszöveg szerkesztése]

 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 blokk esetén legalább egy catch vagy egy finally ágat kötelező használni. A catch ágakból több is lehet, de egy tryban csak egy finally állhat.

Feltétel nélküli ugróutasítások[szerkesztés | forrásszöveg szerkesztése]

A Java nem támogatja a goto utasítást, mivel ennek használata pongyola kó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[szerkesztés | forrásszöveg szerkesztése]

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

 continue;

utasítás befejezi 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 <em>legkülső</em> ciklusból
     }
 }

Korai kilépés az eljárásokból[szerkesztés | forrásszöveg szerkesztése]

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[szerkesztés | forrásszöveg szerkesztése]

A nyelv alapvető adattípusai, más szóval primitív típusai a következők:

Változó típusa Leírás
byte 8 bites előjeles egész
short 16 bites előjeles egész
int 32 bites előjeles egész
long 64 bites előjeles egész
float 32 bites egyszeres lebegőpontosságú (IEEE 754 szabvány)
double 64 bites kétszeres lebegőpontosságú (IEEE 754 szabvány)
char 16 bites Unicode-karakter
boolean logikai érték (igaz / hamis)

A tömbök és karakterláncok nem alapvető adattípusok, hanem objektumok.

Karakterek[szerkesztés | forrásszöveg szerkesztése]

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[szerkesztés | forrásszöveg szerkesztése]

Az egyik fontos tulajdonsága a Javának az, hogy lehetővé teszi interfészek létrehozását, amit az osztályok megvalósítanak. 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 egy eljárással: torol(). 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 amelyeket implementálása nem jár metódus megvalósításával, csak egy bizonyos tulajdonsággal ruházza fel az őt implementáló osztályt. Ilyen pl. a Serializable interfész. Ahogy az osztályok között, az interfészek között is fennállhat öröklődési reláció. Ilyenkor ugyanúgy minden átöröklődik.

Egy osztály absztrakt, ha lehet nem megvalósított 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. Az absztrakt osztálynak és az interfésznek nem létezhetnek példányai, mert akkor futásidőben nem lehetne kideríteni a konkrét viselkedését. Egy kivétel azonban mégis létezik, a névtelen osztály. Ez az absztrakt 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 osztály implementál egy vagy több interfészt, akkor minden megörökölt metódust kötelezően implementálnia kell, kivéve ha az osztály absztrakt, mert akkor az osztály meg nem valósított részét képezik a megörökölt de nem implementált metódusok. 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 ebből az osztályból már nem lehetséges származtatni. Példa:

 public final class Vegleges {
    ...
 }

Ki- és bemenet[szerkesztés | forrásszöveg szerkesztése]

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[szerkesztés | forrásszöveg szerkesztése]

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[szerkesztés | forrásszöveg szerkesztése]

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[szerkesztés | forrásszöveg szerkesztése]

A java 5-től kezdve megjelent az osztályok paraméterezhetővé tétele. A szintaxis hasonlít a C++ nyelv Standard Template Library (STL)-hez.

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

A java 7-től 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ést.

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

A Java története[szerkesztés | forrásszöveg szerkesztése]

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[szerkesztés | forrásszöveg szerkesztése]

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.[2]

JDK verziók[szerkesztés | forrásszöveg szerkesztése]

  • 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.[3]
  • 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.[4]
  • 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[5].
  • 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 [6].
  • 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.[7]
  • 8 (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.
  • 9 (2016-ban várható): 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-el.
  • 10: Erről jelenleg (2013 novemberében) 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.

Kapcsolódó szabad szoftverek[szerkesztés | forrásszöveg szerkesztése]

Források[szerkesztés | forrásszöveg szerkesztése]

További információk[szerkesztés | forrásszöveg szerkesztése]