polymorphism คืออะไรใช้ทำอะไรและใช้อย่างไร?

หากคุณคิดถึงรากเหง้าของเทอมกรีกมันควรจะชัดเจน

• โพลี = มากมาย: รูปหลายเหลี่ยม = หลายด้าน, สไตรีน = สไตรีนจำนวนมาก^(a) , โพลิกอน = หลายภาษาและอื่น ๆ
• Morph = การเปลี่ยนแปลงหรือรูปแบบ: สัณฐานวิทยา = การศึกษารูปแบบทางชีวภาพ, Morpheus = เทพเจ้าแห่งความฝันของกรีกสามารถใช้รูปแบบใดก็ได้

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

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

แต่ในทางเดียวกันว่าชั้นเหมือนBigDecimalหรือRationalหรือImaginaryยังสามารถให้การดำเนินงานดังกล่าวถึงแม้ว่าพวกเขาดำเนินการเกี่ยวกับข้อมูลต่างชนิด

ตัวอย่างคลาสสิกคือShapeคลาสและคลาสทั้งหมดที่สามารถสืบทอดได้ (สแควร์วงกลม dodecahedron รูปหลายเหลี่ยมที่ผิดปกติเครื่องหมายสีแดงและอื่น ๆ )

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

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

shape.Draw()

เพื่อรับพฤติกรรมที่ถูกต้องสำหรับรูปร่างใด ๆ

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

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

^(a)ตอนแรกฉันเขียนว่าเป็นเรื่องตลก แต่มันกลับกลายเป็นว่าถูกต้องและดังนั้นจึงไม่ใช่เรื่องตลก สไตรีนโมโนเมอร์เกิดขึ้นจากคาร์บอนและไฮโดรเจนและสไตรีนนั้นทำจากกลุ่มของมัน, .C8H8(C8H8)n

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

บางครั้งคุณควรเลิกในขณะที่คุณอยู่ด้านหลัง :-)

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

นี่คือตัวอย่างใน C # สร้างสี่คลาสภายในแอปพลิเคชันคอนโซล:

public abstract class Vehicle
{
    public abstract int Wheels;
}

public class Bicycle : Vehicle
{
    public override int Wheels()
    {
        return 2;
    }
}

public class Car : Vehicle
{
    public override int Wheels()
    {
        return 4;
    }
}

public class Truck : Vehicle
{
    public override int Wheels()
    {
        return 18;
    }
}

ตอนนี้สร้างสิ่งต่อไปนี้ใน Main () ของโมดูลสำหรับแอ็พพลิเคชันคอนโซล:

public void Main()
{
    List<Vehicle> vehicles = new List<Vehicle>();

    vehicles.Add(new Bicycle());
    vehicles.Add(new Car());
    vehicles.Add(new Truck());

    foreach (Vehicle v in vehicles)
    {
        Console.WriteLine(
            string.Format("A {0} has {1} wheels.",
                v.GetType().Name, v.Wheels));
    }
}

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

จากนั้นเราเพิ่มจักรยานรถยนต์และรถบรรทุกลงในรายการ

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

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

ฉันหวังว่านี่จะช่วยคุณได้

จากความเข้าใจและการประยุกต์ใช้ความหลากหลายใน PHPขอบคุณ Steve Guidetti

ความแตกต่างเป็นคำที่ยาวสำหรับแนวคิดที่ง่ายมาก

ความแตกต่างอธิบายรูปแบบในการเขียนโปรแกรมเชิงวัตถุที่เรียนมีฟังก์ชั่นที่แตกต่างกันในขณะที่ใช้งานร่วมกันของอินเตอร์เฟซ

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

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

ถ้าใครบอกว่าตัดคนเหล่านี้

1. ศัลยแพทย์
2. ช่างทำผม
3. นักแสดงชาย

อะไรจะเกิดขึ้น?

• ศัลยแพทย์จะเริ่มทำการผ่า
• ช่างทำผมจะเริ่มตัดผมของใครบางคน
• นักแสดงจะหยุดแสดงทันทีจากฉากปัจจุบันโดยรอการชี้นำจากผู้กำกับ

ดังนั้นการเป็นตัวแทนข้างต้นแสดงให้เห็นถึงความหลากหลายคืออะไร (ชื่อเดียวกันพฤติกรรมที่แตกต่าง) ใน OOP

