Java (programovací jazyk)

Při vývoji jazyku Java se vývojáři drželi pěti hlavních principů:[6]

1. Mělo by to být „jednoduché, objektově orientované a povědomé“
2. Mělo by to být „robustní a bezpečné“
3. Mělo by to být „nezávislé na architektuře a přenositelné“
4. Mělo by to být „výkonné“
5. Mělo by to být „interpretované, vícevláknové a dynamické“

• jednoduchý – jeho syntaxe je zjednodušenou (a drobně upravenou) verzí syntaxe jazyka C a C++. Odpadla většina nízkoúrovňových konstrukcí. Součástí jazyka nejsou například ukazatele, bezznaménkové číselné datové typy, příkaz goto nebo preprocesor.
• objektově orientovaný – s výjimkou osmi primitivních datových typů jsou všechny ostatní datové typy objektové.
• distribuovaný – je navržen pro podporu aplikací v síti (podporuje různé úrovně síťového spojení, práce se vzdálenými soubory, umožňuje vytvářet distribuované klientské aplikace a servery.
• interpretovaný – místo skutečného strojového kódu se vytváří pouze tzv. bajtkód. Tento formát je nezávislý na architektuře počítače nebo zařízení. Program pak může pracovat na libovolném počítači nebo zařízení, který má k dispozici interpret Javy, tzv. virtuální stroj Javy – Java Virtual Machine (JVM).

V pozdějších verzích Javy nebyl mezikód přímo interpretován, ale před prvním svým provedením dynamicky zkompilován do strojového kódu daného počítače (tzv. just in time compilation – JIT). Tato vlastnost zásadním způsobem zrychlila provádění programů v Javě, ale výrazně zpomalila start programů.

V současnosti se převážně používají technologie zvané HotSpot compiler, které mezikód zpočátku interpretují a na základě statistik získaných z této interpretace později provedou překlad často používaných částí do strojového kódu včetně dalších dynamických optimalizací (jako je např. inlining krátkých metod atp.).

Některé platformy nabízejí přímou hardwarovou podporu pro Javu. Existují též mikroprocesory, které dokáží spustit Javu hardwarově namísto softwarové emulace Java Virtual Machine. ARM procesory mohou mít přímou hardwarovou podporu pro spuštění binárního kódu Javy.

• robustní – je určen pro psaní vysoce spolehlivého softwaru – z tohoto důvodu neumožňuje některé programátorské konstrukce, které bývají častou příčinou chyb (např. správa paměti, příkaz goto, používání ukazatelů). Používá tzv. silnou typovou kontrolu – veškeré používané proměnné musí mít definovaný svůj datový typ.
• generační správa paměti – správa paměti je realizována pomocí automatického garbage collectoru, který automaticky vyhledává již nepoužívané části paměti a uvolňuje je pro další použití. To bylo v prvních verzích opět příčinou pomalejšího běhu programů. V posledních verzích běhových prostředí je díky novým algoritmům pro garbage collection a tzv. generační správě paměti (paměť je rozdělena na více částí, v každé se používá jiný algoritmus pro garbage collection a objekty jsou mezi těmito částmi přesunovány podle délky svého života) tento problém ze značné části eliminován.
• bezpečný – má vlastnosti, které chrání počítač v síťovém prostředí, na kterém je program zpracováván, před nebezpečnými operacemi nebo napadením vlastního operačního systému nepřátelským kódem.
• nezávislý na architektuře – vytvořená aplikace běží na libovolném operačním systému nebo libovolné architektuře. Ke spuštění programu je potřeba pouze to, aby byl na dané platformě instalován správný virtuální stroj. Podle konkrétní platformy se může přizpůsobit vzhled a chování aplikace.
• přenositelný – vedle zmíněné nezávislosti na architektuře je jazyk nezávislý i co se týká vlastností základních datových typů (je například explicitně určena vlastnost a velikost každého z primitivních datových typů). Přenositelností se však myslí pouze přenášení v rámci jedné platformy Javy (např. J2SE). Při přenášení mezi platformami Javy je třeba dát pozor na to, že platforma určená pro jednodušší zařízení nemusí podporovat všechny funkce dostupné na platformě pro složitější zařízení a kromě toho může definovat některé vlastní třídy doplňující nějakou speciální funkčnost nebo nahrazující třídy vyšší platformy, které jsou pro nižší platformu příliš komplikované.
• výkonný – přestože se jedná o jazyk interpretovaný, není ztráta výkonu významná, neboť překladače mohou pracovat v režimu „just-in-time“ a do strojového kódu se překládá jen ten kód, který je opravdu zapotřebí.
• víceúlohový – podporuje zpracování vícevláknových aplikací
• dynamický – Java byla navržena pro nasazení ve vyvíjejícím se prostředí. Knihovna může být dynamicky za chodu rozšiřována o nové třídy a funkce, a to jak z externích zdrojů, tak vlastním programem.
• elegantní – velice pěkně se v něm pracuje, je snadno čitelný (např. i pro publikaci algoritmů), přímo vyžaduje ošetření výjimek a typovou kontrolu.

James Gosling, hlavní tvůrce

• 1991 – James Gosling, Bill Joy, Mike Sheridan a Patrick Naughton započali Stealth Project (Tajný projekt), který měl za cíl vytvořit systém pro domácí spotřebiče. Projekt se později přejmenoval na Green Project (Zelený projekt), a tým vývojářů dostal název Green Team (Zelený tým). Vedoucím projektu se stal James Gosling.

Green Team zpočátku používal programovací jazyk C++, který ovšem pro jejich cíl nebyl vhodný. Nakonec James Gosling začal pracovat na novém jazyku, který pojmenoval Oak (dub) podle stromu, jež rostl před okny jeho kanceláře.[7][8]

• 1995 – Přejmenování jazyka z Oak na Java. Jazyk s názvem Oak totiž již existoval. Java je americké slangové označení pro kávu.[8]

• 1996 – Java Development Kit (JDK) 1.0

První oficiální verze vyšla 26. srpna 1996.

V prvních verzích Javy a JDK bylo možné použít klíčová slova private a protected k vytvoření dalšího modifikátoru přístupu, a sice k omezení přístupu k metodám a proměnným výhradně na podtřídy dané třídy. Tato funkčnost byla z jazyka odebrána ve verzi 1.0.2.

• 1997 – JDK 1.1

Další významná verze JDK vyšla 19. února 1997. Do jazyka byla přidána podpora vnořených tříd, reflexe (bez podpory modifikace za běhu) a Unicode verze 2.0. JDK obsahovalo následující novinky: JavaBeans, JDBC, Java RMI, rozšíření AWT a JIT kompilátor pro MS Windows.[9]

• 1998 – J2SE 1.2

Verze s kódovým označením Playground ([ˈpleiˌgraund]; anglicky dětské hřiště) byla vydána 8. prosince 1998. Pojmenování se změnilo na Java 2 a název verze J2SE. Část SE z názvu J2SE (Java 2 Platform, Standard Edition) slouží k rozlišení základní platformy od J2EE (Java 2 Platform, Enterprise Edition) a J2ME (Java 2 Platform, Micro Edition).

Do jazyka přibylo klíčové slovo strictfp. Velikost platformy Java se v této verzi ztrojnásobila na 1 520 tříd v 59 balíčcích. Nejvýznamnější změny: knihovna Swing pro sestavení grafického rozhraní, Java 2D API, Java collections framework (JSR 166), Accessibility API, JDBC 2.0, Java Plug-in, Java IDL – pro podporu technologie CORBA, absolutní podpora Unicode včetně psání v japonštině, čínštině a korejském jazyce, lepší výkon JIT-kompilátoru.[10]

• 2000 – J2SE 1.3

Verze s kódovým označením Kestrel ([ˈkestrəl]; anglicky poštolka obecná) byla vydána 8. května 2000. Do jazyka byly přidány syntetické proxy třídy. Další změny: přidání JavaSound, Java Naming and Directory Interface (JNDI) – dříve dostupné jako rozšíření, Java Platform Debugger Architecture (JPDA), modifikace Java RMI pro podporu technologie CORBA a přidání HotSpot JVM.[11]

• 2002 – J2SE 1.4

• 2004 – J2SE 5.0

Specifikovaná verze Java 5.0 vyšla v září roku 2004. Od té doby byla změněna oficiální indexace Javy. Java 1.5 se správně jmenuje Java 5.0. Vnitřní indexace přesto zůstala stejná, tj. 1.x. Daná verze obsahuje celou řadu změn: přidané výčtové typy, anotace, generics, autoboxing/unboxing, cyklus foreach (iterátor), Javadoc komentáře, povolen import statických polí a metod, přidané metody s neurčitým počtem parametrů a další.

Výčtové typy (angl. enum) jsou plnohodnotnou třídou, což znamená, že mohou mít pole a metody, a to dokonce skryté i abstraktní.

Anotace umožňují přidávat do kódu neovlivňující programová data, která například popisují nějakou část kódu a jeho účel.

• 2006 – Java SE 6

Java 6 byla zveřejněna 11. prosince 2006. Oficiální indexace se změnila, místo očekávané verze 6.0 byla Java 6 představena pod tímto názvem. Menší změny (stejně jako v Java 5.0) se přidaly pomocí aktualizací.

• 2011 – Java SE 7

Java 7 byla zveřejněna 28. července roku 2011. Finální verze Java Standard Edition 7 neobsahuje všechny naplánované změny, ty se objeví v Java Standard Edition 8.

• 2014 – Java SE 8

Java 8 byla zveřejněna 18. března roku 2014. Přinesla mimo jiné vybrané prvky z funkcionálního programování jako jsou lambda funkce či proudové zpracování dat. Toto rozšíření Javy sestává z nových syntaktických prvků i z nových instrukcí bajtkódu.

• 2017, 21. září – Java SE 9

Aktuální plán pro Javu 9 zahrnuje například projekt Jigsaw (systém modulů) či podporu pro reaktivní programování.

• 2018, 20. březen – Java SE 10

Novinky zahrnují typovou inferenci lokálních proměnných, konsolidaci repozitářů, nové rozhraní pro garbage collector a další.[12]

• 2018, 25. září - Java SE 11

• 2019, Java SE 12, 13
• 2020, Java SE 14, 15
• 2021, Java SE 16, 17, 18

Společnost Oracle je současným vlastníkem oficiální implementace Java SE platformy, po její akvizici firmy Sun Microsystems 27. ledna 2010. Tato implementace je založena na původní od Sunu. Je dostupná pro macOS, Windows a Solaris. Vzhledem k tomu, že Java postrádá jakékoliv formální standardizace uznané Ecma International, ISO/IEC, ANSI, nebo jinými standardizačními organizacemi třetích stran, implementace Oraclu je de facto standard.

Implementace Oraclu je rozdělena do dvou různých distribucí: Java Runtime Environment (JRE), která obsahuje části Java SE platformy potřebné pro běh programů v jazyce Java a je určena pro koncové uživatele. Druhým balíkem je Java Development Kit (JDK), který je určen pro softwarové vývojáře a obsahuje vývojové nástroje jako je Java kompilátor, Javadoc, Jar a debugger.

OpenJDK je další významnou implementací Javy SE pod licencí GPL. Ta začala, když Sun začal vydávat zdrojový kód Javy pod licencí GPL. Od Javy verze SE 7 je tedy OpenJDK oficiální referenční implementací Javy.

Cílem Javy je, aby byly všechny její implementace kompatibilní. To vyústilo v právní spor se společností Microsoft poté, co Sun prohlásil, že implementace Microsoftu (Microsoft Java Virtual Machine) nepodporují RMI nebo JNI, a že si Microsoft přidal funkce specifické pro jejich vlastní platformu. Sun podal žalobu v roce 1997 a v roce 2001 získal vyrovnání v hodnotě 20 miliónů dolarů, stejně jako nařízení soudu přikazující Microsoftu dodržování licenčních podmínek Sunu.[13] V důsledku toho Microsoft nadále neprodává žádné svoje Windows s Javou (Windows XP SP2, Windows Server 2003 a novější).[14]

Java používá automatickou správu paměti pro řízení paměti v object lifecycle. Programátor určuje kdy bude objekt vytvořen a Java runtime zodpovídá za obnovu paměti jakmile se objekty přestanou používat. Když nezůstanou žádné odkazy na objekt, nepřístupná paměť se stává přístupnou pro garbage collector, který ji automaticky uvolní. Něco podobného úniku paměti přesto může vzniknout, jestliže programátorův kód obsahuje referenci na objekt, který již není potřeba.

Jedním z účelů pro automatickou správu paměti Java bylo zbavit programátora nutnosti lámat si hlavu nad manuální správou paměti. V některých programovacích jazycích je paměť nutná pro vytvoření objektů implicitně přidělena do zásobníku, anebo explicitně přidělena a uvolněna. V takovém případě odpovědnost za správu paměti padá na programátora. Pokud program objekt neuvolní, může dojít k úniku paměti. Pokud se program pokusí uvolnit paměť, která jíž byla uvolněna, výsledek není definován a je obtížné ho odhadnout, takže program se pravděpodobně stane nestabilní a/nebo spadne. To může být částečně odstraněno použitím chytrých ukazatelů, ale to také zvětšuje náročnost a složitost.

Syntaxe Javy je do značné míry odvozena z C++. Na rozdíl od C++, které kombinuje syntaxi pro strukturované, generické, a objektově-orientované programování, Java byla postavena téměř výhradně jako objektově orientovaný jazyk. Veškerý kód je napsán uvnitř třídy a všechno je objekt, s výjimkou primitivních datových typů (tj. celá čísla, desetinná čísla, logické hodnoty a znaky), které nejsou třídy z výkonnostních důvodů.

Na rozdíl od C++ Java nepodporuje přetěžování operátorů nebo vícenásobnou dědičnost pro třídy. To zjednodušuje jazyk a pomáhá při prevenci potenciálních chyb.

Java používá podobné komentovací metody jako C++. Existují tři různé styly komentářů: jednořádkový uvozený dvěma lomítky (//), víceřádkový uvozený /* a uzavřený s */ a Javadoc dokumentační styl komentování uvozený /** a uzavřený */. Komentář typu Javadoc umožňuje uživateli sestavit dokumentaci k programu.

Tradiční program „Hello world“ vypadá takto:

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello world!");
    }
}

