super () em Java

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

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 methods do pai. super.aMethod() seja, super.aMethod()

Mais informações e tutorial aqui

1. super() é usado para chamar pai imediato.

2. super() pode ser usado com membros de instância, isto é, variables ​​de instância e methods de instância.

3. super() pode ser usado dentro do construtor para chamar o construtor da class pai.

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

Confira a diferença entre o programa 1 e 2. Aqui programa 2 provas nossa primeira declaração de 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(); } } 

Saída: –

200

200

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

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

Saída

100

200

No programa 1, a saída foi apenas da class derivada. Não foi possível imprimir a variável da class base ou da class pai. Mas no programa 2, usamos um super() com a variável a enquanto imprimindo sua saída e ao invés de imprimir o valor da variável a de derivada, imprimiu o valor da variável a da class base. Então isso prova que super() é usado para chamar pai imediato.

OK, agora verifique 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(); } } 

Saída

200

Aqui a saída é 200. Quando chamamos a function show, a function show da class derivada foi chamada. Mas o que devemos fazer se quisermos chamar a function show da class pai? Confira o programa 4 para 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(); } } 

Saída

100

200

Aqui estamos obtendo duas saídas 100 e 200. Quando a function show da class derivada é chamada, primeiro chama a function show da class pai porque dentro da function show da class derivada nós chamamos a function show da class pai colocando a palavra-chave super antes do nome da function.

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

Dê uma olhada neste exemplo:

 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. 

O super () é usado para chamar o construtor pai?

Sim.

Pls explica sobre Super ().

super() é um uso especial da palavra super chave super qual você chama um construtor pai sem parâmetros. Em geral, a palavra super chave super pode ser usada para chamar methods substituídos, acessar campos ocultos ou chamar o construtor de uma superclass.

Aqui está o tutorial oficial

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

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

Um rápido google para “Java super” resulta neste

Chamar o super construtor sem argumentos é apenas um desperdício de espaço na canvas 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 como

 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 à variável de membro n.

Se o seu método replace um dos methods de sua superclass, você poderá invocar o método substituído através do uso da palavra-chave super. Você também pode usar super para se referir a um campo oculto (embora esconder campos seja desencorajado). Considere esta class, Superclass:

 public class Superclass { public void printMethod() { System.out.println("Printed in Superclass."); } } 

Aqui está uma subclass, chamada Subclass, que substitui 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(); } } 

Dentro da subclass, o nome simples printMethod () refere-se ao declarado na subclass, que substitui o da superclass. Portanto, para se referir a printMethod () herdado da Superclass, Subclass deve usar um nome qualificado, usando super como mostrado. Compilar e executar Subclass imprime o seguinte:

Impresso na Superclass. Impresso em construtores de subclass de subclass

O exemplo a seguir ilustra como usar a palavra-chave super para chamar o construtor de uma superclass. Lembre-se do exemplo da bicicleta que MountainBike é uma subclass de bicicleta. Aqui está o construtor MountainBike (subclass) que chama o construtor da superclass e, em seguida, adiciona seu próprio código de boot:

 public MountainBike(int startHeight, int startCadence,int startSpeed, int startGear) { super(startCadence, startSpeed, startGear); seatHeight = startHeight; } 

A invocação de um construtor de superclass deve ser a primeira linha no construtor da subclass.

A syntax para chamar um construtor de superclass é

super();
ou: super (lista de parâmetros); Com super (), o construtor sem argumentos da superclass é chamado. Com super (lista de parâmetros), o construtor da superclass com uma lista de parâmetros correspondente é chamado.

Apenas super (); sozinho irá chamar o construtor padrão, se existir da superclass de uma class. 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 Superclass universal, e você não pode chamá-lo em uma subclass.

 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 selenium, você tem um PageObject que pode usar o construtor de seu pai assim:

 public class DeveloperSteps extends ScenarioSteps { public DeveloperSteps(Pages pages) { super(pages); }........ 

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.

Construtores
Em um construtor, você pode usá-lo sem um ponto para chamar outro construtor. super chama um construtor na superclass; this chama um construtor nesta class:

 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 superclass precisar se inicializar. this é útil para permitir que você escreva todo o código de boot 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 superclass; this.method() chama um método nesta class:

 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 class tiver o mesmo método da sua superclass, o Java assumirá que você deseja o da sua class; super permite que você peça o método da superclass. this é útil apenas como uma forma de tornar seu código mais legível.

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

Quando você chama super () com os argumentos corretos, na verdade chamamos o construtor Box , que inicializa as variables 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 variables ​​de class Box como privadas . Coloque nos campos do modificador privado da class Box e certifique-se de que você pode acessá-los sem problemas.

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

super é uma palavra-chave. É usado dentro de uma definição de método de subclass para chamar um método definido na superclass. Métodos privados da superclass não podem ser chamados. Apenas methods públicos e protegidos podem ser chamados pela palavra-chave super. Ele também é usado por construtores de class para chamar construtores de sua class pai.

Verifique aqui para mais explicações.

Super palavra-chave em java

Super palavra-chave é uma variável de referência usada para referenciar o object de class pai.

Por que usar super palavra-chave em java?

Sempre que herda os dados da class base na class derivada é a chance de obter ambigüidade, porque pode ser a class base e os dados da class derivada são iguais, então, para a diferença, esses dados precisam usar a palavra-chave super

Super palavra-chave no nível do método?

Super palavra – chave também é usada para chamar método de class pai. Super palavra-chave deve ser usada em caso de substituição do método.

Quando usar a palavra-chave Super no nível do método?

Uso de palavra-chave super quando o nome do método da class base e o nome do método da class derivada tiverem o mesmo nome.

http://www.tutorial4us.com/java/java-super-keyword