ความแตกต่างใน Java (แบบคงที่และแบบไดนามิก)

Polymorphism คืออะไร Java?

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

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

คลิก Good Farm Animal Welfare Awards หากไม่สามารถเข้าถึงวิดีโอได้

Java ความแตกต่างใน OOP พร้อมตัวอย่าง

เรามีคลาสหลักหนึ่งคลาสคือ 'บัญชี' ซึ่งมีฟังก์ชันการฝากและถอน บัญชีมีคลาสย่อย 2 คลาส การดำเนินการฝากและถอนจะเหมือนกันสำหรับบัญชีออมทรัพย์และบัญชีเงินฝากกระแสรายวัน ดังนั้น วิธีการที่สืบทอดมาจากคลาสบัญชีจึงสามารถใช้ได้

การเปลี่ยนแปลงข้อกำหนดซอฟต์แวร์

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

ขั้นตอน 1) เมื่อเรียกวิธี "ถอนออก" สำหรับบัญชีออมทรัพย์แล้ว จะดำเนินการวิธีจากคลาสบัญชีหลัก

ขั้นตอน 2) แต่เมื่อเรียกใช้วิธี "ถอนเงิน" สำหรับบัญชีที่มีสิทธิพิเศษ (วงเงินเบิกเกินบัญชี) วิธีการถอนเงินที่กำหนดไว้ในคลาสที่มีสิทธิพิเศษจะถูกดำเนินการ นี่คือ ความแตกต่างใน OOP

วิธีการเอาชนะใน Java

Method Overriding กำลังกำหนดวิธี super class ใหม่ในคลาสย่อย

กฎเกณฑ์สำหรับการเอาชนะวิธีการ

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

ตัวอย่าง

class Doctor{
  public void treatPatient(){
  // treatPatient method
  
}
class Surgeon extends Doctor{
  public void treatPatient(){
  // treatPatient method
  }
}
Class run{
  public static void main (String args[]){
    Doctor doctorObj = new Doctor()
	// treatPatient method in class Doctor will be executed
    doctorObj.treatPatient();
   
    Surgeon surgeonObj = new Surgeon();
    // treatPatient  method in class Surgeon  will be executed
    surgeonObj.treatPatient();
  }
}

ความแตกต่างระหว่างการโอเวอร์โหลดและการเอาชนะ

void sum (int a , int b);
void sum (int a , int b, int c);
void sum (float a, double b);

class X{
  public int sum(){
     // some code
  }
}
class Y extends X{
  public int sum(){
    //overridden method
   //signature is same
 }
}

Dynamic Polymorphism คืออะไร?

Dynamic Polymorphism ใน OOP เป็นกลไกที่สามารถกำหนดวิธีการได้หลายวิธีด้วยชื่อและลายเซ็นเดียวกันในซูเปอร์คลาสและคลาสย่อย การเรียกไปยังเมธอดที่ถูกแทนที่ได้รับการแก้ไขในขณะใช้งาน

ตัวอย่างความหลากหลายแบบไดนามิก:

ตัวแปรอ้างอิงของคลาสซุปเปอร์สามารถอ้างถึงอ็อบเจ็กต์คลาสย่อยได้

