Una class astratta può avere un costruttore?

Una class astratta può avere un costruttore?

Se sì, come può essere usato e per quali scopi?

Sì, una class astratta può avere un costruttore. Considera questo:

abstract class Product { int multiplyBy; public Product( int multiplyBy ) { this.multiplyBy = multiplyBy; } public int mutiply(int val) { return multiplyBy * val; } } class TimesTwo extends Product { public TimesTwo() { super(2); } } class TimesWhat extends Product { public TimesWhat(int what) { super(what); } } 

Il Product superclass è astratto e ha un costruttore. La class concreta TimesTwo ha un costruttore che codifica solo il valore 2. La class concreta TimesWhat ha un costruttore che consente al chiamante di specificare il valore.

I costruttori astratti verranno spesso utilizzati per applicare vincoli di class o invarianti come i campi minimi richiesti per impostare la class.

NOTA: poiché non esiste un costruttore predefinito (o no-arg) nella class astratta genitore, il costruttore utilizzato nella sottoclass deve chiamare esplicitamente il costruttore genitore.

Definisci un costruttore in una class astratta se ti trovi in ​​una di queste situazioni:

  • si desidera eseguire un’inizializzazione (nei campi della class astratta) prima che l’istanziazione di una sottoclass abbia effettivamente luogo
  • hai definito i campi finali nella class astratta ma non li hai inizializzati nella dichiarazione stessa; in questo caso, DEVI avere un costruttore per inizializzare questi campi

Nota che:

  • puoi definire più di un costruttore (con argomenti diversi)
  • puoi (dovresti?) definire tutti i tuoi costruttori protetti (renderli pubblici è inutile comunque)
  • il / i costruttore / i della sottoclass può chiamare un costruttore della class astratta; potrebbe anche doverlo chiamare (se non ci sono costruttori no-arg nella class astratta)

In ogni caso, non dimenticare che se non definisci un costruttore, il compilatore ne genererà automaticamente uno per te (questo è pubblico, non ha argomenti e non fa nulla).

Sì, può avere un costruttore ed è definito e si comporta come qualsiasi altro costruttore di class. Tranne che le classi astratte non possono essere istanziate direttamente, solo estese, quindi l’uso è quindi sempre dal costruttore di una sottoclass.

! Le classi astratte possono avere costruttori !

Sì, quando definiamo una class come class astratta non può essere istanziata, ma ciò non significa che una class astratta non possa avere un costruttore. Ogni class astratta deve avere una sottoclass concreta che implementerà i metodi astratti di quella class astratta.

Quando creiamo un object di qualsiasi sottoclass, tutti i costruttori nella struttura ereditaria corrispondente vengono richiamati nell’approccio dall’alto al basso. Lo stesso caso si applica alle classi astratte. Sebbene non possiamo creare un object di una class astratta, quando creiamo un object di una class che è concreta e sottoclass della class astratta, il costruttore della class astratta viene invocato automaticamente. Quindi possiamo avere un costruttore in classi astratte.

Nota: una class non astratta non può avere metodi astratti ma una class astratta può avere un metodo non astratto. La ragione è simile a quella dei costruttori, con la differenza che invece di essere richiamati automaticamente possiamo chiamare super (). Inoltre, non c’è nulla come un costruttore astratto in quanto non ha alcun senso.

Non solo può farlo, lo fa sempre. Se non ne specifichi uno, allora ha un costruttore no arg predefinito, proprio come qualsiasi altra class. Infatti, TUTTE le classi, incluse le classi nidificate e anonime, otterranno un costruttore predefinito se non ne viene specificato uno (nel caso di classi anonime è imansible specificarne uno, quindi otterrete sempre il costruttore predefinito).

Un buon esempio di una class astratta con un costruttore è la class Calendar . Ottieni un object Calendar chiamando Calendar.getInstance (), ma ha anche costruttori che sono protetti. Il motivo per cui i suoi costruttori sono protetti è che solo le sue sottoclassi possono chiamarli (o classi nello stesso pacchetto, ma poiché è astratto, non si applica). GregorianCalendar è un esempio di una class che estende Calendar.

Sì, i costruttori di classi astratte vengono generalmente utilizzati per chiamate super per eventi di inizializzazione comuni a tutte le sottoclassi

