Menu

Costruttori privati, astratti, array e stringhe in Java

private abstract array

Prova Il Nostro Strumento Per Eliminare I Problemi

Questo tutorial discuterà costruttori speciali come il costruttore privato in Java, Abstract, String, Array, Interface e Destructor in Java:

Nel nostro ultimo tutorial sui costruttori in Java, abbiamo imparato i concetti importanti relativi ai costruttori in Java. Abbiamo discusso come creare un costruttore e le regole per definire i costruttori, insieme ai tipi di costruttori, ecc.

Abbiamo anche imparato il sovraccarico dei costruttori e il concatenamento dei costruttori. Ora, parliamo di alcuni costruttori speciali come un costruttore privato, un costruttore astratto e costruttori di stringhe e array in Java. Quindi discuteremo dei distruttori in Java e, infine, esploreremo le differenze tra metodo e costruttori.

=> Dai un'occhiata alla guida per principianti di Java qui.

Costruttori privati ​​e astratti in Java

Cominciamo con un costruttore privato in Java.

Cosa imparerai:

Costruttore privato in Java

Come già accennato, i costruttori nella classe Java possono avere specificatori di accesso associati ad essi. Quindi, possiamo avere costruttori privati ​​o pubblici. Discuteremo di più sugli specificatori di accesso nei nostri tutorial successivi e rivisiteremo anche i costruttori ancora una volta.

Quando il costruttore viene dichiarato privato, è possibile accedervi solo all'interno della classe. Non può accedere alle classi derivate tramite un'altra classe. Quindi dobbiamo fornire un metodo pubblico nella classe che abbia costruttori privati ​​in modo che questo metodo pubblico possa accedere ai costruttori privati.

In Java il costruttore privato può essere utilizzato nelle seguenti situazioni:

  • Per l'implementazione di singleton.
  • Per incorporare metodi di fabbrica.
  • Per classi che hanno solo membri statici (variabili e metodi).
  • Per classi con membri finali. (costanti - finale e statico).
  • Per usare enumerazioni indipendenti dai tipi.

Come esempio , facciamo un corso di singleton. Una classe singleton è una classe che consente solo un oggetto alla volta. Possiamo usare il costruttore privato per assicurarci di non consentire la creazione di più di un oggetto.

Il programma seguente implementa una classe singleton utilizzando un costruttore privato.

