Java - การสืบทอด

การสืบทอดสามารถกำหนดเป็นกระบวนการที่คลาสหนึ่งได้รับคุณสมบัติ (วิธีการและฟิลด์) ของอีกคลาสหนึ่ง ด้วยการใช้การสืบทอดข้อมูลจะถูกจัดการได้ตามลำดับชั้น

คลาสที่สืบทอดคุณสมบัติของอื่น ๆ เรียกว่าคลาสย่อย (คลาสที่ได้รับคลาสย่อย) และคลาสที่มีคุณสมบัติสืบทอดเรียกว่าซูเปอร์คลาส (คลาสพื้นฐานคลาสพาเรนต์)

ขยายคำหลัก

extendsคือคีย์เวิร์ดที่ใช้สืบทอดคุณสมบัติของคลาส ต่อไปนี้เป็นไวยากรณ์ของคำหลักขยาย

Syntax

class Super {
   .....
   .....
}
class Sub extends Super {
   .....
   .....
}

ตัวอย่างรหัส

ต่อไปนี้เป็นตัวอย่างที่แสดงให้เห็นถึงการสืบทอด Java ในตัวอย่างนี้คุณสามารถสังเกตสองคลาส ได้แก่ การคำนวณและการคำนวณของฉัน

การใช้คีย์เวิร์ดขยาย My_Calculation จะสืบทอดวิธีการเพิ่ม () และการลบ () ของคลาสการคำนวณ

คัดลอกและวางโปรแกรมต่อไปนี้ในไฟล์ชื่อ My_Calculation.java

Example

class Calculation {
   int z;
	
   public void addition(int x, int y) {
      z = x + y;
      System.out.println("The sum of the given numbers:"+z);
   }
	
   public void Subtraction(int x, int y) {
      z = x - y;
      System.out.println("The difference between the given numbers:"+z);
   }
}

public class My_Calculation extends Calculation {
   public void multiplication(int x, int y) {
      z = x * y;
      System.out.println("The product of the given numbers:"+z);
   }
	
   public static void main(String args[]) {
      int a = 20, b = 10;
      My_Calculation demo = new My_Calculation();
      demo.addition(a, b);
      demo.Subtraction(a, b);
      demo.multiplication(a, b);
   }
}

คอมไพล์และรันโค้ดด้านบนตามที่แสดงด้านล่าง

javac My_Calculation.java
java My_Calculation

หลังจากรันโปรแกรมแล้วจะให้ผลลัพธ์ดังนี้ -

Output

The sum of the given numbers:30
The difference between the given numbers:10
The product of the given numbers:200

ในโปรแกรมที่กำหนดเมื่อวัตถุไป My_Calculationคลาสถูกสร้างขึ้นสำเนาของเนื้อหาของซูเปอร์คลาสจะถูกสร้างขึ้นภายในนั้น ด้วยเหตุนี้การใช้ออบเจ็กต์ของคลาสย่อยคุณสามารถเข้าถึงสมาชิกของซูเปอร์คลาสได้

ตัวแปรอ้างอิง Superclass สามารถเก็บอ็อบเจ็กต์คลาสย่อยได้ แต่การใช้ตัวแปรนั้นคุณสามารถเข้าถึงได้เฉพาะสมาชิกของ superclass ดังนั้นในการเข้าถึงสมาชิกของทั้งสองคลาสขอแนะนำให้สร้างตัวแปรอ้างอิงให้กับคลาสย่อยเสมอ

หากคุณพิจารณาโปรแกรมข้างต้นคุณสามารถสร้างอินสแตนซ์ของชั้นเรียนได้ตามที่ระบุด้านล่าง แต่ใช้ตัวแปรอ้างอิงระดับซุปเปอร์คลาส (cal ในกรณีนี้) คุณไม่สามารถเรียกใช้เมธอดได้ multiplication()ซึ่งเป็นของคลาสย่อย My_Calculation

