Javassa, luokkaa on suunnitelma, josta voimme luoda yksittäisen kohteen. Java tarjoaa a avainsana nimetty luokka, jolla voimme ilmoittaa luokan. Luokan sisällä määrittelemme luokkaa jäseniä ja toimintoja. Ei ole mahdollista luoda Java-ohjelmat ilman luokkaa. Voimme kutsua luokkaa myös nimellä a käyttäjän määrittelemä Luokkien tyypit

Javassa on seitsemän luokkatyyppiä:

Staattinen luokka Viimeinen luokka Abstrakti luokka Betoni luokka Singleton luokka POJO-luokka Sisäinen luokka

Staattinen luokka

Sisään Java , staattinen on avainsana, joka hallitsee muistissa olevia objekteja. Staattinen objekti kuuluu luokkaan luokan esiintymän sijaan.

Voimme tehdä luokan staattinen jos ja vain jos se on sisäkkäinen luokka. Voidaan myös sanoa, että staattiset luokat tunnetaan sisäkkäisinä luokkina. Se tarkoittaa, että luokka, joka on ilmoitettu staattiseksi toisessa luokassa, tunnetaan staattisena luokkana. Sisäkkäinen staattinen luokka ei vaadi viittausta ulompaan luokkaan. Staattisen luokan tarkoitus on antaa ääriviivat sen peritylle luokalle.

Staattisen luokan ominaisuudet ovat:

• Luokassa on vain staattisia jäseniä.
• Se ei voi käyttää ulomman luokan jäsentä (ei-staattista).
• Emme voi luoda staattisen luokan objektia.

Ymmärretään staattisen luokan käsite ohjelman kautta.

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

Lähtö:

 Javatpoint 

Yllä olevan ohjelman uloimmassa luokassa olemme ilmoittaneet muuttujan str staattisena, koska käytämme tätä muuttujaa staattisesta kontekstista. Jos ilmoitamme tämän muuttujan ei-staattiseksi, kääntäjä näyttää virheen, koska sisäkkäinen staattinen luokka ei voi käyttää ulomman luokan ei-staattisia jäseniä.

Toinen huomioitava asia yllä olevassa ohjelmassa on, että sisäkkäisen luokan objektin luomiseksi meidän ei tarvitse luoda ulomman luokan esiintymää. Jos sisäkkäinen luokka ei ole staattinen luokka, meidän on luotava ulomman luokan esiintymä.

Viimeinen luokka

Sana lopullinen tarkoittaa, että sitä ei voi muuttaa. The lopullinen luokka Javassa voidaan ilmoittaa käyttämällä viimeinen avainsana . Kun julistamme luokan lopulliseksi, arvot pysyvät samoina koko ohjelman ajan. Lopputunnin tarkoituksena on tehdä luokka muuttumaton kuten jousiluokka. Se on vain tapa tehdä luokasta muuttumaton. Muista, että loppuluokkaa ei voida jatkaa . Se myös estää luokan alaluokittelun .

Ymmärretään loppuluokan käsite ohjelman kautta.

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

Lähtö:

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

Abstrakti luokka

An abstrakti luokka on a, joka ilmoitetaan avainsanalla abstrakti . Luokka voi sisältää tai ei sisällä abstrakteja menetelmiä. Emme voi luoda ilmentymää abstraktista luokasta, mutta se voi olla alaluokka. Nämä luokat ovat epätäydellisiä, joten abstraktin luokan täydentämiseksi meidän tulee laajentaa abstraktit luokat konkreettiseksi luokkaksi. Kun julistamme alaluokan abstraktiksi, on välttämätöntä tarjota abstraktien menetelmien toteutus. Siksi alaluokka on myös julistettava abstraktiksi. Voimme saavuttaa tietojen piilottamisen käyttämällä abstraktia luokkaa. Esimerkki abstraktista luokasta on AbstractMap luokka, joka on osa Collections-kehystä.

Ymmärretään abstraktin luokan käsite ohjelman kautta.

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

Lähtö:

 Sum of a and b is: 70 

Betoni luokka

Nämä ovat tavallisia Java-luokkia. Johdettu luokka, joka tarjoaa perustoteutukset kaikille menetelmille, joita ei ole vielä toteutettu perusluokassa, tunnetaan nimellä betoni luokkaa. Toisin sanoen kyseessä ovat tavalliset Java-luokat, joissa kaikki abstraktin luokan menetelmät on toteutettu. Voimme luoda betoniluokan kohteen suoraan. Muista, että konkreettinen luokka ja abstrakti luokka eivät ole sama asia. Konkreettinen luokka voi laajentaa emoluokkaansa. Sitä käytetään erityisiin vaatimuksiin.

Ymmärretään konkreettisen luokan käsite ohjelman kautta.

mikä on monitorini koko

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

Lähtö:

 Product of a and b is: 48 

Singleton luokka

Luokka, jolla on vain objekti kerrallaan, tunnetaan nimellä a singleton luokka . Silti, jos yritämme luoda ilmentymän toisen kerran, äskettäin luotu ilmentymä osoittaa ensimmäiseen esiintymään. Jos teimme luokan sisällä muutoksia minkä tahansa esiintymän kautta, muutos vaikuttaa myös yksittäisen esiintymän muuttujaan. Sitä käytetään yleensä pääsyn hallintaan tietokantayhteyden ja pistorasian ohjelmoinnin yhteydessä. Jos haluamme luoda singleton-luokan, toimi seuraavasti:

• Luo yksityinen rakentaja .
• Luo staattinen menetelmä (laiskalla alustuksella), joka palauttaa singleton-luokan objektin.

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

Lähtö:

 Javatpoint 

POJO-luokka

Javassa POJO tarkoittaa Pelkkä vanha Java-objekti. Java-luokka, joka sisältää vain yksityisiä muuttujia, setterin ja getterin, tunnetaan nimellä POJO luokkaa. Sitä käytetään Java-objektien määrittämiseen, jotka lisäävät Java-ohjelman uudelleenkäytettävyyttä ja luettavuutta. Luokka tarjoaa kapseloinnin. Sitä käytetään laajalti Javassa, koska se on helppo ymmärtää nämä luokat. POJO-luokalla on seuraavat ominaisuudet:

• Se ei laajenna ennalta määritettyjä luokkia, kuten Arrays, HttpServlet jne.
• Se ei voi sisältää ennalta määritettyjä huomautuksia.
• Se ei voi toteuttaa ennalta määritettyjä käyttöliittymät .
• Rakentajaa ei tarvitse lisätä.
• Kaikkien esiintymän muuttujien on oltava yksityisiä.
• Getter/setteri menetelmiä on oltava julkinen.

Ymmärretään POJO-luokan käsite Java-ohjelman kautta.

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

Lähtö:

 The price of an article is 89764.34 Rs. 

Sisäinen luokka

Java antaa meille mahdollisuuden määritellä luokka luokassa, ja tällaiset luokat tunnetaan nimellä sisäkkäiset luokat . Sitä käytetään luokkien loogiseen ryhmittelyyn ja saavuttamiseen kapselointi . Ulkoluokan jäsenet (mukaan lukien yksityiset) pääsevät käsiksi sisäinen luokka . Sisäkkäisen luokan ilmoittamisen yleinen syntaksi on seuraava:

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

Sisäkkäisiä luokkia on kahta tyyppiä:

1. Staattinen sisäkkäinen luokka: Sellainen luokka staattinen ja sisäkkäisiä kutsutaan staattiseksi sisäkkäiseksi luokaksi. Se on vuorovaikutuksessa ulomman luokkansa esiintymän jäsenen kanssa. Voimme luoda staattisen sisäkkäisen luokan objektin käyttämällä seuraavaa syntaksia:

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

2. Ei-staattinen sisäkkäinen luokka: Ei-staattisia sisäkkäisiä luokkia kutsutaan sisäluokat .

Staattisen sisäkkäisen luokan ja sisäisen luokan ilmoittamisen yleinen syntaksi on seuraava:

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

Ymmärretään sisäluokan käsite Java-ohjelman kautta.

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

Sisäluokkien tyypit

Java tarjoaa seuraavat kahden tyyppiset sisäiset luokat:

• Paikalliset luokat tai menetelmä Paikallinen sisäluokka
• Anonyymit luokat tai Anonyymi sisäluokka

Paikallinen sisäluokka

Se on eräänlainen sisäinen luokka, joka määritellään lohkon sisällä. Tässä lohko tarkoittaa metodirunkoa (joukko lauseita, jotka on suljettu aaltosulkeiden väliin). Lohkon sisällä määrittelystä johtuen se tunnetaan myös nimellä method local inner class. Nämä ovat ei-staattisia luokkia, koska ne voivat käyttää lohkon ilmentymän jäseniä. Voimme määritellä paikalliset sisäiset luokat metodin rungossa. Nämä luokat tulee ilmentää siinä lohkossa, jossa ne on määritelty.

Kun käännämme Java-ohjelman (ohjelman, joka sisältää sisäisen luokan), kääntäjä luo kaksi luokkatiedostoa, nimittäin Ulompi.luokka ja OuterInner.class. Toinen ulommalle luokalle ja toinen sisäiselle luokalle, joka sisältää viittauksen ulompaan luokkaan.

Ymmärretään paikallisen sisäluokan käsite Java-ohjelman kautta.

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

Lähtö:

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

Anonyymi sisäluokka

Se on sisäisen luokan tyyppi, joka on sama kuin paikalliset luokat, mutta ainoa ero on, että luokalla ei ole luokan nimeä ja luokasta luodaan yksi objekti. Se tekee koodista tiiviimmän. Sitä käytetään, jos haluamme käyttää paikallista luokkaa kerran. Voimme luoda anonyymejä luokkia seuraavilla kahdella tavalla:

• Käyttöliittymää käyttämällä
• Julistamalla luokan konkreettiseksi ja abstraktiksi

Syntaksi:

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

Yllä olevaa syntaksia tarkasteltaessa näemme, että se on sama kuin konstruktorin kutsu, paitsi että luokassa on määritelmä lohkossa.

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

Lähtö:

 Score is 321 

Java tarjoaa myös toisen tyyppisen Java-luokan, joka tunnetaan nimellä kääreluokka. Keskustellaan siitä yksityiskohtaisesti.

Kääre luokka

Javassa termi kääreluokka edustaa kokoelmaa Java-luokkia, jotka objektivisoivat Javan primitiivisen tyypin. Se tarkoittaa, että jokaiselle primitiivityypille on vastaava kääreluokka. Kääritysluokkia käytetään muuntamiseen primitiivityypistä objektiksi ja päinvastoin. Seuraava kuva esittää kääreluokan hierarkiaa.

lajitella arraylist java

Seuraava taulukko edustaa primitiivistä tyyppiä ja vastaavaa kääreluokkaa.

Ymmärretään wrapper-luokka Java-ohjelman kautta.

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

Lähtö:

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