หากคุณกำลังจะไปสัมภาษณ์และผู้สัมภาษณ์ขอให้คุณบอก / แสดงตัวอย่างสดสำหรับความหลากหลายในห้องเดียวกันที่เรานั่งอยู่พูด -

คำตอบ - ประตู / Windows

สงสัยว่าอย่างไร

ผ่านประตู / หน้าต่าง - สามารถมาคนอากาศได้มาแสงสามารถมาฝนสามารถมา ฯลฯ

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

คำอธิบายง่ายๆโดยการเปรียบเทียบ

ประธานาธิบดีแห่งสหรัฐอเมริกาใช้พหุสัณฐาน อย่างไร? เขามีที่ปรึกษาหลายคน:

1. ที่ปรึกษาทางทหาร
2. ที่ปรึกษากฎหมาย
3. นักฟิสิกส์นิวเคลียร์ (ในฐานะที่ปรึกษา)
4. ที่ปรึกษาทางการแพทย์
5. ฯลฯ

ทุกคนควรรับผิดชอบสิ่งเดียว: ตัวอย่าง:

ประธานาธิบดีไม่ใช่ผู้เชี่ยวชาญด้านการเคลือบสังกะสีหรือฟิสิกส์ควอนตัม เขาไม่รู้อะไรมากมาย - แต่เขารู้เพียงสิ่งเดียวเท่านั้น: วิธีการบริหารประเทศ

มันก็เหมือนกันกับรหัส: ความกังวลและความรับผิดชอบควรแยกออกจากชั้นเรียน / บุคคลที่เกี่ยวข้อง มิฉะนั้นคุณจะมีประธานาธิบดีรู้ทุกอย่างแท้จริงในโลก - วิกิพีเดียทั้งหมด ลองนึกภาพการมีวิกิพีเดียทั้งหมดในรหัสของคุณ: มันคงเป็นฝันร้ายที่ต้องรักษา

เหตุใดจึงเป็นความคิดที่ไม่ดีสำหรับประธานที่จะรู้สิ่งเหล่านี้ทั้งหมด

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

ตัวอย่างเช่นหาก EPA เปลี่ยนกฎหมายมลพิษแล้วเมื่อเกิดเหตุการณ์: คุณต้องทำการเปลี่ยนแปลงในระดับ EPA และระดับประธานาธิบดี การเปลี่ยนรหัสในสองแห่งแทนที่จะเป็นหนึ่งเดียวอาจเป็นอันตรายได้ - เนื่องจากยากต่อการบำรุงรักษามาก

มีแนวทางที่ดีกว่านี้ไหม?

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

เขาสามารถใช้วิธี polymorphic ในการบริหารประเทศ

ตัวอย่าง - การใช้วิธี polymorphic:

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

public class MisterPresident
{
    public void RunTheCountry()
    {
        // assume the Petraeus and Condi classes etc are instantiated.
        petraeus.Advise(); // # Petraeus says send 100,000 troops to Fallujah
        condolezza.Advise(); // # she says negotiate trade deal with Iran
        healthOfficials.Advise(); // # they say we need to spend $50 billion on ObamaCare
    }
}

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

สิ่งที่คุณไม่ต้องการ:

public class MisterPresident
{
    public void RunTheCountry()
    {
        // people walk into the Presidents office and he tells them what to do
        // depending on who they are.

        // Fallujah Advice - Mr Prez tells his military exactly what to do.
        petraeus.IncreaseTroopNumbers();
        petraeus.ImproveSecurity();
        petraeus.PayContractors();

        // Condi diplomacy advice - Prez tells Condi how to negotiate

        condi.StallNegotiations();
        condi.LowBallFigure();
        condi.FireDemocraticallyElectedIraqiLeaderBecauseIDontLikeHim();

        // Health care

        healthOfficial.IncreasePremiums();
        healthOfficial.AddPreexistingConditions();
    }
}

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

สิ่งนี้ทำให้ประธานทำสิ่งที่เขาทำได้ดีที่สุด: กำหนดนโยบายทั่วไปดูดีและเล่นกอล์ฟ: P

มันใช้งานอย่างไร - ผ่านคลาสพื้นฐานหรืออินเตอร์เฟสทั่วไป

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

