Op Java is de klas is een blauwdruk waaruit we een individueel object kunnen creëren. Java biedt een trefwoord benoemde klasse waarmee we een klasse kunnen declareren. Binnen de klas definiëren we klas leden en functies. Het is niet mogelijk om te creëren Java-programma's zonder klasse. We kunnen een klasse ook een gebruiker gedefinieerde Soorten klassen

Er zijn zeven soorten klassen in Java:

Statische klasse Laatste klasse Abstracte klasse Beton klasse Singleton-klasse POJO-klasse Innerlijke klasse

Statische klasse

In Java, statisch is een trefwoord dat objecten in het geheugen beheert. Het statische object behoort tot de klasse in plaats van tot de instantie van de klasse.

We kunnen een klas maken statisch dan en slechts dan als het een geneste klasse is. We kunnen ook zeggen dat statische klassen geneste klassen worden genoemd. Het betekent dat een klasse die binnen een andere klasse als statisch wordt gedeclareerd, een statische klasse wordt genoemd. Voor een geneste statische klasse is geen verwijzing naar de buitenste klasse vereist. Het doel van een statische klasse is om de omtrek van de overgeërfde klasse te schetsen.

De eigenschappen van de statische klasse zijn:

• De klasse heeft alleen statische leden.
• Het heeft geen toegang tot het lid (niet-statisch) van de buitenste klasse.
• We kunnen geen object van de statische klasse maken.

Laten we het concept van statische klasse begrijpen via een programma.

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

Uitgang:

 Javatpoint 

In de buitenste klasse van het bovenstaande programma hebben we een variabele gedeclareerd str als statisch omdat we die variabele benaderen vanuit een statische context. Als we die variabele als niet-statisch declareren, geeft de compiler een fout omdat een geneste statische klasse heeft geen toegang tot niet-statische leden van de buitenste klasse.

Het tweede dat moet worden opgemerkt in het bovenstaande programma is dat we voor het maken van het object van de geneste klasse geen instantie van de buitenste klasse hoeven te maken. Als de geneste klasse geen statische klasse is, moeten we een instantie van de buitenste klasse maken.

Laatste klasse

Het woord definitief betekent dat dit niet kan worden gewijzigd. De laatste klasse in Java kan worden gedeclareerd met behulp van de laatste trefwoord . Zodra we een klasse als definitief verklaren, blijven de waarden gedurende het hele programma hetzelfde. Het doel van de laatste les is om de klas te maken onveranderlijk zoals de String-klasse. Het is slechts een manier om de klasse onveranderlijk te maken. Vergeet niet dat de De laatste les kan niet worden verlengd . Het ook voorkomt dat de klasse wordt gesubclassificeerd .

Laten we het concept van de laatste les begrijpen via een programma.

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

Uitgang:

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

Abstracte klasse

Een abstracte klasse is een die wordt gedeclareerd met het trefwoord abstract . De klasse kan al dan niet abstracte methoden bevatten. We kunnen geen instantie van een abstracte klasse maken, maar het kan een subklasse zijn. Deze klassen zijn onvolledig, dus om de abstracte klasse te voltooien moeten we de abstracte klassen uitbreiden tot een concrete klasse. Wanneer we een subklasse als abstract declareren, is het noodzakelijk om de implementatie van abstracte methoden te bieden. Daarom moet de subklasse ook abstract worden verklaard. We kunnen gegevens verbergen door de abstracte klasse te gebruiken. Een voorbeeld van een abstracte klasse is Abstarctkaart klasse die deel uitmaakt van het Collections-framework.

Laten we het concept van abstracte klasse begrijpen via een programma.

pete davidson-nationaliteit

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

Uitgang:

 Sum of a and b is: 70 

Beton klasse

Dit zijn de reguliere Java-klassen. Een afgeleide klasse die de basisimplementaties levert voor alle methoden die nog niet in de basisklasse zijn geïmplementeerd, staat bekend als a concreet klas. Met andere woorden: het zijn reguliere Java-klassen waarin alle methoden van een abstracte klasse zijn geïmplementeerd. We kunnen rechtstreeks een object van de concrete klasse maken. Bedenk dat concrete klasse en abstracte klasse niet hetzelfde zijn. Een betonklasse kan zijn bovenliggende klasse uitbreiden. Het wordt gebruikt voor specifieke vereisten.

Laten we het concept van de concrete klasse begrijpen via een programma.

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

Uitgang:

 Product of a and b is: 48 

Singleton-klasse

Een klasse die slechts één object tegelijk heeft, staat bekend als a singleton klasse . Maar als we een tweede exemplaar proberen te maken, verwijst dat nieuw gemaakte exemplaar naar het eerste exemplaar. Als we via een instantie een wijziging binnen de klasse hebben aangebracht, heeft de wijziging ook invloed op de variabele van de enkele instantie. Het wordt meestal gebruikt om de toegang te controleren tijdens het omgaan met de databaseverbinding en socketprogrammering. Als we een singleton-klasse willen maken, doe dan het volgende:

• Maak een privé bouwer .
• Maak een statische methode (door de luie initialisatie te gebruiken) die het object van de singleton-klasse retourneert.

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

Uitgang:

 Javatpoint 

POJO-klasse

Op Java staat POJO voor Gewoon oud Java-object. Een Java-klasse die alleen privévariabelen bevat, setter en getter, staat bekend als POJO klas. Het wordt gebruikt om Java-objecten te definiëren die de herbruikbaarheid en leesbaarheid van een Java-programma vergroten. De klasse biedt inkapseling. Het wordt veel gebruikt in Java omdat het deze klassen gemakkelijk te begrijpen is. POJO-klasse heeft de volgende eigenschappen:

• Het breidt de vooraf gedefinieerde klassen zoals Arrays, HttpServlet, enz. niet uit.
• Het mag geen vooraf gespecificeerde annotaties bevatten.
• Het kan vooraf gedefinieerde waarden niet implementeren interfaces .
• Het is niet vereist om een ​​constructor toe te voegen.
• Alle instantievariabelen moeten privé zijn.
• De getter/setter methoden moet openbaar zijn.

Laten we het concept van de POJO-klasse begrijpen via een Java-programma.

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

Uitgang:

 The price of an article is 89764.34 Rs. 

Innerlijke klasse

Java stelt ons in staat een klasse binnen een klasse te definiëren en dergelijke klassen staan ​​bekend als geneste klassen . Het wordt gebruikt om de klassen logisch te groeperen en te bereiken inkapseling . De buitenste klasseleden (inclusief privé) zijn toegankelijk via de innerlijke klasse . De algemene syntaxis voor het declareren van de geneste klasse is als volgt:

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

Er zijn twee typen geneste klassen:

1. Statische geneste klasse: Een klasse dus statisch En genest wordt een statische geneste klasse genoemd. Het werkt samen met het instantielid van zijn buitenste klasse. We kunnen een object van de statische geneste klasse maken door de volgende syntaxis te gebruiken:

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

2. Niet-statische geneste klasse: Niet-statische geneste klassen worden aangeroepen innerlijke klassen .

De algemene syntaxis voor het declareren van de statische geneste klasse en binnenklasse is als volgt:

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

Laten we het concept van innerlijke klasse begrijpen via een Java-programma.

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

Soorten innerlijke klassen

Java biedt de volgende twee soorten innerlijke klassen:

• Lokale klassen of methode Lokale binnenklasse
• Anonieme lessen of Anonieme innerlijke klasse

Lokale innerlijke klasse

Het is een type innerlijke klasse die binnen een blok wordt gedefinieerd. Hier duidt blok een methodelichaam aan (een groep instructies tussen accolades). Omdat het binnen een blok wordt gedefinieerd, wordt het ook wel de lokale binnenklasse van de methode genoemd. Dit zijn de niet-statische klassen omdat ze toegang hebben tot de instantieleden van het blok. We kunnen de lokale innerlijke klassen definiëren in de body van een methode. Deze klassen moeten worden geïnstantieerd in het blok waarin ze zijn gedefinieerd.

Wanneer we een Java-programma compileren (een programma dat een innerlijke klasse bevat), genereert de compiler namelijk de twee klassenbestanden Buitenklasse En BuitensteBinnenste.klasse. Eén voor de buitenste klasse en de andere voor de binnenste klasse die een verwijzing naar de buitenste klasse bevat.

Laten we het concept van een lokale innerlijke klasse begrijpen via een Java-programma.

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

Uitgang:

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

Anonieme innerlijke klasse

Het is een type innerlijke klasse dat hetzelfde is als lokale klassen, maar het enige verschil is dat de klasse geen klassenaam heeft en dat er één enkel object van de klasse wordt gemaakt. Het maakt de code beknopter. Het wordt gebruikt als we de lokale klasse één keer willen gebruiken. We kunnen op de volgende twee manieren anonieme klassen maken:

• Door gebruik te maken van een interface
• Door de klasse concreet en abstract te verklaren

Syntaxis:

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

Als we naar de bovenstaande syntaxis kijken, zien we dat deze hetzelfde is als de aanroep van de constructor, behalve dat de klasse een definitie in het blok heeft.

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

Uitgang:

 Score is 321 

Java biedt ook een ander type Java-klasse, de wrapper-klasse. Laten we het in detail bespreken.

Wrapper-klasse

Op Java is de term wikkelklasse vertegenwoordigt een verzameling Java-klassen die het primitieve type Java objectiveren. Het betekent dat er voor elk primitief type een overeenkomstige wrapper-klasse is. De wrapper-klassen worden gebruikt om de conversie uit te voeren van een primitief type naar een object en omgekeerd. De volgende afbeelding toont de hiërarchie van de wrapperklasse.

De volgende tabel vertegenwoordigt het primitieve type en de bijbehorende wrapperklasse.

Laten we de wrapper-klasse begrijpen via een Java-programma.

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

Uitgang:

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