Calculation demo = new My_Calculation();
demo.addition(a, b);
demo.Subtraction(a, b);

Note- คลาสย่อยจะสืบทอดสมาชิกทั้งหมด (ฟิลด์เมธอดและคลาสที่ซ้อนกัน) จากซูเปอร์คลาส Constructor ไม่ใช่สมาชิกดังนั้นจึงไม่ได้รับการสืบทอดจากคลาสย่อย แต่สามารถเรียกตัวสร้างของ superclass จากคลาสย่อยได้

ซูเปอร์คีย์เวิร์ด

super คีย์เวิร์ดคล้ายกับ thisคำสำคัญ. ต่อไปนี้เป็นสถานการณ์จำลองที่ใช้ซุปเปอร์คีย์เวิร์ด

  • มันถูกใช้เพื่อ differentiate the members ของซูเปอร์คลาสจากสมาชิกของคลาสย่อยหากมีชื่อเดียวกัน

  • มันถูกใช้เพื่อ invoke the superclass ตัวสร้างจากคลาสย่อย

สร้างความแตกต่างให้กับสมาชิก

ถ้าคลาสกำลังสืบทอดคุณสมบัติของคลาสอื่น และถ้าสมาชิกของ superclass มีชื่อเหมือนกับคลาสย่อยเพื่อแยกความแตกต่างของตัวแปรเหล่านี้เราใช้คำหลักระดับสูงตามที่แสดงด้านล่าง

super.variable
super.method();

ตัวอย่างรหัส

ส่วนนี้แสดงโปรแกรมที่สาธิตการใช้งานไฟล์ super คำสำคัญ.

ในโปรแกรมที่กำหนดคุณมีสองคลาสคือSub_classและSuper_classทั้งสองมีเมธอดชื่อ display () ที่มีการนำไปใช้งานที่แตกต่างกันและตัวแปรชื่อ num ที่มีค่าต่างกัน เรากำลังเรียกใช้วิธี display () ของทั้งสองคลาสและพิมพ์ค่าของตัวแปร num ของทั้งสองคลาส ที่นี่คุณสามารถสังเกตได้ว่าเราได้ใช้คำหลักระดับสูงเพื่อแยกความแตกต่างของสมาชิกของซูเปอร์คลาสจากคลาสย่อย

คัดลอกและวางโปรแกรมในไฟล์ชื่อ Sub_class.java

Example

class Super_class {
   int num = 20;

   // display method of superclass
   public void display() {
      System.out.println("This is the display method of superclass");
   }
}

public class Sub_class extends Super_class {
   int num = 10;

   // display method of sub class
   public void display() {
      System.out.println("This is the display method of subclass");
   }

   public void my_method() {
      // Instantiating subclass
      Sub_class sub = new Sub_class();

      // Invoking the display() method of sub class
      sub.display();

      // Invoking the display() method of superclass
      super.display();

      // printing the value of variable num of subclass
      System.out.println("value of the variable named num in sub class:"+ sub.num);

      // printing the value of variable num of superclass
      System.out.println("value of the variable named num in super class:"+ super.num);
   }

   public static void main(String args[]) {
      Sub_class obj = new Sub_class();
      obj.my_method();
   }
}

คอมไพล์และรันโค้ดด้านบนโดยใช้ไวยากรณ์ต่อไปนี้

javac Super_Demo
java Super

ในการดำเนินการโปรแกรมคุณจะได้รับผลลัพธ์ดังต่อไปนี้ -

Output

This is the display method of subclass
This is the display method of superclass
value of the variable named num in sub class:10
value of the variable named num in super class:20

เรียกใช้ Superclass Constructor

ถ้าคลาสกำลังสืบทอดคุณสมบัติของคลาสอื่นคลาสย่อยจะได้รับคอนสตรัคเตอร์เริ่มต้นของซูเปอร์คลาสโดยอัตโนมัติ แต่ถ้าคุณต้องการเรียกตัวสร้างพารามิเตอร์ของซูเปอร์คลาสคุณต้องใช้ซูเปอร์คีย์เวิร์ดดังที่แสดงด้านล่าง

