types classes java
Questo tutorial discuterà vari tipi di classi in Java come Abstract, Concrete, Final, Inner, POJO, Static e altre classi speciali con esempi:
Nel nostro precedente tutorial, abbiamo discusso di classi e oggetti in Java. Una classe in Java è un modello o un progetto. Può anche essere definito come una raccolta di oggetti simili. Definiamo oggetti di tipo classe e quindi comunichiamo tramite questi oggetti.
Ogni oggetto è un'istanza di una classe che ha uno stato e un comportamento.
=> Visita qui per l'esclusiva serie di tutorial di formazione Java.
Cosa imparerai:
- Tipi di classi in Java - Introduzione
- Tipi di classi in Java
- Altre classi speciali in Java
- Conclusione
Tipi di classi in Java - Introduzione
Sappiamo tutti che la classe ha i seguenti componenti:
- Modificatori: Specifica l'accesso per la classe.
- Nome della classe: Nome della classe.
- Parole chiave: Parole chiave che suggeriscono se una classe estende o implementa una classe o un'interfaccia.
- Il corpo della classe racchiuso tra parentesi graffe {}
A seconda dei diversi modificatori utilizzati, del corpo della classe specificato e delle parole chiave utilizzate, abbiamo vari tipi di classi in Java.
spettacoli anime gratuiti da guardare online
- Classe calcestruzzo: Una classe normale che ha l'implementazione concreta di metodi.
- Classe POJO: Questo è 'Plain Old Java Object' contenente solo variabili membro private e metodi getter setter per accedere a queste variabili.
- Classe astratta: Questa classe ha uno o più metodi astratti.
- Classe finale: Una classe finale non può essere ereditata.
- Classe statica: Una classe contenente solo membri statici.
- Classe interna: Una classe interna è una classe che è un membro di un'altra classe.
In questo tutorial, discuteremo ciascuno di questi tipi di classe con esempi.
Discuteremo anche alcuni altri tipi di classi che sono considerate classi speciali in Java.
- Classe anonima: Una classe senza nome.
- Classe immutabile: Una classe il cui oggetto non può essere modificato.
- Classe Singleton: Una classe la cui singola istanza può essere creata.
- Classe oggetto: La classe base di tutte le funzionalità Java.
- Classe wrapper: Ogni tipo di dati primitivo in Java ha una classe wrapper.
Ma prima, esaminiamo brevemente come importare una classe in Java insieme alla classe Main in Java che contiene il metodo principale o il punto di partenza in Java.
Importa in Java
In Java, se vogliamo includere qualsiasi caratteristica o funzionalità nel nostro programma, possiamo usare l'istruzione 'import'. Usando l'istruzione import possiamo importare un intero pacchetto e usarne le funzionalità nel nostro programma oppure possiamo anche includere una singola classe.
Di seguito è riportata la sintassi per l'istruzione import.
import packageName/classname; Se vogliamo importare il pacchetto java.lang e tutte le sue classi, possiamo scrivere la seguente dichiarazione:
import java.lang.*; Supponiamo di voler includere la funzionalità della classe Arrays nel nostro programma, quindi possiamo scrivere la seguente dichiarazione:
import java.util.Arrays; L'istruzione import è equivalente all'istruzione include C / C ++. L'istruzione import viene inserita all'inizio del programma Java come prima istruzione. Possiamo avere più di una dichiarazione nel programma Java.
Classe principale in Java
Sappiamo già che in Java il metodo main () è il punto di partenza dell'esecuzione di qualsiasi programma e può essere inserito in qualsiasi classe di quella particolare applicazione. Tuttavia, se abbiamo un'applicazione complessa con troppi file e classi, è consigliabile avere una classe Main e inserire il metodo main () in questa classe Main.
class Main{ public static void main(String() args){ System.out.println(“Hello, World!”); } } Notare che la JVM non crea un oggetto della classe Main. La logica alla base di questo è che, poiché main () è un metodo statico, può essere chiamato senza alcun oggetto classe.
Tipi di classi in Java
Passiamo ora ai tipi di classi in Java. Spiegheremo ognuna di queste classi una per una seguita dagli esempi di programmazione.
# 1) Classe calcestruzzo
Una classe concreta è una qualsiasi classe normale in un programma Java. Questa classe non avrà metodi astratti. Tutti i metodi nella classe concrete sono completamente implementati.
Una classe concreta può ereditare da un'altra classe, anche una classe astratta o implementare un'interfaccia. Possiamo istanziare la classe concreta e creare i suoi oggetti.
Di seguito è mostrato un semplice esempio di una 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); } } Produzione
Il programma sopra mostra una classe concreta. Vediamo che questa classe ha un'implementazione completa. Non c'è nulla di incompleto o non implementato.
# 2) Classe POJO
Un POJO (Plain Old Java Object) è una classe contenente solo variabili membro private. Oltre alle variabili membro private, contiene solo metodi getter e setter usati da queste variabili membro.
Una classe POJO non ha il suo comportamento. Tuttavia, potrebbe sovrascrivere alcuni metodi come uguale o interfacce.
Proprietà della classe POJO:
- La classe POJO deve avere un metodo getter e setter pubblico.
- Tutti i membri o le variabili di istanza devono essere privati.
- La classe POJO non estende o implementa classi o interfacce pre-specificate.
- Non contengono annotazioni pre-specificate.
- Non ha un costruttore senza argomenti (costruttore senza argomenti).
Di seguito è riportato un programma Java che dimostra 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()); } } Produzione
La dimostrazione sopra della classe POJO mostra che ha una variabile privata e i metodi getter setter per questa variabile. Per accedere a questa variabile membro, utilizziamo il metodo getter. Il metodo setter viene utilizzato per aggiornare il valore.
# 3) Classe astratta
Una classe astratta è una classe incompleta o la cui implementazione non è stata completata. Non è possibile creare un'istanza di una classe astratta. Deve essere esteso dalle altre classi e implementare i suoi metodi per formare una classe concreta.
Una classe astratta viene dichiarata utilizzando la parola chiave 'abstract'. Una classe astratta può avere metodi statici e finali, nonché costruttori.
Dimostriamo una classe astratta in 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); } }Produzione
Nel programma sopra, abbiamo un'interfaccia moltiplicata. Creiamo un prodotto di classe astratta che implementa un'interfaccia multipla. All'interno del prodotto, abbiamo un prodotto metodo che non è implementato. Quindi abbiamo una classe Main che eredita la classe Product e implementa il metodo del prodotto. Successivamente, chiameremo questo metodo sull'oggetto della classe Main.
# 4) Classe statica
Una statica in Java in generale indica l'oggetto che appartiene a una classe e non alle singole istanze. Quindi non è necessario accedere a un membro o metodo statico in Java con un oggetto ma utilizzando direttamente un nome di classe.
Una classe statica in Java può contenere solo membri statici. Inoltre, non possiamo creare un'istanza di una classe statica.
Il seguente programma Java mostra una classe statica.
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 } } Produzione
La classe sopra mostra la classe statica. Qui abbiamo una classe statica che è un membro di un'altra classe concreta. All'interno della classe statica, calcoliamo la somma di due numeri e memorizziamo il risultato in una variabile statica che è un membro della classe esterna.
# 5) Classe finale
Una classe finale è una classe che non può essere ereditata o sottoclasse. Una volta che una classe è dichiarata finale in Java, è una sorta di costante e diventa immutabile.
Quindi per rendere una classe immutabile, dobbiamo dichiararla come finale.
//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(); } } Produzione
Il programma sopra prima dichiara una Base_Class che è contrassegnata come 'finale'. Quindi, quando proviamo ad estenderlo in Derived_Class, otteniamo un errore del compilatore. (La riga commentata). Ma possiamo creare il suo oggetto e chiamare il metodo Display.
# 6) Classe annidata / Classe interna
La classe annidata, nota anche come classe interna in Java, viene utilizzata per migliorare l'incapsulamento. Una classe nidificata / classe interna è una classe racchiusa all'interno di un'altra classe.
Proprio come una classe ha variabili e metodi come membri, può anche avere una classe interna come membro.
Una classe nidificata ha la struttura seguente:
class OuterClass{ class NestedClass{ //nested class code… } //outerclass code… } Le classi interne hanno i seguenti sottotipi:
strumenti di test delle API resto open source
- Classe interna annidata
- Metodo Classe interna locale
- Classe interna anonima
- Statico Classe annidata
# 1) Classe interna annidata
Una classe interna nidificata ha accesso alle variabili membro private di una classe esterna. Possiamo anche applicare modificatori di accesso alla classe interna annidata.
# 2) Metodo Classe Interna Locale
Questa è la classe interna dichiarata all'interno di un metodo della classe esterna.
# 3) Classe interna anonima
La classe interna anonima è una classe interna dichiarata all'interno di una classe esterna ed è senza nome.
# 4) Classe annidata statica
Nel modo in cui una classe ha una variabile membro statica, può anche avere una classe statica come membro.
Di seguito viene fornito un esempio di una classe annidata / 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'); } } Produzione
Altre classi speciali in Java
Classe immutabile in Java
Una classe immutabile genera oggetti immutabili. Un oggetto immutabile è un oggetto il cui contenuto non può essere modificato una volta creato l'oggetto. Quindi una classe immutabile è quella il cui oggetto non può essere modificato una volta creato.
Tutte le classi wrapper in Java per i tipi primitivi (Integer, Boolean, Byte, ecc.) Sono immutabili. Anche la classe String è immutabile.
Possiamo anche avere classi immutabili definite dall'utente in Java.
Affinché una classe sia immutabile, deve essere dichiarata finale insieme a tutti i suoi membri dati. Inoltre, la classe dovrebbe avere un costruttore parametrizzato. Tutte le variabili membro dovrebbero avere un metodo getter ma non un metodo setter.
Tutti i requisiti di cui sopra devono essere soddisfatti affinché una classe sia immutabile.
Implementiamo un programma Java per dimostrare la classe immutabile.
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 } } Produzione
Nel programma precedente, abbiamo dichiarato una classe City. Questa è una classe finale e in questa classe abbiamo dichiarato due variabili membro e un costruttore parametrizzato. Abbiamo anche dichiarato metodi getter per queste due variabili membro. Quindi la classe City soddisfa tutti i requisiti di una classe immutabile.
Notare la riga di codice commentata nel metodo principale. Se rimuoviamo il commento da questa riga, otterremo un errore del compilatore (fornito nel commento qui) poiché stiamo cercando di impostare il valore per una variabile membro.
Classe Singleton in Java
Una classe singleton consente una singola istanza alla volta. In Java, un singleton è un modello di progettazione. Questo modello di progettazione garantisce che esista solo un'istanza di una classe in qualsiasi momento. Quindi ogni classe definita come singleton ha un unico punto di accesso ed è globale.
Si noti che la fine del ciclo di vita dell'applicazione non distrugge una classe singleton come le classi normali. Quando una classe viene dichiarata singleton, non creiamo una nuova istanza ogni volta che viene effettuata una nuova richiesta per l'oggetto.
La stessa istanza viene utilizzata più volte. In questo modo possiamo risparmiare lo spazio di memoria principalmente in caso di applicazioni multi-thread e database.
Possiamo usare una classe singleton per attività come la memorizzazione nella cache, la registrazione, ecc.
Il seguente programma mostra una classe 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); } } Produzione
Nel programma precedente, abbiamo definito una classe singleton con un costruttore privato. Abbiamo definito una variabile membro di tipo String. Nel metodo main dichiariamo due istanze della classe singleton. Quindi cambiamo la variabile String usando una delle istanze.
Quando stampiamo il valore String per entrambe le istanze, notiamo che il valore della variabile String è cambiato per entrambe le istanze. Quindi, anche se abbiamo modificato il valore solo per un'istanza, a causa della classe singleton, le modifiche si riflettono in tutte le istanze.
Restituiamo sempre la stessa istanza anche se sembra che creiamo istanze diverse.
Classe di oggetti in Java
La classe Object è la classe genitore o la prima classe in Java. Si trova al livello più alto della gerarchia Java.
Poiché tutte le classi hanno la classe Object come superclasse, tutti gli oggetti Java inclusi gli Arrays implementano i metodi della classe Object. La classe oggetto è presente nel pacchetto 'java.lang'.
La dichiarazione per java.lang.Object è:
oggetto di classe pubblica
La tabella seguente descrive i costruttori e i metodi della classe Object.
| Costruttore / Metodo | Descrizione |
|---|---|
| Classe getClass () | Restituisce la classe di runtime dell'oggetto. |
| Costruttore di classi di oggetti | |
| Oggetto() | Costruttore di classi di oggetti |
| Metodi della classe di oggetti | |
| oggetto protetto clone () | Restituisce un clone o una copia dell'oggetto. |
| booleano è uguale a (Object obj) | Controlla se un dato oggetto obj è uguale a questo oggetto. |
| protetto void finalize () | Chiamato dal Garbage Collector quando tutti i riferimenti all'oggetto vengono eliminati. |
| int hashCode () | Restituisce il codice hash per l'oggetto. |
| void notify () | Utilizzare per riattivare un singolo thread in attesa. |
| void notifyAll () | Riattiva tutti i thread in attesa. |
| String toString () | Restituisce l'equivalente String dell'oggetto. |
| void wait () | Fa in modo che un thread attenda fino a quando non viene svegliato dal metodo di notifica da un altro thread. |
| void wait (timeout lungo) | Fa in modo che il thread attenda fino allo scadere del tempo fornito da 'timeout' o fino a quando non viene riattivato dai metodi notify o notifyAll. |
| void wait (timeout lungo, int nanos) | Fa in modo che il thread attenda fino allo scadere del tempo specificato o fino a quando notify () o notifyAll () vengono richiamati da un altro thread. |
Implementiamo un esempio di programma Java che dimostrerà alcuni dei metodi della 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.'); } } Produzione
Qui abbiamo una classe principale. Nel metodo main () creiamo un oggetto della classe Main. Questo oggetto è un discendente della classe Object e supporta tutti i metodi della classe Object. Quindi usiamo questo oggetto e chiamiamo alcuni metodi della classe Object come hashCode (), System.GC (), finalize () ecc.
Classe wrapper in Java
Java fornisce una funzionalità chiamata classe wrapper che ha un meccanismo che converte il tipo di dati primitivo in oggetto e viceversa. Le classi wrapper sono le classi che rappresentano tipi primitivi come int, char, ecc. Come oggetti.
Pertanto ogni tipo di dati primitivo in Java ha la sua classe wrapper corrispondente.
La tabella seguente mostra i tipi di dati primitivi e la loro classe wrapper equivalente.
| Tipo primitivo | Tipo di wrapper |
|---|---|
| galleggiante | Galleggiante |
| booleano | Booleano |
| char | Personaggio |
| byte | Byte |
| corto | Corto |
| int | Numero intero |
| lungo | Lungo |
| Doppio | Doppio |
Per convertire le primitive in oggetti e gli oggetti in primitive, abbiamo delle tecniche chiamate rispettivamente 'autoboxing' e 'boxing'. Ase Java è un linguaggio di programmazione orientato agli oggetti, ci occupiamo sempre di oggetti e abbiamo anche molte funzionalità come Collezioni, Serializzazione , ecc. che richiedono anche oggetti e tipi primitivi.
Quindi è imperativo che abbiamo sempre bisogno di oggetti e tipi primitivi in Java e quindi abbiamo bisogno di queste tecniche di autoboxing e unboxing.
miglior editor python per mac os x
Boxing automatico
L'autoboxing è una tecnica per convertire automaticamente un tipo di dati primitivo in un oggetto della sua classe wrapper corrispondente. Per esempio , la conversione di int in classe Integer, char in classe Character, ecc. sono istanze di autoboxing.
Nota: Le classi wrapper utilizzano il metodo valueOf () per convertire la primitiva in oggetti che sono stati svalutati a partire da Java 5.
Spacchettamento
La conversione inversa degli oggetti della classe wrapper nei corrispondenti tipi di dati primitivi è chiamata 'unboxing'.
Nota: A partire da Java 5, il metodo intValue () che converte l'oggetto wrapper in un tipo primitivo è sconsigliato.
Di seguito è riportato un esempio di boxe / 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); } } Produzione
Il programma sopra mostra l'autoboxing e unboxing sul valore int. Innanzitutto, convertiamo int in oggetto Integer e quindi un oggetto Integer viene convertito nel tipo di dati int.
Implementiamo un programma che dimostri le classi wrapper presenti in 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); } } Produzione
L'output del programma precedente mostra la conversione da tipi primitivi a oggetti wrapper (Autoboxing) e inverte la conversione da oggetti wrapper a tipi primitivi (unboxing).
Domande frequenti
D # 1) Qual è il tipo di dati della classe in Java?
Risposta: Java fornisce una classe denominata 'Class' che contiene informazioni su tutte le classi, gli oggetti e le interfacce dell'applicazione in esecuzione. La classe Class rappresenta anche i tipi di dati primitivi e il tipo void.
La classe Class fa parte del pacchetto java.lang.
D # 2) Cos'è la classe normale in Java?
Risposta: Una classe normale in Java è una classe non statica. Possiamo creare oggetti di una classe normale usando la nuova parola chiave. Inoltre, qualsiasi classe normale può avere un'altra classe come membro. In questo caso, la classe membro è chiamata classe nidificata o interna e la classe che la racchiude è chiamata classe esterna.
D # 3) String è una classe wrapper in Java?
Risposta: No, String non è una classe wrapper in Java. Affinché una classe sia una classe wrapper, abbiamo bisogno del suo tipo primitivo corrispondente. Per esempio, per la classe wrapper Integer abbiamo il tipo primitivo int. Per la classe String, non abbiamo un tipo di dati primitivo corrispondente.
D # 4) Qual è il vantaggio di Wrapper Class?
Risposta: Le classi wrapper vengono utilizzate per la conversione di tipi di dati primitivi in oggetti. In altre parole, le classi wrapper racchiudono i tipi primitivi in oggetti. Le classi wrapper vengono utilizzate quando alcune funzionalità Java come le collezioni si aspettano solo oggetti e non tipi di dati primitivi.
D # 5) Perché la classe Singleton viene utilizzata in Java?
Risposta: Ogni volta che vogliamo un punto di accesso globale per un particolare oggetto, optiamo per un pattern singleton che ci consenta di progettare una classe singleton in cui ci sarà solo un'istanza. Le classi Singleton vengono utilizzate nelle cache, nel pool di thread, nelle applicazioni di database, nella registrazione, ecc.
Conclusione
In questo tutorial, abbiamo coperto i vari tipi di classi utilizzati in Java. Abbiamo visto i tipi di classe concreta, astratta, finale, statica, annidata, POJO, ecc. Oltre a questo, abbiamo anche discusso delle classi Singleton, delle classi immutabili e abbiamo discusso anche dei loro esempi di implementazione.
Abbiamo anche trattato classi wrapper e classi oggetto in Java. Le classi wrapper sono le classi che racchiudono i tipi di dati primitivi di Java in oggetti. La classe di oggetti in Java è la superclasse di tutte le altre classi. È la classe più in alto nella gerarchia Java.
Ora che abbiamo discusso le classi e gli oggetti in Java e i tipi di classe, nel prossimo tutorial procederemo con una discussione dettagliata sui costruttori in Java.
=> Dai un'occhiata alla guida di formazione Java perfetta qui.
Lettura consigliata
- Tutorial sull'interfaccia Java e sulla classe astratta con esempi
- Nozioni di base su Java: sintassi Java, classe Java e concetti principali di Java
- Qual è la parola chiave statica in Java?
- Java Integer e Java BigInteger Class con esempi
- Tutorial di classe per scanner Java con esempi
- Java Class Vs Object - Come utilizzare la classe e l'oggetto in Java
- Tutorial Java Array Class - classe java.util.Arrays con esempi
- Cos'è Java Vector | Tutorial Java Vector Class con esempi