ความหลากหลาย - กำหนดเพียงสองประโยค [ปิด]

ฉันได้ดูคำจำกัดความและคำอธิบายอื่น ๆ แล้วและไม่มีข้อใดที่ทำให้ฉันพอใจ ฉันต้องการดูว่ามีใครสามารถกำหนดความหลากหลายได้มากที่สุดสองประโยคโดยไม่ต้องใช้รหัสหรือตัวอย่างใด ๆ ฉันไม่อยากได้ยินว่า 'คุณมีคน / รถ / ที่เปิดกระป๋อง ... ' หรือคำนี้ได้มาอย่างไร (ไม่มีใครประทับใจที่คุณรู้ว่า poly และ morph หมายถึงอะไร) หากคุณมีความเข้าใจเป็นอย่างดีว่าพหูสูตคืออะไรและมีความสามารถในการใช้ภาษาอังกฤษได้ดีกว่าที่ควรจะสามารถตอบคำถามนี้ได้โดยใช้คำจำกัดความสั้น ๆ แม้ว่าจะหนาแน่น หากคำจำกัดความของคุณกำหนดความหลากหลายได้อย่างถูกต้อง แต่มีความหนาแน่นมากจนต้องอ่านซ้ำสองสามครั้งนั่นคือสิ่งที่ฉันกำลังมองหา

ทำไมแค่สองประโยค? เพราะคำจำกัดความสั้นและฉลาด คำอธิบายยาวและมีตัวอย่างและรหัส ดูคำอธิบายที่นี่ (คำตอบในหน้าเหล่านั้นไม่เป็นที่พอใจสำหรับคำถามของฉัน):

Polymorphism vs Overriding vs Overloading
พยายามอธิบายความหลากหลายให้ง่ายที่สุดเท่าที่จะทำได้

ทำไมฉันถึงถามคำถามนี้ เนื่องจากฉันถูกถามคำถามเดียวกันและพบว่าฉันไม่สามารถหาคำจำกัดความที่น่าพอใจได้ (ตามมาตรฐานของฉันซึ่งค่อนข้างสูง) ฉันต้องการดูว่ามีจิตใจที่ยอดเยี่ยมในไซต์นี้หรือไม่

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

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

(*) ในกรณีที่ดีที่สุด - แน่นอนว่าบ่อยครั้งที่รหัสการโทรได้เลือกการใช้งานที่เหมาะสมโดยเจตนา!

ผลไม้สามารถรับประทานได้ตามปกติ แต่ผลไม้ประเภทต่างๆจะรับประทานในรูปแบบที่แตกต่างกัน แอปเปิ้ลซึ่งเป็นผลไม้สามารถรับประทานได้ (เพราะเป็นผลไม้) กล้วยยังสามารถรับประทานได้ (เพราะเป็นผลไม้เช่นกัน) แต่จะมีลักษณะที่แตกต่างจากแอปเปิ้ล คุณลอกมันก่อน

อย่างน้อยฉันก็ทำ แต่ฉันก็แปลกในบางแง่ดังนั้นฉันจะรู้อะไร

สิ่งนี้แสดงให้เห็นถึงการถ่ายทอดทางพันธุกรรม (ผลไม้สามารถรับประทานได้) ความหลากหลาย (สิ่งที่กินผลไม้สามารถกินผลไม้ได้ทุกประเภท) และการห่อหุ้ม (กล้วยมีผิว)

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

Polymorphism กำลังประกาศอินเทอร์เฟซที่เหมือนกันซึ่งไม่ทราบประเภทโดยทิ้งรายละเอียดการใช้งานไปยังประเภทคอนกรีตที่ใช้อินเทอร์เฟซ

Wikipedia: Polymorphism เป็นคุณลักษณะภาษาโปรแกรมที่อนุญาตให้จัดการค่าของข้อมูลประเภทต่างๆโดยใช้อินเทอร์เฟซที่เหมือนกัน ค่อนข้างตรงไปตรงมาสำหรับฉัน

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

• ad-hoc polymorphism (ดูเหมือนเป็ดและเดินเหมือนเป็ด => คือเป็ด) สามารถเห็นได้ใน Haskell และ Python เช่น

