I Java er klasse er en blåkopi som vi kan lage et individuelt objekt fra. Java gir en nøkkelord navngitt klasse som vi kan erklære en klasse med. Inne i klassen definerer vi klasse medlemmer og funksjoner. Det er ikke mulig å lage Java-programmer uten klasse. Vi kan også referere en klasse som en brukerdefinert Typer av klasser
Det er syv typer klasser i Java:
Statisk klasse
Vi kan lage en klasse statisk hvis og bare hvis det er en nestet klasse. Vi kan også si at statiske klasser er kjent som nestede klasser. Det betyr at en klasse som er erklært som statisk innenfor en annen klasse er kjent som en statisk klasse. Nestet statisk klasse krever ikke referanse til den ytre klassen. Hensikten med en statisk klasse er å gi omrisset av dens nedarvede klasse.
Egenskapene til den statiske klassen er:
- Klassen har kun statiske medlemmer.
- Den kan ikke få tilgang til medlemmet (ikke-statisk) av den ytre klassen.
- Vi kan ikke lage et objekt av den statiske klassen.
La oss forstå konseptet med statisk klasse gjennom 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(); } } Produksjon:
a b c tall
Javatpoint
I den ytre klassen av programmet ovenfor har vi erklært en variabel str som statisk fordi vi får tilgang til den variabelen fra en statisk kontekst. Hvis vi erklærer den variabelen som ikke-statisk, viser kompilatoren en feil fordi en nestet statisk klasse kan ikke få tilgang til ikke-statiske medlemmer av den ytre klassen.
Den andre tingen å legge merke til i programmet ovenfor er at for å lage objektet til den nestede klassen trenger vi ikke å lage en forekomst av den ytre klassen. Hvis den nestede klassen ikke er en statisk klasse, må vi lage en forekomst av den ytre klassen.
Siste klasse
Ordet endelig betyr at det ikke kan endres. De endelig klasse i Java kan erklæres ved hjelp av siste søkeord . Når vi erklærer en klasse som endelig, forblir verdiene de samme gjennom hele programmet. Hensikten med den siste klassen er å gjøre klassen uforanderlig som String-klassen. Det er bare en måte å gjøre klassen uforanderlig på. Husk at sluttklassen kan ikke forlenges . Det også forhindrer at klassen blir underklassifisert .
La oss forstå konseptet med den siste klassen gjennom 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(); } } Produksjon:
/FinalClassExample.java:11: error: cannot inherit from final A class B extends A
Abstrakt klasse
An abstrakt klasse er en som er deklarert med nøkkelordet abstrakt . Klassen kan inneholde abstrakte metoder eller ikke. Vi kan ikke lage en forekomst av en abstrakt klasse, men det kan være en underklasse. Disse klassene er ufullstendige, så for å fullføre den abstrakte klassen bør vi utvide de abstrakte klassene til en konkret klasse. Når vi erklærer en underklasse som abstrakt, er det nødvendig å gi implementering av abstrakte metoder. Derfor må underklassen også erklæres abstrakt. Vi kan oppnå dataskjul ved å bruke den abstrakte klassen. Et eksempel på en abstrakt klasse er AbstarctMap klasse som er en del av rammeverket for samlinger.
La oss forstå konseptet med abstrakt klasse gjennom 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(); } } Produksjon:
Sum of a and b is: 70
Betongklasse
Dette er de vanlige Java-klassene. En avledet klasse som gir de grunnleggende implementeringene for alle metodene som ikke allerede er implementert i basisklassen, er kjent som en betong klasse. Det er med andre ord vanlige Java-klasser der alle metodene til en abstrakt klasse er implementert. Vi kan lage et objekt av betongklassen direkte. Husk at konkret klasse og abstrakt klasse ikke er det samme. En betongklasse kan utvide sin overordnede klasse. Den brukes til spesifikke krav.
La oss forstå konseptet med betongklassen gjennom 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); } } Produksjon:
Product of a and b is: 48
Singleton klasse
En klasse som bare har et objekt om gangen er kjent som en singleton klasse . Likevel, hvis vi prøver å opprette en forekomst en gang til, peker den nyopprettede forekomsten til den første forekomsten. Hvis vi gjorde noen endring i klassen gjennom en forekomst, vil modifikasjonen også påvirke variabelen til enkeltforekomsten. Det brukes vanligvis til å kontrollere tilgang mens du arbeider med databasetilkoblingen og socket-programmering. Hvis vi vil lage en singleton-klasse, gjør du følgende:
- Opprett en privat konstruktør .
- Lag en statisk metode (ved å bruke den late initialiseringen) som returnerer objektet til 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; } } Produksjon:
alfabetet nummerert
Javatpoint
POJO klasse
I Java står POJO for Vanlig gammelt Java-objekt. En Java-klasse som bare inneholder private variabler, setter og getter er kjent som POJO klasse. Det brukes til å definere Java-objekter som øker gjenbrukbarheten og lesbarheten til et Java-program. Klassen gir innkapsling. Det er mye brukt i Java fordi det er lett å forstå disse klassene. POJO-klassen har følgende egenskaper:
- Den utvider ikke de forhåndsdefinerte klassene som Arrays, HttpServlet, etc.
- Den kan ikke inneholde forhåndsdefinerte merknader.
- Den kan ikke implementere forhåndsdefinerte grensesnitt .
- Det er ikke nødvendig å legge til noen konstruktør.
- Alle forekomstvariabler må være private.
- Getteren/setteren metoder må være offentlig.
La oss forstå konseptet med POJO-klassen gjennom 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.'); } } Produksjon:
The price of an article is 89764.34 Rs.
Indre klasse
Java lar oss definere en klasse i en klasse, og slike klasser er kjent som nestede klasser . Den brukes til å gruppere klassene logisk og for å oppnå innkapsling . De ytre klassemedlemmene (inkludert private) kan nås av indre klasse . Den generelle syntaksen for å deklarere den nestede klassen er som følger:
class OuterClass { //code class NestedClass { //code } } De nestede klassene er av to typer:
1. Statisk nestet klasse: En klasse altså statisk og nestet kalles en statisk nestet klasse. Den samhandler med instansmedlemmet i dens ytre klasse. Vi kan lage et objekt av den statiske nestede klassen ved å bruke følgende syntaks:
OuterClass.StaticNestedClass nestedObject = new OuterClass.StaticNestedClass();
2. Ikke-statisk nestet klasse: Ikke-statiske nestede klasser kalles indre klasser .
strengfunksjoner i java
Den generelle syntaksen for å deklarere den statiske nestede klassen og den indre klassen er som følger:
class OuterClass { ... static class StaticNestedClass { ... } class InnerClass { ... } } La oss forstå begrepet indre klasse gjennom 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 indre klasser
Java gir de to typene indre klasser 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 som er definert inne i en blokk. Her betegner blokk en metodekropp (en gruppe setninger innelukket mellom et par parenteser). På grunn av definering inne i en blokk er det også kjent som metode lokal indre klasse. Dette er de ikke-statiske klassene fordi de kan få tilgang til forekomstmedlemmene av blokken. Vi kan definere de lokale indre klassene i kroppen til en metode. Disse klassene må instansieres i blokken de er definert i.
Når vi kompilerer et Java-program (et program som inneholder en indre klasse), genererer kompilatoren de to klassefilene, nemlig Ytre.klasse og YtreInner.klasse. En for den ytre klassen og den andre for den indre klassen som inneholder en referanse til den ytre klassen.
La oss forstå konseptet med en lokal indre klasse gjennom 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(); } } Produksjon:
Divisor = 4 Remainder = 0 We are inside the inner class Quotient = 5
Anonym indre klasse
Det er en type indre klasse som er den samme som lokale klasser, men den eneste forskjellen er at klassen ikke har et klassenavn og et enkelt objekt er opprettet av klassen. Det gjør koden mer kortfattet. Den brukes hvis vi ønsker å bruke den lokale klassen en gang. Vi kan opprette anonyme klasser på følgende to måter:
- Ved å bruke et grensesnitt
- Ved å 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å syntaksen ovenfor, ser vi at det er det samme som påkallelsen av konstruktør bortsett fra at klassen har en definisjon inneholdt i blokken.
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(); } } Produksjon:
Score is 321
Java gir også en annen type Java-klasse som er kjent som wrapper-klasse. La oss diskutere det i detalj.
Innpakningsklasse
På Java er begrepet innpakningsklasse representerer en samling av Java-klasser som objektifiserer den primitive typen Java. Det betyr at for hver primitiv type er det en tilsvarende innpakningsklasse. Wrapper-klassene brukes til å utføre konverteringen fra en primitiv type til et objekt og omvendt. Følgende figur viser omslagsklassehierarkiet.
Følgende tabell representerer den primitive typen og tilsvarende innpakningsklasse.
| Primitiv type | Innpakningsklasse |
|---|---|
| boolsk | boolsk |
| int | Heltall |
| røye | Karakter |
| dobbelt | Dobbelt |
| flyte | Flyte |
| lang | Lang |
| byte | Byte |
| kort | Kort |
La oss forstå innpakningsklassen gjennom et Java-program.
java innsetting 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); } } Produksjon:
Byte object byteobj: 0 Integer object intobj: 23 Character object charobj: m