super () di Jawa

Apakah super()digunakan untuk memanggil orang tua konstruktor? Tolong jelaskan super().

super() memanggil induk konstruktor tanpa argumen.

Dapat digunakan juga dengan argumen. Yaitu super(argument1)dan itu akan memanggil konstruktor yang menerima 1 parameter dari tipe argument1(jika ada).

Juga dapat digunakan untuk memanggil metode dari orang tua. Yaitusuper.aMethod()

Info lebih lanjut dan tutorial di sini

Beberapa fakta:

1. super() digunakan untuk memanggil orang tua langsung.
2. super() dapat digunakan dengan anggota instance, yaitu variabel instan dan metode instance.
3. super() dapat digunakan dalam konstruktor untuk memanggil konstruktor dari kelas induk.

OK, sekarang mari kita secara praktis mengimplementasikan poin-poin ini super().

Lihat perbedaan antara program 1 dan 2. Di sini, program 2 membuktikan pernyataan pertama kami super()di Jawa.

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

Keluaran:

200
200

Sekarang periksa program 2 dan coba cari tahu perbedaan utamanya.

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

Keluaran:

100
200

Dalam program 1, output hanya dari kelas turunan. Itu tidak bisa mencetak variabel baik kelas dasar maupun kelas induk. Namun dalam program 2, kami menggunakan super()variabel asaat mencetak outputnya, dan alih-alih mencetak nilai variabel adari kelas turunan, ia mencetak nilai variabel adari kelas dasar. Jadi itu membuktikan yang super()digunakan untuk memanggil orang tua langsung.

OK, sekarang periksa perbedaan antara program 3 dan program 4.

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

Keluaran:

200

Di sini outputnya adalah 200. Ketika kami memanggil Show(), Show()fungsi dari kelas turunan dipanggil. Tetapi apa yang harus kita lakukan jika kita ingin memanggil Show()fungsi kelas induk? Lihat program 4 untuk solusinya.

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

Keluaran:

100
200

Di sini kita mendapatkan dua output, 100 dan 200. Ketika Show()fungsi kelas turunan dipanggil, pertama-tama memanggil Show()fungsi kelas induk, karena di dalam Show()fungsi kelas turunan, kita memanggil Show()fungsi kelas induk dengan meletakkan yang superkata kunci sebelum nama fungsi.

Sumber artikel: Java: Calling super ()

Iya. super(...)akan memanggil konstruktor kelas super.

Ilustrasi:

Contoh yang berdiri sendiri:

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

Cetakan:

Constructing an animal: From Dog constructor
Constructing a dog.

Apakah super () digunakan untuk memanggil konstruktor induk?

Iya.

Tolong jelaskan tentang Super ().

super()adalah penggunaan khusus superkata kunci tempat Anda memanggil konstruktor induk tanpa parameter. Secara umum, superkata kunci dapat digunakan untuk memanggil metode yang diganti, mengakses bidang tersembunyi atau memanggil konstruktor superclass.

Inilah tutorial resmi

Memanggil konstruktor tanpa-argumen super hanya membuang-buang ruang layar dan waktu programmer. Kompiler menghasilkan kode yang persis sama, baik Anda menulisnya atau tidak.

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

class Implicit {
    Implicit() {
    }
}

Ya, super()(huruf kecil) memanggil konstruktor dari kelas induk. Anda bisa memasukkan argumen:super(foo, bar)

Ada juga superkata kunci, yang dapat Anda gunakan dalam metode untuk memanggil metode dari superclass

Google cepat untuk "Java super" menghasilkan ini

Itu betul. Super digunakan untuk memanggil konstruktor induk. Jadi misalkan Anda memiliki blok kode seperti itu

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

Kemudian Anda dapat menetapkan nilai ke variabel anggota n.

Saya telah melihat semua jawabannya. Tetapi semua orang lupa menyebutkan satu hal yang sangat penting:

super () harus dipanggil atau digunakan di baris pertama konstruktor.