ในคำอื่น ๆ Petraeus, สภาพนั้นและ HealthOfficials ทั้งหมดจะเรียนที่ "ใช้อินเตอร์เฟซ" - ขอเรียกมันว่าอินเตอร์เฟซที่เพิ่งมีวิธีที่หนึ่ง:IAdvisor Advise()แต่ตอนนี้เรากำลังเข้าสู่ข้อมูลเฉพาะ

นี่จะเหมาะ

    public class MisterPresident
    {
            // You can pass in any advisor: Condi, HealthOfficials,
            //  Petraeus etc. The president has no idea who it will 
            // be. But he does know that he can ask them to "advise" 
            // and that's all Mr Prez cares for.

        public void RunTheCountry(IAdvisor governmentOfficer)
        {             
            governmentOfficer.Advise();              
        }
    }


    public class USA
    {
        MisterPresident president;

        public USA(MisterPresident president)
        {
            this.president = president;
        }

        public void ImplementPolicy()
        {
            IAdvisor governmentOfficer = getAdvisor(); // Returns an advisor: could be condi, or petraus etc.
            president.RunTheCountry(governmentOfficer);
        }
    }

สรุป

สิ่งที่คุณต้องรู้คือ:

• ประธานาธิบดีไม่จำเป็นต้องรู้ข้อมูลเฉพาะ - คนเหล่านั้นถูกทิ้งให้คนอื่น
• ประธานาธิบดีทุกคนต้องรู้คือการถามว่าใครเดินเข้ามาเพื่อแนะนำเขา - และเรารู้ว่าพวกเขาจะรู้ว่าต้องทำอย่างไรเมื่อถูกขอให้แนะนำ (เพราะพวกเขาทั้งหมดอยู่ในความเป็นจริงที่ปรึกษา (หรือ IAdvisors :))

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

ความแตกต่างคือความสามารถในการรักษาระดับของวัตถุราวกับว่ามันเป็นชั้นผู้ปกครอง

ตัวอย่างเช่นสมมติว่ามีคลาสที่ชื่อว่า Animal และคลาสที่ชื่อว่า Dog ที่สืบทอดมาจาก Animal ความแตกต่างคือความสามารถในการรักษาวัตถุสุนัขใด ๆ ที่เป็นวัตถุสัตว์เช่น:

Dog* dog = new Dog;
Animal* animal = dog;

polymorphism:

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

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

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

• ชื่อวิธีได้รับการคุ้มครองด้วย ต่างจากชื่อฟังก์ชั่น C ชื่อวิธีไม่ใช่สัญลักษณ์สากล ชื่อของวิธีการในชั้นหนึ่งไม่สามารถขัดแย้งกับชื่อวิธีการในชั้นเรียนอื่น ๆ ; สองชั้นที่แตกต่างกันมากสามารถใช้วิธีการตั้งชื่อเหมือนกัน

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

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

ตัวอย่าง:

ตัวอย่างที่ 1:นี่คือตัวอย่างง่ายๆที่เขียนในหลาม 2.x

class Animal:
    def __init__(self, name):    # Constructor of the class
        self.name = name
    def talk(self):              # Abstract method, defined by convention only
        raise NotImplementedError("Subclass must implement abstract method")

class Cat(Animal):
    def talk(self):
        return 'Meow!'

class Dog(Animal):
    def talk(self):
        return 'Woof! Woof!'

animals = [Cat('Missy'),
           Dog('Lassie')]

for animal in animals:
    print animal.name + ': ' + animal.talk()

ตัวอย่างที่ 2: ความหลากหลายถูกนำมาใช้ในJavaโดยใช้วิธีการมากไปและวิธีการเอาชนะแนวคิด

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

แต่แต่ละคนมีคุณสมบัติขั้นสูงของตัวเองและเทคโนโลยีขั้นสูงที่เกี่ยวข้องกับพฤติกรรมการย้ายของพวกเขา

ตอนนี้ให้เราสร้างรถยนต์ประเภทพื้นฐาน

Car.java

public class Car {

    int price;
    String name;
    String color;

    public void move(){
    System.out.println("Basic Car move");
    }

}

ให้เราใช้ตัวอย่างฟอร์ดคาร์

ฟอร์ดขยายประเภทรถเพื่อสืบทอดสมาชิกทั้งหมด (คุณสมบัติและวิธีการ)

Ford.java

public class Ford extends Car{
  public void move(){
    System.out.println("Moving with V engine");
  }
}

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

Honda.java

public class Honda extends Car{
  public void move(){
    System.out.println("Move with i-VTEC engine");
  }
}