Una class astratta può avere un costruttore MA non è ansible creare un object di class astratta, quindi come si usa quel costruttore?

Il momento in cui si eredita la class astratta nella sottoclass è ansible passare valori al costruttore (dell’estratto) attraverso il metodo super (valore) nella sottoclass e non si eredita un costruttore.

così usando super puoi passare valori in un costruttore della class astratta e per quanto mi ricordo deve essere la prima affermazione nel tuo metodo o costruttore.

Sebbene ci siano molte buone risposte, vorrei dare i miei 2 centesimi.

Il costruttore NON COSTRUISCE L’OGGETTO . È usato per inizializzare un object.

Sì, una class astratta ha sempre un costruttore. Se non si definisce il proprio costruttore, il compilatore assegnerà un costruttore predefinito alla class Abstract. Sopra vale per tutte le classi: nidificate, astratte, anonime, ecc.

Una class astratta (diversamente dall’interfaccia) può avere campi non statici non finali che necessitano di inizializzazione. Puoi scrivere il tuo costruttore nella class astratta per farlo. Ma, in quel caso, non ci sarà alcun costruttore predefinito.

 public abstract class Abs{ int i; int j; public Abs(int i,int j){ this.i = i; this.j = j; System.out.println(i+" "+j); } } 

Fai attenzione mentre estendi sopra la class astratta, devi chiamare esplicitamente super da ogni costruttore. La prima riga di qualsiasi funzione di costruzione chiama super (). se non si chiama esplicitamente super (), Java lo farà per te. Sotto il codice non verrà compilato:

 public class Imp extends Abs{ public Imp(int i, int j,int k, int l){ System.out.println("2 arg"); } } 

Devi usarlo come nell’esempio seguente:

 public class Imp extends Abs{ public Imp(int i, int j,int k, int l){ super(i,j); System.out.println("2 arg"); } } 

Considera questo:

 abstract class Product { int value; public Product( int val ) { value= val; } abstract public int multiply(); } class TimesTwo extends Product { public int mutiply() { return value * 2; } } 

La superclass è astratta e ha un costruttore.

Naturalmente, la class astratta può avere un costruttore. Generalmente il costruttore della class viene utilizzato per inizializzare i campi. Quindi, un costruttore di classi astratte viene utilizzato per inizializzare i campi della class astratta. Fornirebbe un costruttore per una class astratta se si desidera inizializzare determinati campi della class astratta prima che l’istanziazione di una class figlio abbia luogo. Un costruttore di classi astratte può anche essere utilizzato per eseguire codice rilevante per ogni class di figlio. Ciò impedisce la duplicazione del codice.

Non possiamo creare un’istanza di una class astratta, ma possiamo creare istanze di classi derivate dalla class astratta. Quindi, quando viene creata un’istanza della class derivata, viene chiamato automaticamente il costruttore della class astratta genitore.

Riferimento: questo articolo

In una class concreta, la dichiarazione di un costruttore per un tipo concreto Fnord espone efficacemente due cose:

  • Un mezzo attraverso il quale il codice può richiedere la creazione di un’istanza di Fnord

  • Un mezzo mediante il quale un’istanza di un tipo derivata da Fnord che è in costruzione può richiedere l’inizializzazione di tutte le funzionalità di class base.

Mentre ci dovrebbe essere forse un mezzo attraverso il quale queste due abilità potrebbero essere controllate separatamente, per ogni tipo concreto una definizione consentirà entrambe. Sebbene la prima abilità non sia significativa per una class astratta, la seconda abilità è altrettanto significativa per una class astratta come sarebbe per qualsiasi altra, e quindi la sua dichiarazione è altrettanto necessaria e utile.

