Teknik penggunaan semula nama yang berbeza di Jawa

Di Java, terdapat teknik penggunaan semula nama yang berbeza untuk pelbagai jenis entiti seperti pembolehubah, kaedah, jenis data atau pakej. Teknologi ini mempengaruhi kebolehcapaian dan tingkah laku entiti berdasarkan keperluan dan penggunaannya. Dalam artikel ini, kita akan membincangkan empat cara biasa untuk menggunakan semula nama dalam Java: mengatasi, menyembunyikan, melebihkan dan membayangi

Namakan teknologi guna semula dalam Java

Bayang-bayang

Teknik ini membolehkan pembolehubah tempatan mempunyai nama yang sama dengan medan lain atau ahli kelas yang disertakan. Dalam kes ini, pelaksanaan ahli sebelum ini dikaburkan oleh pengisytiharan pembolehubah baharu. Pembolehubah tersembunyi tidak boleh diakses dengan nama ringkasnya dalam skop tersembunyi.

Contoh Bayang

Contoh berikut menunjukkan lorekan pembolehubah

class OuterClass {
   int val1 = 12109659; // instance variable
   void printX() {
      int val1 = 11368; // local variable
      System.out.println("Value 1: " + val1); // belongs to current method
      System.out.println("Value 2: " + this.val1); // belongs to class
   }
}
public class Shwd {
   public static void main(String[] args) {
      OuterClass oc = new OuterClass(); // creating class object
      oc.printX(); // method call
   }
}

Output

Value 1: 11368
Value 2: 12109659

Dalam kod di atas, kami telah menyembunyikan pembolehubah contoh "val1" dalam kaedah "printX()". Untuk mengakses "val1" kami menggunakan kata kunci "ini".

Sembunyi

Teknik ini membolehkan subkelas menyembunyikan kaedah statik atau medan yang ditakrifkan dalam superclass mereka. Entiti subkelas mesti mempunyai nama dan tandatangan yang sama dengan entiti superclass. kebanyakannya Sebilangan daripada kita tersilap percaya bahawa bersembunyi adalah keterlaluan. Dalam kaedah mengatasi, subkelas menggantikan Laksanakan kaedah asal dengan kaedah baru, tetapi secara bersembunyi, kita hanya bersembunyi Kaedah kelas super. Selain itu, kami tidak boleh mengatasi kaedah statik.

Sembunyikan contoh

Contoh berikut menggambarkan kaedah bersembunyi.

class ClassA {
   public static void print() {
      System.out.println("This is Super Class method");
   }
}
class ClassB extends ClassA {
   public static void print() {
      System.out.println("This is Sub Class method");
   }
}
public class Main {
   public static void main(String[] args) {
      ClassA s1 = new ClassA(); // creating object
      ClassA s2 = new ClassB();
      // calling the methods
      s1.print();
      s2.print();
      ClassB.print();
   }
}

Output

This is Super Class method
This is Super Class method
This is Sub Class method

Dalam kod di atas, kami mentakrifkan kelas "Super" dan "Sub" dan "print()" kaedah. Kaedah 'print()' kelas 'Sub' menyembunyikan kaedah kelas 'Super'. jika 's2.print' akan mencetak kandungan subkelas, maka contoh ini akan dipertimbangkan Ditindih sebagai kaedah dan bukannya tersembunyi.

Kaedah terlebih beban

Apabila kita mencipta dua atau lebih kaedah dengan nama yang sama tetapi dengan senarai yang berbeza Kemudian, jika parameter berada dalam badan kelas yang sama, kami memanggilnya kaedah terlebih beban. penyusun Tentukan panggilan kaedah masa kompilasi berdasarkan jenis parameter

Contoh kaedah terlebih beban

Contoh ini menunjukkan pelaksanaan kaedah lebih muatan.

public class Ovrld {
   public static void methodA(String st1) {
      System.out.println("First method string: " + st1);
   }
   public static void methodA(String st1, String st2) { // overloading
      System.out.println("Second Method");
      System.out.println("String1: " + st1 + ", String2: " + st2);
   }
   public static void main(String args[]) {
      Ovrld obj = new Ovrld();
      // method calling
      obj.methodA("Tutorialspoint");
      obj.methodA("Simple", "Learning");
   }
}

Output

First method string: Tutorialspoint
Second Method
String1: Simple, String2: Learning

Dalam kod di atas, kami mentakrifkan dua kaedah dengan nama yang sama tetapi parameter berbeza. Semasa panggilan kami menggunakan hujah yang berbeza.

Kaedah menulis semula

Apabila kami mencipta dua atau lebih kaedah dengan nama yang sama dan senarai parameter yang sama dalam kelas super dan subkelas, kami memanggilnya mengatasi kaedah. Jenis pulangan kaedah juga sama.

Contoh penulisan semula kaedah

Contoh berikut menunjukkan kaedah mengatasi.

class Ovriid1 {
   public void methodA(String st1) {
      System.out.println("First method string: " + st1);
   }
}
public class Ovriid2 extends Ovriid1 {
   public void methodA(String st1) {
      System.out.println("Second Method string: " + st1);
   }
   public static void main(String args[]) {
      Ovriid1 obj1 = new Ovriid1();
      Ovriid1 obj2 = new Ovriid2();
      obj1.methodA("Tutorialspoint");
      obj2.methodA("Tutorialspoint");
   }
}

Output

First method string: Tutorialspoint
Second Method string: Tutorialspoint

Dalam kod di atas, subkelas "Ovriid2" mengatasi "methodA()" kelas super.

Kesimpulan

Dalam artikel ini, kami mempelajari pelbagai teknik untuk menggunakan semula pembolehubah dan nama kaedah seperti kaedah terlebih muatan, menyembunyikan, menyembunyikan dan mengatasi kaedah. Kami juga melihat cara untuk melaksanakannya dalam program Java.

Atas ialah kandungan terperinci Teknik penggunaan semula nama yang berbeza di Jawa. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!