• ความหลากหลายทั่วไป (โดยที่ประเภทเป็นตัวอย่างของประเภททั่วไปบางประเภท) ตัวอย่างเช่นสามารถเห็นได้ใน C ++ (เวกเตอร์ของ int และเวกเตอร์ของสตริงทั้งสองมีขนาดฟังก์ชันสมาชิก)

• ความหลากหลายประเภทย่อย (โดยที่ประเภทสืบทอดมาจากประเภทอื่น) สามารถเห็นได้ในภาษาโปรแกรม OO ส่วนใหญ่ (เช่น Triangle is a Shape)

ฉันเข้าใจจริงๆว่าทำไมคุณถึงถามคำถามนี้ ฉันเข้าใจความหลากหลาย แต่ฉันอยู่ระหว่างการสัมภาษณ์งานและถูกขอให้ให้คำจำกัดความที่สั้นและชัดเจนของความหลากหลาย เพราะฉันไม่สามารถให้คำจำกัดความที่ชัดเจนและสั้นได้ฉันจึงเริ่มคิดถึงมันและนี่คือคำจำกัดความของฉัน:

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

คำจำกัดความ :

Polymorphism เป็นคำที่มีมูลค่า $ 10 สำหรับความคิด $ 1 ซึ่งเมื่อฉันขอบางสิ่งบางอย่างฉันไม่สนใจว่ามันจะสำเร็จได้อย่างไรตราบเท่าที่ผลลัพธ์สุดท้ายนั้นเหมาะสม ตราบใดที่การบริการที่มีให้อย่างถูกต้องผมไม่สนใจเกี่ยวกับการดำเนินงาน

อภิปรายผล

แม้ว่าจะใช้กันทั่วไปในการพัฒนาซอฟต์แวร์โดยเฉพาะอย่างยิ่งในระบบที่พัฒนาตามหลักการเชิงวัตถุ แต่ Polymorphism เป็นหลักการพื้นฐานของโลกแห่งความเป็นจริงและควรกำหนดไว้ในแง่ของโลกแห่งความเป็นจริงไม่ใช่เทคโนโลยี

ตัวอย่าง

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

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

การใช้งานหลายอินเทอร์เฟซเดียวกัน

ตัวอย่าง: โทรศัพท์หลายรุ่นใช้อินเทอร์เฟซแป้นพิมพ์ตัวเลข

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

ตกลงยาก ....

ฉันคิดว่าฉันต้องการเพิ่มการตีความของตัวเองในสิ่งที่แตกต่างคือมากโดยทั่วไป, ความแตกต่างคือการกระทำของการให้บริการที่มีอินเตอร์เฟซเดียวกับหน่วยงานของประเภทที่แตกต่างกัน

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

โพลีมอร์ฟิซึมเฉพาะกิจ

Ad hoc polymorphismคือการจัดเตรียมการใช้งานหลายวิธีในวิธีเดียวกันสำหรับพารามิเตอร์ประเภทต่างๆ ในOOPก็เป็นที่รู้จักกันโดยทั่วไปว่าเป็นวิธีการบรรทุกเกินพิกัด ตัวอย่างเช่น:

public String format(int a) {
    return String.format("%2d", a);
}

public String format(Date a) {
    return new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss'Z'").format(a);
}

ทั้งสองformatวิธีร่วมกันอินเตอร์เฟซเดียวแต่พวกเขาทำงานในหน่วยงานของประเภทที่แตกต่างกัน

ความหลากหลายเชิงพาราเมตริก

Parametric polymorphismคือการทำให้คลาส (หรือเมธอด) ทำงานกับชนิดที่เป็นพารามิเตอร์ของคลาส (หรือเมธอด) มันมักจะเรียกว่ายาชื่อสามัญ

ตัวอย่างเช่น Java List[T]คาดว่าจะมีพารามิเตอร์Tในเวลาสร้างอินสแตนซ์และพารามิเตอร์นี้กำหนดประเภทของอ็อบเจ็กต์ผลลัพธ์

โปรดทราบสำหรับคนเจ้าระเบียบว่าฉันเพิกเฉยต่อประเภทดิบโดยเจตนาเพราะฉันรู้สึกว่าพวกเขาแค่ทำให้น้ำขุ่นมัวในบริบทนี้

