V Jave, trieda je plán, z ktorého môžeme vytvoriť individuálny objekt. Java poskytuje a kľúčové slovo pomenovaná trieda, pomocou ktorej môžeme deklarovať triedu. Vo vnútri triedy definujeme trieda členov a funkcií. Nie je možné vytvoriť Java programy bez triedy. Triedu môžeme označiť aj ako a definované užívateľom Typy tried

V Jave je sedem typov tried:

Statická trieda Záverečná trieda Abstraktná trieda Trieda betónu Singletonova trieda Trieda POJO Vnútorná trieda

Statická trieda

In Java , static je kľúčové slovo, ktoré riadi objekty v pamäti. Statický objekt patrí do triedy namiesto inštancie triedy.

Môžeme urobiť triedu statické vtedy a len vtedy, ak ide o vnorenú triedu. Môžeme tiež povedať, že statické triedy sú známe ako vnorené triedy. Znamená to, že trieda, ktorá je v inej triede deklarovaná ako statická, je známa ako statická trieda. Vnorená statická trieda nevyžaduje odkaz na vonkajšiu triedu. Účelom statickej triedy je poskytnúť obrys jej zdedenej triedy.

Vlastnosti statickej triedy sú:

• Trieda má iba statické členy.
• Nemôže pristupovať k členovi (nestatickému) vonkajšej triedy.
• Nemôžeme vytvoriť objekt statickej triedy.

Poďme pochopiť koncept statickej triedy prostredníctvom programu.

ako čítať súbor json

