Wat is precies een standaardconstructor kunt u me vertellen welke van de volgende een standaardconstructor is en wat het onderscheidt van andere constructors?
public Module() {
this.name = "";
this.credits = 0;
this.hours = 0;
}
public Module(String name, int credits, int hours) {
this.name = name;
this.credits = credits;
this.hours = hours;
}
Antwoord 1, autoriteit 100%
Geen van beiden. Als je het definieert, is het niet de standaardinstelling.
De standaardconstructor is de constructor zonder argumenten die automatisch wordt gegenereerd, tenzij u een andere constructor definieert. Alle niet-geïnitialiseerde velden worden ingesteld op hun standaardwaarden. Voor jouw voorbeeld zou het er als volgt uitzien, ervan uitgaande dat de typen String, int en int zijn, en dat de klasse zelf openbaar is:
public Module()
{
super();
this.name = null;
this.credits = 0;
this.hours = 0;
}
Dit is precies hetzelfde als
public Module()
{}
En precies hetzelfde als helemaal geen constructeurs hebben. Als u echter ten minste één constructor definieert, wordt de standaardconstructor niet gegenereerd.
Referentie: Java-taal Specificatie
Als een klasse geen constructordeclaraties bevat, wordt impliciet een standaardconstructor zonder formele parameters en zonder throws-clausule gedeclareerd.
Verduidelijking
Technisch gezien is het niet de constructor (standaard of anderszins) die de velden standaard initialiseert. Ik laat het echter bij het antwoord omdat
- de vraag had de verkeerde standaardwaarden, en
- de constructor heeft precies hetzelfde effect, of ze nu zijn opgenomen of niet.
Antwoord 2, autoriteit 14%
Een standaardconstructor wordt gemaakt als u geen constructors in uw klasse definieert. Het is gewoon een no-argument constructor die niets doet. Bewerken: behalve oproep super()
public Module(){
}
Antwoord 3, autoriteit 8%
Een standaardconstructor wordt automatisch gegenereerd door de compiler als u niet expliciet ten minste één constructor in uw klasse definieert. Je hebt er twee gedefinieerd, dus je klas heeft geen standaardconstructor.
Per De Java-taalspecificatie derde editie:
8.8.9 Standaard Constructor
Als een klasse geen constructor bevat
declaraties, dan een standaard
constructor die geen parameters nodig heeft
wordt automatisch verstrekt…
Antwoord 4, autoriteit 7%
Hallo. Voor zover ik weet, laat me het concept van de standaardconstructor duidelijk maken:
De compiler biedt automatisch een standaardconstructor zonder argument
voor elke klasse zonder constructeurs. Deze standaardconstructor roept
de no-argument constructor van de superklasse. In deze situatie is de
compiler zal klagen als de superklasse geen nee-argument heeft
constructor, dus u moet controleren of dit het geval is. Als je klas geen . heeft
expliciete superklasse, dan heeft het een impliciete superklasse van Object,
die wel een constructor zonder argumenten heeft.
Ik heb deze informatie gelezen in de Java-tutorials.
Antwoord 5, autoriteit 3%
Java biedt een standaardconstructor die geen argumenten aanneemt en geen speciale acties of initialisaties uitvoert, als er geen expliciete constructors zijn.
De enige actie die wordt ondernomen door de impliciete standaardconstructor is om de superklasseconstructor aan te roepen met de super()-aanroep. Constructorargumenten bieden u een manier om parameters te verschaffen voor de initialisatie van een object.
Hieronder ziet u een voorbeeld van een kubusklasse die 2 constructors bevat. (één standaard en één geparametriseerde constructor).
public class Cube1 {
int length;
int breadth;
int height;
public int getVolume() {
return (length * breadth * height);
}
Cube1() {
length = 10;
breadth = 10;
height = 10;
}
Cube1(int l, int b, int h) {
length = l;
breadth = b;
height = h;
}
public static void main(String[] args) {
Cube1 cubeObj1, cubeObj2;
cubeObj1 = new Cube1();
cubeObj2 = new Cube1(10, 20, 30);
System.out.println("Volume of Cube1 is : " + cubeObj1.getVolume());
System.out.println("Volume of Cube1 is : " + cubeObj2.getVolume());
}
}
Antwoord 6, autoriteit 2%
Algemene terminologie is dat als u geen constructor in uw object opgeeft, er automatisch een constructor zonder argument wordt geplaatst die de standaardconstructor wordt genoemd.
Als je een constructor definieert die hetzelfde is als degene die zou worden geplaatst als je er geen opgeeft, wordt deze over het algemeen aangeduid als een constructor zonder argumenten. Het is slechts een conventie, aangezien sommige programmeurs dit liever expliciet noemen, definieerde geen argumenten-constructor als standaard constructor. Maar als we gaan door te benoemen als we er een expliciet definiëren, dan wordt het niet standaard.
Volgens de docs
Als een klasse geen constructordeclaraties bevat, wordt impliciet een standaardconstructor zonder formele parameters en zonder throws-clausule gedeclareerd.
Voorbeeld
public class Dog
{
}
wordt als volgt automatisch gewijzigd (door standaardconstructor toe te voegen)
public class Dog{
public Dog() {
}
}
en wanneer u het object maakt
Dog myDog = new Dog();
deze standaardconstructor wordt aangeroepen.
Antwoord 7
standaardconstructor verwijst naar een constructor die automatisch wordt gegenereerd door de compiler bij afwezigheid van door de programmeur gedefinieerde constructors.
Als er geen constructor is geleverd door de programmeur, declareert de compiler impliciet een standaardconstructor die super() aanroept, geen throws-clausule heeft en ook geen formele parameters.
Bijvoorbeeld
class Klass {
// Default Constructor gets generated
}
new Klass(); // Correct
-------------------------------------
class KlassParameterized {
KlassParameterized ( String str ) { //// Parameterized Constructor
// do Something
}
}
new KlassParameterized(); //// Wrong - you need to explicitly provide no-arg constructor. The compiler now never declares default one.
--------------------------------
class KlassCorrected {
KlassCorrected (){ // No-arg Constructor
/// Safe to Invoke
}
KlassCorrected ( String str ) { //// Parameterized Constructor
// do Something
}
}
new KlassCorrected(); /// RIGHT -- you can instantiate
Antwoord 8
Als een klasse geen door de programmeur geleverde constructor heeft, dan zal de java-compiler een standaardconstructor toevoegen zonder parameters die de constructor van de superklasse intern aanroept met super()-aanroep. Dit wordt de standaardconstructor genoemd.
In jouw geval is er geen standaardconstructor omdat je ze programmatisch toevoegt.
Als er geen constructors door u zijn toegevoegd, ziet de door de compiler gegenereerde standaardconstructor er als volgt uit.
public Module()
{
super();
}
Opmerking: in de standaardconstructor aan de zijkant wordt ook de aanroep super() toegevoegd om de constructor van de superklasse aan te roepen.
Doel van het toevoegen van standaardconstructor:
Het is de taak van de constructeur om instantievariabelen te initialiseren. Als er geen instantievariabelen zijn, kunt u ervoor kiezen om de constructor uit uw klasse te verwijderen. Maar wanneer u een klasse erft, is het uw klasseverantwoordelijkheid om de superklasse-constructor aan te roepen om ervoor te zorgen dat de superklasse alle instantievariabelen correct initialiseert.
Daarom zal de Java-compiler, als er geen constructors zijn, een standaardconstructor toevoegen en de constructor van superklasse aanroepen.
Antwoord 9
Als we niet expliciet een constructor voor een klasse definiëren, maakt java een standaardconstructor voor de klasse. Het is in wezen een niet-geparametriseerde constructor, d.w.z. het accepteert geen argumenten.
De taak van de standaardconstructor is om de constructor van de superklasse aan te roepen en alle instantievariabelen te initialiseren. Als de constructor van de superklasse niet aanwezig is, initialiseert deze automatisch de instantievariabelen naar nul. Dus dat dient het doel van het gebruik van constructor, dat is om de interne status van een object te initialiseren, zodat de code die een instantie maakt, een volledig geïnitialiseerd, bruikbaar object heeft.
Zodra we onze eigen constructor voor de klasse hebben gedefinieerd, wordt de standaardconstructor niet meer gebruikt. Geen van beide is dus een standaardconstructor.
Antwoord 10
Als u geen enkele constructor in uw klasse definieert, definieert de compiler de standaardconstructor voor u, maar wanneer u een constructor declareert (in uw voorbeeld heeft u al een geparameteriseerde constructor gedefinieerd), doet de compiler dit niet voor u.
Aangezien je een constructor in klassencode hebt gedefinieerd, heeft de compiler er geen standaardversie van gemaakt. Tijdens het maken van een object roept u standaard een aan, die niet bestaat in klassencode. Dan geeft de code een compilatiefout.
Antwoord 11
Wanneer u een nieuw Module-object maakt, voegt Java-compiler een standaardconstructor voor u toe omdat er helemaal geen constructor is.
class Module{} // you will never see the default constructor
Als je een of andere constructor toevoegt, zelfs en niet-arg, dan heb je die van jezelf en voeg je geen standaardconstructor meer toe.
Dit is een niet-arg-constructor die intern de super()-constructor uit zijn bovenliggende klasse aanroept, zelfs als je er geen hebt. (als je klas geen bovenliggende klasse heeft, wordt de Object.Class-constructor aangeroepen)
class Module{
Module() {} // this look like a default constructor but in not.
}
Antwoord 12
Een standaardconstructor accepteert geen argumenten:
public class Student {
// default constructor
public Student() {
}
}
Antwoord 13
Ik hoop dat je je antwoord hebt gekregen over wat de standaardconstructor is.
Maar ik geef onderstaande verklaringen om de gegeven opmerkingen te corrigeren.
Java initialiseert geen enkele lokale variabele naar een standaardwaarde. Dus
als je een object van een klasse maakt, wordt het standaard genoemd
constructor en geef standaardwaarden op voor Object.Standaardconstructor levert de standaardwaarden voor het object, zoals 0,
null enz. afhankelijk van het type.
Zie onderstaande link voor meer details.