เช่นเดียวกับฟอร์ดฮอนด้ายังขยายประเภทของรถยนต์และนำวิธีการย้ายมาใช้ในแบบของตัวเอง

การแทนที่เมธอดเป็นคุณลักษณะที่สำคัญในการเปิดใช้งาน Polymorphism การใช้เมธอดการแทนที่ชนิดย่อยสามารถเปลี่ยนวิธีที่วิธีการทำงานพร้อมใช้งานผ่านการสืบทอด

PolymorphismExample.java

public class PolymorphismExample {
  public static void main(String[] args) {
    Car car = new Car();
    Car f = new Ford();
    Car h = new Honda();

    car.move();
    f.move();
    h.move();

  }
}

ความแตกต่างตัวอย่างเอาท์พุท:

ในวิธีการหลักของคลาส Polymorphism ตัวอย่างฉันได้สร้างวัตถุสามชิ้นคือรถยนต์ฟอร์ดและฮอนด้า วัตถุทั้งสามนั้นถูกอ้างอิงโดยประเภทรถ

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

ดังนั้นสำหรับรถยนต์อ้างอิง f และ h ใน PolymorphismExample วิธีการย้ายมีอยู่จากประเภทรถยนต์ ดังนั้นคอมไพเลอร์ผ่านกระบวนการรวบรวมโดยไม่มีปัญหาใด ๆ

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

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

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

• ความแตกต่างในการเขียนโปรแกรมเชิงวัตถุ
• ประเภทความแตกต่าง

แก้ไข: ลิงก์เสียคงที่

ความแตกต่างคือสิ่งนี้:

class Cup {
   int capacity
}

class TeaCup : Cup {
   string flavour
}

class CoffeeCup : Cup {
   string brand
}

Cup c = new CoffeeCup();

public int measure(Cup c) {
    return c.capacity
}

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

ฉันรู้ว่านี่เป็นคำถามเก่าที่มีคำตอบที่ดีมากมาย แต่ฉันต้องการที่จะรวมคำตอบหนึ่งประโยค:

การรักษาประเภทที่ได้มาราวกับว่ามันเป็นประเภทพื้นฐาน

มีตัวอย่างมากมายที่แสดงการกระทำนี้ แต่ฉันรู้สึกว่านี่เป็นคำตอบที่กระชับ

(ฉันกำลังอ่านบทความเกี่ยวกับสิ่งที่แตกต่างอย่างสิ้นเชิง .. และ polymorphism โผล่ขึ้นมา ... ตอนนี้ฉันคิดว่าฉันรู้ว่า polymorphism คืออะไร .... แต่เห็นได้ชัดว่าไม่ได้ในวิธีที่สวยงามนี้อธิบาย .. อยากเขียนลงที่ไหนสักแห่ง .. ยังดีกว่าจะแบ่งปัน ... )

http://www.eioba.com/a/1htn/how-i-explained-rest-to-my-wife

อ่านต่อจากส่วนนี้:

..... ความหลากหลาย นั่นเป็นวิธีที่เกินบรรยายว่าคำนามต่าง ๆ สามารถใช้คำกริยาเดียวกันกับพวกเขาได้

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

• ฟังก์ชั่นโอเวอร์โหลด: การกำหนดฟังก์ชั่นจำนวนมากด้วยชื่อเดียวกันและชนิดพารามิเตอร์ที่แตกต่างกันเช่น sqrt (float), sqrt (double) และ sqrt (complex) ในภาษาส่วนใหญ่ที่อนุญาตสิ่งนี้คอมไพเลอร์จะเลือกหนึ่งที่ถูกต้องโดยอัตโนมัติสำหรับประเภทของการโต้แย้งที่ถูกส่งผ่านมันดังนั้นนี่คือการรวบรวมความแตกต่างเวลา

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

• เทมเพลต: คุณสมบัติของภาษา OO บางภาษาที่ฟังก์ชันคลาส ฯลฯ สามารถกำหนดพารามิเตอร์ด้วยชนิด ตัวอย่างเช่นคุณสามารถกำหนดคลาสเทมเพลต "list" ทั่วไปแล้วยกตัวอย่างเป็น "list of integers", "list of strings", หรือแม้แต่ "list of list of strings" หรือสิ่งที่คล้ายกัน โดยทั่วไปคุณเขียนโค้ดหนึ่งครั้งสำหรับโครงสร้างข้อมูลประเภทองค์ประกอบเองและคอมไพเลอร์สร้างรุ่นของมันสำหรับประเภทองค์ประกอบต่างๆ

