Является ли super()
используется для вызова родительского конструктора? Пожалуйста, объясните super()
.
Является ли super()
используется для вызова родительского конструктора? Пожалуйста, объясните super()
.
Ответы:
super()
вызывает родительский конструктор без аргументов.
Может использоваться и с аргументами. Т.е. super(argument1)
и он будет вызывать конструктор, который принимает 1 параметр типа argument1
(если существует).
Также его можно использовать для вызова методов родителя. Т.е.super.aMethod()
Больше информации и учебник здесь
super(...)
может использоваться только как первый оператор в конструкторе.
Некоторые факты:
super()
используется для вызова непосредственного родителя.super()
может использоваться с членами экземпляра, т.е. переменными экземпляра и методами экземпляра.super()
может использоваться в конструкторе для вызова конструктора родительского класса.Хорошо, теперь давайте практически реализовать эти пункты super()
.
Обратите внимание на разницу между программой 1 и 2. Здесь программа 2 подтверждает наше первое утверждение super()
в Java.
Программа 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();
}
}
Вывод:
200
200
Теперь проверьте программу 2 и попытайтесь выяснить основное отличие.
Программа 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();
}
}
Вывод:
100
200
В программе 1 вывод был только производного класса. Не удалось вывести переменную ни базового класса, ни родительского класса. Но в программе 2 мы использовали super()
переменную a
при печати ее вывода, и вместо того, чтобы печатать значение переменной a
производного класса, она печатала значение переменной a
базового класса. Таким образом, это доказывает, что super()
используется для вызова непосредственного родителя.
Хорошо, теперь проверьте разницу между программой 3 и программой 4.
Программа 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();
}
}
Вывод:
200
Здесь вывод равен 200. Когда мы вызывали Show()
, вызывалась Show()
функция производного класса. Но что нам делать, если мы хотим вызвать Show()
функцию родительского класса? Проверьте программу 4 для решения.
Программа 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();
}
}
Вывод:
100
200
Здесь мы получаем два вывода, 100 и 200. Когда Show()
вызывается функция производного класса, она сначала вызывает Show()
функцию родительского класса, потому что внутри Show()
функции производного класса мы вызывали Show()
функцию родительского класса, помещая super
ключевое слово перед именем функции.
super()
это не ключевое слово. Это вызов конструктора. super
является ключевым словом, и # 1 и # 2 имеют смысл только с этим определением.
Исходная статья: Java: Вызов super ()
Да. super(...)
вызовет конструктор суперкласса.
Иллюстрация:
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();
}
}
Печать:
Constructing an animal: From Dog constructor
Constructing a dog.
super()
его, то вызовете конструктор суперкласса, который не принимает аргументов. Точно так же он вызовет конструктор с 1 аргументом, если вы это сделаете super(arg1)
, и так далее.
super()
не будет допустимым вызовом.
Это super () используется для вызова родительского конструктора?
Да.
Просьба объяснить про Супер ().
super()
это специальное использование super
ключевого слова, где вы вызываете родительский конструктор без параметров. В общем, super
ключевое слово может использоваться для вызова переопределенных методов, доступа к скрытым полям или вызова конструктора суперкласса.
super()
используется для вызова родительского конструктора, super.myMethod()
используется для вызова переопределенного метода.
Вызов супер-конструктора без аргументов - просто трата экранного пространства и времени программиста. Компилятор генерирует точно такой же код, независимо от того, пишете вы его или нет.
class Explicit() {
Explicit() {
super();
}
}
class Implicit {
Implicit() {
}
}
Это верно. Super используется для вызова родительского конструктора. Итак, предположим, у вас есть блок кода, как это
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;
}
}
Затем вы можете присвоить значение переменной-члену n.
Я видел все ответы. Но все забыли упомянуть один очень важный момент:
super () должен вызываться или использоваться в первой строке конструктора.
Просто супер (); один вызовет конструктор по умолчанию, если он существует из суперкласса класса. Но вы должны явно написать конструктор по умолчанию самостоятельно. Если у вас нет Java, сгенерируйте его для вас без реализаций, сохраните super (); , ссылаясь на универсальный объект суперкласса, и вы не можете вызвать его в подклассе.
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.
}
}
Я хотел бы поделиться с кодами, что я понял.
Ключевое слово super в java - это ссылочная переменная, которая используется для ссылки на объекты родительского класса. Он в основном используется в следующих контекстах:
1. Использование супер с переменными:
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();
}
}
Вывод:-
Maximum Speed: 120
/* 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();
}
}
Вывод:-
This is student class
This is person class
3. Использование супер с конструкторами:
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();
}
}
Вывод:-
Person class Constructor
Student class Constructor
Конструкторы
В конструкторе вы можете использовать его без точки для вызова другого конструктора. super
вызывает конструктор в суперклассе; this
вызывает конструктор в этом классе:
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.
}
super
полезно, если суперкласс должен инициализировать себя. this
полезно, чтобы вы могли писать весь жесткий код инициализации только один раз в одном из конструкторов и вызывать его из всех других, гораздо более простых в написании конструкторов.
Методы
В любом методе вы можете использовать его с точкой для вызова другого метода. super.method()
вызывает метод в суперклассе; this.method()
вызывает метод в этом классе:
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]";
}
super
полезно в определенном сценарии: если ваш класс имеет тот же метод, что и ваш суперкласс, Java предполагает, что вы хотите использовать тот же класс в своем классе; super
позволяет вместо этого запросить метод суперкласса. this
полезен только как способ сделать ваш код более читабельным.
Супер можно использовать ключевое слово для вызова конструктора суперкласса и обратиться к члену суперкласса
Когда вы вызываете super () с правильными аргументами, мы фактически вызываем конструктор Box , который инициализирует переменные ширины , высоты и глубины , на которые ссылаются, используя значения соответствующих параметров. Вам остается только инициализировать его добавленную стоимость. При необходимости вы можете теперь делать переменные класса Box как приватные . Заполните поля приватного модификатора класса Box и убедитесь, что вы можете получить к ним доступ без проблем.
У суперкласса может быть несколько перегруженных конструкторов версий, поэтому вы можете вызывать метод super () с разными параметрами. Программа выполнит конструктор, который соответствует указанным аргументам.
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;
}
}
супер это ключевое слово. Он используется внутри определения метода подкласса для вызова метода, определенного в суперклассе. Частные методы суперкласса не могут быть вызваны. Только ключевое слово super может вызывать только открытые и защищенные методы. Он также используется конструкторами классов для вызова конструкторов его родительского класса.
Проверьте здесь для дальнейшего объяснения.
Как уже говорилось, внутри конструктора по умолчанию есть неявный super (), вызываемый в первой строке конструктора.
Это super () автоматически вызывает цепочку конструкторов, начиная с верхней части иерархии классов, и перемещается вниз по иерархии.
Если бы в иерархии классов программы было более двух классов, сначала вызывался бы конструктор высшего класса по умолчанию .
Вот пример этого:
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();
}
}
Выше будет выводить:
Constructor A
Constructor B
Constructor C