Výpočet mediánu:

public class SortLinefOfTextFile {
    void sortAtextFile(String fileName, String toFileame){
    }
    public static void main(String[] args){
                File file = new File("C:\\"); //načtení souboru
                Scanner sc = null; //scanner =třída, která umí načítat vstupy, sc = null definice vstupu, která nemá žádnou hodnotu null= rovná se ničemu nulová 
                try {
                    sc = new Scanner(file); //načte soubor "file" který má v sobě data(čísla)
                    } 
                catch (FileNotFoundException e)     //osetreni načteni souboru
                    {
                    System.out.println("Soubor nebyl nalezen.");
                    return; //když vyskočí chyba "soubor nebyl nalezen tak se znovu program opakuje
                    }
                ArrayList<Float> list = new ArrayList<Float>(); //float = desetinné číslo(může být i double liší se velikostí),vytvoreni seznamu
                while (sc.hasNextFloat())           //zapsani čisel do seznamu
                    list.add(sc.nextFloat()); //přidá další hodnotu (číslo)
                int size = list.size(); //načtení velikosti pole
                if (size == 0) {        //osetreni prazdneho souboru
                    System.out.println("Prázdný soubor"); //vypíše
                    return; //program se opakuje
                }
                Collections.sort(list);     //seřazeni seznamu
                for (int i = 0; i < size; i++) { //vypsání čísel
                    System.out.print(list.get(i) + " ");
                }
                System.out.println(); //prázdný řádek
                //median
                float median; //typ proměnné
                if (size % 2 == 0) {
                    float x1 = list.get(size / 2 - 1);
                    float x2 = list.get(size / 2);
                    median = (x1 + x2) / 2;
                } else {
                    median = list.get(size / 2);
                }
                System.out.println("Median=" + median);
                }
}