List[String]และList[Date]แบ่งปันอินเตอร์เฟซเดียวแต่ทำงานใน (และ) ประเภทที่แตกต่างกัน

ความแตกต่างของชนิดย่อย

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

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

ถ้าCatและDogมีทั้งคลาสย่อยAnimalแล้วพวกเขาก็แบ่งเป็นอินเตอร์เฟซเดียวแต่ในความเป็นจริงที่แตกต่างกัน

ฉันจะออกไปแทนเจนต์เล็กน้อยที่นี่ แต่ความหลากหลายประเภทย่อยคือ (ฉันคิดว่า) เป็นสิ่งเดียวที่อนุญาตให้มีการลบล้าง : การกำหนดพฤติกรรมของเมธอดที่กำหนดโดยคลาสพาเรนต์ใหม่ สิ่งนี้มักสับสนกับการโอเวอร์โหลดซึ่งอย่างที่เราเห็นมาก่อนเป็นความหลากหลายและไม่จำเป็นต้องมีคลาสย่อย (หรือไม่จำเป็นต้องมีคลาสจริงๆ)

ดูเหมือนว่าจะมีคำจำกัดความที่ดีที่สุดที่นี่ดังนั้นขอฉันเพิ่มสองเซ็นต์ของฉันสำหรับผู้สังเกตการณ์คนอื่น ๆ ฉันหวังว่ามันจะช่วยได้มากกว่านี้

ความหลากหลายมีสองประเภท:

1. Compile-time (static) polymorphism or (ad hoc) polymorphism.

นั่นเป็นเพียงวิธีการโอเวอร์โหลดและการโอเวอร์โหลดของตัวดำเนินการ

2.  Run time or (dynamic) polymorphism.

คำศัพท์แรกสืบทอดมาจากคำศัพท์ Java และ C ++

แต่ใน.NETคำศัพท์เฉพาะที่สอง ( ผมหมายถึงความแตกต่างเวลาทำงาน ) ควรจริงๆเป็นความแตกต่างและก็เรียกว่าแตกต่าง

และเท่าที่ฉันรู้ว่ามีสามวิธีในการดำเนินการ ( เวลาทำงาน ) ความแตกต่าง

 1. Parametric polymorphism or simply the use of generics (templates in C++).

 2. Inheritance-based polymorphism or subtyping.

 3. Interface-based polymorphism.

ตัวอย่างง่ายๆของความหลากหลายตามอินเทอร์เฟซ:

interface Imobile
{
    void Move();
}

class Person :Imobile
{
    public void Move() { Console.WriteLine("I am a person and am moving in my way."); }
}

class Bird :Imobile
{
    public void Move() { Console.WriteLine("I am a bird and am moving in my way."); }
}

class Car :Imobile
{
    public void Move() { Console.WriteLine("I am a car and am moving in my way."); }
}


class Program
{

    static void Main(string[] args)
    {
        // Preparing a list of objects
        List<Imobile> mobileList = new List<Imobile>();

        mobileList.Add(new Person());
        mobileList.Add(new Bird());
        mobileList.Add(new Car());

        foreach (Imobile mobile in mobileList)
        {
            mobile.Move();
        }

        // Keep the console open
        Console.WriteLine("Press any key to exit the program:");
        Console.ReadKey();
    }
}

เอาท์พุต:

 I am a person and am moving in my way.
 I am a bird and am moving in my way.
 I am a car and am moving in my way.
 Press any key to exit the program:

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

พอล.

polymorphism == หลายคลาส + ลายเซ็นวิธีเดียวกัน + พฤติกรรมเฉพาะคลาส

หลายรูปแบบของวัตถุเดียวเรียกว่า Polymorphism

ความแตกต่าง

วัตถุที่แตกต่างกันสามารถตอบสนองต่อข้อความเดียวกันในรูปแบบที่แตกต่างกันทำให้วัตถุสามารถโต้ตอบกันได้โดยไม่ทราบประเภทที่แน่นอน

ทาง: http://www.agiledata.org/essays/objectOrientation101.html

Polymorphism คือความสามารถของวัตถุที่จะปรากฏและทำงานแตกต่างกันสำหรับการร้องขอเดียวกัน เช่นสัตว์แต่ละตัวจะปรากฏและส่งเสียงไม่เหมือนกัน (เมื่อคุณตีมัน :))