StaticClassExample.java

 public class StaticClassExample { private static String str = 'Javatpoint'; //nested class which is a Static class public static class StaticDemo { //non-static method of Static class public void show() { System.out.println(str); } } public static void main(String args[]) { StaticClassExample.StaticDemo obj = new StaticClassExample.StaticDemo(); obj.show(); } } 

Výkon:

 Javatpoint 

Vo vonkajšej triede vyššie uvedeného programu sme deklarovali premennú str ako statické, pretože k tejto premennej pristupujeme zo statického kontextu. Ak túto premennú deklarujeme ako nestatickú, kompilátor zobrazí chybu, pretože vnorená statická trieda nemôže získať prístup k nestatickým členom vonkajšej triedy.

Druhá vec, ktorú si treba všimnúť vo vyššie uvedenom programe je, že na vytvorenie objektu vnorenej triedy nepotrebujeme vytvárať inštanciu vonkajšej triedy. Ak vnorená trieda nie je statická trieda, musíme vytvoriť inštanciu vonkajšej triedy.

Záverečná trieda

Slovo konečný znamená, že sa to nedá zmeniť. The Konečný trieda v jazyku Java môže byť deklarovaná pomocou konečné kľúčové slovo . Akonáhle deklarujeme triedu ako konečnú, hodnoty zostanú rovnaké v celom programe. Účelom záverečnej triedy je vytvoriť triedu nemenný ako trieda String. Je to len spôsob, ako urobiť triedu nemennou. Pamätajte si, že záverečnú triedu nie je možné predĺžiť . To tiež bráni triede v podtriede .

Poďme pochopiť koncept záverečnej triedy prostredníctvom programu.

FinalClassExample.java

 //base class declared as final final class A { void printmsg() { System.out.print('Base class method is executed.'); } } //derived class //extending a final class which is not possible //it shows the error cannot inherit final class at compile time class B extends A { void printmsg() { System.out.print('Derived class method is executed.'); } } //main class public class FinalClassExample { public static void main(String[] arg) { B obj = new B(); obj.printmsg(); } } 

Výkon:

 /FinalClassExample.java:11: error: cannot inherit from final A class B extends A 

Abstraktná trieda

An abstraktná trieda je deklarovaný s kľúčovým slovom abstraktné . Trieda môže alebo nemusí obsahovať abstraktné metódy. Nemôžeme vytvoriť inštanciu abstraktnej triedy, ale môže to byť podtrieda. Tieto triedy sú neúplné, takže na dokončenie abstraktnej triedy by sme mali abstraktné triedy rozšíriť na konkrétnu triedu. Keď deklarujeme podtriedu ako abstraktnú, potom je potrebné zabezpečiť implementáciu abstraktných metód. Preto musí byť podtrieda tiež vyhlásená za abstraktnú. Pomocou abstraktnej triedy môžeme dosiahnuť skrytie údajov. Príkladom abstraktnej triedy je AbstarctMap triedy, ktorá je súčasťou rámca Collections.

Poďme pochopiť koncept abstraktnej triedy prostredníctvom programu.

AbstractClassExample.java

 //abstract class abstract class MathematicalOperations { int a=30, b=40; //abstract method public abstract void add(); } public class Operation extends MathematicalOperations { //definition of abstract method public void add() { System.out.println('Sum of a and b is: 'a+b); } public static void main(String args[]) { MathematicalOperations obj = new Operation(); obj.add(); } } 

Výkon:

 Sum of a and b is: 70 

Trieda betónu

Toto sú bežné triedy Java. Odvodená trieda, ktorá poskytuje základné implementácie pre všetky metódy, ktoré ešte nie sú implementované v základnej triede, je známa ako a betón trieda. Inými slovami, sú to bežné Java triedy, v ktorých sú implementované všetky metódy abstraktnej triedy. Objekt konkrétnej triedy môžeme vytvoriť priamo. Pamätajte, že konkrétna trieda a abstraktná trieda nie sú to isté. Konkrétna trieda môže rozšíriť svoju rodičovskú triedu. Používa sa na špecifické požiadavky.

Poďme pochopiť koncept konkrétnej triedy prostredníctvom programu.

ConcreteClassExample.java

 //Concrete Class public class ConcreteClassExample { //method of the concreted class static int product(int a, int b) { return a * b; } public static void main(String args[]) { //method calling int p = product(6, 8); System.out.println('Product of a and b is: ' + p); } } 

Výkon:

 Product of a and b is: 48 

Singletonova trieda

Trieda, ktorá má súčasne iba objekt, je známa ako a trieda singleton . Napriek tomu, ak sa pokúšame vytvoriť inštanciu druhýkrát, táto novovytvorená inštancia ukazuje na prvú inštanciu. Ak sme vykonali akúkoľvek zmenu v triede prostredníctvom akejkoľvek inštancie, modifikácia ovplyvní aj premennú jedinej inštancie. Zvyčajne sa používa na riadenie prístupu pri práci s databázovým pripojením a programovaním soketov. Ak chceme vytvoriť triedu singleton, postupujte takto:

• Vytvorte si súkromnú konštruktér .
• Vytvorte statickú metódu (pomocou lenivej inicializácie), ktorá vráti objekt triedy singleton.

SingletonClassExample.java

 public class Singleton { private String objectState; private static Singleton instance = null; private Singleton() throws Exception { this.objectState = 'Javatpoint'; } public static Singleton getInstance() { if(instance==null) { try { instance=new Singleton(); } catch(Exception e) { e.printStackTrace(); } } return instance; } public String getObjectState() { return objectState; } public void setObjectState(String objectState) { this.objectState = objectState; } } 

Výkon:

 Javatpoint 

Trieda POJO

V Jave znamená POJO Obyčajný starý objekt Java. Trieda Java, ktorá obsahuje iba súkromné ​​premenné, setter a getter, je známa ako POJO trieda. Používa sa na definovanie objektov Java, ktoré zvyšujú opätovnú použiteľnosť a čitateľnosť programu Java. Trieda poskytuje zapuzdrenie. Je široko používaný v Jave, pretože je ľahké pochopiť tieto triedy. Trieda POJO má nasledujúce vlastnosti:

pole.z java

• Nerozširuje preddefinované triedy, ako sú Arrays, HttpServlet atď.
• Nemôže obsahovať vopred špecifikované anotácie.
• Nemôže implementovať vopred definované rozhrania .
• Nie je potrebné pridávať žiadny konštruktor.
• Všetky premenné inštancie musia byť súkromné.
• Getter/setter metódy musí byť verejný.

Poďme pochopiť koncept triedy POJO prostredníctvom programu Java.

PojoClassExample.java

 class PojoDemo { //private variable private double price=89764.34; //getter method public double getPrice() { return price; } //setter method public void setPrice(int price) { this.price = price; } } //main class public class PojoClassExample { public static void main(String args[]) { PojoDemo obj = new PojoDemo(); System.out.println('The price of an article is '+ obj.getPrice()+' Rs.'); } } 

Výkon:

 The price of an article is 89764.34 Rs. 

Vnútorná trieda

Java nám umožňuje definovať triedu v rámci triedy a takéto triedy sú známe ako vnorené triedy . Používa sa na logické zoskupenie tried a na dosiahnutie zapuzdrenie . K členom vonkajšej triedy (vrátane súkromných) má prístup vnútorná trieda . Všeobecná syntax na deklarovanie vnorenej triedy je nasledovná:

 class OuterClass { //code class NestedClass { //code } } 

Vnorené triedy sú dvoch typov:

1. Statická vnorená trieda: Trieda, ktorá je statické a vnorené sa nazýva statická vnorená trieda . Interaguje s členom inštancie svojej vonkajšej triedy. Objekt statickej vnorenej triedy môžeme vytvoriť pomocou nasledujúcej syntaxe:

 OuterClass.StaticNestedClass nestedObject = new OuterClass.StaticNestedClass(); 

2. Nestatická vnorená trieda: Volajú sa nestatické vnorené triedy vnútorné triedy .

Všeobecná syntax na deklarovanie statickej vnorenej triedy a vnútornej triedy je nasledovná:

 class OuterClass { ... static class StaticNestedClass { ... } class InnerClass { ... } } 

Poďme pochopiť koncept vnútornej triedy prostredníctvom programu Java.

InnerClassExample.java

 public class InnerClassExample { public static void main(String[] args) { System.out.println('This is outer class.'); } class InnerClass { public void printinner() { System.out.println('This is inner class.'); } } } 

Typy vnútorných tried

Java poskytuje dva typy vnútorných tried:

• Miestne triedy alebo metóda Miestna vnútorná trieda
• Anonymné triedy resp Anonymná vnútorná trieda

Miestna vnútorná trieda

Je to typ vnútornej triedy, ktorá je definovaná vo vnútri bloku. Blok tu označuje telo metódy (skupinu príkazov uzavretých medzi párom zložených zátvoriek). Vďaka definovaniu vo vnútri bloku je tiež známy ako lokálna vnútorná trieda metódy. Toto sú nestatické triedy, pretože majú prístup k členom inštancie bloku. Lokálne vnútorné triedy môžeme definovať v tele metódy. Tieto triedy musia byť vytvorené v bloku, v ktorom sú definované.

Keď kompilujeme program Java (program, ktorý obsahuje vnútornú triedu), kompilátor vygeneruje konkrétne dva súbory triedy Vonkajšia.trieda a Vonkajšia Vnútorná.trieda. Jeden pre vonkajšiu triedu a druhý pre vnútornú triedu, ktorá obsahuje odkaz na vonkajšiu triedu.

Poďme pochopiť koncept lokálnej vnútornej triedy prostredníctvom programu Java.

OuterClass.java

 public class OuterClass { private void getValue() { //if you are using Java 7 make the variable final //if you are using Java 8 the code runs successfully int sum = 20; //declaring method local inner class class InnerClass { public int divisor; public int remainder; public InnerClass() { divisor = 4; remainder = sum%divisor; } private int getDivisor() { return divisor; } private int getRemainder() { return sum%divisor; } private int getQuotient() { System.out.println('We are inside the inner class'); return sum / divisor; } } //creating an instance of inner class InnerClass ic = new InnerClass(); System.out.println('Divisor = '+ ic.getDivisor()); System.out.println('Remainder = ' + ic.getRemainder()); System.out.println('Quotient = ' + ic.getQuotient()); } public static void main(String[] args) { //creating an instance of outer class OuterClass oc = new OuterClass(); oc.getValue(); } } 

Výkon:

 Divisor = 4 Remainder = 0 We are inside the inner class Quotient = 5 

Anonymná vnútorná trieda

Je to typ vnútornej triedy, ktorý je rovnaký ako lokálne triedy, ale jediný rozdiel je v tom, že trieda nemá názov triedy a z triedy je vytvorený jeden objekt. Vďaka tomu je kód stručnejší. Používa sa, ak chceme lokálnu triedu použiť raz. Anonymné triedy môžeme vytvoriť dvoma spôsobmi:

• Pomocou rozhrania
• Vyhlásením triedy za konkrétnu a abstraktnú

Syntax:

 // the class may an interface, abstract or concrete class DemoClass obj = new DemoClass() { //methods //data members public void demomethod() { //statements } }; 

Keď sa pozrieme na vyššie uvedenú syntax, vidíme, že je to rovnaké ako vyvolanie konštruktora okrem toho, že trieda má definíciu obsiahnutú v bloku.

AnonymousClassExample.java

 interface Score { int run = 321; void getScore(); } public class AnonymousClassExample { public static void main(String[] args) { // Myclass is hidden inner class of Score interface // whose name is not written but an object to it // is created. Score s = new Score() { @Override public void getScore() { //prints score System.out.print('Score is '+run); } }; s.getScore(); } } 

Výkon:

 Score is 321 

Java tiež poskytuje ďalší typ triedy Java, ktorý je známy ako obalová trieda. Poďme si to podrobne rozobrať.

Trieda obalov

V Jave termín obalová trieda predstavuje kolekciu tried Java, ktoré objektivizujú primitívny typ Java. To znamená, že pre každý primitívny typ existuje zodpovedajúca trieda obalu. Triedy obalov sa používajú na vykonanie konverzie z primitívneho typu na objekt a naopak. Nasledujúci obrázok znázorňuje hierarchiu tried obalov.

pokladňa v git

Nasledujúca tabuľka predstavuje primitívny typ a zodpovedajúcu triedu obalu.

Poďme pochopiť triedu wrapper prostredníctvom programu Java.

WrapperClassExample.java

 public class WrapperClassExample { public static void main(String args[]) { byte x = 0; //wrapping byte primitive type into Byte object Byte byteobj = new Byte(x); int y = 23; //wrapping int primitive type into Integer object Integer intobj = new Integer(y); char c='m'; //wrapping char primitive type into Character object Character charobj=c; //printing values from objects System.out.println('Byte object byteobj: ' + byteobj); System.out.println('Integer object intobj: ' + intobj); System.out.println('Character object charobj: ' + charobj); } } 

Výkon:

 Byte object byteobj: 0 Integer object intobj: 23 Character object charobj: m