class SingleTonClass { //Static Class Reference private static SingleTonClass obj=null; private SingleTonClass(){ System.out.println('SingleTonClass::Private constructor'); } public static SingleTonClass create_object(){ //logic to create only one instance if(obj==null){ obj= new SingleTonClass(); } return obj; } public void display(){ System.out.println('This is SingleTonClass !!'); } } class Main { public static void main(String args()){ //cannot call private constructor directly. SingleTonClass myobject= SingleTonClass.create_object(); myobject.display(); } }

Produzione:

Costruttore privato in Java

Il programma precedente dichiara una classe singleton. Abbiamo fornito un costruttore privato e un metodo pubblico per accedere al costruttore privato e anche per limitare il numero di oggetti a uno solo. Nel metodo principale, eseguiamo il metodo pubblico per creare un oggetto di classe singleton.

Costruttore di classi astratte in Java

Classe astratta in Java come C ++ tranne per il fatto che, a differenza di C ++, abbiamo una parola chiave astratta in Java utilizzata per dichiarare una classe astratta. Le classi astratte in Java possono avere costruttori. Questo costruttore di classi astratte viene chiamato quando creiamo un'istanza di una classe di implementazione (che eredita la classe astratta).

Considera il seguente esempio di un costruttore di classi astratte.

//abstract class declaration abstract class BaseClass { BaseClass() { System.out.println('BaseClass::Constructor Called'); } abstract void func1(); } class DerivedClass extends BaseClass { DerivedClass() { System.out.println('DerivedClass::Constructor Called'); } void func1() { System.out.println('DerivedClass::func1() called'); } } class Main { public static void main(String args()) { DerivedClass d = new DerivedClass(); } }

Produzione:

Costruttore di classi astratte in Java - output

Poiché una classe astratta non può essere istanziata, ereditiamo una nuova classe da questa classe astratta. L'output del programma mostra che quando creiamo un oggetto della classe derivata nel metodo principale, viene chiamato per primo il costruttore della classe astratta, seguito da un costruttore della classe derivata.

Costruttore di interfaccia in Java

Le interfacce in Java sono simili alle classi astratte. Le interfacce sono per impostazione predefinita un abstract pubblico e hanno solo prototipi di metodo. Questi prototipi vengono poi implementati nella classe che implementa l'interfaccia.

Quindi i costruttori sono presenti in Interfaces?

No. Le interfacce non hanno costruttori. Questo perché i metodi in un'interfaccia sono solo prototipi e quindi non abbiamo bisogno di istanziare o creare un oggetto dell'interfaccia poiché non lo useremo affatto. Quindi non è necessario nemmeno avere un costruttore nell'interfaccia.

Il seguente programma Java dimostra questa logica.

//interface declaration interface Interface_Add{ public int addNumbers(int num1, int num2); //method prototype } class AddClass implements Interface_Add{ public int addNumbers(int num1, int num2){ //method implementation int result= num1+num2; return result; } } class Main{ public static void main(String args()) { AddClass obj= new AddClass(); System.out.println('Result of addition:' + obj.addNumbers(2, 3)); } }

Produzione:

Costruttore dell

Qui abbiamo un'interfaccia 'Interface_add' con un prototipo di metodo 'addNumbers'. Quindi una classe 'AddClass' implementa questa interfaccia e anche il metodo addNumbers.

Nel metodo principale, la classe viene istanziata e il metodo viene eseguito. Quindi non vediamo alcuna necessità di un costruttore in questa interfaccia.

Ora parliamo dei costruttori di alcune classi preesistenti in String e Array simili a Java.

Costruttore di stringhe in Java

Un oggetto stringa in Java può essere definito come un oggetto della classe String. La classe String fornisce i seguenti costruttori per creare e inizializzare oggetti String.

Alcuni di questi costruttori sono discussi di seguito:

# 1) Stringa (byte () myArray)

Costruisce un nuovo oggetto String da un dato array di byte. Per costruire l'oggetto stringa, utilizza il set di caratteri della piattaforma predefinito e decodifica l'array di byte.

Esempio:

byte() myArray = {65, 66, 67, 68, 69}; String str =new String(myArray); //ABCDE

# 2) Stringa (byte () myArray, set di caratteri char_set)

Questo costruttore costruisce un nuovo oggetto stringa utilizzando char_set specificato nella chiamata al costruttore per decodificare l'array di byte.

gateway predefinito non disponibile Windows 10 2019

Esempio:

byte() myArray = {65, 66, 67, 68, 69}; Charset cs = Charset.defaultCharset(); String str = new String(myArray, cs); //ABCDE

# 3) String (char () myArray)

Possiamo costruire un oggetto String da un array di caratteri.

Esempio:

char myArray() = {'P', 'a', 'r', 'i', 's'}; String s = new String(myArray); //Paris

# 4) String (char () myArray, int start_index, int count)

Qui, costruiamo un oggetto String da un array di caratteri includendo il numero di caratteri da start_index fino al conteggio.

Esempio:

char myArray() = {'P', 'a', 'r', 'i', 's'}; String s = new String(myArray, 0,2); //Pa

# 5) String (int () intArray, int offset, int count)

Il costruttore precedente alloca un nuovo oggetto String da un array int. Il numero di caratteri nella stringa è definito da offset e count.

Esempio:

int() intArray = {65, 69,73,79,85 }; String s = new String (intArray, 0, 5); //AEIOU

# 6) String (StringBuffer strbuffer)

In questo costruttore, un nuovo oggetto String viene costruito da un oggetto StringBuffer.

Esempio:

StringBuffer strbuffer = new StringBuffer('SoftwareTestingHelp'); String s = new String (strbuffer); //SoftwareTestingHelp

# 7) String (StringBuilder strbuilder)

Un nuovo oggetto String viene creato utilizzando l'oggetto StringBuilder.

Esempio:

StringBuilder strbuilder = new StringBuilder('SoftwareTestingHelp'); String s = new String(strbuilder); // SoftwareTestingHelp

Costruttori di array in Java

Gli array utilizzano i costruttori per creare e inizializzare gli array utilizzando una nuova parola chiave come mostrato di seguito.

int() data = new int(4);

L'istruzione precedente inizializza un array di 4 elementi sul valore predefinito 0.

Di seguito viene fornito un altro modo per inizializzare l'array:

int() data = new int(){2, 4, 6, 8};

Distruttore in Java

Finora abbiamo visto costruttori in Java che utilizzano i quali creiamo un oggetto. Quando l'oggetto ha terminato il suo lavoro e non è più necessario, la memoria allocata all'oggetto deve essere rilasciata o deallocata. Questo è il lavoro di un distruttore in Java.

In Java, Garbage Collector è responsabile del rilascio degli oggetti che non sono più in uso o sono diventati irraggiungibili. I distruttori in Java sono chiamati finalizzatori e non sono deterministici in modo tale che non possiamo garantire che verranno eseguiti.

In Java, non dobbiamo preoccuparci dei distruttori. I distruttori non hanno una sintassi specifica in Java. Gli oggetti vengono distrutti ma non chiamiamo distruttore nel modo in cui lo chiamiamo in C ++.

Come accennato in precedenza, il lavoro del distruttore è svolto dal finalizzatore che viene chiamato dal Garbage Collector.

domande e risposte all'intervista con gli analisti del supporto tecnico

Il metodo finalizer in Java è illustrato di seguito come riferimento.

class Main { public static void main(String() args) { Main dm = new Main(); //create object dm = null; System.gc(); //call garbage collector System.out.println('Main Mathod'); } protected void finalize() //finalize method { System.out.println('Finalize method :: object is garbage collected'); } }

Produzione:

Distruttore in Java

Nel programma sopra, creiamo un oggetto classe. Impostalo su null e quindi chiamiamo il metodo System.gc (). Ora quell'oggetto è irraggiungibile e il metodo finalize (distruttore) viene chiamato implicitamente.

Metodo costruttore vs in Java

Tabularizziamo alcune delle differenze tra un costruttore e un metodo in Java.

CostruttoriMetodo
Crea un nuovo oggetto.Opera su un oggetto già esistente.
Un blocco di codice utilizzato per inizializzare i membri della classe durante la creazione di un oggetto.Una raccolta di istruzioni di programmazione che generano un risultato quando vengono eseguite.
Utilizzato per eseguire l'inizializzazione degli oggetti.Una sequenza di istruzioni che vengono eseguite da Java. Può contenere o meno una routine di inizializzazione.
Invocato implicitamente.Deve essere invocato esplicitamente in un programma.
Richiamato quando viene creato un nuovo oggetto utilizzando la nuova parola chiave.Richiamato quando il metodo viene chiamato dal programmatore.
Ha lo stesso nome di quello di una classe.Può avere qualsiasi nome consentito dal linguaggio di programmazione.
Non ha un tipo di ritorno.Deve avere un tipo di ritorno altrimenti dovrebbe restituire void.
Una classe può avere molti costruttori sovraccaricati.La classe può avere metodi di overload e distinti.
Non può essere ereditato dalla classe figlia.Può essere ereditato dalla classe figlio e persino sovrascritto.

Domande frequenti

D # 1) I costruttori possono essere privati?

Risposta: Sì. I costruttori in Java possono essere privati. Tutte le classi, comprese le classi astratte, possono avere costruttori privati. Usando costruttori privati ​​possiamo impedire che la classe venga istanziata o possiamo limitare il numero di oggetti di quella classe.

D # 2) Qual è l'uso di Abstract Class Constructor in Java?

Risposta: Quando creiamo un oggetto della classe derivata che eredita la classe astratta, viene richiamato un costruttore di classi astratte. Inoltre, se la classe astratta ha alcune variabili membro, possiamo inizializzarle nel costruttore della classe astratta.

D # 3) Possiamo definire un costruttore parametrizzato in una classe astratta in Java?

Risposta: Sì, possiamo avere un costruttore parametrizzato in una classe astratta. Quindi possiamo chiamare questo costruttore dalla classe derivata che ha ereditato la classe astratta usando la chiamata super ().

D # 4) Sai perché non esiste un Destructor in Java?

Risposta: Java non ha bisogno di un distruttore specifico in quanto ha il suo garbage collector. Questo garbage collector distrugge gli oggetti irraggiungibili e libera la memoria. Un metodo chiamato finalize è anche una parte del garbage collector che viene eseguito in modo non deterministico e svolge la funzione di distruttore come liberare le risorse ecc.

D # 5) La classe astratta può avere un corpo?

Risposta: No. Una classe astratta può avere solo dichiarazioni di metodi e costruttori. I suoi metodi non sono implementati. La classe che eredita questa classe astratta implementa i metodi. Oltre al prototipo o alle dichiarazioni, può anche avere visibilità o specificatori di accesso.

Conclusione

Questo completa il nostro tutorial sui costruttori in Java. Qui abbiamo coperto la definizione, la creazione e i tipi di costruttori. Abbiamo anche discusso del sovraccarico dei costruttori e del concatenamento dei costruttori in Java.

Abbiamo esplorato costruttori astratti e privati ​​in Java e abbiamo appreso perché le interfacce non possono avere costruttori. Abbiamo visto costruttori che vengono utilizzati nelle classi array e String.

Abbiamo anche discusso dei distruttori in Java che svolgono la funzione opposta a quella dei costruttori. I costruttori creano oggetti mentre i distruttori distruggono oggetti. In Java, la funzione distruttore viene eseguita dal finalizzatore che viene eseguito durante la garbage collection.

Pertanto, non abbiamo un distruttore specifico in Java e non è necessario definirlo nel modo in cui lo facciamo in C ++. Abbiamo anche discusso le differenze tra metodo e costruttore. Sappiamo che il costruttore non è la stessa cosa di un metodo, ma possiamo vedere il costruttore come un metodo speciale.

=> Leggere attraverso la serie di formazione Easy Java.

Lettura consigliata

^