metodo - super java use

A palavra - chave super pode ser usada para chamar o construtor da superclasse e para 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 largura , altura e profundidade , referenciadas usando os valores dos parâmetros correspondentes. Você só resta para inicializar seu peso adicional. Se necessário, você pode fazer agora as variáveis ​​de classe Box como privadas . Coloque nos campos do modificador privado da classe Box e certifique-se de que você pode acessá-los sem problemas.

Na superclasse pode haver vários construtores de versões sobrecarregados, então você pode 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;
    }

}

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 fizer um Java irá gerar um para você sem implementações, salve super (); , referindo-se ao Objeto Superclasse universal, 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.
   }

}

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

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

class Implicit {
    Implicit() {
    }
}

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

Então você pode atribuir um valor para a variável de membro n.

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

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

public class DeveloperSteps extends ScenarioSteps {

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

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

Há também uma super palavra super chave, que você pode usar em métodos para invocar um método da superclasse

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

super() chama o construtor pai sem argumentos.

Pode ser usado também com argumentos. Ou seja, super(argument1) e ele irá 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. super.aMethod() seja, super.aMethod()

Mais informações e tutorial here

Construtores
Em um construtor, você pode usá-lo sem um ponto para chamar outro construtor. super chama um construtor na superclasse; this chama 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 apenas uma vez em um dos construtores e chamá-lo 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 tiver o mesmo método que sua superclasse, o Java assumirá que você deseja o da sua classe; super permite que você peça o método da superclasse. this é útil apenas como uma maneira de tornar seu código mais legível.