ความแตกต่างของคำมาจาก:

poly = มากมาย

morphism = ความสามารถในการเปลี่ยนแปลง

ในการเขียนโปรแกรม polymorphism เป็น "เทคนิค" ที่ช่วยให้คุณ "ดู" ที่วัตถุว่าเป็นสิ่งของมากกว่าหนึ่งประเภท ตัวอย่างเช่น

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

บรรทัดล่าง "มอง" ที่วัตถุเดียวกันจาก "มุม" ที่แตกต่างกันสามารถให้มุมมอง "ที่แตกต่าง" (เช่นคุณสมบัติหรือวิธีการที่แตกต่างกัน)

ดังนั้นเทคนิคนี้ช่วยให้คุณสร้างสิ่งต่าง ๆ ที่สามารถ "มอง" จากมุมที่แตกต่างกัน

ทำไมเราถึงใช้พหุนาม สำหรับผู้เริ่มต้น ... สิ่งที่เป็นนามธรรม ณ จุดนี้มันควรมีข้อมูลเพียงพอ :)

ลองใช้การเปรียบเทียบกัน สำหรับบทละครเพลงที่ได้รับนักดนตรีทุกคนที่เล่นมันจะให้สัมผัสของเธอเองในการตีความ

นักดนตรีสามารถแยกออกได้ด้วยส่วนต่อประสานประเภทที่นักดนตรีสามารถเป็นคลาส abstrac ซึ่งกำหนดกฎการตีความระดับโลกบางส่วนและนักดนตรีทุกคนที่เล่นสามารถจำลองด้วยคลาสที่เป็นรูปธรรม

หากคุณเป็นผู้ฟังผลงานดนตรีคุณมีการอ้างอิงถึงสคริปต์เช่น Bach ของ 'Fuga และ Tocata' และนักดนตรีทุกคนที่ทำมันจะทำมัน polymorphicaly ในแบบของเธอเอง

นี่เป็นเพียงตัวอย่างของการออกแบบที่เป็นไปได้ (ใน Java):

public interface Musician {
  public void play(Work work);
}

public interface Work {
  public String getScript();
}

public class FugaAndToccata implements Work {
  public String getScript() {
    return Bach.getFugaAndToccataScript();
  }
}

public class AnnHalloway implements Musician {
  public void play(Work work) {
    // plays in her own style, strict, disciplined
    String script = work.getScript()
  }
}

public class VictorBorga implements Musician {
  public void play(Work work) {
    // goofing while playing with superb style
    String script = work.getScript()
  }
}

public class Listener {
  public void main(String[] args) {
    Musician musician;
    if (args!=null && args.length > 0 && args[0].equals("C")) {
      musician = new AnnHalloway();
    } else {
      musician = new TerryGilliam();
    }
    musician.play(new FugaAndToccata());
}

ฉันได้ให้ภาพรวมระดับสูงของ polymorphism สำหรับคำถามอื่น:

ความแตกต่างใน c ++

หวังว่ามันจะช่วย สารสกัด ...

... มันช่วยให้เริ่มต้นจากการทดสอบอย่างง่ายสำหรับมันและนิยามของ [polymorphism] พิจารณารหัส:

Type1 x;
Type2 y;

f(x);
f(y);

นี่f()คือการดำเนินการบางอย่างและได้รับค่าxและyเป็นอินพุต ในการเป็น polymorphic f()จะต้องสามารถทำงานกับค่าที่แตกต่างกันอย่างน้อยสองประเภท (เช่นintและdouble) การค้นหาและดำเนินการโค้ดที่เหมาะสมกับประเภท

(ต่อที่polymorphism ใน c ++ )

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

ความแตกต่างคือความสามารถของวัตถุที่ใช้ในหลายรูปแบบ การใช้ polymorphism ที่พบบ่อยที่สุดใน OOP เกิดขึ้นเมื่อมีการใช้การอ้างอิงระดับผู้ปกครองเพื่ออ้างถึงวัตถุคลาสลูก ในตัวอย่างนี้เขียนด้วยภาษาจาวาเรามียานพาหนะสามประเภท เราสร้างวัตถุสามแบบที่แตกต่างกันและพยายามใช้วิธีล้อของพวกเขา:

public class PolymorphismExample {

