I Java är klass är en ritning från vilken vi kan skapa ett enskilt objekt. Java tillhandahåller en nyckelord namngiven klass som vi kan deklarera en klass med. Inne i klassen definierar vi klass medlemmar och funktioner. Det går inte att skapa Java-program utan klass. Vi kan också hänvisa till en klass som en användardefinierad Typer av klasser

Det finns sju typer av klasser i Java:

Statisk klass Avslutande klass Abstrakt klass Betongklass Singleton klass POJO klass Inre klass

Statisk klass

I Java , static är ett nyckelord som hanterar objekt i minnet. Det statiska objektet tillhör klassen istället för klassens instans.

Vi kan göra en klass statisk om och bara om det är en kapslad klass. Vi kan också säga att statiska klasser är kända som kapslade klasser. Det betyder att en klass som deklareras som statisk inom en annan klass är känd som en statisk klass. Kapslad statisk klass kräver inte referens till den yttre klassen. Syftet med en statisk klass är att ge konturerna av dess ärvda klass.

Egenskaperna för den statiska klassen är:

• Klassen har bara statiska medlemmar.
• Den kan inte komma åt medlemmen (icke-statisk) i den yttre klassen.
• Vi kan inte skapa ett objekt av den statiska klassen.

Låt oss förstå begreppet statisk klass genom ett program.

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(); } } 

Produktion:

 Javatpoint 

I den yttre klassen av ovanstående program har vi deklarerat en variabel str som statisk eftersom vi kommer åt den variabeln från ett statiskt sammanhang. Om vi ​​deklarerar den variabeln som icke-statisk visar kompilatorn ett fel eftersom en kapslad statisk klass kan inte komma åt icke-statiska medlemmar av den yttre klassen.

Det andra som bör noteras i programmet ovan är att för att skapa objektet för den kapslade klassen behöver vi inte skapa en instans av den yttre klassen. Om den kapslade klassen inte är en statisk klass måste vi skapa en instans av den yttre klassen.

Avslutande klass

Ordet final betyder att det inte går att ändra. De slutlig klass i Java kan deklareras med hjälp av sista sökordet . När vi väl förklarar en klass som final, förblir värdena desamma under hela programmet. Syftet med den sista klassen är att göra klassen oföränderlig som String-klassen. Det är bara ett sätt att göra klassen oföränderlig. Kom ihåg att slutklassen kan inte förlängas . Det är också förhindrar att klassen underklassas .

Låt oss förstå konceptet med den sista klassen genom ett program.

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(); } } 

Produktion:

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

Abstrakt klass

En abstrakt klass är en som deklareras med nyckelordet abstrakt . Klassen kan innehålla abstrakta metoder eller inte. Vi kan inte skapa en instans av en abstrakt klass men det kan vara en underklass. Dessa klasser är ofullständiga, så för att slutföra den abstrakta klassen bör vi utöka de abstrakta klasserna till en konkret klass. När vi deklarerar en underklass som abstrakt är det nödvändigt att tillhandahålla implementeringen av abstrakta metoder. Därför måste även underklassen förklaras abstrakt. Vi kan uppnå datadöljning genom att använda den abstrakta klassen. Ett exempel på en abstrakt klass är AbstarctMap klass som är en del av samlingsramverket.

Låt oss förstå konceptet med abstrakt klass genom ett program.

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(); } } 

Produktion:

 Sum of a and b is: 70 

Betongklass

Det här är de vanliga Java-klasserna. En härledd klass som tillhandahåller de grundläggande implementeringarna för alla metoder som inte redan är implementerade i basklassen är känd som en betong klass. Med andra ord är det vanliga Java-klasser där alla metoder för en abstrakt klass är implementerade. Vi kan skapa ett objekt av betongklassen direkt. Kom ihåg att konkret klass och abstrakt klass inte är samma sak. En betongklass kan utöka sin moderklass. Den används för specifika krav.

Låt oss förstå konceptet med betongklassen genom ett program.

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); } } 

Produktion:

 Product of a and b is: 48 

Singleton klass

En klass som bara har ett objekt åt gången kallas en singelklass . Ändå, om vi försöker skapa en instans en andra gång, pekar den nyskapade instansen på den första instansen. Om vi ​​gjorde någon ändring i klassen genom någon instans, påverkar ändringen variabeln för den enskilda instansen också. Det används vanligtvis för att kontrollera åtkomst när man hanterar databasanslutningen och socketprogrammering. Om vi ​​vill skapa en singleton-klass, gör följande:

• Skapa en privat konstruktör .
• Skapa en statisk metod (genom att använda den lata initieringen) som returnerar objektet för singleton-klassen.

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; } } 

Produktion:

 Javatpoint 

POJO klass

I Java står POJO för Vanligt gammalt Java-objekt. En Java-klass som endast innehåller privata variabler, setter och getter kallas POJO klass. Det används för att definiera Java-objekt som ökar återanvändbarheten och läsbarheten för ett Java-program. Klassen ger inkapsling. Det används ofta i Java eftersom det är lätt att förstå dessa klasser. POJO-klassen har följande egenskaper:

• Det utökar inte de fördefinierade klasserna som Arrays, HttpServlet, etc.
• Den kan inte innehålla fördefinierade kommentarer.
• Den kan inte implementera fördefinierade gränssnitt .
• Det är inte nödvändigt att lägga till någon konstruktör.
• Alla instansvariabler måste vara privata.
• Gettern/sättaren metoder måste vara offentliga.

Låt oss förstå begreppet POJO-klass genom ett Java-program.

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.'); } } 

Produktion:

 The price of an article is 89764.34 Rs. 

Inre klass

Java tillåter oss att definiera en klass inom en klass och sådana klasser är kända som kapslade klasser . Det används för att gruppera klasserna logiskt och för att uppnå inkapsling . De yttre klassmedlemmarna (inklusive privata) kan nås av inre klass . Den allmänna syntaxen för att deklarera den kapslade klassen är följande:

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

De kapslade klasserna är av två typer:

1. Statisk kapslad klass: En klass alltså statisk och kapslade kallas en statisk kapslad klass. Den interagerar med instansmedlemmen i dess yttre klass. Vi kan skapa ett objekt av den statiska kapslade klassen genom att använda följande syntax:

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

2. Icke-statisk kapslad klass: Icke-statiska kapslade klasser anropas inre klasser .

Den allmänna syntaxen för att deklarera den statiska kapslade klassen och den inre klassen är följande:

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

Låt oss förstå begreppet inre klass genom ett Java-program.

InnerClassExample.java

vad är 10 av 100

 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.'); } } } 

Typer av inre klasser

Java tillhandahåller de två typerna av inre klasser som följer:

• Lokala klasser eller metod Lokal inre klass
• Anonyma klasser eller Anonym inre klass

Lokal inre klass

Det är en typ av inre klass som definieras inuti ett block. Här betecknar blocket en metodkropp (en grupp av satser inneslutna mellan ett par klammerparenteser). På grund av att definiera inuti ett block är det också känt som metod lokal inre klass. Dessa är de icke-statiska klasserna eftersom de kan komma åt instansmedlemmarna i blocket. Vi kan definiera de lokala inre klasserna i kroppen av en metod. Dessa klasser måste instansieras i blocket där de definieras.

När vi kompilerar ett Java-program (ett program som innehåller en inre klass), genererar kompilatorn de två klassfilerna, nämligen Ytterklass och YtterInner.klass. En för den yttre klassen och den andra för den inre klassen som innehåller en referens till den yttre klassen.

Låt oss förstå konceptet med en lokal inre klass genom ett Java-program.

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(); } } 

Produktion:

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

Anonym inre klass

Det är en typ av inre klass som är samma som lokala klasser men den enda skillnaden är att klassen inte har ett klassnamn och ett enda objekt skapas av klassen. Det gör koden mer koncis. Den används om vi vill använda den lokala klassen en gång. Vi kan skapa anonyma klasser på följande två sätt:

• Genom att använda ett gränssnitt
• Genom att förklara klassen konkret och abstrakt

Syntax:

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

Om vi ​​tittar på ovanstående syntax ser vi att det är samma som anropet av konstruktor förutom att klassen har en definition i blocket.

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(); } } 

Produktion:

 Score is 321 

Java tillhandahåller också en annan typ av Java-klass som kallas omslagsklass. Låt oss diskutera det i detalj.

Omslagsklass

På Java, termen omslagsklass representerar en samling Java-klasser som objektifierar den primitiva typen av Java. Det betyder att det för varje primitiv typ finns en motsvarande omslagsklass. Omslagsklasserna används för att utföra omvandlingen från en primitiv typ till ett objekt och vice versa. Följande figur visar omslagsklasshierarkin.

Följande tabell representerar den primitiva typen och motsvarande omslagsklass.

Låt oss förstå omslagsklassen genom ett Java-program.

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); } } 

Produktion:

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