super () em Java

É super()usado para chamar o construtor pai? Por favor explique super().

super() chama o construtor pai sem argumentos.

Também pode ser usado com argumentos. Ou seja, super(argument1)e ele chamará o construtor que aceita 1 parâmetro do tipo de argument1(se existir).

Também pode ser usado para chamar métodos do pai. Ou seja,super.aMethod()

Mais informações e tutorial aqui

Alguns fatos:

1. super() é usado para chamar o pai imediato.
2. super() pode ser usado com membros da instância, ou seja, variáveis ​​e métodos da instância.
3. super() pode ser usado dentro de um construtor para chamar o construtor da classe pai.

OK, agora vamos praticamente implementar esses pontos de super().

Confira a diferença entre os programas 1 e 2. Aqui, o programa 2 prova nossa primeira declaração super()em Java.

Programa 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();
    }
}

Resultado:

200
200

Agora confira o programa 2 e tente descobrir a principal diferença.

Programa 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();
    }
}

Resultado:

100
200

No programa 1, a saída era apenas da classe derivada. Não foi possível imprimir a variável nem da classe base nem da classe pai. Mas no programa 2, usamos super()a variável aao imprimir sua saída e, em vez de imprimir o valor da variável ada classe derivada, ele imprimiu o valor da variável ada classe base. Portanto, isso prova que super()é usado para chamar o pai imediato.

OK, verifique agora a diferença entre o programa 3 e o programa 4.

Programa 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();
    }
}

Resultado:

200

Aqui a saída é 200. Quando chamamos Show(), a Show()função da classe derivada foi chamada. Mas o que devemos fazer se quisermos chamar a Show()função da classe pai? Confira o programa 4 para a solução.

Programa 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();
    }
}

Resultado:

100
200

Aqui estamos obtendo duas saídas, 100 e 200. Quando a Show()função da classe derivada é invocada, ela primeiro chama a Show()função da classe pai, porque, dentro da Show()função da classe derivada, chamamos a Show()função da classe pai colocando a superpalavra - chave antes do nome da função.

Artigo de origem: Java: Calling super ()

Sim. super(...)invocará o construtor da superclasse.

Ilustração:

Exemplo independente:

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();
    }
}

Impressões:

Constructing an animal: From Dog constructor
Constructing a dog.

É super () usado para chamar o construtor pai?

Sim.

Pls explica sobre Super ().

super()é um uso especial da superpalavra - chave em que você chama um construtor pai sem parâmetros. Em geral, a superpalavra - chave pode ser usada para chamar métodos substituídos, acessar campos ocultos ou chamar o construtor de uma superclasse.

Aqui está o tutorial oficial

Chamar o super construtor sem argumentos é apenas um desperdício de espaço na tela e tempo do programador. O compilador gera exatamente o mesmo código, independentemente de você o escrever ou não.

class Explicit() {
    Explicit() {
        super();
    }
}

class Implicit {
    Implicit() {
    }
}

Sim, super()(em minúsculas) chama um construtor da classe pai. Você pode incluir argumentos:super(foo, bar)

Há também uma superpalavra - chave, que você pode usar em métodos para chamar um método da superclasse

Um rápido google para "Java super" resulta neste

Está correto. Super é usado para chamar o construtor pai. Então, suponha que você tenha um bloco de código assim

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;
    }
}

Em seguida, você pode atribuir um valor à variável de membro n.

Eu já vi todas as respostas. Mas todo mundo esqueceu de mencionar um ponto muito importante:

super () deve ser chamado ou usado na primeira linha do construtor.

Apenas super (); sozinho chamará o construtor padrão, se existir da superclasse de uma classe. Mas você deve escrever explicitamente o construtor padrão. Se você não um Java, irá gerar um para você sem implementações, salve super (); , referindo-se ao objeto universal da superclasse e você não pode chamá-lo em uma subclasse.

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.
   }

}

Por exemplo, na automação de selênio, você tem um PageObject que pode usar o construtor de seus pais assim:

public class DeveloperSteps extends ScenarioSteps {

public DeveloperSteps(Pages pages) {
    super(pages);
}........

Gostaria de compartilhar com os códigos tudo o que entendi.

A super palavra-chave em java é uma variável de referência usada para referenciar objetos de classe pai. É usado principalmente nos seguintes contextos: -

1. Uso de super com variáveis:

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(); 
    } 
} 

Resultado:-

Maximum Speed: 120

2. Uso de super com métodos:

/* 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(); 
    } 
}

Resultado:-

This is student class
This is person class

3. Uso de super com construtores:

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(); 
    } 
} 

Resultado:-

Person class Constructor
Student class Constructor

Construtores
Em um construtor, você pode usá-lo sem um ponto para chamar outro construtor. superchama um construtor na superclasse; thischama um construtor nesta classe:

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é útil se a superclasse precisar se inicializar. thisé útil para permitir que você escreva todo o código de inicialização permanente apenas uma vez em um dos construtores e chame-o de todos os outros, construtores muito mais fáceis de escrever.

Métodos
Em qualquer método, você pode usá-lo com um ponto para chamar outro método. super.method()chama um método na superclasse; this.method()chama um método nesta classe:

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é útil em um determinado cenário: se sua classe possui o mesmo método que sua superclasse, o Java assumirá que você deseja aquele em sua classe; superpermite que você solicite o método da superclasse. thisé útil apenas como uma maneira de tornar seu código mais legível.

A super palavra - chave pode ser usada para chamar o construtor da superclasse e se referir a um membro da superclasse

Quando você chama super () com os argumentos corretos, na verdade chamamos o construtor Box , que inicializa as variáveis width , height e depth , referenciado a ele usando os valores dos parâmetros correspondentes. Você só resta inicializar seu peso com valor agregado. Se necessário, agora você pode classificar as variáveis ​​Box como privadas . Coloque nos campos do modificador privado da classe Box e verifique se você pode acessá-los sem problemas.

Na superclasse pode haver vários construtores de versões sobrecarregadas, para que você possa chamar o método super () com parâmetros diferentes. O programa executará o construtor que corresponde aos argumentos especificados.

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 é uma palavra-chave. É usado dentro de uma definição de método de subclasse para chamar um método definido na superclasse. Métodos particulares da superclasse não podem ser chamados. Somente métodos públicos e protegidos podem ser chamados pela super palavra-chave. Também é usado pelos construtores de classe para invocar construtores de sua classe pai.

Verifique aqui para mais explicações.

Como afirmado, dentro do construtor padrão, há um super () implícito chamado na primeira linha do construtor.

Esse super () chama automaticamente uma cadeia de construtores começando no topo da hierarquia de classes e desce a hierarquia.

Se houvesse mais de duas classes na hierarquia de classes do programa, o construtor padrão de primeira classe seria chamado primeiro .

Aqui está um exemplo disso:

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();
    }
} 

O acima resultaria:

Constructor A
Constructor B
Constructor C