    public static abstract class Vehicle
    {
        public int wheels(){
            return 0;
        }
    }

    public static class Bike extends Vehicle
    {
        @Override
        public int wheels()
        {
            return 2;
        }
    }

    public static class Car extends Vehicle
    {
        @Override
        public int wheels()
        {
            return 4;
        }
    }

    public static class Truck extends Vehicle
    {
        @Override
        public int wheels()
        {
            return 18;
        }
    }

    public static void main(String[] args)
    {
        Vehicle bike = new Bike();
        Vehicle car = new Car();
        Vehicle truck = new Truck();

        System.out.println("Bike has "+bike.wheels()+" wheels");
        System.out.println("Car has "+car.wheels()+" wheels");
        System.out.println("Truck has "+truck.wheels()+" wheels");
    }

}

ผลลัพธ์คือ:

สำหรับข้อมูลเพิ่มเติมกรุณาเยี่ยมชมhttps://github.com/m-vahidalizadeh/java_advanced/blob/master/src/files/PolymorphismExample.java ฉันหวังว่ามันจะช่วย

ความแตกต่างคือความสามารถของโปรแกรมเมอร์ในการเขียนวิธีการในชื่อเดียวกันที่ทำสิ่งต่าง ๆ สำหรับวัตถุประเภทต่าง ๆ ขึ้นอยู่กับความต้องการของวัตถุเหล่านั้น ตัวอย่างเช่นหากคุณกำลังพัฒนาคลาสที่เรียกว่าFractionและคลาสที่เรียกว่าComplexNumberทั้งสองนี้อาจมีวิธีการที่เรียกว่าdisplay()แต่แต่ละคนจะใช้วิธีการที่แตกต่างกัน ยกตัวอย่างเช่นใน PHP คุณอาจใช้มันในลักษณะนี้:

//  Class definitions

class Fraction
{
    public $numerator;
    public $denominator;

    public function __construct($n, $d)
    {
        //  In real life, you'd do some type checking, making sure $d != 0, etc.
        $this->numerator = $n;
        $this->denominator = $d;
    }

    public function display()
    {
        echo $this->numerator . '/' . $this->denominator;
    }
}

class ComplexNumber
{
    public $real;
    public $imaginary;

    public function __construct($a, $b)
    {
        $this->real = $a;
        $this->imaginary = $b;
    }

    public function display()
    {
        echo $this->real . '+' . $this->imaginary . 'i';
    }
}


//  Main program

$fraction = new Fraction(1, 2);
$complex = new ComplexNumber(1, 2);

echo 'This is a fraction: '
$fraction->display();
echo "\n";

echo 'This is a complex number: '
$complex->display();
echo "\n";

ขาออก:

This is a fraction: 1/2
This is a complex number: 1 + 2i

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

อย่างน้อยในภาษาที่พิมพ์แบบไดนามิกเช่น PHP (ฉันไม่รู้เกี่ยวกับ C ++ หรือ Java), polymorphism ช่วยให้นักพัฒนาสามารถเรียกวิธีการโดยไม่จำเป็นต้องรู้ชนิดของวัตถุล่วงหน้าและเชื่อมั่นว่าการใช้วิธีการที่ถูกต้องจะ ถูกเรียก ตัวอย่างเช่นสมมติว่าผู้ใช้เลือกประเภทของการNumberสร้าง:

$userNumberChoice = $_GET['userNumberChoice'];

switch ($userNumberChoice) {
    case 'fraction':
        $userNumber = new Fraction(1, 2);
        break;
    case 'complex':
        $userNumber = new ComplexNumber(1, 2);
        break;
}

echo "The user's number is: ";
$userNumber->display();
echo "\n";

ในกรณีนี้display()จะเรียกวิธีการที่เหมาะสมแม้ว่าผู้พัฒนาจะไม่ทราบล่วงหน้าว่าผู้ใช้จะเลือกเศษส่วนหรือจำนวนเชิงซ้อน

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

ความหลากหลายหมายถึงตัวอักษรหลายรูปร่าง (หรือหลายฟอร์ม): วัตถุจากคลาสที่ต่างกันและวิธีชื่อเดียวกัน แต่เวิร์กโฟลว์แตกต่างกัน ตัวอย่างง่ายๆคือ:

พิจารณาบุคคล X

เขาเป็นเพียงคนเดียว แต่ทำหน้าที่เป็นคนมากมาย คุณอาจถามว่า:

เขาเป็นลูกชายของแม่ เพื่อนกับเพื่อนของเขา น้องชายกับน้องสาวของเขา

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

ตัวอย่างเช่นShapeเป็นส่วนต่อประสานซึ่งมีชนิดย่อยSquare , Circle , Diamond ตอนนี้คุณมีวัตถุสแควร์แล้วคุณสามารถอัปโหลดสแควร์เป็นรูปร่างโดยอัตโนมัติเนื่องจากสแควร์เป็นรูปร่าง แต่เมื่อคุณพยายามที่จะลดขนาด Shape to Square คุณต้องทำการแคสต์ชนิดที่ชัดเจนเนื่องจากคุณไม่สามารถพูดได้ว่า Shape is Square อาจเป็น Circle ได้เช่นกัน ดังนั้นคุณต้องใช้มันด้วยรหัสเช่นSquare s = (Square)shapeถ้ารูปร่างเป็น Circle คุณจะได้รับjava.lang.ClassCastExceptionเพราะ Circle ไม่ใช่ Square

polymorphism:

การดำเนินการที่แตกต่างกันตามอินสแตนซ์ของคลาสไม่ใช่ประเภทของตัวแปรอ้างอิง

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

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

อย่าลืมว่าแต่ละคลาสจะต้องบันทึกไว้ในไฟล์แยกกัน

รหัสต่อไปนี้เป็นตัวอย่าง Polymorphism:

The SuperClass:

public class Parent {
    //Define things that all classes share
    String maidenName;
    String familyTree;

