Wordt super()gebruikt om de bovenliggende constructor aan te roepen?
Leg aub super()uit.
Antwoord 1, autoriteit 100%
super()roept de bovenliggende constructor aan zonder argumenten.
Het kan ook met argumenten worden gebruikt. D.w.z. super(argument1)en het zal de constructor aanroepen die 1 parameter van het type argument1accepteert (indien aanwezig).
Het kan ook worden gebruikt om methoden van de ouder aan te roepen. D.w.z. super.aMethod()
Meer info en tutorial hier
Antwoord 2, autoriteit 58%
Enkele feiten:
super()wordt gebruikt om de directe ouder aan te roepen.super()kan worden gebruikt met instantieleden, d.w.z. instantievariabelen en instantiemethoden.super()kan binnen een constructor worden gebruikt om de constructor van de bovenliggende klasse aan te roepen.
OK, laten we nu deze punten van super()praktisch implementeren.
Bekijk het verschil tussen programma 1 en 2. Hier bewijst programma 2 onze eerste verklaring van super()in Java.
Programma 1
class Base
{
int a = 100;
}
class Sup1 extends Base
{
int a = 200;
void Show()
{
System.out.println(a);
System.out.println(a);
}
public static void main(String[] args)
{
new Sup1().Show();
}
}
Uitvoer:
200
200
Bekijk nu programma 2 en probeer het belangrijkste verschil te ontdekken.
Programma 2
class Base
{
int a = 100;
}
class Sup2 extends Base
{
int a = 200;
void Show()
{
System.out.println(super.a);
System.out.println(a);
}
public static void main(String[] args)
{
new Sup2().Show();
}
}
Uitvoer:
100
200
In programma 1 was de uitvoer alleen van de afgeleide klasse. Het kon de variabele van noch de basisklasse noch de bovenliggende klasse afdrukken. Maar in programma 2 gebruikten we super()met variabele atijdens het afdrukken van de uitvoer, en in plaats van de waarde van variabele avan de afgeleide klasse, drukte het de waarde van variabele avan de basisklasse af. Het bewijst dus dat super()wordt gebruikt om de directe ouder aan te roepen.
OK, bekijk nu het verschil tussen programma 3 en programma 4.
Programma 3
class Base
{
int a = 100;
void Show()
{
System.out.println(a);
}
}
class Sup3 extends Base
{
int a = 200;
void Show()
{
System.out.println(a);
}
public static void Main(String[] args)
{
new Sup3().Show();
}
}
Uitvoer:
200
Hier is de uitvoer 200. Toen we Show()aanriepen, werd de functie Show()van de afgeleide klasse aangeroepen. Maar wat moeten we doen als we de functie Show()van de bovenliggende klasse willen aanroepen? Bekijk programma 4 voor de oplossing.
Programma 4
class Base
{
int a = 100;
void Show()
{
System.out.println(a);
}
}
class Sup4 extends Base
{
int a = 200;
void Show()
{
super.Show();
System.out.println(a);
}
public static void Main(String[] args)
{
new Sup4().Show();
}
}
Uitvoer:
100
200
Hier krijgen we twee outputs, 100 en 200. Wanneer de functie Show()van de afgeleide klasse wordt aangeroepen, roept deze eerst de functie Show()van de bovenliggende klasse, omdat we binnen de functie Show()van de afgeleide klasse de functie Show()van de bovenliggende klasse hebben genoemd door de supertrefwoord voor de functienaam.
Antwoord 3, autoriteit 14%
Bronartikel: Java: Super() aanroepen
Ja. super(...)zal de constructor van de superklasse aanroepen.
Illustratie:
Stand-alone voorbeeld:
class Animal {
public Animal(String arg) {
System.out.println("Constructing an animal: " + arg);
}
}
class Dog extends Animal {
public Dog() {
super("From Dog constructor");
System.out.println("Constructing a dog.");
}
}
public class Test {
public static void main(String[] a) {
new Dog();
}
}
Afdrukken:
Constructing an animal: From Dog constructor
Constructing a dog.
Antwoord 4, autoriteit 11%
Wordt super() gebruikt om de bovenliggende constructor aan te roepen?
Ja.
Leg alsjeblieft uit over Super().
super()is een speciaal gebruik van het supersleutelwoord waarbij je een parameterloze parent-constructor aanroept. Over het algemeen kan het trefwoord superworden gebruikt om overschreven methoden aan te roepen, verborgen velden te openen of de constructor van een superklasse aan te roepen.
Hier is de officiële tutorial
Antwoord 5, autoriteit 3%
De superconstructor zonder argumenten noemen is gewoon een verspilling van schermruimte en programmeertijd. De compiler genereert exact dezelfde code, of je het nu schrijft of niet.
class Explicit() {
Explicit() {
super();
}
}
class Implicit {
Implicit() {
}
}
Antwoord 6, autoriteit 2%
Ja, super()(kleine letters) roept een constructor van de bovenliggende klasse aan. U kunt argumenten opnemen: super(foo, bar)
Er is ook een supertrefwoord, dat u in methoden kunt gebruiken om een methode van de superklasse aan te roepen
Een snelle google voor “Java super” resulteert in dit
Antwoord 7
Dat klopt. Super wordt gebruikt om de bovenliggende constructor aan te roepen. Dus stel dat je zo’n codeblok hebt
class A{
int n;
public A(int x){
n = x;
}
}
class B extends A{
int m;
public B(int x, int y){
super(x);
m = y;
}
}
Vervolgens kunt u een waarde toewijzen aan de lidvariabele n.
Antwoord 8
Ik heb alle antwoorden gezien. Maar iedereen vergat een heel belangrijk punt te vermelden:
super () moet worden genoemd of gebruikt in de eerste regel van de constructor.
Antwoord 9
gewoon super (); Alleen zal de standaardconstructeur bellen, als het bestaat uit de superclass van een klasse. Maar u moet expliciet de standaardconstructeur zelf schrijven. Als u geen JAVA een voor u zult genereren zonder implementaties, bewaart u Super (); , verwijzend naar het object van de universele superclass, en u kunt het niet in een subklasse noemen.
public class Alien{
public Alien(){ //Default constructor is written out by user
/** Implementation not shown…**/
}
}
public class WeirdAlien extends Alien{
public WeirdAlien(){
super(); //calls the default constructor in Alien.
}
}
Antwoord 10
Bijvoorbeeld, in Selenium Automation, hebt u een paginaObject die de constructor van zijn ouder als volgt kan gebruiken:
public class DeveloperSteps extends ScenarioSteps {
public DeveloperSteps(Pages pages) {
super(pages);
}........
Antwoord 11
Ik zou graag willen delen met codes wat ik ook begreep.
Het Super-trefwoord in Java is een referentievariabele die wordt gebruikt om ouderklasse-objecten te verwijzen. Het wordt muitly gebruikt in de volgende contexten: –
1. Gebruik van super met variabelen:
class Vehicle
{
int maxSpeed = 120;
}
/* sub class Car extending vehicle */
class Car extends Vehicle
{
int maxSpeed = 180;
void display()
{
/* print maxSpeed of base class (vehicle) */
System.out.println("Maximum Speed: " + super.maxSpeed);
}
}
/* Driver program to test */
class Test
{
public static void main(String[] args)
{
Car small = new Car();
small.display();
}
}
Uitvoer:-
Maximum Speed: 120
- Gebruik van super met methoden:
/* Base class Person */
class Person
{
void message()
{
System.out.println("This is person class");
}
}
/* Subclass Student */
class Student extends Person
{
void message()
{
System.out.println("This is student class");
}
// Note that display() is only in Student class
void display()
{
// will invoke or call current class message() method
message();
// will invoke or call parent class message() method
super.message();
}
}
/* Driver program to test */
class Test
{
public static void main(String args[])
{
Student s = new Student();
// calling display() of Student
s.display();
}
}
Uitvoer:-
This is student class
This is person class
3. Gebruik van super met constructors:
class Person
{
Person()
{
System.out.println("Person class Constructor");
}
}
/* subclass Student extending the Person class */
class Student extends Person
{
Student()
{
// invoke or call parent class constructor
super();
System.out.println("Student class Constructor");
}
}
/* Driver program to test*/
class Test
{
public static void main(String[] args)
{
Student s = new Student();
}
}
Uitgang: –
Person class Constructor
Student class Constructor
Antwoord 12
Waar kunnen we super voor gebruiken?
Toegang tot Superclass-leden
Als uw methode een aantal van de methoden van de superclas overschrijft, kunt u de opgeheven methode oproepen via het gebruik van het trefwoord superals super.methodName();
Bevordering van Superclass Constructors
Als een constructor niet expliciet een superclass-constructeur roept, voegt de Java-compiler automatisch een oproep in aan de no-argument-constructeur van de superclass. Als de superklasse geen no-argument-constructor heeft, krijgt u een compileer-tijdfout.
Bekijk de onderstaande code:
class Creature {
public Creature() {
system.out.println("Creature non argument constructor.");
}
}
class Animal extends Creature {
public Animal (String name) {
System.out.println("Animal one argument constructor");
}
public Animal (Stirng name,int age) {
this(name);
system.out.println("Animal two arguments constructor");
}
}
class Wolf extends Animal {
public Wolf() {
super("tigerwang",33);
system.out.println("Wolf non argument constructor");
}
public static void main(string[] args) {
new Wolf();
}
}
Bij het maken van een object voert de JVM altijd eerst de constructor uit in de klasse
van de bovenste laag in de erfenisboom. En dan helemaal in de overervingboom. De
Reden waarom dit mogelijk is, is dat de Java-compiler automatisch een oproep inzet
naar de constructor zonder argument van de superklasse.Als er geen constructor zonder argument is
in de superklasse en de subklasse zegt niet expliciet welke van de constructor moet
worden uitgevoerd in de superklasse, krijgt u een compileerfout.
In de bovenstaande code, als we met succes een Wolf-object willen maken, de constructor van de
klasse moet worden uitgevoerd. En tijdens dat proces, de twee-argu-constructor in de Animal
klasse wordt aangeroepen. Tegelijkertijd roept het expliciet de één-argu-constructor in dezelfde
klasse en de één-argu-constructor roept impliciet de niet-argu-constructor in het schepsel aan
klasse en de niet-argu-constructor roept opnieuw impliciet de lege constructor in het Object aan
klas.
Antwoord 13
Constructeurs
In een constructor kun je het zonder punt gebruiken om een andere constructor aan te roepen. superroept een constructor aan in de superklasse; thisroept een constructor aan in deze klasse :
public MyClass(int a) {
this(a, 5); // Here, I call another one of this class's constructors.
}
public MyClass(int a, int b) {
super(a, b); // Then, I call one of the superclass's constructors.
}
superis handig als de superklasse zichzelf moet initialiseren. thisis handig om u in staat te stellen alle harde initialisatiecode slechts één keer in een van de constructors te schrijven en deze aan te roepen vanuit alle andere, veel gemakkelijker te schrijven constructors.
Methoden
In elke methode kun je het met een punt gebruiken om een andere methode aan te roepen. super.method()roept een methode aan in de superklasse; this.method()roept een methode aan in deze klasse :
public String toString() {
int hp = this.hitpoints(); // Calls the hitpoints method in this class
// for this object.
String name = super.name(); // Calls the name method in the superclass
// for this object.
return "[" + name + ": " + hp + " HP]";
}
superis handig in een bepaald scenario: als je klasse dezelfde methode heeft als je superklasse, gaat Java ervan uit dat je die in je klasse wilt; Met superkun je in plaats daarvan om de methode van de superklasse vragen. thisis alleen nuttig als een manier om uw code leesbaarder te maken.
Antwoord 14
Het supersleutelwoord kan worden gebruikt om de superklasse-constructor aan te roepen en om te verwijzen naar een lid van de superklasse
Als je super()aanroept met de juiste argumenten, noemen we eigenlijk de constructor Box, die variabelen breedte, hoogteen diepte, waarnaar wordt verwezen met behulp van de waarden van de bijbehorende parameters. U hoeft alleen nog het gewicht van de toegevoegde waarde te initialiseren. Indien nodig kunt u nu de variabelen Box classeren als private. Zet in de velden van de Box class private modifier en zorg ervoor dat je ze zonder problemen kunt openen.
Bij de superklasse kunnen verschillende overbelaste versie-constructors zijn, dus je kunt de methode super()aanroepen met verschillende parameters. Het programma zal de constructor uitvoeren die overeenkomt met de opgegeven argumenten.
public class Box {
int width;
int height;
int depth;
Box(int w, int h, int d) {
width = w;
height = h;
depth = d;
}
public static void main(String[] args){
HeavyBox heavy = new HeavyBox(12, 32, 23, 13);
}
}
class HeavyBox extends Box {
int weight;
HeavyBox(int w, int h, int d, int m) {
//call the superclass constructor
super(w, h, d);
weight = m;
}
}
Antwoord 15
superis een zoekwoord. Het wordt gebruikt binnen een methodedefinitie van een subklasse om een methode aan te roepen die in de superklasse is gedefinieerd. Private methoden van de superklasse kunnen niet worden aangeroepen. Alleen openbare en beveiligde methoden kunnen worden aangeroepen door het super-sleutelwoord. Het wordt ook gebruikt door klasseconstructeurs om constructors van zijn bovenliggende klasse aan te roepen.
Kijk hiervoor meer uitleg.
Antwoord 16
Zoals gezegd, is er binnen de standaardconstructor een implicietesuper()die wordt aangeroepen op de eerste regelvan de constructor.
Deze super() roept automatisch een keten van constructorsaan die bovenaan de klassenhiërarchie begint en naar beneden in de hiërarchie gaat.
Als er meer dan twee klassenin de klassenhiërarchie van het programma waren, zou de standaardconstructor van de hoogste klasse aangeroepeneerstekrijgen.
Hier is een voorbeeld hiervan:
class A {
A() {
System.out.println("Constructor A");
}
}
class B extends A{
public B() {
System.out.println("Constructor B");
}
}
class C extends B{
public C() {
System.out.println("Constructor C");
}
public static void main(String[] args) {
C c1 = new C();
}
}
Het bovenstaande zou het volgende opleveren:
Constructor A
Constructor B
Constructor C
Antwoord 17
The super keyword in Java is a reference variable that is used to refer to the immediate parent class object.
Gebruik van Java-superzoekwoord
-
superkan worden gebruikt om te verwijzen naar de instantievariabele van de directe bovenliggende klasse.
-
superkan worden gebruikt om de directe bovenliggende klassenmethode aan te roepen.
-
super()kan worden gebruikt om de constructor van de directe bovenliggende klasse aan te roepen.