types classes java
Tento výukový program bude diskutovat různé typy tříd v Javě, jako jsou abstraktní, konkrétní, konečné, vnitřní, POJO, statické a další speciální třídy s příklady:
V našem předchozím kurzu jsme diskutovali o třídách a objektech v Javě. Třída v Javě je šablona nebo plán. Lze jej také definovat jako kolekci podobných objektů. Definujeme objekty třídy typů a poté komunikujeme prostřednictvím těchto objektů.
Každý objekt je instancí třídy, která má stav a chování.
=> Navštivte zde exkluzivní sérii výukových programů Java.
Co se naučíte:
Typy tříd v Javě - úvod
Všichni víme, že třída má následující komponenty:
- Modifikátory: Zadejte přístup pro třídu.
- Jméno třídy: Název třídy.
- Klíčová slova: Klíčová slova naznačující, zda třída rozšiřuje nebo implementuje třídu nebo rozhraní.
- Tělo třídy uzavřené do složených závorek {}
V závislosti na různých použitých modifikátorech, specifikovaném těle třídy a použitých klíčových slovech máme v Javě různé typy tříd.
nejlepší bezplatný software pro zálohování obrázků 2017
- Třída betonu: Normální třída, která má konkrétní implementaci metod.
- POJO třída: Toto je „Obyčejný starý objekt Java“ obsahující pouze soukromé členské proměnné a metody getter setter pro přístup k těmto proměnným.
- Abstraktní třída: Tato třída má jednu nebo více abstraktních metod.
- Závěrečná třída: Konečnou třídu nelze zdědit.
- Statická třída: Třída obsahující pouze statické členy.
- Vnitřní třída: Vnitřní třída je třída, která je členem jiné třídy.
V tomto kurzu probereme každý z těchto typů tříd s příklady.
Budeme také diskutovat o některých dalších typech tříd, které jsou v Javě považovány za speciální třídy.
- Anonymní třída: Třída bez jména.
- Neměnná třída: Třída, jejíž objekt nelze změnit.
- Třída Singleton: Třída, jejíž jednu instanci lze vytvořit.
- Třída objektu: Základní třída všech funkcí Java.
- Třída zavinovačky: Každý primitivní datový typ v Javě má třídu wrapper.
Nejprve si ale pojďme krátce promluvit o tom, jak importovat třídu v Javě spolu s hlavní třídou v Javě, která obsahuje hlavní metodu nebo výchozí bod v Javě.
Importovat v Javě
Pokud v Javě chceme do našeho programu zahrnout jakoukoli funkci nebo funkčnost, můžeme použít příkaz „import“. Pomocí příkazu import můžeme importovat celý balíček a používat jeho funkčnost v našem programu nebo můžeme také zahrnout jednu třídu.
Níže je uvedena syntaxe příkazu import.
import packageName/classname; Pokud chceme importovat balíček java.lang a všechny jeho třídy, můžeme napsat následující příkaz:
import java.lang.*; Předpokládejme, že chceme do našeho programu zahrnout funkčnost třídy Arrays, pak můžeme napsat následující příkaz:
import java.util.Arrays; Příkaz import je ekvivalentní příkazu C / C ++ include. Výpis importu je umístěn na začátek programu Java jako první příkaz. V programu Java můžeme mít více než jedno prohlášení.
Hlavní třída v Javě
Již víme, že v Javě je metoda main () výchozím bodem provádění jakéhokoli programu a lze ji umístit do jakékoli třídy dané konkrétní aplikace. Pokud však máme složitou aplikaci s příliš mnoha soubory a třídami, je vhodné mít hlavní třídu a do této hlavní třídy umístit metodu main ().
class Main{ public static void main(String() args){ System.out.println(“Hello, World!”); } } Všimněte si, že JVM nevytváří objekt třídy Main. Logika za tím spočívá v tom, že main () je statická metoda, lze ji volat bez jakéhokoli objektu třídy.
Druhy tříd v Javě
Nyní přejdeme k typům tříd v Javě. Vysvětlíme každou z těchto tříd jednu po druhé, následovanou příklady programování.
# 1) Betonová třída
Konkrétní třída je jakákoli normální třída v programu Java. Tato třída nebude mít žádné abstraktní metody. Všechny metody v konkrétní třídě jsou zcela implementovány.
Konkrétní třída může dědit z jiné třídy, dokonce iz abstraktní třídy nebo implementovat rozhraní. Můžeme vytvořit instanci konkrétní třídy a vytvořit její objekty.
Níže je uveden jednoduchý příklad konkrétní třídy.
public class Main { // Concrete Class example static int total(int val1, int val2) { return val1 + val2; } public static void main(String args()) { int sum = total(100, 108); System.out.println('Total of two integers: ' + sum); } } Výstup
Výše uvedený program ukazuje konkrétní třídu. Vidíme, že tato třída má kompletní implementaci. Nezůstane nic nekompletního nebo neimplementovaného.
# 2) POJO třída
POJO (Plain Old Java Object) je třída obsahující pouze soukromé členské proměnné. Kromě soukromých členských proměnných obsahuje pouze metody getter a setter používané těmito členskými proměnnými.
Třída POJO nemá své chování. Může však přepsat některé metody, například equals nebo interfaces.
Vlastnosti třídy POJO:
- Třída POJO musí mít veřejnou metodu getter a setter.
- Všechny proměnné členů nebo instance by měly být soukromé.
- Třída POJO nerozšiřuje ani neimplementuje předem zadané třídy nebo rozhraní.
- Neobsahují předem určené poznámky.
- Nemá konstruktor bez argumentů (konstruktor bez argumentů).
Níže je uveden program Java, který předvádí třídu POJO.
//declare a POJO class class POJO_Class { private int daysOfWeek=7; //private variable public int getdaysOfWeek() { //getter return daysOfWeek; } public void setdaysOfWeek(int dow) { //setter this.daysOfWeek = dow; } } public class Main { public static void main(String args()){ POJO_Class pojoDemo = new POJO_Class(); //instance of POJO class System.out.println('Days of the week:' + pojoDemo.getdaysOfWeek()); } } Výstup
Výše uvedená ukázka třídy POJO ukazuje, že má pro tuto proměnnou soukromou proměnnou a metody getter setter. Pro přístup k této členské proměnné používáme metodu getter. K aktualizaci hodnoty se používá metoda setter.
# 3) Abstraktní třída
Abstraktní třída je třída, která je neúplná nebo jejíž implementace není dokončena. Nelze vytvořit instanci abstraktní třídy. Je třeba ji rozšířit o další třídy a implementovat její metody k vytvoření konkrétní třídy.
Abstraktní třída je deklarována pomocí klíčového slova „abstrakt“. Abstraktní třída může mít statické a konečné metody i konstruktory.
Pojďme si předvést abstraktní třídu v Javě.
interface multiply //interface multiply { int product(int num1, int num2); } // abstract class abstract class Product implements multiply { // this is an abstract method to calculate product of two numbers public abstract int product(int num1, int num2); } // Concrete class :this will implement the abstract method above class Main extends Product { public int product(int num1, int num2) { return num1*num2; } // main method public static void main(String args()) { Main obj = new Main(); int prod = obj.product(100, 20); // print product System.out.println('Product of two numbers: ' + prod); } }Výstup
Ve výše uvedeném programu máme násobení rozhraní. Vytváříme abstraktní třídu Product, která implementuje multiply interface. Uvnitř produktu máme produkt metody, který není implementován. Pak máme třídu Main, která dědí třídu Product a implementuje metodu produktu. Později tuto metodu zavoláme na objekt hlavní třídy.
# 4) Statická třída
Statika v Javě obecně znamená objekt, který patří do třídy a nikoli do jednotlivých instancí. Statický člen nebo metoda v Javě tedy nemusí být přístupná pomocí objektu, ale přímo pomocí názvu třídy.
Statická třída v Javě může obsahovat pouze statické členy. Také nemůžeme vytvořit instanci statické třídy.
Následující program Java ukazuje statickou třídu.
class Static_Class { static int total; // static variable static void sum(int val1, int val2) { // static method System.out.print('Static method to calculate sum:' + ' '); total = val1 + val2; System.out.println(val1 + '+' + val2); // print the numbers } static class Nested_Class { // static class static { // static block System.out.println('static block inside a static nested class'); } public void displaySum() { sum(25, 75); // call static method // print the value in static variable total, it holds the sum of two numbers System.out.println('Sum of two numbers:' + total); } } } public class Main { public static void main(String args()) { // declare static class object Static_Class.Nested_Class object = new Static_Class.Nested_Class(); object.displaySum(); // call displaySum method inside a static class } } Výstup
Výše uvedená třída ukazuje statickou třídu. Zde máme statickou třídu, která je členem jiné konkrétní třídy. Uvnitř statické třídy vypočítáme součet dvou čísel a výsledek uložíme do statické proměnné, která je členem vnější třídy.
# 5) Finální třída
Konečná třída je třída, kterou nelze zdědit ani podtřídit. Jakmile je třída v Javě prohlášena za konečnou, je to jakási konstanta a stává se neměnnou.
Proto, aby byla třída neměnná, musíme ji prohlásit za konečnou.
zdarma DVD Ripper pro Windows 8.1
//final class final class Base_Class { void Display() { System.out.println('Base_Class::Display()'); } } //class Derived_Class extends Base_Class { //Compile-time error - can't inherit final class class Derived_Class{ void Display() { System.out.println('Derived_Class::Display()'); } } public class Main { public static void main(String() arg) { Base_Class base_obj = new Base_Class(); //create a final class object base_obj.Display(); Derived_Class deri_obj = new Derived_Class(); deri_obj.Display(); } } Výstup
Výše uvedený program nejprve deklaruje Base_Class, který je označen jako „konečný“. Proto když se pokusíme rozšířit jej v Derived_Class, dostaneme chybu kompilátoru. (Komentovaný řádek). Ale můžeme vytvořit jeho objekt a zavolat metodu Display.
# 6) Vnořená třída / vnitřní třída
Vnořená třída, známá také jako Vnitřní třída v Javě, se používá k vylepšení zapouzdření. Vnořená třída / vnitřní třída je třída uzavřená uvnitř jiné třídy.
Stejně jako třída má proměnné a metody jako své členy, může mít také vnitřní třídu jako svého člena.
Vnořená třída má následující strukturu:
class OuterClass{ class NestedClass{ //nested class code… } //outerclass code… } Vnitřní třídy mají následující podtypy:
- Vnořená vnitřní třída
- Metoda Místní vnitřní třída
- Anonymní vnitřní třída
- Statická vnořená třída
# 1) Vnořená vnitřní třída
Vnořená vnitřní třída má přístup k soukromým členským proměnným vnější třídy. Můžeme také použít modifikátory přístupu na vnořenou vnitřní třídu.
# 2) Metoda Místní vnitřní třída
Toto je vnitřní třída, která je deklarována uvnitř metody vnější třídy.
# 3) Anonymní vnitřní třída
Anonymní vnitřní třída je vnitřní třída deklarovaná uvnitř vnější třídy a je bez jakéhokoli jména.
# 4) Statická vnořená třída
Způsob, jakým má třída statickou členskou proměnnou, může také mít statickou třídu jako svého člena.
Níže je uveden příklad vnořené / vnitřní třídy:
public class Main { //nested/inner class enclosed inside Main class. class InnerClass { public void inner_print() { System.out.println('Inner class'); } } public static void main(String() args) { System.out.println('Main in Outer class'); } } Výstup
Další speciální třídy v Javě
Nezměnitelná třída v Javě
Neměnná třída generuje neměnné objekty. Neměnný objekt je objekt, jehož obsah nelze po vytvoření objektu změnit. Neměnná třída je tedy ta, jejíž objekt nelze po vytvoření změnit.
Všechny třídy wrapperů v jazyce Java pro primitivní typy (Integer, Boolean, Byte atd.) Jsou neměnné. Třída String je také neměnná.
V Javě můžeme mít také uživatelem definované neměnné třídy.
Aby byla třída neměnná, musí být prohlášena za konečnou spolu se všemi jejími datovými členy. Třída by měla mít také parametrizovaný konstruktor. Všechny členské proměnné by měly mít metodu getter, ale nikoli metodu setter.
Aby byla třída neměnná, musí být splněny všechny výše uvedené požadavky.
Implementujme program Java, abychom předvedli neměnnou třídu.
final class City { final String city_name; final int cityId; //parameterised constructor public City(String name, int id) { this.city_name = name; this.cityId = id; } //getters for member variables public String getcityName() { return city_name; } public int getcityId() { return cityId; } } // Driver class class Main { public static void main(String args()) { City city = new City('New York', 1001); System.out.print('City Id:' + city.getcityId() + ' '); System.out.println('City Name:' + city.getcityName()); //city.cityId = 1002; //cannot assign a value to final variable regNo } } Výstup
Ve výše uvedeném programu jsme vyhlásili třídu City. Toto je finální třída a v této třídě jsme deklarovali dvě členské proměnné a parametrizovaný konstruktor. Také jsme deklarovali metody getru pro tyto dvě členské proměnné. Třída City tedy splňuje všechny požadavky neměnné třídy.
Všimněte si komentovaného řádku kódu v hlavní metodě. Pokud odkomentujeme tento řádek, dostaneme chybu kompilátoru (uvedenou v komentáři zde), protože se pokoušíme nastavit hodnotu členské proměnné.
Singleton Class v Javě
Třída singleton umožňuje jednu instanci najednou. V Javě je singleton návrhový vzor. Tento návrhový vzor zajišťuje, že v určitém okamžiku existuje pouze jedna instance třídy. Každá třída definovaná jako singleton má tedy jediný přístupový bod a je globální.
Všimněte si, že ukončení životního cyklu aplikace nezničí třídu singletonu, jako jsou běžné třídy. Když je třída deklarována jako singleton, nevytváříme novou instanci pokaždé, když je vytvořen nový požadavek na objekt.
Znovu a znovu se používá stejná instance. Tímto způsobem můžeme ušetřit paměťové místo hlavně v případě vícevláknových a databázových aplikací.
Třídu singleton můžeme použít pro aktivity jako ukládání do mezipaměti, protokolování atd.
Následující program ukazuje třídu Singleton.
class Singleton { // static variable of type Singleton private static Singleton single_instance = null; // String variable public String str; // private constructor : restricted to this class private Singleton() { str = 'Singleton class::private constructor'; } // create instance of Singleton class using getInstance static method public static Singleton getInstance() { if (single_instance == null) single_instance = new Singleton(); return single_instance; } } class Main { public static void main(String args()) { // instantiate Singleton class with obj1 Singleton obj1 = Singleton.getInstance(); // instantiate Singleton class with obj2 Singleton obj2 = Singleton.getInstance(); System.out.println('obj1(str):' + obj1.str); System.out.println('obj2(str):' + obj2.str); // change variable of instance obj1 obj1.str = (obj1.str).toUpperCase(); System.out.println('
After changing obj1(str):'); System.out.println('obj1(str):' + obj1.str); System.out.println('obj2(str):' + obj2.str); } } Výstup
Ve výše uvedeném programu jsme definovali třídu singleton se soukromým konstruktorem. Definovali jsme členskou proměnnou typu String. V hlavní metodě deklarujeme dvě instance třídy singleton. Potom pomocí jedné z instancí změníme proměnnou String.
Když vytiskneme hodnotu String pro obě instance, všimneme si, že hodnota proměnné String se pro obě instance změnila. Proto i když jsme změnili hodnotu pouze pro jednu instanci, kvůli třídě singleton se změny projeví ve všech instancích.
Vždy vracíme stejnou instanci, i když se zdá, že vytváříme různé instance.
Třída objektů v Javě
Třída Object je nadřazená třída nebo první třída v Javě. Je na nejvyšší úrovni hierarchie prostředí Java.
Protože všechny třídy mají třídu Object jako nadtřídu, všechny objekty Java včetně polí implementují metody třídy Object. Třída objektu je obsažena v balíčku „java.lang“.
Deklarace pro java.lang.Object je:
objekt veřejné třídy
Následující tabulka popisuje konstruktory a metody třídy Object.
| Konstruktor / metoda | Popis |
|---|---|
| Třída getClass () | Vrátí běhovou třídu objektu. |
| Konstruktor třídy objektů | |
| Objekt() | Konstruktor třídy objektů |
| Metody tříd objektů | |
| klon chráněného objektu () | Vrátí klon nebo kopii objektu. |
| boolean equals (Object obj) | Zkontroluje, zda se daný objekt obj rovná tomuto objektu. |
| chráněná prázdnota finalize () | Volá garbage collector, když jsou zničeny všechny odkazy na objekt. |
| int hashCode () | Vrátí hash kód pro objekt. |
| zrušit upozornění () | Slouží k probuzení jednoho čekajícího vlákna. |
| void notifyAll () | Probudí všechna čekající vlákna. |
| String toString () | Vrátí String ekvivalent objektu. |
| void wait () | Dělá vlákno čekat, až se probudí metodou upozornění jiným vláknem. |
| neplatné čekání (dlouhý časový limit) | Zajistí, aby vlákno počkalo, dokud neuplyne čas daný časovým limitem nebo ho probudí metodami oznámit nebo oznámit všechny. |
| void wait (long timeout, int nanos) | Způsobí, že vlákno počká, dokud neuplyne zadaný čas, nebo dokud není vyvolána notifikace () nebo notifyAll () jiným vláknem. |
Implementujme ukázkový program Java, který předvede některé metody třídy Object.
public class Main { public static void main(String() args) { Main t = new Main(); System.out.println('Main class Object HashCode:' + t.hashCode()); t = null; // call garbage collector System.gc(); System.out.println('Main class:End'); } @Override protected void finalize() { System.out.println('Main Class::finalize method called.'); } } Výstup
nejlepší program pro monitorování teploty CPU
Tady máme hlavní třídu. V metodě main () vytvoříme objekt třídy Main. Tento objekt je potomkem třídy Object a podporuje všechny metody třídy Object. Proto používáme tento objekt a voláme několik metod třídy Object, jako hashCode (), System.GC (), finalize () atd.
Obálka třídy v Javě
Java poskytuje funkci nazvanou wrapper class, která má mechanismus, který převádí primitivní datový typ na objekt a naopak. Obálky třídy jsou třídy, které představují primitivní typy jako int, char atd. Jako objekty.
Každý primitivní datový typ v Javě má tedy odpovídající třídu obalů.
Následující tabulka ukazuje primitivní datové typy a jejich ekvivalentní obalovou třídu.
| Primitivní typ | Typ obalu |
|---|---|
| plovák | Plovák |
| booleovský | Booleovský |
| char | Charakter |
| byte | Byte |
| krátký | Krátký |
| int | Celé číslo |
| dlouho | Dlouho |
| dvojnásobek | Dvojnásobek |
Chcete-li převést primitiva na objekty a objekty na primitiva, máme techniky zvané „autoboxing“ a „boxing“. Ase Java je objektově orientovaný programovací jazyk, vždy pracujeme s objekty a máme také spoustu funkcí, jako jsou sbírky, Serializace atd., které také potřebují objekty a primitivní typy.
Je tedy nezbytně nutné, abychom v Javě vždy potřebovali objekty a primitivní typy, a proto vyžadujeme tyto techniky autoboxu a unboxingu.
Autoboxing
Autoboxing je technika automatického převodu primitivního datového typu na objekt odpovídající třídy obálky. Například , převod int na třídu Integer, char do třídy Character atd. jsou příklady autoboxu.
Poznámka: Třídy typu Wrapper používají metodu valueOf () k převodu primitiva na objekty, které se od Java 5 odepisují.
Rozbalení
Zpětná konverze objektů třídy wrapper do jejich odpovídajících primitivních datových typů se nazývá „unboxing“.
Poznámka: Od prostředí Java 5 se metoda intValue (), která převádí obalový objekt na primitivní typ, odepisuje.
Níže je uveden příklad boxu / unboxingu.
public class Main { public static void main(String args()){ //Convert int to Integer : boxing int num=20; Integer int_class= Integer.valueOf(num);//explicit conversion from int to Integer Integer inum=num;//autoboxing System.out.println('int => Integer: ' + num+' => '+inum); //Convert Integer to int: unboxing Integer val=new Integer (3); int ival=val.intValue();//explicit conversion from Integer to int int jval=val;//unboxing System.out.println('Integer => int:' + val+' => '+jval); } } Výstup
Výše uvedený program ukazuje autoboxing a unboxing na hodnotu int. Nejprve převedeme int na Integer objekt a poté se Integer objekt převede na datový typ int.
Pojďme implementovat program, který předvádí obálkové třídy přítomné v Javě.
public class Main { public static void main(String args()) { byte bbyte=10; short sshort=20; int iint=300; long llong=400; float ffloat=3.14F; double ddouble=77.2D; char cchar='A'; boolean bboolean=true; //Convert primitives into objects => Autoboxing Byte byteobj=bbyte; Short shortobj=sshort; Integer intobj=iint; Long longobj=llong; Float floatobj=ffloat; Double doubleobj=ddouble; Character charobj=cchar; Boolean boolobj=bboolean; //Print converted objects System.out.println('Primitives converted to Objects:'); System.out.println('Byte object: '+byteobj); System.out.println('Short object: '+shortobj); System.out.println('Integer object: '+intobj); System.out.println('Long object: '+longobj); System.out.println('Float object: '+floatobj); System.out.println('Double object: '+doubleobj); System.out.println('Character object: '+charobj); System.out.println('Boolean object: '+boolobj); //Convert Objects to Primitives => Unboxing byte bytevalue=byteobj; short shortvalue=shortobj; int intvalue=intobj; long longvalue=longobj; float floatvalue=floatobj; double doublevalue=doubleobj; char charvalue=charobj; boolean boolvalue=boolobj; //Print primitives System.out.println('Converting Objects to Primitives'); System.out.println('byte value: '+bytevalue); System.out.println('short value: '+shortvalue); System.out.println('int value: '+intvalue); System.out.println('long value: '+longvalue); System.out.println('float value: '+floatvalue); System.out.println('double value: '+doublevalue); System.out.println('char value: '+charvalue); System.out.println('boolean value: '+boolvalue); } } Výstup
Výše uvedený výstup programu ukazuje převod z primitivních typů na obálkové objekty (Autoboxing) a obrátí převod z obalových objektů na primitivní typy (rozbalení).
Často kladené otázky
Otázka č. 1) Co je typ dat třídy v Javě?
Odpovědět: Java poskytuje třídu s názvem „Třída“, která obsahuje informace o všech třídách, objektech a rozhraních spuštěné aplikace. Třída Class také představuje primitivní datové typy a void typ.
Třída Class je součástí balíčku java.lang.
Otázka 2) Co je normální třída v Javě?
Odpovědět: Normální třída v Javě je nestatická třída. Můžeme vytvořit objekty normální třídy pomocí nového klíčového slova. Jakákoli normální třída může také mít za člena jinou třídu. V tomto případě se členská třída nazývá vnořená nebo vnitřní třída a obklopující třída se nazývá vnější třída.
Otázka č. 3) Je řetězec v Javě třídou Wrapper?
Odpovědět: Ne, String není v Javě obalová třída. Aby třída byla obálkovou třídou, potřebujeme její odpovídající primitivní typ. Například, pro třídu obalů Integer máme primitivní typ int. Pro třídu String nemáme odpovídající primitivní datový typ.
Otázka č. 4) Jaká je výhoda třídy Wrapper?
Odpovědět: Obálky třídy se používají pro převod primitivních datových typů na objekty. Jinými slovy, souhrnné třídy zalamují primitivní typy do objektů. Obálky třídy se používají, když určité funkce Java, jako jsou kolekce, očekávají pouze objekty a nikoli primitivní datové typy.
Otázka č. 5) Proč se třída Singleton používá v Javě?
Odpovědět: Kdykoli chceme globální přístupový bod pro konkrétní objekt, přejdeme k singletonovému vzoru, který nám umožní navrhnout singletonovou třídu, ve které bude pouze jedna instance. Třídy Singleton se používají v mezipaměti, sdružování vláken, databázových aplikacích, protokolování atd.
Závěr
V tomto tutoriálu jsme probrali různé typy tříd používané v Javě. Viděli jsme konkrétní, abstraktní, finální, statické, vnořené, POJO atd. Typy tříd. Kromě toho jsme také diskutovali třídy Singleton, třídy Immutable a diskutovali také jejich příklady implementace.
Také jsme pokryli třídy obalů a třídy objektů v Javě. Obálky třídy jsou třídy, které zabalí primitivní datové typy Javy do objektů. Třída objektů v Javě je nadtřídou všech ostatních tříd. Jedná se o nejvyšší třídu v hierarchii prostředí Java.
Nyní, když jsme diskutovali o třídách a objektech v Javě a typech tříd, budeme v dalším kurzu pokračovat podrobnou diskusí o konstruktorech v Javě.
=> Podívejte se na průvodce Perfect Java Training Guide zde.
Doporučené čtení
- Výukový program pro rozhraní Java a abstrakt třídy s příklady
- Základy jazyka Java: Syntaxe jazyka Java, třída Java a základní koncepty Java
- Co je statické klíčové slovo v Javě?
- Celé číslo Java a třída Java BigInteger s příklady
- Výukový program třídy skeneru Java s příklady
- Objekt Java Class Vs - Jak používat třídu a objekt v Javě
- Výukový program třídy Java Array - java.util.Arrays Class with examples
- Co je Java Vector | Výukový program Java Vector Class s příklady