I Java er klasse er en plan, hvorfra vi kan skabe et individuelt objekt. Java giver en søgeord navngivet klasse, som vi kan erklære en klasse med. Inde i klassen definerer vi klasse medlemmer og funktioner. Det er ikke muligt at skabe Java programmer uden klasse. Vi kan også henvise en klasse som en brugerdefineret Typer af klasser

Der er syv typer klasser i Java:

Statisk klasse Afsluttende klasse Abstrakt klasse Beton klasse Singleton klasse POJO klasse Indre klasse

Statisk klasse

I Java , statisk er et nøgleord, der håndterer objekter i hukommelsen. Det statiske objekt tilhører klassen i stedet for klassens forekomst.

Vi kan lave en klasse statisk hvis og kun hvis det er en indlejret klasse. Vi kan også sige, at statiske klasser er kendt som indlejrede klasser. Det betyder, at en klasse, der er erklæret som statisk i en anden klasse, er kendt som en statisk klasse. Indlejret statisk klasse kræver ikke reference til den ydre klasse. Formålet med en statisk klasse er at give omridset af dens nedarvede klasse.

Egenskaberne for den statiske klasse er:

• Klassen har kun statiske medlemmer.
• Den kan ikke få adgang til medlemmet (ikke-statisk) af den ydre klasse.
• Vi kan ikke skabe et objekt af den statiske klasse.

Lad os forstå begrebet statisk klasse gennem et 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:

a b c tal

 Javatpoint 

I den ydre klasse af ovenstående program har vi erklæret en variabel str som statisk, fordi vi får adgang til den variabel fra en statisk kontekst. Hvis vi erklærer den variabel som ikke-statisk, viser compileren en fejl, fordi en indlejret statisk klasse kan ikke få adgang til ikke-statiske medlemmer af den ydre klasse.

Den anden ting, der skal bemærkes i ovenstående program, er, at for at skabe objektet for den indlejrede klasse behøver vi ikke at oprette en instans af den ydre klasse. Hvis den indlejrede klasse ikke er en statisk klasse, skal vi oprette en forekomst af den ydre klasse.

Afsluttende klasse

Ordet endelig betyder, at det ikke kan ændres. Det endelig klasse i Java kan erklæres ved hjælp af sidste søgeord . Når vi erklærer en klasse som endelig, forbliver værdierne de samme gennem hele programmet. Formålet med den afsluttende klasse er at gøre klassen uforanderlig ligesom String-klassen. Det er kun en måde at gøre klassen uforanderlig på. Husk at afsluttende klasse kan ikke forlænges . Det også forhindrer klassen i at blive underklasset .

Lad os forstå konceptet med den sidste klasse gennem et 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 klasse

An abstrakt klasse er en, der er deklareret med søgeordet abstrakt . Klassen kan indeholde abstrakte metoder eller ikke. Vi kan ikke oprette en instans af en abstrakt klasse, men den kan være en underklasse. Disse klasser er ufuldstændige, så for at fuldføre den abstrakte klasse bør vi udvide de abstrakte klasser til en konkret klasse. Når vi erklærer en underklasse som abstrakt, er det nødvendigt at sørge for implementeringen af ​​abstrakte metoder. Derfor skal underklassen også erklæres abstrakt. Vi kan opnå dataskjul ved at bruge den abstrakte klasse. Et eksempel på en abstrakt klasse er AbstarctMap klasse, der er en del af samlingsrammen.

Lad os forstå begrebet abstrakt klasse gennem et 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 

Beton klasse

Dette er de almindelige Java-klasser. En afledt klasse, der leverer de grundlæggende implementeringer for alle de metoder, der ikke allerede er implementeret i basisklassen, er kendt som en beton klasse. Det er med andre ord almindelige Java-klasser, hvor alle metoderne i en abstrakt klasse er implementeret. Vi kan skabe et objekt af betonklassen direkte. Husk at konkret klasse og abstrakt klasse ikke er det samme. En betonklasse kan udvide sin forældreklasse. Det bruges til specifikke krav.

Lad os forstå konceptet med den konkrete klasse gennem et 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 klasse

En klasse, der kun har et objekt ad gangen, er kendt som en singleton klasse . Alligevel, hvis vi forsøger at oprette en instans en anden gang, peger den nyoprettede instans på den første instans. Hvis vi lavede en ændring inde i klassen gennem en instans, påvirker ændringen også variablen for den enkelte instans. Det bruges normalt til at kontrollere adgangen, mens du håndterer databaseforbindelsen og socket-programmering. Hvis vi vil oprette en singleton-klasse, skal du gøre følgende:

