Супер () в Java
Является super() раньше вызывал родительский конструктор? Пожалуйста, объясни super(),
20 ответов
super() вызывает родительский конструктор без аргументов.
Может использоваться и с аргументами. Т.е. super(argument1) и он будет вызывать конструктор, который принимает 1 параметр типа argument1 (если существует).
Также его можно использовать для вызова методов родителя. Т.е. super.aMethod()
Больше информации и учебник здесь
Некоторые факты:
super()используется для вызова непосредственного родителя.super()может использоваться с членами экземпляра, т.е. переменными экземпляра и методами экземпляра.super()может использоваться в конструкторе для вызова конструктора родительского класса.
Хорошо, теперь давайте практически реализовать эти пункты super(),
Проверьте разницу между программой 1 и 2. Здесь программа 2 подтверждает наше первое утверждение super() на Яве.
Программа 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(...) вызовет конструктор суперкласса.
Посмотрите на этот пример:
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() для вызова родительского конструктора?
Да.
Просьба объяснить про Супер ().
super() это специальное использование super ключевое слово, где вы вызываете родительский конструктор без параметров. В общем, super Ключевое слово может использоваться для вызова переопределенных методов, доступа к скрытым полям или вызова конструктора суперкласса.
Вызов супер-конструктора без аргументов - это просто трата экранного пространства и времени программиста. Компилятор генерирует точно такой же код, независимо от того, пишете вы его или нет.
class Explicit() {
Explicit() {
super();
}
}
class Implicit {
Implicit() {
}
}
Да, super() (нижний регистр) вызывает конструктор родительского класса. Вы можете включить аргументы: super(foo, bar)
Также есть super ключевое слово, которое вы можете использовать в методах для вызова метода суперкласса
Быстрый Google для "Java Super" приводит к этому
Это правильно. 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. Вы также можете использовать super для обозначения скрытого поля (хотя скрывать поля не рекомендуется). Рассмотрим этот класс, Суперкласс:
public class Superclass {
public void printMethod() {
System.out.println("Printed in Superclass.");
}
}
Вот подкласс, называемый Subclass, который переопределяет printMethod():
public class Subclass extends Superclass {
// overrides printMethod in Superclass
public void printMethod() {
super.printMethod();
System.out.println("Printed in Subclass");
}
public static void main(String[] args) {
Subclass s = new Subclass();
s.printMethod();
}
}
Внутри подкласса простое имя printMethod () ссылается на объявленное в подклассе, которое переопределяет имя в суперклассе. Таким образом, для ссылки на printMethod (), унаследованный от Superclass, Subclass должен использовать полное имя, используя super, как показано. Компиляция и выполнение Subclass печатает следующее:
Напечатано в суперклассе. Напечатано в Конструкторах Подкласса.
В следующем примере показано, как использовать ключевое слово super для вызова конструктора суперкласса. Вспомните из примера Bicycle, что MountainBike является подклассом Bicycle. Вот конструктор MountainBike (подкласс), который вызывает конструктор суперкласса, а затем добавляет собственный код инициализации:
public MountainBike(int startHeight, int startCadence,int startSpeed,
int startGear) {
super(startCadence, startSpeed, startGear);
seatHeight = startHeight;
}
Вызов конструктора суперкласса должен быть первой строкой в конструкторе подкласса.
Синтаксис для вызова конструктора суперкласса
супер();
или: super (список параметров); С super () вызывается конструктор суперкласса без аргументов. С super (список параметров) вызывается конструктор суперкласса с соответствующим списком параметров.
Я видел все ответы. Но все забыли упомянуть один очень важный момент:
super () должен вызываться или использоваться в первой строке конструктора.
Например, в автоматизации селена у вас есть PageObject, который может использовать конструктор своего родителя, например так:
public class DeveloperSteps extends ScenarioSteps {
public DeveloperSteps(Pages pages) {
super(pages);
}........
Просто супер (); один вызовет конструктор по умолчанию, если он существует из суперкласса класса. Но вы должны явно написать конструктор по умолчанию самостоятельно. Если у вас нет 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 нравиться
super.methodName();
Вызов конструкторов суперкласса
Если конструктор явно не вызывает конструктор суперкласса, компилятор Java автоматически вставляет вызов в конструктор суперкласса без аргументов. Если суперкласс не имеет конструктора без аргументов, вы получите ошибку времени компиляции.
Посмотрите на код ниже:
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();
}
}
При создании объекта JVM всегда сначала выполняет конструктор в классе верхнего уровня в дереве наследования, а затем полностью вниз по дереву наследования. Причина, по которой это возможно, заключается в том, что компилятор Java автоматически вставляет вызов конструктора без аргументов суперкласса. Если в суперклассе нет конструктора без аргументов, а подкласс явно не говорит, какой конструктор должен быть выполнен в суперклассе, вы получите ошибку времени компиляции .
В приведенном выше коде, если мы хотим успешно создать объект Wolf, должен быть выполнен конструктор класса. И во время этого процесса вызывается конструктор с двумя аргументами в классе Animal. Одновременно он явно вызывает один -argu-constructor в том же классе и конструктор с одним аргументом неявно вызывает конструктор без аргументов в классе Creature, а конструктор без аргументов снова неявно вызывает пустой конструктор в классе Object.
Я хотел бы поделиться с кодами тем, что понял.
Ключевое слово super в java - это ссылочная переменная, которая используется для ссылки на объекты родительского класса. Он в основном используется в следующих контекстах:-
1. Использование super с переменными:
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
- Использование методов super with:
/* 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. Использование super с конструкторами:
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
Есть пара других применений.
Ссылка на метод по умолчанию унаследованного интерфейса:
import java.util.Collection;
import java.util.stream.Stream;
public interface SkipFirstCollection<E> extends Collection<E> {
@Override
default Stream<E> stream() {
return Collection.super.stream().skip(1);
}
}
Существует также редко используемый случай, когда квалифицированныйsuperиспользуется для предоставления внешнего экземпляра конструктору суперкласса при создании экземпляра статического подкласса:
public class OuterInstance {
public static class ClassA {
final String name;
public ClassA(String name) {
this.name = name;
}
public class ClassB {
public String getAName() {
return ClassA.this.name;
}
}
}
public static class ClassC extends ClassA.ClassB {
public ClassC(ClassA a) {
a.super();
}
}
public static void main(String[] args) {
final ClassA a = new ClassA("jeff");
final ClassC c = new ClassC(a);
System.out.println(c.getAName());
}
}
Затем:
$ javac OuterInstance.java && java OuterInstance
jeff
Ключевое слово super может использоваться для вызова конструктора суперкласса и ссылки на член суперкласса
Когда вы вызываете 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
Конструкторы
В конструкторе вы можете использовать его без точки для вызова другого конструктора. 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 полезен только как способ сделать ваш код более читабельным.
The super keyword in Java is a reference variable that is used to refer to the immediate parent class object.
Использование ключевого слова Java super
super может использоваться для ссылки на непосредственную переменную экземпляра родительского класса.
super можно использовать для непосредственного вызова метода родительского класса.
super() можно использовать для непосредственного вызова конструктора родительского класса.
Супер ключевое слово в Java
Ключевое слово Super - это ссылочная переменная, которая используется для ссылки на родительский объект класса.
Зачем использовать супер ключевое слово в Java?
Всякий раз, когда наследует данные базового класса в производный класс, это дает возможность получить неоднозначность, потому что могут быть данные базового класса и данные производного класса одинаковы, поэтому для различия этих данных необходимо использовать ключевое слово super
Супер ключевое слово на уровне метода?
Ключевое слово Super также используется для вызова метода родительского класса. Ключевое слово super следует использовать в случае переопределения метода.
Когда использовать ключевое слово Super на уровне метода?
Супер-ключевое слово используется, когда имя метода базового класса и имя метода производного класса имеют одинаковые имена