super(values);

ตัวอย่างรหัส

โปรแกรมที่ให้ในส่วนนี้แสดงให้เห็นถึงวิธีการใช้ซูเปอร์คีย์เวิร์ดเพื่อเรียกใช้ตัวสร้างพารามิเตอร์ของซูเปอร์คลาส โปรแกรมนี้มีซูเปอร์คลาสและคลาสย่อยโดยที่ซูเปอร์คลาสมีคอนสตรัคเตอร์ที่กำหนดพารามิเตอร์ซึ่งยอมรับค่าจำนวนเต็มและเราใช้ซูเปอร์คีย์เวิร์ดเพื่อเรียกใช้คอนสตรัคเตอร์ที่กำหนดพารามิเตอร์ของซูเปอร์คลาส

คัดลอกและวางโปรแกรมต่อไปนี้ในไฟล์ชื่อ Subclass.java

Example

class Superclass {
   int age;

   Superclass(int age) {
      this.age = age; 		 
   }

   public void getAge() {
      System.out.println("The value of the variable named age in super class is: " +age);
   }
}

public class Subclass extends Superclass {
   Subclass(int age) {
      super(age);
   }

   public static void main(String args[]) {
      Subclass s = new Subclass(24);
      s.getAge();
   }
}

คอมไพล์และรันโค้ดด้านบนโดยใช้ไวยากรณ์ต่อไปนี้

javac Subclass
java Subclass

ในการดำเนินการโปรแกรมคุณจะได้รับผลลัพธ์ดังต่อไปนี้ -

Output

The value of the variable named age in super class is: 24

IS-A ความสัมพันธ์

IS-A เป็นวิธีการพูด: วัตถุนี้เป็นประเภทของวัตถุนั้น ให้เราดูว่าextends คีย์เวิร์ดใช้เพื่อบรรลุการสืบทอด

public class Animal {
}

public class Mammal extends Animal {
}

public class Reptile extends Animal {
}

public class Dog extends Mammal {
}

ตอนนี้ตามตัวอย่างข้างต้นในแง่ของ Object-Oriented ต่อไปนี้เป็นจริง -

  • สัตว์เป็นซุปเปอร์คลาสของสัตว์เลี้ยงลูกด้วยนม
  • สัตว์เป็นซุปเปอร์คลาสของสัตว์เลื้อยคลาน
  • สัตว์เลี้ยงลูกด้วยนมและสัตว์เลื้อยคลานเป็นคลาสย่อยของคลาสสัตว์
  • สุนัขเป็นคลาสย่อยของทั้งสัตว์เลี้ยงลูกด้วยนมและสัตว์

ตอนนี้ถ้าเราพิจารณาความสัมพันธ์ IS-A เราสามารถพูดได้ว่า -

  • สัตว์เลี้ยงลูกด้วยนม IS-A
  • สัตว์เลื้อยคลาน IS-A สัตว์
  • สุนัข IS-A เลี้ยงลูกด้วยนม
  • ดังนั้น: สุนัขก็เป็นสัตว์เช่นกัน

ด้วยการใช้คีย์เวิร์ดขยายคลาสย่อยจะสามารถสืบทอดคุณสมบัติทั้งหมดของซูเปอร์คลาสได้ยกเว้นคุณสมบัติส่วนตัวของซูเปอร์คลาส

เราสามารถมั่นใจได้ว่าสัตว์เลี้ยงลูกด้วยนมเป็นสัตว์ที่มีการใช้ตัวดำเนินการอินสแตนซ์

Example

class Animal {
}

class Mammal extends Animal {
}

class Reptile extends Animal {
}

public class Dog extends Mammal {