Hanya super (); sendiri akan memanggil konstruktor default, jika ada superclass kelas. Tetapi Anda harus secara eksplisit menulis konstruktor default sendiri. Jika Anda tidak, Java akan menghasilkan satu untuk Anda tanpa implementasi, save super (); , mengacu pada Obyek Superclass universal, dan Anda tidak dapat menyebutnya dalam subkelas.

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

}

Misalnya, dalam otomatisasi selenium, Anda memiliki PageObject yang dapat menggunakan konstruktor induknya seperti ini:

public class DeveloperSteps extends ScenarioSteps {

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

Saya ingin berbagi dengan kode apa pun yang saya mengerti.

Kata kunci super di java adalah variabel referensi yang digunakan untuk merujuk objek kelas induk. Ini sebagian besar digunakan dalam konteks berikut: -

1. Penggunaan super dengan variabel:

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

Keluaran:-

Maximum Speed: 120

2. Penggunaan super dengan metode:

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

Keluaran:-

This is student class
This is person class

3. Penggunaan super dengan konstruktor:

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

Keluaran:-

Person class Constructor
Student class Constructor

Konstruktor
Dalam konstruktor, Anda dapat menggunakannya tanpa titik untuk memanggil konstruktor lain. supermemanggil konstruktor di superclass; thismemanggil konstruktor di kelas ini:

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

superberguna jika superclass perlu diinisialisasi sendiri. thisberguna untuk memungkinkan Anda untuk menulis semua kode inisialisasi keras hanya sekali di salah satu konstruktor dan memanggilnya dari semua yang lain, jauh lebih mudah untuk menulis konstruktor.

Metode
Dalam metode apa pun, Anda dapat menggunakannya dengan titik untuk memanggil metode lain. super.method()memanggil metode dalam superclass; this.method()memanggil metode di kelas ini:

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

superberguna dalam skenario tertentu: jika kelas Anda memiliki metode yang sama dengan superclass Anda, Java akan menganggap Anda menginginkan yang ada di kelas Anda; supermemungkinkan Anda untuk meminta metode superclass. thishanya berguna sebagai cara untuk membuat kode Anda lebih mudah dibaca.

Kata kunci super dapat digunakan untuk memanggil konstruktor superclass dan merujuk ke anggota superclass

Saat Anda memanggil super () dengan argumen yang benar, kami sebenarnya memanggil Kotak konstruktor , yang menginisialisasi variabel lebar , tinggi dan kedalaman , merujuknya dengan menggunakan nilai-nilai parameter yang sesuai. Anda tinggal menginisialisasi bobot nilai tambahnya. Jika perlu, Anda dapat melakukan sekarang variabel Box kelas sebagai pribadi . Letakkan di bidang pengubah pribadi kelas Box dan pastikan bahwa Anda dapat mengaksesnya tanpa masalah.

Pada superclass dapat ada beberapa konstruktor versi kelebihan beban, sehingga Anda dapat memanggil metode super () dengan parameter yang berbeda. Program akan melakukan konstruktor yang cocok dengan argumen yang ditentukan.

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 adalah kata kunci. Ini digunakan di dalam definisi metode sub-kelas untuk memanggil metode yang didefinisikan dalam superclass. Metode pribadi superclass tidak dapat dipanggil. Hanya metode publik dan yang dilindungi yang dapat dipanggil oleh kata kunci super. Ini juga digunakan oleh konstruktor kelas untuk memanggil konstruktor dari kelas induknya.

Periksa di sini untuk penjelasan lebih lanjut.

Seperti yang dinyatakan, di dalam konstruktor default ada super implisit () dipanggil pada baris pertama konstruktor.

Super () ini secara otomatis memanggil rantai konstruktor mulai dari atas hierarki kelas dan bergerak ke bawah hierarki.

Jika ada lebih dari dua kelas dalam hirarki kelas program, konstruktor default kelas atas akan dipanggil terlebih dahulu .

Berikut ini contohnya:

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

Output di atas akan:

Constructor A
Constructor B
Constructor C