• Opret en privat konstruktør .
• Opret en statisk metode (ved at bruge den dovne initialisering), der returnerer objektet for 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:

alfabetet nummereret

 Javatpoint 

POJO klasse

På Java står POJO for Almindelig gammelt Java-objekt. En Java-klasse, der kun indeholder private variabler, setter og getter, er kendt som POJO klasse. Det bruges til at definere Java-objekter, der øger genbrugbarheden og læsbarheden af ​​et Java-program. Klassen giver indkapsling. Det er meget brugt i Java, fordi det er nemt at forstå disse klasser. POJO-klassen har følgende egenskaber:

• Det udvider ikke de foruddefinerede klasser som Arrays, HttpServlet osv.
• Den kan ikke indeholde foruddefinerede annoteringer.
• Det kan ikke implementere foruddefinerede grænseflader .
• Det er ikke nødvendigt at tilføje nogen konstruktør.
• Alle instansvariabler skal være private.
• Getteren/sætteren metoder skal være offentlig.

Lad os forstå begrebet POJO-klasse gennem et 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. 

Indre klasse

Java giver os mulighed for at definere en klasse inden for en klasse, og sådanne klasser er kendt som indlejrede klasser . Det bruges til at gruppere klasserne logisk og til at opnå indkapsling . De ydre klassemedlemmer (inklusive private) kan tilgås af indre klasse . Den generelle syntaks til at erklære den indlejrede klasse er som følger:

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

De indlejrede klasser er af to typer:

1. Statisk indlejret klasse: En klasse altså statisk og indlejret kaldes en statisk indlejret klasse. Den interagerer med instansmedlemmet af dens ydre klasse. Vi kan oprette et objekt af den statiske indlejrede klasse ved at bruge følgende syntaks:

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

2. Ikke-statisk indlejret klasse: Ikke-statiske indlejrede klasser kaldes indre klasser .

vende strengen i java

Den generelle syntaks til at erklære den statiske indlejrede klasse og indre klasse er som følger:

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

Lad os forstå begrebet indre klasse gennem et Java-program.

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

Typer af indre klasser

Java giver de to typer af indre klasser er som følger:

• Lokale klasser eller metode Lokal indre klasse
• Anonyme klasser eller Anonym indre klasse

Lokal indre klasse

Det er en type indre klasse, der er defineret inde i en blok. Her betegner blok en metodelegeme (en gruppe af udsagn indesluttet mellem et par klammer). På grund af at definere inde i en blok er det også kendt som metode lokal indre klasse. Disse er de ikke-statiske klasser, fordi de kan få adgang til instansmedlemmerne af blokken. Vi kan definere de lokale indre klasser i en metodes krop. Disse klasser skal instansieres i den blok, hvor de er defineret.

Når vi kompilerer et Java-program (et program, der indeholder en indre klasse), genererer compileren de to klassefiler, nemlig Yderklasse og YdreIndre.klasse. En for den ydre klasse og den anden for den indre klasse, der indeholder en reference til den ydre klasse.

Lad os forstå konceptet med en lokal indre klasse gennem et 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 indre klasse

Det er en type indre klasse, der er det samme som lokale klasser, men den eneste forskel er, at klassen ikke har et klassenavn, og der oprettes et enkelt objekt af klassen. Det gør koden mere kortfattet. Det bruges, hvis vi vil bruge den lokale klasse én gang. Vi kan oprette anonyme klasser på følgende to måder:

• Ved at bruge en grænseflade
• Ved at erklære klassen konkret og abstrakt

Syntaks:

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

Ser vi på ovenstående syntaks, ser vi, at det er det samme som påkaldelsen af ​​konstruktør, bortset fra at klassen har en definition indeholdt i blokken.

AnonymClassExample.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 giver også en anden type Java-klasse, der er kendt som wrapper-klasse. Lad os diskutere det i detaljer.

Indpakningsklasse

På Java er udtrykket indpakningsklasse repræsenterer en samling af Java-klasser, der objektificerer den primitive type Java. Det betyder, at der for hver primitiv type er en tilsvarende indpakningsklasse. Indpakningsklasserne bruges til at udføre konverteringen fra en primitiv type til et objekt og omvendt. Følgende figur viser indpakningsklassehierarkiet.

Følgende tabel repræsenterer den primitive type og den tilsvarende indpakningsklasse.

Lad os forstå indpakningsklassen gennem et Java-program.

java indsættelse sortering

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