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

Polymorphism คืออะไร Java?

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

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

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

เหตุใดจึงใช้โพลีมอร์ฟิซึมใน Java?

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

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

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

Java ตัวอย่างความหลากหลาย

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

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

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

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

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

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

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

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

ตัวอย่าง

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

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

การโอเวอร์โหลดเมธอด (Method Overloading) เกิดขึ้นภายในคลาสเดียวกัน โดยใช้ชื่อเมธอดเดียวกันแต่มีลายเซ็นที่แตกต่างกัน ในขณะที่การโอเวอร์ไรด์เมธอด (Method Overriding) เกิดขึ้นระหว่างคลาสแม่และคลาสลูก โดยที่คลาสลูกจะกำหนดนิยามใหม่ของเมธอดที่ประกาศไว้ในคลาสแม่

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 คืออะไร?

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

ตัวอย่างโพลีมอร์ฟิซึมแบบไดนามิก

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

 Doctor obj = new Surgeon();

ลองพิจารณาข้อความต่อไปนี้:

obj.treatPatient();

นี่คือตัวแปรอ้างอิง obj ตัวแปรนั้นเป็นของคลาสแม่ แต่ตัวชี้ไปยังวัตถุนั้นเป็นของคลาสลูก ดังแสดงในแผนภาพของโพลีมอร์ฟิซึม

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

ความแตกต่างระหว่างโพลีมอร์ฟิซึมแบบคงที่และแบบไดนามิก

ความหลากหลายแบบคงที่ใน Java Polymorphism แบบ `constructed` คือรูปแบบหนึ่งของ polymorphism ที่รวบรวมข้อมูลสำหรับการเรียกใช้เมธอดในระหว่างการคอมไพล์ ในขณะที่ Dynamic Polymorphism คือรูปแบบหนึ่งของ polymorphism ที่รวบรวมข้อมูลสำหรับการเรียกใช้เมธอดในระหว่างการทำงานของโปรแกรม

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` สามารถใช้เพื่อเข้าถึงสมาชิกข้อมูลหรือเมธอดใดๆ ของคลาสแม่ภายในคลาสลูกได้ ต่อไปเราจะมาเรียนรู้เกี่ยวกับคีย์เวิร์ด `super` กัน มรดกและภาวะพหุรูปใน Java พร้อมตัวอย่างโปรแกรม

ตัวอย่าง: เพื่อเรียนรู้เรื่องการสืบทอด (Inheritance), พหุรูป (Polymorphism) และคำหลัก super

ขั้นตอน 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(){
            // overridden 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) ข้อผิดพลาด = ? เนื่องจากคลาสย่อยไม่สามารถเข้าถึงสมาชิกส่วนตัวของคลาสแม่ได้

คำถามที่พบบ่อย