Polymorphism เป็นคุณลักษณะของภาษาโปรแกรมที่อนุญาตให้ใช้วัตถุเป็นตัวอย่างของ supertype

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

นี่คือคำจำกัดความที่ฉันติดตามมาตลอด:

ออบเจ็กต์สองชิ้นมีความหลากหลาย (เกี่ยวกับโปรโตคอลเฉพาะ) ระหว่างวัตถุทั้งสองหากทั้งสองตอบสนองต่อข้อความเดียวกันด้วยความหมายเดียวกัน

ความหลากหลายเป็นเรื่องของข้อความเกี่ยวกับความสามารถในการตอบสนองชุดข้อความเดียวกันด้วยความหมายเดียวกัน

หากวัตถุสองชิ้นสามารถตอบสนองต่อความว่างเปล่า? แต่ความหมายของข้อความนั้นแตกต่างกันดังนั้น .. พวกเขาจึงไม่ใช่ความหลากหลาย

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

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

Polymorphism คือฟังก์ชันการทำงานของภาษาที่ช่วยให้โค้ดอัลกอริทึมระดับสูงทำงานได้โดยไม่เปลี่ยนแปลงกับข้อมูลหลายประเภท และประโยคอื่น ๆ สำหรับ ... ;-P.

(ประเภทที่รองรับ C ++ อยู่ในรายการและเปรียบเทียบกับคำตอบของฉัน: ความหลากหลายใน c ++ )

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

คุณสามารถกำหนดรายการได้ดังนี้:

List list = new List();

แต่หากคุณตรวจสอบIListคุณจะได้รับประโยชน์จากอินเทอร์เฟซดังนี้:

IList list = new List();

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

ตอนนี้ข้อมูลที่มีค่ามากขึ้นกำลังจะมา:
Java เป็นโพลีมอร์ฟิกเริ่มต้นในขณะที่. NET และ C ++ ไม่ใช่ใน MS คุณต้องประกาศฟังก์ชันพื้นฐานvirtual(และในoverrideคำหลัก. NET )

นอกจากนี้ยังมีกฎสำคัญ 2 ข้อในความหลากหลาย หนึ่งคือการสืบทอด (ผ่านอินเทอร์เฟซโดยนัยหรือผ่านการขยายคลาส) และอีกอันถูกแทนที่ หากไม่มีการลบล้างความหลากหลายจะไม่มีอยู่จริง โปรดทราบว่าการโอเวอร์โหลดเมธอด (ซึ่งมักจะอยู่ในคลาสเดียว) ก็เป็นความหลากหลายประเภท "มินิมอร์ฟิสม์" เช่นกัน

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

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

เช่นใน Java ในฐานะ ArrayList และ LinkedList ต่างก็ใช้ List หากคุณประกาศตัวแปรเป็น List คุณสามารถดำเนินการตามที่อนุญาตใน List ได้ตลอดเวลาไม่ว่าตัวแปรของคุณจะถูกอินสแตนซ์เป็น ArrayList หรือ LinkedList ก็ตาม

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

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

ฉันเดาว่าบางครั้งมีการเรียกวัตถุแบบไดนามิก คุณไม่แน่ใจว่าวัตถุนั้นจะเป็นสามเหลี่ยมสี่เหลี่ยม ฯลฯ ในรูปทรงคลาสสิคหรือไม่ ตัวอย่าง.

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

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

Polymorphism คือความสามารถของฟังก์ชันในการปรับให้เข้ากับข้อมูลอินพุตของข้อมูลประเภทต่างๆโดยอัตโนมัติ คุณสามารถ "เพิ่ม" สองคู่ "1.1" และ "2.2" และรับ "3.3" หรือ "เพิ่ม" สองสตริง "Stack" และ "Overflow" และรับ "StackOverflow"

Polymorphism คือเมื่อวัตถุต่าง ๆ ตอบสนองต่อวิธีการเดียวกันในลักษณะที่แตกต่างกัน ตัวอย่างเช่นรถเคลื่อนไปบนถนนในขณะที่คนเดินบนถนน สิ่งเหล่านี้คือวัตถุสองชิ้นที่ตอบสนองต่อถนนสายเดียวกันในลักษณะที่แตกต่างกัน