 Doctor obj = new Surgeon();

พิจารณาข้อความดังกล่าว

obj.treatPatient();

ในที่นี้ตัวแปรอ้างอิง “obj” เป็นของคลาสพาเรนต์ แต่ออบเจ็กต์ที่มันชี้ไปนั้นเป็นของคลาสลูก (ดังแสดงในตัวอย่างไดอะแกรมด้านล่างของ Polymorphism)

obj.treatPatient() จะดำเนินการเมธอด treatPatient() ของคลาสย่อย - ศัลยแพทย์

หากใช้การอ้างอิงคลาสพื้นฐานเพื่อเรียกเมธอด JVM จะตัดสินใจเมธอดที่จะเรียกใช้ ขึ้นอยู่กับออบเจ็กต์ที่การอ้างอิงชี้ไป

ตัวอย่างเช่น แม้ว่า obj จะอ้างอิงถึง Doctor แต่ก็เรียกวิธีการของ Surgeon เนื่องจากชี้ไปที่วัตถุ Surgeon

สิ่งนี้จะถูกตัดสินใจในระหว่างรันไทม์และด้วยเหตุนี้จึงเรียกว่า พลวัต or ความหลากหลายทางรันไทม์

void sum (int a , int b);
void sum (float a, double b);
int sum (int a, int b); //compiler gives error.

//reference of parent pointing to child object
 Doctor obj = new Surgeon();
// method of child called
obj.treatPatient();

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

จะเกิดอะไรขึ้นหากวิธี treatPatient ในคลาส Surgeon ต้องการดำเนินการฟังก์ชันที่กำหนดไว้ในคลาส Doctor จากนั้นจึงดำเนินการฟังก์ชันเฉพาะของตัวเอง ในกรณีนี้ คีย์เวิร์ด superสามารถใช้เพื่อเข้าถึงวิธีการของคลาสหลักจากคลาสย่อยได้ วิธีการ treatPatient ในคลาส Surgeon สามารถเขียนได้ดังนี้:

treatPatient(){
   super.treatPatient();
     //add code specific to Surgeon
}

คีย์เวิร์ด super สามารถใช้เพื่อเข้าถึงสมาชิกข้อมูลหรือวิธีการของคลาสซุปเปอร์ในคลาสย่อย

ต่อไป เราจะมาเรียนรู้เกี่ยวกับซูเปอร์คีย์เวิร์ด มรดก และความหลากหลายใน Java พร้อมตัวอย่างโปรแกรม

ตัวอย่าง:-เพื่อเรียนรู้การสืบทอด ความหลากหลาย และคีย์เวิร์ดขั้นสูง

ขั้นตอน 1) คัดลอกโค้ดต่อไปนี้ลงในโปรแกรมแก้ไข

public class Test{
     public static void main(String args[]){
        X x= new X();
       Y y = new  Y();
       y.m2();
      //x.m1();
      //y.m1();
     //x = y;// parent pointing to object of child
     //x.m1() ;
     //y.a=10;
   }
}
class X{
   private int a;
   int b;
      public void m1(){
       System.out.println("This is method m1 of class X");
     }
}
class Y extends X{
      int c; // new instance variable of class Y
         public void m1(){
            // overriden method
            System.out.println("This is method m1 of class Y");
        }
       public void m2(){
           super.m1();
           System.out.println("This is method m2 of class Y");
      }
}

ขั้นตอน 2) บันทึก คอมไพล์ และรันโค้ด สังเกตผลลัพธ์

ขั้นตอน 3) ยกเลิกการแสดงความคิดเห็น บรรทัดที่ 6-9 บันทึก คอมไพล์ และรันโค้ด สังเกตผลลัพธ์

ขั้นตอน 4) ไม่แสดงความคิดเห็นบรรทัด # 10 . บันทึกและคอมไพล์โค้ด

ขั้นตอน 5) ข้อผิดพลาด = ? เนื่องจากคลาสย่อยไม่สามารถเข้าถึงสมาชิกส่วนตัวของคลาสซุปเปอร์ได้

สรุป

• ความแตกต่างในการเขียนโปรแกรมเชิงวัตถุเกิดขึ้นเมื่อมีคลาสหรืออ็อบเจ็กต์ตั้งแต่หนึ่งคลาสขึ้นไปที่เกี่ยวข้องกันโดยการสืบทอด เป็นความสามารถของวัตถุที่มีหลายรูปแบบ
• Method Overriding กำลังกำหนดวิธี super class ใหม่ในคลาสย่อย
• ความแตกต่างแบบไดนามิกใน Java เป็นกลไกที่สามารถกำหนดได้หลายวิธีด้วยชื่อและลายเซ็นเดียวกันในซูเปอร์คลาสและคลาสย่อย
• ความหลากหลายแบบคงที่ใน Java เป็นประเภทของความหลากหลายที่รวบรวมข้อมูลสำหรับการเรียกใช้เมธอด ณ เวลาที่คอมไพล์ ในขณะที่ Dynamic Polymorphism คือความหลากหลายประเภทหนึ่งที่รวบรวมข้อมูลสำหรับการเรียกใช้เมธอด ณ รันไทม์
• สามารถใช้คีย์เวิร์ด Super เพื่อเข้าถึงวิธีการของคลาสหลักจากคลาสย่อยได้