V Javě, třída je plán, ze kterého můžeme vytvořit individuální objekt. Java poskytuje a klíčové slovo pojmenovaná třída, pomocí které můžeme deklarovat třídu. Uvnitř třídy definujeme třída členů a funkcí. Není možné vytvořit Java programy bez třídy. Třídu můžeme také označit jako a uživatelsky definované Typy tříd

V Javě je sedm typů tříd:

Statická třída Závěrečná třída Abstraktní třída Třída betonu Třída Singleton Třída POJO Vnitřní třída

Statická třída

v Java , static je klíčové slovo pro správu objektů v paměti. Statický objekt patří do třídy místo instance třídy.

Můžeme udělat třídu statický tehdy a jen tehdy, když se jedná o vnořenou třídu. Můžeme také říci, že statické třídy jsou známé jako vnořené třídy. Znamená to, že třída, která je v jiné třídě deklarována jako statická, je známá jako statická třída. Vnořená statická třída nevyžaduje odkaz na vnější třídu. Účelem statické třídy je poskytnout obrys její zděděné třídy.

Vlastnosti statické třídy jsou:

• Třída má pouze statické členy.
• Nemůže přistupovat k členu (nestatickému) vnější třídy.
• Nemůžeme vytvořit objekt statické třídy.

Pojďme pochopit koncept statické třídy prostřednictvím programu.

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ýstup:

 Javatpoint 

Ve vnější třídě výše uvedeného programu jsme deklarovali proměnnou str jako statické, protože k této proměnné přistupujeme ze statického kontextu. Pokud tuto proměnnou deklarujeme jako nestatickou, kompilátor zobrazí chybu, protože vnořená statická třída nemá přístup k nestatickým členům vnější třídy.

Druhá věc, kterou je třeba si ve výše uvedeném programu všimnout, je, že pro vytvoření objektu vnořené třídy nepotřebujeme vytvářet instanci vnější třídy. Pokud vnořená třída není statická třída, musíme vytvořit instanci vnější třídy.

Závěrečná třída

Slovo konečný znamená, že to nelze změnit. The finále třídu v Javě lze deklarovat pomocí konečné klíčové slovo . Jakmile deklarujeme třídu jako konečnou, hodnoty zůstanou v celém programu stejné. Účelem závěrečné třídy je vytvořit třídu neměnný jako třída String. Je to pouze způsob, jak učinit třídu neměnnou. Pamatujte, že závěrečnou třídu nelze prodloužit . To také zabraňuje třídění podtřídy .

Pojďme pochopit koncept závěrečné třídy prostřednictvím 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ýstup:

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

Abstraktní třída

An abstraktní třída je a, které je deklarováno pomocí klíčového slova abstraktní . Třída může nebo nemusí obsahovat abstraktní metody. Nemůžeme vytvořit instanci abstraktní třídy, ale může to být podtřída. Tyto třídy jsou neúplné, takže pro dokončení abstraktní třídy bychom měli rozšířit abstraktní třídy na konkrétní třídu. Když deklarujeme podtřídu jako abstraktní, je nutné zajistit implementaci abstraktních metod. Proto musí být podtřída také deklarována jako abstraktní. Skrytí dat můžeme dosáhnout použitím abstraktní třídy. Příkladem abstraktní třídy je AbstarctMap třídy, která je součástí frameworku Collections.

Pojďme pochopit koncept abstraktní třídy prostřednictvím 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ýstup:

 Sum of a and b is: 70 

Třída betonu

Toto jsou běžné třídy Java. Odvozená třída, která poskytuje základní implementace pro všechny metody, které ještě nejsou implementovány v základní třídě, je známá jako a beton třída. Jinými slovy, jsou to běžné Java třídy, ve kterých jsou implementovány všechny metody abstraktní třídy. Objekt konkrétní třídy můžeme vytvořit přímo. Pamatujte, že konkrétní třída a abstraktní třída nejsou totéž. Konkrétní třída může rozšířit svou rodičovskou třídu. Používá se pro specifické požadavky.

Pojďme pochopit koncept konkrétní třídy prostřednictvím 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ýstup:

 Product of a and b is: 48 

Třída Singleton

Třída, která má současně pouze objekt, se nazývá a třída singleton . Přesto, pokud se pokoušíme vytvořit instanci podruhé, nově vytvořená instance ukazuje na první instanci. Pokud jsme provedli jakoukoli změnu uvnitř třídy prostřednictvím jakékoli instance, změna ovlivní také proměnnou jediné instance. Obvykle se používá k řízení přístupu při práci s databázovým připojením a programováním soketů. Pokud chceme vytvořit třídu singleton, proveďte následující:

• Vytvořte soukromý konstruktér .
• Vytvořte statickou metodu (pomocí pomalé inicializace), která vrátí objekt třídy 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ýstup:

 Javatpoint 

Třída POJO

V Javě POJO znamená Obyčejný starý objekt Java. Třída Java, která obsahuje pouze soukromé proměnné, setter a getter, je známá jako POJO třída. Používá se k definování objektů Java, které zvyšují opětovnou použitelnost a čitelnost programu Java. Třída poskytuje zapouzdření. V Javě je široce používán, protože je snadné těmto třídám porozumět. Třída POJO má následující vlastnosti:

• Nerozšiřuje předdefinované třídy, jako jsou Arrays, HttpServlet atd.
• Nemůže obsahovat předem zadané anotace.
• Nemůže implementovat předem definované rozhraní .
• Není nutné přidávat žádný konstruktor.
• Všechny proměnné instance musí být soukromé.
• Getter/setter metody musí být veřejný.

Pojďme pochopit koncept třídy POJO prostřednictvím programu Java.

PojoClassExample.java

chromový adresní řádek

 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ýstup:

 The price of an article is 89764.34 Rs. 

Vnitřní třída

Java nám umožňuje definovat třídu v rámci třídy a takové třídy jsou známé jako vnořené třídy . Používá se k logickému seskupování tříd ak dosažení zapouzdření . K členům vnější třídy (včetně soukromých) má přístup vnitřní třída . Obecná syntaxe pro deklaraci vnořené třídy je následující:

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

Vnořené třídy jsou dvou typů:

1. Statická vnořená třída: Třída, která je statický a vnořený se nazývá statická vnořená třída . Interaguje s členem instance své vnější třídy. Objekt statické vnořené třídy můžeme vytvořit pomocí následující syntaxe:

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

2. Nestatická vnořená třída: Volají se nestatické vnořené třídy vnitřní třídy .

Obecná syntaxe pro deklaraci statické vnořené třídy a vnitřní třídy je následující:

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

Pojďme pochopit koncept vnitřní třídy prostřednictvím 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 vnitřních tříd

Java poskytuje dva typy vnitřních tříd:

• Místní třídy nebo metoda Místní vnitřní třída
• Anonymní třídy popř Anonymní vnitřní třída

Místní vnitřní třída

Je to typ vnitřní třídy, která je definována uvnitř bloku. Blok zde označuje tělo metody (skupinu příkazů uzavřených mezi párem složených závorek). Kvůli definici uvnitř bloku je také známá jako místní vnitřní třída metody. Toto jsou nestatické třídy, protože mají přístup k členům instance bloku. Lokální vnitřní třídy můžeme definovat v těle metody. Tyto třídy musí být konkretizovány v bloku, ve kterém jsou definovány.

Když kompilujeme Java program (program, který obsahuje vnitřní třídu), kompilátor vygeneruje dva soubory tříd Vnější.třída a Vnější Vnitřní.třída. Jeden pro vnější třídu a druhý pro vnitřní třídu, která obsahuje odkaz na vnější třídu.

Pojďme pochopit koncept místní vnitřní třídy prostřednictvím 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ýstup:

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

Anonymní vnitřní třída

Jedná se o typ vnitřní třídy, který je stejný jako místní třídy, ale jediný rozdíl je v tom, že třída nemá název třídy a je vytvořen jediný objekt třídy. Díky tomu je kód stručnější. Používá se, pokud chceme jednorázově použít místní třídu. Anonymní třídy můžeme vytvořit dvěma způsoby:

• Pomocí rozhraní
• Prohlášením třídy za konkrétní a abstraktní

Syntax:

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

Když se podíváme na výše uvedenou syntaxi, vidíme, že je stejná jako vyvolání konstruktoru kromě toho, že třída má definici obsaženou 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ýstup:

 Score is 321 

Java také poskytuje další typ třídy Java, známý jako třída wrapper. Pojďme to probrat podrobně.

Třída obalů

V Javě termín obalová třída představuje kolekci tříd Java, které objektivizují primitivní typ Java. To znamená, že pro každý primitivní typ existuje odpovídající třída wrapperu. Třídy wrapper se používají k provedení převodu z primitivního typu na objekt a naopak. Následující obrázek ukazuje hierarchii tříd obálky.

Následující tabulka představuje primitivní typ a odpovídající třídu wrapperu.

Pojďme pochopit třídu wrapper prostřednictvím 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ýstup:

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