    //Give the top class a default method
    public void speak(){
         System.out.println("We are all Parents");
    }
}

พ่อ subclass:

public class Father extends Parent{
    //Can use maidenName and familyTree here
    String name="Joe";
    String called="dad";

    //Give the top class a default method
    public void speak(){
        System.out.println("I am "+name+", the father.");
    }
}

เด็กคลาสย่อยอื่น:

public class Child extends Father {
    //Can use maidenName, familyTree, called and name here

    //Give the top class a default method
    public void speak(){
        System.out.println("Hi "+called+". What are we going to do today?");
    }
}

วิธีการดำเนินการอ้างอิงระดับผู้ปกครองที่จะเริ่มต้น:

public class Parenting{
    public static void main(String[] args) {
        Parent parents = new Parent();
        Parent parent = new Father();
        Parent child = new Child();

        parents.speak();
        parent.speak();
        child.speak();
    }
}

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

หวังว่านี่จะช่วยและทำให้ชัดเจน ฉันจะโพสต์ผลลัพธ์เมื่อฉันพบคอมพิวเตอร์ที่ฉันสามารถใช้เพื่อตรวจสอบรหัส ขอบคุณสำหรับความอดทน!

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

เนื่องจากคำตอบที่มีอยู่จำนวนมากกำลังสร้างความสับสนให้กับ subtyping ด้วย polymorphism ต่อไปนี้เป็นสามวิธี (รวมถึง subtyping) เพื่อสร้าง polymorphism

• พารามิเตอร์หลากหลาย (ทั่วไป)อนุญาตให้รูทีนยอมรับพารามิเตอร์ประเภทหนึ่งหรือหลายพารามิเตอร์นอกเหนือจากพารามิเตอร์ปกติและเรียกใช้ตัวเองในประเภทเหล่านั้น
• polymorphism ชนิดย่อยอนุญาตให้รูทีนดำเนินการกับชนิดย่อยของพารามิเตอร์
• Ad Hoc polymorphismโดยทั่วไปจะใช้การทำงานหนักเกินปกติเพื่อให้เกิดพฤติกรรมที่หลากหลาย แต่สามารถอ้างถึงการใช้งาน polymorphism อื่น ๆ ได้เช่นกัน

ดูสิ่งนี้ด้วย:

http://wiki.c2.com/?CategoryPolymorphism

https://en.wikipedia.org/wiki/Polymorphism_(computer_science)

ในภาษาเชิงวัตถุความหลากหลายสามารถช่วยให้การรักษาและการจัดการชนิดข้อมูลที่แตกต่างกันผ่านอินเตอร์เฟซเดียวกัน ตัวอย่างเช่นพิจารณาการสืบทอดใน C ++: คลาส B มาจากคลาส A ตัวชี้ประเภท A * (ตัวชี้ไปยังคลาส A) อาจใช้เพื่อจัดการกับทั้งวัตถุของคลาส A และวัตถุของคลาส B

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

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

โดยใช้ polymorphism โมดูลระดับสูงไม่ได้ขึ้นอยู่กับโมดูลระดับต่ำ ทั้งสองขึ้นอยู่กับ abstractions สิ่งนี้ช่วยให้เราสามารถใช้หลักการผกผันของการพึ่งพา ( https://en.wikipedia.org/wiki/Dependency_inversion_principle )

นี่คือที่ฉันพบคำนิยามข้างต้น ประมาณ 50 นาทีในวิดีโอผู้สอนอธิบายข้างต้น https://www.youtube.com/watch?v=TMuno5RZNeE

ความแตกต่างคืออะไร?

ความแตกต่างคือความสามารถในการ:

• เรียกใช้การดำเนินการในตัวอย่างของการเป็นชนิดพิเศษโดยเฉพาะการรู้ประเภททั่วไปในขณะที่เรียกวิธีการของชนิดพิเศษและไม่ว่าประเภททั่วไปที่: มันเป็นความแตกต่างแบบไดนามิก

• กำหนดวิธีการหลายวิธีที่มีบันทึกชื่อ แต่มีพารามิเตอร์ differents: มันเป็นความแตกต่างแบบคงที่

ครั้งแรกหากนิยามทางประวัติศาสตร์และที่สำคัญที่สุด

polymorphism ใช้ทำอะไร?

อนุญาตให้สร้างความสอดคล้องอย่างยิ่งของลำดับชั้นของชั้นเรียนและทำสิ่งมหัศจรรย์บางอย่างเช่นการจัดการรายการของวัตถุประเภทต่าง ๆ โดยไม่ทราบประเภทของตน

การพิมพ์ที่แข็งแกร่งและอ่อนแอ

ตัวอย่าง

นี่คือรูปร่างบางส่วนเช่น Point, Line, สี่เหลี่ยมผืนผ้าและ Circle ที่มีการดำเนินการ Draw () โดยไม่ใช้พารามิเตอร์ใด ๆ หรืออย่างใดอย่างหนึ่งเพื่อตั้งค่าการหมดเวลาเพื่อลบ

public class Shape
{
 public virtual void Draw()
 {
   DoNothing();
 }
 public virtual void Draw(int timeout)
 {
   DoNothing();
 }
}

public class Point : Shape
{
 int X, Y;
 public override void Draw()
 {
   DrawThePoint();
 }
}

public class Line : Point
{
 int Xend, Yend;
 public override Draw()
 {
   DrawTheLine();
 }
}

public class Rectangle : Line
{
 public override Draw()
 {
   DrawTheRectangle();
 }
}

var shapes = new List<Shape> { new Point(0,0), new Line(0,0,10,10), new rectangle(50,50,100,100) };

foreach ( var shape in shapes )
  shape.Draw();

ต่อไปนี้เป็นคลาส Shape และ Shape.Draw () วิธีการควรถูกทำเครื่องหมายเป็นนามธรรม

พวกเขาไม่ได้เพื่อให้เข้าใจ

ชี้แจง

หากไม่มี polymorphism โดยใช้ abstract-virtual-override ขณะแยกวิเคราะห์รูปร่างมันเป็นเพียงวิธี Spahe.Draw () ที่เรียกว่า CLR โดยไม่รู้วิธีที่จะเรียก ดังนั้นมันจึงเรียกเมธอดของชนิดที่เราดำเนินการและนี่คือประเภทคือรูปร่างเนื่องจากการประกาศรายการ ดังนั้นโค้ดจึงไม่ทำอะไรเลย

ด้วย polymorphism CLR สามารถอนุมานชนิดของวัตถุที่แท้จริงที่เรากระทำโดยใช้สิ่งที่เรียกว่าตารางเสมือน ดังนั้นจึงเรียกวิธีการที่ดีและที่นี่เรียก Shape.Draw () ถ้า Shape is Point เรียก Point.Draw () ดังนั้นรหัสวาดรูปร่าง

อ่านเพิ่มเติม

C # - ความหลากหลาย (ระดับ 1)

ความแตกต่างใน Java (ระดับ 2)

ความหลากหลาย (คู่มือการเขียนโปรแกรม C #)

ตารางวิธีการเสมือน