Come descritto da javafun qui , questo è un esempio:

 public abstract class TestEngine { private String engineId; private String engineName; public TestEngine(String engineId , String engineName) { this.engineId = engineId; this.engineName = engineName; } //public gettors and settors public abstract void scheduleTest(); } public class JavaTestEngine extends TestEngine { private String typeName; public JavaTestEngine(String engineId , String engineName , String typeName) { super(engineId , engineName); this.typeName = typeName; } public void scheduleTest() { //do Stuff } } 

Sì, le classi astratte possono avere costruttori!

Ecco un esempio utilizzando il costruttore in class astratta:

 abstract class Figure { double dim1; double dim2; Figure(double a, double b) { dim1 = a; dim2 = b; } // area is now an abstract method abstract double area(); } class Rectangle extends Figure { Rectangle(double a, double b) { super(a, b); } // override area for rectangle double area() { System.out.println("Inside Area for Rectangle."); return dim1 * dim2; } } class Triangle extends Figure { Triangle(double a, double b) { super(a, b); } // override area for right triangle double area() { System.out.println("Inside Area for Triangle."); return dim1 * dim2 / 2; } } class AbstractAreas { public static void main(String args[]) { // Figure f = new Figure(10, 10); // illegal now Rectangle r = new Rectangle(9, 5); Triangle t = new Triangle(10, 8); Figure figref; // this is OK, no object is created figref = r; System.out.println("Area is " + figref.area()); figref = t; System.out.println("Area is " + figref.area()); } } 

Quindi penso che tu abbia la risposta.

La class astratta può avere un costruttore sebbene non possa essere istanziata. Ma il costruttore definito in una class astratta può essere usato per l’istanziazione della class concreta di questa class astratta. Controlla JLS :

È un errore in fase di compilazione se si tenta di creare un’istanza di una class astratta utilizzando un’espressione di creazione di un’istanza di class .

Una sottoclass di una class astratta che non è essa stessa astratta può essere istanziata, risultando nell’esecuzione di un costruttore per la class astratta e, quindi, l’esecuzione degli inizializzatori di campo per le variabili di istanza di quella class.

sì. E un costruttore di classi astratte viene chiamato quando viene creata un’istanza di una class ereditata. Ad esempio, il seguente è un programma Java valido.

 // An abstract class with constructor abstract class Base { Base() { System.out.println("Base Constructor Called"); } abstract void fun(); } class Derived extends Base { Derived() { System.out.println("Derived Constructor Called"); } void fun() { System.out.println("Derived fun() called"); } } class Main { public static void main(String args[]) { Derived d = new Derived(); } } 

Questo è l’output del codice sopra,

Costruttore di base chiamato costruttore derivato chiamato

riferimenti: inserisci la descrizione del link qui

Poiché una class astratta può avere variabili di tutti i modificatori di accesso, devono essere inizializzate su valori predefiniti, quindi è necessario il costruttore. Mentre istanziate la class figlia, viene invocato un costruttore di una class astratta e le variabili vengono inizializzate.

Al contrario, un’interfaccia contiene solo variabili costanti significa che sono già inizializzate. Quindi l’interfaccia non ha bisogno di un costruttore.

Per ottenere il concatenamento del costruttore, la class astratta avrà un costruttore. Il compilatore mantiene l’istruzione Super () all’interno del costruttore della sottoclass, che chiamerà il costruttore della superclass. Se non ci fossero costruttori per le classi astratte, allora le regole java sono violate e non possiamo ottenere il concatenamento del costruttore.

Sì, una class astratta può avere un costruttore. Puoi sovraccaricare il numero di Costruttori che vuoi in una Classe astratta. Questi contraenti possono essere utilizzati per inizializzare lo stato iniziale degli oggetti estendendo la class astratta. Come sappiamo, non possiamo creare un object di una class astratta perché gli oggetti sono creati dalle “nuove” parole chiave e non dai costruttori … sono lì solo per inizializzare lo stato degli oggetti sottoclass.

Sì, sicuramente puoi aggiungerne uno, come già accennato per l’inizializzazione delle variabili di class Abstract. MA se non lo dichiari esplicitamente, ha comunque un costrutto implicito per “Constructor Chaining” per funzionare.

Lo scopo del costruttore in una class è usato per inizializzare i campi ma non per “build oggetti”. Quando provi a creare una nuova istanza di una SuperClass astratta, il compilatore ti darà un errore. Tuttavia, possiamo ereditare un dipendente di class astratta e utilizzare il suo costruttore impostando le sue variabili Vedere l’esempio di seguito

 public abstract class Employee { private String EmpName; abstract double calcSalary(); Employee(String name) { this.EmpName = name;// constructor of abstract class super class } } class Manager extends Employee{ Manager(String name) { super(name);// setting the name in the constructor of sub class } double calcSalary() { return 0; } } 

Sì … È come qualsiasi altra class. Può avere un costruttore e viene chiamato dopo aver creato l’object per la class base.