TechCodeview

A Java, el classe és un plànol a partir del qual podem crear un objecte individual. Java proporciona a paraula clau classe anomenada per la qual podem declarar una classe. Dins de la classe, definim classe membres i funcions. No és possible crear Programes Java sense classe. També podem referir una classe com a usuari definit Tipus de Classes

Hi ha set tipus de classes a Java:

Classe estàtica Classe final Classe abstracta Classe de formigó Classe Singleton Classe de POJO Classe interior

Classe estàtica

En Java , static és una paraula clau que gestiona objectes a la memòria. L'objecte estàtic pertany a la classe en lloc de la instància de la classe.

Podem fer una classe estàtica si i només si és una classe imbricada. També podem dir que les classes estàtiques es coneixen com a classes imbricades. Significa que una classe que es declara estàtica dins d'una altra classe es coneix com a classe estàtica. La classe estàtica niuada no requereix referència a la classe externa. El propòsit d'una classe estàtica és proporcionar l'esquema de la seva classe heretada.

Les propietats de la classe estàtica són:

• La classe només té membres estàtics.
• No pot accedir al membre (no estàtica) de la classe externa.
• No podem crear un objecte de la classe estàtica.

Entendrem el concepte de classe estàtica a través d'un programa.

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

Sortida:

què és desktop ini

 Javatpoint 

A la classe externa del programa anterior, hem declarat una variable str com a estàtica perquè estem accedint a aquesta variable des d'un context estàtic. Si declarem aquesta variable com a no estàtica, el compilador mostra un error perquè una classe estàtica imbricada no pot accedir als membres no estàtics de la classe externa.

La segona cosa que cal observar en el programa anterior és que per crear l'objecte de la classe imbricada no hem de crear una instància de la classe externa. Si la classe imbricada no és una classe estàtica, hem de crear una instància de la classe externa.

Classe final

La paraula final significa que no es pot canviar. El final La classe en Java es pot declarar utilitzant el paraula clau final . Un cop declarem una classe com a final, els valors romanen iguals durant tot el programa. L'objectiu de la classe final és fer la classe immutable com la classe String. Només és una manera de fer que la classe sigui immutable. Recordeu que el la classe final no es pot ampliar . També impedeix que la classe sigui subclassificada .

Entendrem el concepte de la classe final a través d'un programa.

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

Sortida:

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

Classe abstracta

An classe abstracta és un que es declara amb la paraula clau abstracte . La classe pot contenir o no mètodes abstractes. No podem crear una instància d'una classe abstracta, però pot ser una subclasse. Aquestes classes estan incompletes, així que per completar la classe abstracta haurem d'estendre les classes abstractes a una classe concreta. Quan declarem una subclasse com a abstracta, cal proporcionar la implementació de mètodes abstractes. Per tant, la subclasse també s'ha de declarar abstracta. Podem aconseguir ocultar dades utilitzant la classe abstracta. Un exemple de classe abstracta és Mapa Abstarct classe que forma part del marc de col·leccions.

Entendrem el concepte de classe abstracta a través d'un programa.

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

Sortida:

 Sum of a and b is: 70 

Classe de formigó

Aquestes són les classes habituals de Java. Una classe derivada que proporciona les implementacions bàsiques per a tots els mètodes que encara no estan implementats a la classe base es coneix com a formigó classe. En altres paraules, són classes Java habituals en les quals s'implementen tots els mètodes d'una classe abstracta. Podem crear directament un objecte de la classe concreta. Recordeu que classe concreta i classe abstracta no són el mateix. Una classe concreta pot ampliar la seva classe pare. S'utilitza per a requisits específics.

Entendrem el concepte de classe concreta a través d'un programa.

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

Sortida:

 Product of a and b is: 48 

Classe Singleton

Una classe que només té un objecte alhora es coneix com a classe singleton . Tot i així, si estem intentant crear una instància una segona vegada, aquesta instància acabada de crear apunta a la primera instància. Si hem fet alguna alteració dins de la classe mitjançant qualsevol instància, la modificació també afecta la variable de la instància única. Normalment s'utilitza per controlar l'accés mentre es tracta de la connexió de la base de dades i la programació del sòcol. Si volem crear una classe singleton, feu el següent:

• Crea un privat constructor .
• Creeu un mètode estàtic (utilitzant la inicialització mandrosa) que retorni l'objecte de la classe singleton.

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

Sortida:

 Javatpoint 

Classe de POJO

A Java, POJO significa Objecte Java antic senzill. Es coneix com a classe Java que només conté variables privades, setter i getter POJO classe. S'utilitza per definir objectes Java que augmenten la reutilització i la llegibilitat d'un programa Java. La classe proporciona encapsulació. S'utilitza àmpliament a Java perquè és fàcil d'entendre aquestes classes. La classe POJO té les propietats següents:

• No amplia les classes predefinides com ara Arrays, HttpServlet, etc.
• No pot contenir anotacions preespecificades.
• No es pot implementar predefinits interfícies .
• No cal afegir cap constructor.
• Totes les variables d'instància han de ser privades.
• El getter/setter mètodes ha de ser públic.

Entendrem el concepte de classe POJO a través d'un programa Java.

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

Sortida:

 The price of an article is 89764.34 Rs. 

Classe interior

Java ens permet definir una classe dins d'una classe i aquestes classes es coneixen com a classes imbricades . S'utilitza per agrupar les classes lògicament i per aconseguir encapsulació . Es pot accedir als membres de la classe externa (inclosos els privats). classe interna . La sintaxi general per declarar la classe imbricada és la següent:

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

Les classes imbricades són de dos tipus:

1. Classe imbricada estàtica: Una classe que és estàtica i niat s'anomena classe imbricada estàtica. Interacciona amb el membre de la instància de la seva classe externa. Podem crear un objecte de la classe imbricada estàtica utilitzant la sintaxi següent:

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

2. Classe anidada no estàtica: Es criden classes imbricades no estàtiques classes internes .

La sintaxi general per declarar la classe imbricada estàtica i la classe interna és la següent:

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

Entendrem el concepte de classe interna a través d'un programa Java.

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

Tipus de classes internes

Java proporciona els dos tipus de classes internes són els següents:

• Classes locals o Mètode Classe interna local
• Classes anònimes o Classe interior anònima

Classe interna local

És un tipus de classe interna que es defineix dins d'un bloc. Aquí el bloc denota el cos d'un mètode (un grup d'instruccions tancades entre un parell de claus). A causa de la definició dins d'un bloc, també es coneix com a classe interna de mètode local. Aquestes són les classes no estàtiques perquè poden accedir als membres d'instància del bloc. Podem definir les classes internes locals al cos d'un mètode. Aquestes classes s'han d'instanciar al bloc en què es defineixen.

Quan compilem un programa Java (un programa que conté una classe interna), el compilador genera els dos fitxers de classe, és a dir classe.exterior i OuterInner.class. Un per a la classe externa i l'altre per a la classe interna que conté una referència a la classe externa.

Entendrem el concepte d'una classe interna local mitjançant un programa Java.

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

Sortida:

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

Classe interior anònima

És un tipus de classe interna que és el mateix que les classes locals, però l'única diferència és que la classe no té un nom de classe i es crea un únic objecte de la classe. Fa que el codi sigui més concís. S'utilitza si volem utilitzar la classe local una vegada. Podem crear classes anònimes de les dues maneres següents:

• Mitjançant l'ús d'una interfície
• Declarant la classe concreta i abstracta

Sintaxi:

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

Mirant la sintaxi anterior, veiem que és el mateix que la invocació del constructor, excepte que la classe té una definició continguda al bloc.

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

Sortida:

 Score is 321 

Java també proporciona un altre tipus de classe Java que es coneix com a classe wrapper. Parlem-ho en detall.

Classe d'embolcall

A Java, el terme classe d'embolcall representa una col·lecció de classes Java que objectitzen el tipus primitiu de Java. Vol dir que per a cada tipus primitiu hi ha una classe d'embolcall corresponent. Les classes d'embolcall s'utilitzen per realitzar la conversió d'un tipus primitiu a un objecte i viceversa. La figura següent mostra la jerarquia de classes d'embolcall.

La taula següent representa el tipus primitiu i la classe d'embolcall corresponent.

Entendrem la classe wrapper mitjançant un programa Java.

cadena comparada

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

Sortida:

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