types classes java
En aquest tutorial es parlaran de diversos tipus de classes en Java, com ara Resum, Concret, Final, Interior, POJO, Estàtic i altres classes especials, amb exemples:
Al nostre tutorial anterior, vam parlar de classes i objectes a Java. Una classe a Java és una plantilla o un pla. També es pot definir com una col·lecció d'objectes similars. Definim objectes de classe tipus i després ens comuniquem mitjançant aquests objectes.
Cada objecte és una instància d'una classe que té un estat i un comportament.
=> Visiteu aquí la sèrie exclusiva de cursos de formació de Java.
Què aprendreu:
- Tipus de classes a Java - Introducció
- Tipus de classes a Java
- Altres classes especials a Java
- Conclusió
Tipus de classes a Java - Introducció
Tots sabem que la classe té els components següents:
- Modificadors: Especifiqueu l'accés per a la classe.
- ClassName: Nom de la classe.
- Paraules clau: Paraules clau que suggereixen si una classe amplia o implementa la classe o la interfície.
- La classe Body entre claudàtors {}
En funció dels diferents modificadors utilitzats, del cos de classe especificat i de les paraules clau utilitzades, tenim diversos tipus de classes a Java.
Què és el cicle de vida del desenvolupament de programari?
- Classe de formigó: Una classe normal que té la implementació concreta de mètodes.
- Classe POJO: Es tracta de 'Plain Old Java Object' que conté només variables de membre privat i mètodes de configuració de configurador per accedir a aquestes variables.
- Classe de resum: Aquesta classe té un o més mètodes abstractes.
- Classe final: No es pot heretar una classe final.
- Classe estàtica: Una classe que només conté membres estàtics.
- Classe interior: Una classe interior és una classe que és membre d’una altra classe.
En aquest tutorial, parlarem de cadascun d’aquests tipus de classes amb exemples.
També parlarem d'altres tipus de classes que es consideren classes especials a Java.
- Classe anònima: Una classe sense cap nom.
- Classe immutable: Una classe l'objecte no es pot canviar.
- Classe Singleton: Una classe la instància única de la qual es pot crear.
- Classe d'objecte: La classe base de totes les funcions de Java.
- Classe d'embolcall: Tots els tipus de dades primitius a Java tenen una classe d’embolcall.
En primer lloc, analitzem breument com importar una classe a Java juntament amb la classe Main a Java que conté el mètode principal o el punt de partida a Java.
Importa a Java
A Java, si volem incloure alguna característica o funcionalitat al nostre programa, podem utilitzar la declaració 'importar'. Mitjançant la declaració d’importació podem importar tot un paquet i utilitzar-ne la funcionalitat al nostre programa o també podem incloure una sola classe.
A continuació es mostra la sintaxi de la sentència d’importació.
import packageName/classname; Si volem importar el paquet java.lang i totes les seves classes, podem escriure la següent afirmació:
import java.lang.*; Suposem que volem incloure la funcionalitat de la classe Arrays al nostre programa, llavors podem escriure la següent afirmació:
import java.util.Arrays; La declaració d’importació equival a la declaració d’inclusió C / C ++. La declaració d'importació es col·loca al principi del programa Java com a primera declaració. Podem tenir més d’una afirmació al programa Java.
Classe principal a Java
Ja sabem que a Java, el mètode main () és el punt de partida de l'execució de qualsevol programa i es pot col·locar en qualsevol classe d'aquesta aplicació en particular. Tanmateix, si tenim una aplicació complexa amb massa fitxers i classes, és recomanable tenir una classe Main i col·locar el mètode main () en aquesta classe Main.
class Main{ public static void main(String() args){ System.out.println(“Hello, World!”); } } Tingueu en compte que la JVM no crea cap objecte de la classe Main. La lògica que hi ha darrere d'això és que, com main () és un mètode estàtic, es pot anomenar sense cap objecte de classe.
Tipus de classes a Java
Ara anem a passar als tipus de classes a Java. Explicarem cadascuna d’aquestes classes una per una seguida dels exemples de programació.
# 1) Classe de formigó
Una classe concreta és qualsevol classe normal d’un programa Java. Aquesta classe no tindrà cap mètode abstracte. Tots els mètodes de la classe concreta estan completament implementats.
Una classe concreta pot heretar d’una altra classe, fins i tot una classe abstracta o implementar una interfície. Podem instanciar la classe concreta i crear-ne els objectes.
A continuació es mostra un exemple senzill de classe concreta.
public class Main { // Concrete Class example static int total(int val1, int val2) { return val1 + val2; } public static void main(String args()) { int sum = total(100, 108); System.out.println('Total of two integers: ' + sum); } } Sortida
El programa anterior mostra una classe concreta. Veiem que aquesta classe té una implementació completa. No queda res incomplet o no implementat.
# 2) Classe POJO
Un POJO (Plain Old Java Object) és una classe que només conté variables membres privades. A part de les variables de membre privat, només conté mètodes getter i setter utilitzats per aquestes variables de membre.
Una classe POJO no té el seu comportament. Tanmateix, pot anul·lar alguns mètodes com ara iguals o interfícies.
Propietats de la classe POJO:
- La classe POJO ha de tenir un mètode getter i setter públic.
- Tots els membres o variables d’instància han de ser privats.
- La classe POJO no amplia ni implementa classes ni interfícies que estiguin predeterminades.
- No contenen anotacions preespecificades.
- No té un constructor sense arguments (constructor sense arguments).
A continuació es mostra un programa Java que demostra la classe POJO.
//declare a POJO class class POJO_Class { private int daysOfWeek=7; //private variable public int getdaysOfWeek() { //getter return daysOfWeek; } public void setdaysOfWeek(int dow) { //setter this.daysOfWeek = dow; } } public class Main { public static void main(String args()){ POJO_Class pojoDemo = new POJO_Class(); //instance of POJO class System.out.println('Days of the week:' + pojoDemo.getdaysOfWeek()); } } Sortida
La demostració anterior de la classe POJO mostra que té una variable privada i els mètodes getter setter per a aquesta variable. Per accedir a aquesta variable membre, fem servir el mètode getter. El mètode setter s’utilitza per actualitzar el valor.
# 3) Classe abstracta
Una classe abstracta és una classe incompleta o la implementació de la qual no s'ha completat. No es pot crear una classe abstracta. Ha de ser ampliat per les altres classes i implementar els seus mètodes per formar una classe concreta.
Es declara una classe abstracta mitjançant la paraula clau 'abstract'. Una classe abstracta pot tenir tant mètodes estàtics i finals com constructors.
Demostrem una classe abstracta a Java.
interface multiply //interface multiply { int product(int num1, int num2); } // abstract class abstract class Product implements multiply { // this is an abstract method to calculate product of two numbers public abstract int product(int num1, int num2); } // Concrete class :this will implement the abstract method above class Main extends Product { public int product(int num1, int num2) { return num1*num2; } // main method public static void main(String args()) { Main obj = new Main(); int prod = obj.product(100, 20); // print product System.out.println('Product of two numbers: ' + prod); } }Sortida
Al programa anterior, tenim una interfície de multiplicar. Creem un producte de classe abstracta que implementa una interfície de multiplicació. Dins del producte, tenim un mètode de producte que no està implementat. Després tenim una classe principal que hereta la classe Producte i implementa el mètode del producte. Més endavant, anomenem aquest mètode a l'objecte de la classe Main.
# 4) Classe estàtica
Una estàtica a Java en general significa l'objecte que pertany a una classe i no a les instàncies individuals. Per tant, no cal accedir a un membre o mètode estàtic a Java amb un objecte, sinó directament mitjançant un nom de classe.
Una classe estàtica a Java només pot contenir membres estàtics. A més, no podem instanciar una classe estàtica.
El següent programa Java mostra una classe estàtica.
class Static_Class { static int total; // static variable static void sum(int val1, int val2) { // static method System.out.print('Static method to calculate sum:' + ' '); total = val1 + val2; System.out.println(val1 + '+' + val2); // print the numbers } static class Nested_Class { // static class static { // static block System.out.println('static block inside a static nested class'); } public void displaySum() { sum(25, 75); // call static method // print the value in static variable total, it holds the sum of two numbers System.out.println('Sum of two numbers:' + total); } } } public class Main { public static void main(String args()) { // declare static class object Static_Class.Nested_Class object = new Static_Class.Nested_Class(); object.displaySum(); // call displaySum method inside a static class } } Sortida
La classe anterior mostra la classe estàtica. Aquí tenim una classe estàtica que és membre d’una altra classe concreta. Dins de la classe estàtica, calculem la suma de dos nombres i emmagatzemem el resultat en una variable estàtica que és membre de la classe exterior.
# 5) Classe final
Una classe final és una classe que no es pot heretar ni subclassar. Un cop una classe es declara final a Java, és una mena de constant i es torna immutable.
Per tant, per fer immutable una classe, hem de declarar-la com a definitiva.
//final class final class Base_Class { void Display() { System.out.println('Base_Class::Display()'); } } //class Derived_Class extends Base_Class { //Compile-time error - can't inherit final class class Derived_Class{ void Display() { System.out.println('Derived_Class::Display()'); } } public class Main { public static void main(String() arg) { Base_Class base_obj = new Base_Class(); //create a final class object base_obj.Display(); Derived_Class deri_obj = new Derived_Class(); deri_obj.Display(); } } Sortida
El programa anterior declara primer una Base_Class que està marcada com a 'final'. Per tant, quan intentem ampliar-lo a Derived_Class, obtenim un error del compilador. (La línia comentada). Però podem crear el seu objecte i anomenar el mètode Display.
# 6) Classe imbricada / Classe interna
La classe imbricada, també coneguda com a classe interna a Java, s'utilitza per millorar l'encapsulació. Una classe imbricada / classe interna és una classe inclosa dins d’una altra classe.
Igual que una classe té com a membres variables i mètodes, també pot tenir una classe interna com a membre.
Una classe imbricada té la següent estructura:
class OuterClass{ class NestedClass{ //nested class code… } //outerclass code… } Les classes interiors tenen els següents subtipus:
- Classe interior imbricada
- Mètode Local Class interior
- Classe interior anònima
- Classe estàtica nidificada
# 1) Classe interior imbricada
Una classe interna imbricada té accés a variables membres privades d’una classe externa. També podem aplicar modificadors d’accés a la classe interna imbricada.
# 2) Mètode de classe interna local
Aquesta és la classe interior que es declara dins d’un mètode de classe exterior.
# 3) Classe interna anònima
La classe interior anònima és una classe interior declarada dins d’una classe externa i no té cap nom.
# 4) Classe imbricada estàtica
La forma en què una classe té una variable de membre estàtic, també pot tenir una classe estàtica com a membre.
A continuació es mostra un exemple de classe imbricada / interna:
public class Main { //nested/inner class enclosed inside Main class. class InnerClass { public void inner_print() { System.out.println('Inner class'); } } public static void main(String() args) { System.out.println('Main in Outer class'); } } Sortida
Altres classes especials a Java
Classe immutable a Java
Una classe immutable genera objectes immutables. Un objecte immutable és un objecte el contingut del qual no es pot canviar un cop creat l'objecte. Per tant, una classe immutable és aquella l'objecte de la qual no es pot canviar un cop creada.
Totes les classes d'embolcall de Java per als tipus primitius (Enter, Boolean, Byte, etc.) són immutables. La classe String també és immutable.
També podem tenir classes immutables definides per l'usuari a Java.
Perquè una classe sigui immutable, cal declarar-la definitiva juntament amb tots els seus membres de dades. A més, la classe ha de tenir un constructor parametritzat. Totes les variables membres han de tenir un mètode getter però no un mètode setter.
Cal que es compleixin tots els requisits anteriors perquè una classe sigui immutable.
Implantem un programa Java per demostrar la classe immutable.
final class City { final String city_name; final int cityId; //parameterised constructor public City(String name, int id) { this.city_name = name; this.cityId = id; } //getters for member variables public String getcityName() { return city_name; } public int getcityId() { return cityId; } } // Driver class class Main { public static void main(String args()) { City city = new City('New York', 1001); System.out.print('City Id:' + city.getcityId() + ' '); System.out.println('City Name:' + city.getcityName()); //city.cityId = 1002; //cannot assign a value to final variable regNo } } Sortida
tipus de proves en desenvolupament de programari
Al programa anterior, hem declarat classe City. Aquesta és una classe final i, en aquesta classe, hem declarat dues variables membres i un constructor parametritzat. També hem declarat mètodes getter per a aquestes dues variables membres. Per tant, la classe City compleix tots els requisits d’una classe immutable.
Tingueu en compte la línia de codi comentada al mètode principal. Si fem un comentari a aquesta línia, obtindrem un error del compilador (proporcionat al comentari aquí), ja que intentem establir el valor d’una variable membre.
Singleton Class A Java
Una classe singleton permet una sola instància a la vegada. A Java, un singleton és un patró de disseny. Aquest patró de disseny garanteix que només existeixi una instància d'una classe en qualsevol moment. Per tant, qualsevol classe definida com a singleton té un únic punt d’accés i és global.
Tingueu en compte que la finalització del cicle de vida de l'aplicació no destrueix una classe singleton com les classes normals. Quan es declara una classe singleton, no creem cap instància nova cada vegada que es fa una nova sol·licitud de l'objecte.
La mateixa instància s'utilitza una i altra vegada. D'aquesta manera, podem estalviar espai de memòria principalment en cas d'aplicacions de múltiples fils i bases de dades.
Podem utilitzar una classe individual per a activitats com la memòria cau, el registre, etc.
El programa següent mostra una classe de Singleton.
class Singleton { // static variable of type Singleton private static Singleton single_instance = null; // String variable public String str; // private constructor : restricted to this class private Singleton() { str = 'Singleton class::private constructor'; } // create instance of Singleton class using getInstance static method public static Singleton getInstance() { if (single_instance == null) single_instance = new Singleton(); return single_instance; } } class Main { public static void main(String args()) { // instantiate Singleton class with obj1 Singleton obj1 = Singleton.getInstance(); // instantiate Singleton class with obj2 Singleton obj2 = Singleton.getInstance(); System.out.println('obj1(str):' + obj1.str); System.out.println('obj2(str):' + obj2.str); // change variable of instance obj1 obj1.str = (obj1.str).toUpperCase(); System.out.println('
After changing obj1(str):'); System.out.println('obj1(str):' + obj1.str); System.out.println('obj2(str):' + obj2.str); } } Sortida
Al programa anterior, hem definit una classe singleton amb un constructor privat. Hem definit una variable membre de tipus String. En el mètode principal, declarem dues instàncies de la classe singleton. A continuació, canviem la variable String mitjançant una de les instàncies.
Quan imprimim el valor String per a les dues instàncies, ens adonem que el valor de la variable String ha canviat per a les dues instàncies. Per tant, tot i que hem canviat el valor només per una instància, a causa de la classe singleton, els canvis es reflecteixen en totes les instàncies.
Sempre retornem la mateixa instància tot i que sembli que creem instàncies diferents.
Classe d'objectes a Java
La classe Object és la classe pare o la primera classe de Java. Es troba al nivell més alt de la jerarquia de Java.
Com que totes les classes tenen la classe Object com a superclasse, tots els objectes Java inclosos Arrays implementen els mètodes de classe Object. La classe objecte està present al paquet 'java.lang'.
La declaració per a java.lang.Object és:
Objecte de classe pública
La taula següent descriu els constructors i els mètodes de la classe Object.
| Constructor / Mètode | Descripció |
|---|---|
| Classe getClass () | Retorna la classe d'execució de l'objecte. |
| Constructor de classes d'objectes | |
| Objecte() | Constructor de classes d'objectes |
| Mètodes de classe d'objectes | |
| clon d'objectes protegits () | Retorna un clon o una còpia de l'objecte. |
| booleà és igual (object object) | Comprova si un objecte determinat és igual a aquest objecte. |
| buit protegit finalitzar () | Trucat pel recollidor d'escombraries quan es destrueixen totes les referències a l'objecte. |
| int hashCode () | Retorna el codi hash de l'objecte. |
| notificar nul () | Utilitzeu-lo per despertar un únic fil d'espera. |
| void notificationAll () | Desperta tots els fils d’espera. |
| String toString () | Retorna l'equivalent de cadena de l'objecte. |
| void wait () | Fa esperar un fil fins que es desperti mitjançant un mètode de notificació per un altre fil. |
| espera nul·la (temps llarg) | Fa que el fil esperi fins que transcorri el temps donat pel 'temps d'espera' o es desperti mitjançant mètodes de notificació o de notificació de tots. |
| espera nul·la (temps d'espera llarg, int nanos) | Fa que el fil s’esperi fins que hagi transcorregut el temps especificat o fins que un altre fil invoca la notificació () o notificationAll (). |
Implantem un exemple de programa Java que demostri alguns dels mètodes de la classe Object.
public class Main { public static void main(String() args) { Main t = new Main(); System.out.println('Main class Object HashCode:' + t.hashCode()); t = null; // call garbage collector System.gc(); System.out.println('Main class:End'); } @Override protected void finalize() { System.out.println('Main Class::finalize method called.'); } } Sortida
Aquí tenim una classe principal. Al mètode principal () creem un objecte de la classe Main. Aquest objecte és descendent de la classe Object i admet tots els mètodes de la classe Object. Per tant, fem servir aquest objecte i anomenem alguns mètodes de classe Object, com ara hashCode (), System.GC (), finalize (), etc.
Classe Wrapper a Java
Java proporciona una característica anomenada classe wrapper que té un mecanisme que converteix el tipus de dades primitiu en objecte i viceversa. Les classes Wrapper són les classes que representen tipus primitius com int, char, etc. com a objectes.
Per tant, cada tipus de dades primitiu a Java té la seva classe d'embolcall corresponent.
A la taula següent es mostren els tipus de dades primitius i la seva classe d'embolcall equivalent.
| Tipus primitiu | Tipus d’embolcall |
|---|---|
| surar | Flotador |
| booleà | Booleà |
| char | Personatge |
| byte | Byte |
| curt | Curt |
| int | Enter |
| llarg | Llarg |
| doble | Doble |
Per convertir les primitives en objectes i objectes en primitives, disposem de tècniques anomenades 'autoboxing' i 'boxa' respectivament. Ase Java és un llenguatge de programació orientat a objectes, sempre tractem objectes i també tenim moltes funcions com ara Col·leccions, Serialització , etc. que també necessiten objectes i tipus primitius.
Per tant, és imprescindible que sempre necessitem objectes i tipus primitius a Java i, per tant, necessitem aquestes tècniques d’autoboxing i unboxing.
Autoboxing
Autoboxing és una tècnica per convertir automàticament un tipus de dades primitiu en un objecte de la seva classe d’embolcall corresponent. Per exemple , la conversió d’int a classe sencera, caràcter a classe de caràcters, etc. són casos d’autoboxing.
Nota: Les classes Wrapper utilitzen el mètode valueOf () per convertir la primitiva en objectes que es deprecien des de Java 5.
Unboxing
La conversió inversa d'objectes de classe wrapper en els seus corresponents tipus de dades primitives s'anomena 'unboxing'.
Nota: Des de Java 5, el mètode intValue () que converteix l'objecte wrapper en un tipus primitiu es deprecia.
A continuació es mostra un exemple de boxa / unboxing.
public class Main { public static void main(String args()){ //Convert int to Integer : boxing int num=20; Integer int_class= Integer.valueOf(num);//explicit conversion from int to Integer Integer inum=num;//autoboxing System.out.println('int => Integer: ' + num+' => '+inum); //Convert Integer to int: unboxing Integer val=new Integer (3); int ival=val.intValue();//explicit conversion from Integer to int int jval=val;//unboxing System.out.println('Integer => int:' + val+' => '+jval); } } Sortida
El programa anterior mostra la caixa automàtica i la desconnexió del valor int. Primer, convertim int a objecte sencer i després es converteix un objecte sencer al tipus de dades int.
Implantem un programa que demostri les classes de wrapper presents a Java.
public class Main { public static void main(String args()) { byte bbyte=10; short sshort=20; int iint=300; long llong=400; float ffloat=3.14F; double ddouble=77.2D; char cchar='A'; boolean bboolean=true; //Convert primitives into objects => Autoboxing Byte byteobj=bbyte; Short shortobj=sshort; Integer intobj=iint; Long longobj=llong; Float floatobj=ffloat; Double doubleobj=ddouble; Character charobj=cchar; Boolean boolobj=bboolean; //Print converted objects System.out.println('Primitives converted to Objects:'); System.out.println('Byte object: '+byteobj); System.out.println('Short object: '+shortobj); System.out.println('Integer object: '+intobj); System.out.println('Long object: '+longobj); System.out.println('Float object: '+floatobj); System.out.println('Double object: '+doubleobj); System.out.println('Character object: '+charobj); System.out.println('Boolean object: '+boolobj); //Convert Objects to Primitives => Unboxing byte bytevalue=byteobj; short shortvalue=shortobj; int intvalue=intobj; long longvalue=longobj; float floatvalue=floatobj; double doublevalue=doubleobj; char charvalue=charobj; boolean boolvalue=boolobj; //Print primitives System.out.println('Converting Objects to Primitives'); System.out.println('byte value: '+bytevalue); System.out.println('short value: '+shortvalue); System.out.println('int value: '+intvalue); System.out.println('long value: '+longvalue); System.out.println('float value: '+floatvalue); System.out.println('double value: '+doublevalue); System.out.println('char value: '+charvalue); System.out.println('boolean value: '+boolvalue); } } Sortida
La sortida del programa anterior mostra la conversió de tipus primitius a objectes wrapper (Autoboxing) i inverteix la conversió d’objectes wrapper a tipus primitius (unboxing).
Preguntes freqüents
P # 1) Quin és el tipus de classe de dades a Java?
Resposta: Java proporciona una classe anomenada 'Class' que conté informació sobre totes les classes, objectes i interfícies de l'aplicació en execució. La classe Class també representa els tipus de dades primitius i el tipus de buit.
La classe Class és una part del paquet java.lang.
Q # 2) Què és la classe normal a Java?
etl test de preguntes i respostes de l'entrevista pdf
Resposta: Una classe normal a Java és una classe no estàtica. Podem crear objectes d’una classe normal amb la nova paraula clau. A més, qualsevol classe normal pot tenir una altra classe com a membre. En aquest cas, la classe membre s’anomena classe imbricada o interna i la classe adjunta es diu classe externa.
P # 3) La cadena és una classe Wrapper a Java?
Resposta: No, String no és una classe d'embolcall a Java. Perquè una classe sigui una classe d’embolcall, necessitem el seu tipus primitiu corresponent. Per exemple, per a la classe d'embolcall enter tenim un tipus primitiu int. Per a la classe String, no tenim un tipus de dades primitiu corresponent.
P # 4) Quin avantatge té Wrapper Class?
Resposta: Les classes Wrapper s’utilitzen per a la conversió de tipus de dades primitives a objectes. Dit d’una altra manera, les classes d’embolcall envolten tipus primitius en objectes. Les classes Wrapper s’utilitzen quan determinades funcions de Java, com ara les col·leccions, només esperen objectes i no tipus de dades primitives.
P # 5) Per què s'utilitza la classe Singleton a Java?
Resposta: Sempre que volem un punt d’accés global per a un objecte concret, anem per un patró de singleton que ens permeti dissenyar una classe de singleton en què només hi haurà una instància. Les classes Singleton s’utilitzen en memòries cau, agrupació de fils, aplicacions de bases de dades, registre, etc.
Conclusió
En aquest tutorial, hem tractat els diversos tipus de classes utilitzats a Java. Vam veure els tipus de classes concrets, abstractes, finals, estàtics, Nested, POJO, etc. A part d'això, també vam discutir les classes de Singleton i Immutable, i també vam discutir els seus exemples d'implementació.
També vam tractar les classes de wrapper i les classes d'objectes a Java. Les classes Wrapper són les classes que envolten els tipus de dades primitives de Java en objectes. La classe d'objectes a Java és la superclasse de totes les altres classes. És la classe més alta de la jerarquia de Java.
Ara que hem debatut sobre les classes i els objectes en Java i els tipus de classes, en el següent tutorial procedirem amb una discussió detallada sobre els constructors en Java.
=> Consulteu la guia de formació Java perfecta aquí.
Lectura recomanada
- Interfície Java i tutoria de classes abstractes amb exemples
- Conceptes bàsics de Java: sintaxi de Java, Java Class i conceptes bàsics de Java
- Què és la paraula clau estàtica a Java?
- Java Integer i Java BigInteger Class amb exemples
- Tutorial de classe Java Scanner amb exemples
- Objecte Java Class Vs: com s'utilitza la classe i l'objecte a Java
- Tutorial de classe Java Array: classe java.util.Arrays amb exemples
- Què és Java Vector | Tutorial de Java Vector Class amb exemples