Řazení slov menších jak 5 ze souboru

public class Priklad_1 { //třída

    public static void main(String[] args) { //deklarace typu proměnné string = deklarace slov
        File soubor = splitFiles("C:\\", "C:\\"); //načteni vstupniho a vystupniho souboru
    }
    public static File splitFiles(String input, String output) {    //metody, sting = typ promenné, split = rozdělení souborů
        try (BufferedReader br = new BufferedReader(new FileReader(input))) {       //načteni souboru
            String line; // definice proměnné line
            ArrayList<String> results = new ArrayList<>(); //vytvoření seznamu
            while ((line = br.readLine()) != null) {    //čteni radku
                String[] parts = line.split(" ");   //rozděleni slov po "mezeře"
                for (String part : parts) {         //nahrazeni znaků
                    part = part.replace("*", ""); //nahrazení hvězdičky mezerou atd...
                   
                    if (part.length() > 5) {        //vybrani slov větších jak 5 znaků
                        results.add(part);          //tak se to vypíše do toho dalšího souboru
                    }
                }
            }
            Collections.sort(results); //serazeni vysledku podle abecedy může se to použít i pro čísla
            
            
            try (BufferedWriter bwr = new BufferedWriter(new FileWriter(output))) { //zapsani vysledku do souboru
               for (String result : results) {
                    bwr.write(result);//zapsání nového slova
                    bwr.newLine(); //vytvoření nové řádky 
                }
               
            }
        } catch (Exception e) { //pro zachycení chyby aby program nespadl.
            System.err.println("Chyba při četení ze souboru."); //osetreni vstupu souboru
        }
        return new File(output); //musí být je to návrácení do metody main
    }

Pohyb auta po stisknuti klávesy

public class Car2 extends Application {
    @Override
    public void start(Stage primaryStage) throws Exception {
        //vytvoreni obrázku
        Pane pane = new Pane(); //kontejner, ve kterém se vytváří obrázek
        Image carImage = new Image(new FileInputStream("E:\\auto.jpg")); 
        //načteni obrazku z disku
        ImageView cImage = new ImageView(carImage); //zobrazení obrázku
        cImage.setFitWidth(120);    //nastaveni velikosti obrázku, šířka obrázku
        cImage.setFitHeight(80); //výška obrázku
        pane.getChildren().addAll(cImage); //
        Scene scene = new Scene(pane, 800, 500);  //nastaveni velikost okna
        scene.setOnKeyPressed(new EventHandler<KeyEvent>() { //příkaz pro stlačení tlačítka
            @Override
            public void handle(KeyEvent e) { //nadefinované 
                //Automaticke posouvani s přerušenim po stlačení mezerniku  
                  /*if (e.getCode() == KeyCode.RIGHT) {
                    int times = 1;
                    while (times < 10) {
                        cImage.setLayoutX(cImage.getLayoutX() + 10);
                        try {
                            Thread.sleep(100);
                        } catch (InterruptedException ex) {
                            ex.printStackTrace();
                        }
                        if (e.getCode() == KeyCode.SPACE) {
                            break; //po stihnutí mezerníku se obrázek zastaví
                        }
                        times++;
                    }
                }*/
                if (e.getCode() == KeyCode.RIGHT) {    //posunuti doprava
                    cImage.setLayoutX(cImage.getLayoutX() + 10); //x= souřadnice posunutí o 10px
                }

                if (e.getCode() == KeyCode.LEFT) {     //posunuti doleva
                    cImage.setLayoutX(cImage.getLayoutX() - 10);
                }

                if (e.getCode() == KeyCode.UP) {       //posunuti nahoru

                    cImage.setLayoutY(cImage.getLayoutY() - 10);
                }

                if (e.getCode() == KeyCode.DOWN) {     //posunuti dolu

                    cImage.setLayoutY(cImage.getLayoutY() + 10);
                }
            }
        });
        //zobrazeni
        primaryStage.setTitle("Car");
        primaryStage.setScene(scene);
        primaryStage.show();
    }
    public static void main(String[] args) {
        launch(args);
    }
}

Netradiční verze „Hello world“ s malou ukázkou objektového přístupu:

public class HelloWorld {
    public static void main(String[] args) {
        Pozdrav pozdrav = new Pozdrav("Ahoj světe!");
        pozdrav.print();
    }
}

class Pozdrav {
    private String text;

    public Pozdrav(String pozdrav) {
        text = pozdrav;
    }

    private String getText() {
        return text;
    }

    public void print() {
        System.out.println(getText());
    }
}

Seznam vybraných IDE pro vývoj v jazyce Java (řazeno abecedně):

• BlueJ – multiplatformní vývojové prostředí (volně šiřitelné)
• Eclipse – multiplatformní vývojové prostředí pro programování v jazycích Java, C++ a dalších (volně šiřitelné)
• IntelliJ IDEA – multiplatformní vývojové prostředí pro programování v jazycích Java, Groovy a dalších (Community verze zdarma, Ultimate placená verze)
• JDeveloper – vývojové prostředí firmy Oracle (volně šiřitelné)
• NetBeans – vývojové prostředí pro Javu, C/C++, Groovy a PHP (volně šiřitelné)