   public static void main(String args[]) {
      Animal a = new Animal();
      Mammal m = new Mammal();
      Dog d = new Dog();

      System.out.println(m instanceof Animal);
      System.out.println(d instanceof Mammal);
      System.out.println(d instanceof Animal);
   }
}

สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้ -

Output

true
true
true

เนื่องจากเรามีความเข้าใจเป็นอย่างดีเกี่ยวกับไฟล์ extends คำหลักให้เราดูว่า implements คีย์เวิร์ดใช้เพื่อรับความสัมพันธ์ IS-A

โดยทั่วไปไฟล์ implementsคีย์เวิร์ดใช้กับคลาสเพื่อสืบทอดคุณสมบัติของอินเทอร์เฟซ ไม่สามารถขยายอินเทอร์เฟซตามคลาสได้

Example

public interface Animal {
}

public class Mammal implements Animal {
}

public class Dog extends Mammal {
}

อินสแตนซ์ของคำหลัก

ให้เราใช้ไฟล์ instanceof เจ้าหน้าที่ตรวจสอบว่าสัตว์เลี้ยงลูกด้วยนมเป็นสัตว์จริงหรือไม่และสุนัขก็เป็นสัตว์จริงๆ

Example

interface Animal{}
class Mammal implements Animal{}

public class Dog extends Mammal {

   public static void main(String args[]) {
      Mammal m = new Mammal();
      Dog d = new Dog();

      System.out.println(m instanceof Animal);
      System.out.println(d instanceof Mammal);
      System.out.println(d instanceof Animal);
   }
}

สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้ -

Output

true
true
true

HAS-A ความสัมพันธ์

ความสัมพันธ์เหล่านี้ขึ้นอยู่กับการใช้งานเป็นหลัก สิ่งนี้กำหนดว่าเป็นคลาสใดคลาสหนึ่งHAS-Aสิ่งที่แน่นอน ความสัมพันธ์นี้ช่วยลดความซ้ำซ้อนของรหัสและจุดบกพร่อง

มาดูตัวอย่างกัน -

Example

public class Vehicle{}
public class Speed{}

public class Van extends Vehicle {
   private Speed sp;
}

นี่แสดงว่าคลาส Van HAS-A Speed ด้วยการมีคลาสแยกต่างหากสำหรับ Speed ​​เราไม่จำเป็นต้องใส่โค้ดทั้งหมดที่เป็นของ speed ไว้ในคลาส Van ซึ่งทำให้สามารถนำคลาส Speed ​​มาใช้ซ้ำได้ในหลาย ๆ แอพพลิเคชั่น

ในคุณสมบัติเชิงวัตถุผู้ใช้ไม่จำเป็นต้องกังวลว่าวัตถุใดกำลังทำงานจริง เพื่อให้บรรลุสิ่งนี้คลาส Van จะซ่อนรายละเอียดการใช้งานจากผู้ใช้คลาส Van ดังนั้นโดยพื้นฐานแล้วสิ่งที่เกิดขึ้นคือผู้ใช้จะขอให้คลาส Van ดำเนินการบางอย่างและคลาส Van จะทำงานด้วยตัวเองหรือขอให้คลาสอื่นดำเนินการ

ประเภทของมรดก

การถ่ายทอดทางพันธุกรรมมีหลายประเภทดังแสดงด้านล่าง

ข้อเท็จจริงที่สำคัญมากที่ต้องจำไว้คือ Java ไม่รองรับการสืบทอดหลายรายการ ซึ่งหมายความว่าคลาสไม่สามารถขยายได้มากกว่าหนึ่งคลาส การทำตามจึงผิดกฎหมาย -

Example

public class extends Animal, Mammal{}

อย่างไรก็ตามคลาสสามารถใช้หนึ่งอินเทอร์เฟซหรือมากกว่าซึ่งช่วยให้ Java กำจัดความเป็นไปไม่ได้ของการสืบทอดหลายรายการ