V Javě jsou třídy a objekty základními koncepty objektově orientovaného programování (OOP), které se používají k reprezentaci konceptů a entit reálného světa. Třída představuje skupinu objektů s podobnými vlastnostmi a chováním. Například typ zvířete Pes je třída, zatímco konkrétní pes se jmenuje Tommy je předmětem Pes třída.
V tomto článku se budeme zabývat Java objekty a třídami a jak je implementovat do našeho programu.
Třídy Java
Třída v Javě je sada objektů, které sdílejí společné vlastnosti/chování a společné vlastnosti/atributy. Je to uživatelsky definovaný plán nebo prototyp, ze kterého jsou vytvářeny objekty. Například Student je třída, zatímco konkrétní student jménem Ravi je objekt.
Vlastnosti tříd Java
- Třída není entitou ze skutečného světa. Je to jen šablona nebo plán nebo prototyp, ze kterého jsou vytvořeny objekty.
- Třída nezabírá paměť.
- Třída je skupina proměnných různých datových typů a skupina metod.
- Třída v Javě může obsahovat:
- Datový člen
- Metoda
- Konstruktér
- Vnořená třída
- Rozhraní
Deklarace třídy v Javě
access_modifier class < class_name>{ datový člen; metoda; konstruktér; vnořená třída; rozhraní; }> Příklad třídy Java
Jáva
// Java Program for class example> class> Student {> >// data member (also instance variable)> >int> id;> >// data member (also instance variable)> >String name;> >public> static> void> main(String args[])> >{> >// creating an object of> >// Student> >Student s1 =>new> Student();> >System.out.println(s1.id);> >System.out.println(s1.name);> >}> }> |
>
>
Jáva
// Java program to Illustrate Creation of Object> // Using new Instance> // Main class> class> GFG {> >// Declaring and initializing string> >String name =>'GeeksForGeeks'>;> >// Main driver method> >public> static> void> main(String[] args)> >{> >// Try block to check for exceptions> >try> {> >Class cls = Class.forName(>'GFG'>);> >// Creating object of main class> >// using instance method> >GFG obj = (GFG)cls.newInstance();> >// Print and display> >System.out.println(obj.name);> >}> >catch> (ClassNotFoundException e) {> >e.printStackTrace();> >}> >catch> (InstantiationException e) {> >e.printStackTrace();> >}> >catch> (IllegalAccessException e) {> >e.printStackTrace();> >}> >}> }> |
>
>
j e s t
Jáva
// Java program to Illustrate Creation of Object> // Using clone() method> // Main class> // Implementing Cloneable interface> class> GFG>implements> Cloneable {> >// Method 1> >@Override> >protected> Object clone()> >throws> CloneNotSupportedException> >{> >// Super() keyword refers to parent class> >return> super>.clone();> >}> >String name =>'GeeksForGeeks'>;> >// Method 2> >// main driver method> >public> static> void> main(String[] args)> >{> >GFG obj1 =>new> GFG();> >// Try block to check for exceptions> >try> {> >GFG obj2 = (GFG)obj1.clone();> >System.out.println(obj2.name);> >}> >catch> (CloneNotSupportedException e) {> >e.printStackTrace();> >}> >}> }> |
>
>
Výstup 1
0 null>
Výstup 2
GeeksForGeeks>
Výstup 3
GeeksForGeeks>
Komponenty tříd Java
Obecně mohou deklarace tříd obsahovat tyto komponenty v tomto pořadí:
- Modifikátory : Třída může být veřejná nebo má výchozí přístup (viz tento pro detaily).
- Klíčové slovo třídy: Klíčové slovo class se používá k vytvoření třídy.
- Jméno třídy: Název by měl začínat počátečním písmenem (velkými písmeny podle konvence).
- Superclass (pokud existuje): Název rodiče třídy (nadtřída), pokud existuje, před kterým je klíčové slovo extends. Třída může rozšířit (podtřídu) pouze o jednoho rodiče.
- Rozhraní (pokud existují): Čárkami oddělený seznam rozhraní implementovaných třídou, pokud existuje, před kterým je klíčové slovo implements. Třída může implementovat více než jedno rozhraní.
- Tělo: Tělo třídy je obklopeno složenými závorkami { }.
Konstruktory se používají pro inicializaci nových objektů. Pole jsou proměnné, které poskytují stav třídy a jejích objektů, a metody se používají k implementaci chování třídy a jejích objektů.
Existují různé typy tříd, které se používají v aplikacích v reálném čase jako např vnořené třídy , anonymní třídy , a lambda výrazy .
Java objekty
Objekt v Javě je základní jednotkou objektově orientovaného programování a představuje entity reálného života. Objekty jsou instance třídy, které jsou vytvořeny k použití atributů a metod třídy. Typický program v Javě vytváří mnoho objektů, které, jak víte, interagují vyvoláním metod. Objekt se skládá z:
- Stát : Je reprezentován atributy objektu. Odráží také vlastnosti objektu.
- Chování : Je reprezentován metodami objektu. Odráží také reakci objektu s jinými objekty.
- Identita : Přiděluje objektu jedinečný název a umožňuje interakci jednoho objektu s jinými objekty.
Příklad předmětu: pes
Java objekty
Předměty odpovídají věcem nalezeným v reálném světě. Například grafický program může mít objekty jako kruh, čtverec a nabídka. Online nákupní systém může mít objekty, jako je nákupní košík, zákazník a produkt.
bash pro smyčku
Poznámka: Když vytvoříme objekt, který není primitivním datovým typem, je vždy alokován v paměti haldy.
Deklarování objektů (také nazývané vytváření instance třídy)
Když je vytvořen objekt třídy, říká se, že třída je vytvořená instance . Všechny instance sdílejí atributy a chování třídy. Ale hodnoty těchto atributů, tj. stavu, jsou pro každý objekt jedinečné. Jedna třída může mít libovolný počet instancí.
Příklad:
Java Object Declaration
Jak deklarujeme proměnné jako (název typu;). To oznámí kompilátoru, že toto jméno použijeme k odkazování na data, jejichž typ je typ. S primitivní proměnnou tato deklarace také rezervuje správné množství paměti pro proměnnou. Takže u referenčních proměnných musí být typ striktně konkrétní název třídy. Obecně platí, že my nemůže vytvářet objekty abstraktní třídy nebo rozhraní.
Dog tuffy;>
Pokud deklarujeme referenční proměnnou (tuffy) takto, její hodnota bude neurčitá (null), dokud nebude objekt skutečně vytvořen a přiřazen k ní. Pouhé deklarování referenční proměnné nevytvoří objekt.
Inicializace objektu Java
Operátor new vytvoří instanci třídy přidělením paměti pro nový objekt a vrácením odkazu na tuto paměť. Operátor new také vyvolá konstruktor třídy.
Příklad:
Jáva
// Class Declaration> public> class> Dog {> >// Instance Variables> >String name;> >String breed;> >int> age;> >String color;> >// Constructor Declaration of Class> >public> Dog(String name, String breed,>int> age,> >String color)> >{> >this>.name = name;> >this>.breed = breed;> >this>.age = age;> >this>.color = color;> >}> >// method 1> >public> String getName() {>return> name; }> >// method 2> >public> String getBreed() {>return> breed; }> >// method 3> >public> int> getAge() {>return> age; }> >// method 4> >public> String getColor() {>return> color; }> >@Override> public> String toString()> >{> >return> (>'Hi my name is '> +>this>.getName()> >+>'.
My breed,age and color are '> >+>this>.getBreed() +>','> +>this>.getAge()> >+>','> +>this>.getColor());> >}> >public> static> void> main(String[] args)> >{> >Dog tuffy> >=>new> Dog(>'tuffy'>,>'papillon'>,>5>,>'white'>);> >System.out.println(tuffy.toString());> >}> }> |
>
>Výstup
Hi my name is tuffy. My breed,age and color are papillon,5,white>
Inicializujte pomocí metody/funkce:
Jáva
public> class> GFG {> >// sw=software> >static> String sw_name;> >static> float> sw_price;> >static> void> set(String n,>float> p)> >{> >sw_name = n;> >sw_price = p;> >}> >static> void> get()> >{> >System.out.println(>'Software name is: '> + sw_name);> >System.out.println(>'Software price is: '> >+ sw_price);> >}> >public> static> void> main(String args[])> >{> >GFG.set(>'Visual studio'>,>0>.0f);> >GFG.get();> >}> }> |
>
>Výstup
Software name is: Visual studio Software price is: 0.0>
Tato třída obsahuje jeden konstruktor. Konstruktor poznáme, protože jeho deklarace používá stejný název jako třída a nemá návratový typ. Kompilátor Java rozlišuje konstruktory na základě počtu a typu argumentů. Konstruktor v Pes třída má čtyři argumenty. Následující příkaz uvádí hodnoty tuffy, papillon,5 a white pro tyto argumenty:
Dog tuffy = new Dog('tuffy','papillon',5, 'white');> Výsledek provedení tohoto příkazu lze ilustrovat takto:
Alokace paměti Java objektů
Poznámka: Všechny třídy mají min jeden konstruktér. Pokud třída žádnou explicitně nedeklaruje, kompilátor Java automaticky poskytne konstruktor bez argumentů, nazývaný také výchozí konstruktor. Tento výchozí konstruktor volá konstruktor bez argumentů rodiče třídy (protože obsahuje pouze jeden příkaz, tj. super();), nebo Objekt konstruktor třídy, pokud třída nemá žádného jiného rodiče (protože třída Object je rodičem všech tříd buď přímo, nebo nepřímo).
Způsoby, jak vytvořit objekt třídy
Existují čtyři způsoby vytváření objektů v Javě. Přísně vzato, existuje pouze jeden způsob (pomocí a Nový klíčové slovo) a zbytek interně používá a Nový klíčové slovo.
1. Použití nového klíčového slova
Je to nejběžnější a nejobecnější způsob, jak vytvořit objekt v Javě.
Příklad:
// creating object of class Test Test t = new Test();>
2. Použití metody Class.forName(String className).
V balíčku java.lang je předdefinovaná třída s názvem Class. Metoda forName(String className) vrací objekt Class spojený s třídou s daným názvem řetězce. Třídě musíme dát plně kvalifikovaný název. Při volání nové metody Instance() na tomto objektu Class vrátí novou instanci třídy s daným názvem řetězce.
runas v powershell
// creating object of public class Test // consider class Test present in com.p1 package Test obj = (Test)Class.forName('com.p1.Test').newInstance();> 3. Použití metody clone().
metoda clone() je přítomna ve třídě Object. Vytvoří a vrátí kopii objektu.
// creating object of class Test Test t1 = new Test(); // creating clone of above object Test t2 = (Test)t1.clone();>
4. Deseralizace
De-serializace je technika čtení objektu z uloženého stavu v souboru. Odkazují na Serializace/De-serializace v Javě
FileInputStream file = new FileInputStream(filename); ObjectInputStream in = new ObjectInputStream(file); Object obj = in.readObject();>
Vytváření více objektů pouze jedním typem (Dobrý postup)
V reálném čase potřebujeme různé objekty třídy v různých metodách. Vytváření množství referencí pro jejich ukládání není dobrou praxí, a proto deklarujeme statickou referenční proměnnou a používáme ji, kdykoli je to potřeba. V tomto případě je plýtvání pamětí menší. Objekty, které již nejsou odkazovány, budou zničeny Popelář z Javy.
Příklad:
Test test = new Test(); test = new Test();>
V systému dědičnosti používáme k uložení objektu podtřídy referenční proměnnou nadřazené třídy. V tomto případě se můžeme přepnout do různých objektů podtřídy pomocí stejné odkazované proměnné.
Příklad:
class Animal {} class Dog extends Animal {} class Cat extends Animal {} public class Test { // using Dog object Animal obj = new Dog(); // using Cat object obj = new Cat(); }> Anonymní objekty v Javě
Anonymní objekty jsou objekty, které jsou konkretizovány, ale nejsou uloženy v referenční proměnné.
- Používají se pro okamžitá volání metod.
- Po volání metody budou zničeny.
- Jsou široce používány v různých knihovnách. Například v knihovnách AWT se používají k provedení nějaké akce při zachycení události (např. stisknutí klávesy).
- V níže uvedeném příkladu, když je stisknuto klíčové tlačítko (označované btn), jednoduše vytváříme anonymní objekt třídy EventHandler pro pouhé volání metody handle.
btn.setOnAction(new EventHandler() { public void handle(ActionEvent event) { System.out.println('Hello World!'); } });> Rozdíl mezi třídou Java a objekty
Rozdíly mezi třídou a objektem v Javě jsou následující:
| Třída | Objekt |
|---|---|
| Třída je plán objektu. Používá se k vytváření objektů. | Objekt je instancí třídy. |
| Při deklaraci třídy není přidělena žádná paměť. | Paměť je alokována, jakmile je objekt vytvořen. |
| Třída je skupina podobných objektů. | Objekt je entita reálného světa, jako je kniha, auto atd. |
| Třída je logická entita. | Objekt je fyzická entita. |
| Třídu lze deklarovat pouze jednou. | Objekty mohou být vytvořeny mnohokrát podle požadavků. |
| Příkladem třídy může být auto. | Předměty vozu třídy mohou být BMW, Mercedes, Ferrari atd. |