สมมติว่าฉันกำลังทำงานกับระบบที่มีอยู่และมีขนาดใหญ่พอสมควร ฉันมีวัตถุmyObjectของคลาสMyClass(เพื่อประโยชน์ของตัวอย่างสมมติว่าฉันทำงานใน Java) myObjectเป็นองค์ประกอบที่ประกอบด้วย a Collection, say, a Listและวัตถุอื่น ๆ ที่ (ฉันคิดว่า) ไม่เกี่ยวข้อง มันมีวิธีการมอบหมายซึ่งเพียงแค่ให้บริการที่จะเรียกร้องให้วิธีการของListมันประกอบด้วยเพื่อให้แน่ใจว่าListมันจะไม่ได้สัมผัส (ขออภัยถ้าฉันมีคำศัพท์ของฉันผิด)

Let 's พูดที่ว่านี้Listเป็นแต่ด้วยเหตุผลบางอย่างที่วิธีการเข้าถึงหลักเป็นวิธีหน้ากากสำหรับการเรียนList<String> SomeOtherClassถ้าผมอยากจะใส่คู่ค่าใหม่เข้าไปในของฉันListแล้วฉันมีวัตถุของที่เรียกว่าSomeOtherClass someObjectฉันต้องการโทรmyObject.insert(someObject)และภายในinsertวิธีการจะมีความมหัศจรรย์บางอย่างที่จะดึงข้อมูลที่จะใส่ลงไปในStringList<String>

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

ฉันเดาว่าถ้าฉันทำมากไปมันจะมีลักษณะเช่นนี้ ...

public void insert(String s) {
    ...
}

public void insert(SomeOtherObject obj) {
    this.insert(obj.magicStringMethod());
}

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

นี่เป็นสถานที่ที่เหมาะสมในการโอเวอร์โหลดเมธอดหรือไม่? ถ้าไม่ฉันควรโอเวอร์โหลดเมธอดเมื่อใด

คุณโอเวอร์โหลดเมื่อคุณต้องการสนับสนุนประเภทต่าง ๆ :

public overload void MyMethod(int value)
{ 
}

public overload void MyMethod(bool value)
{
}

public overload void MyMethod(string value)
{
}

หรือเพื่อสนับสนุนส่วนต่อประสานแบบก้าวหน้าโดยใช้รายการพารามิเตอร์อื่น:

public overload void MyOtherMethod()
{
    this.MyOtherMethod(DefaultValue);
}

public overload void MyOtherMethod(int value)
{
    this.MyOtherMethod(value, DefaultOtherValue);
}

public overload void MyOtherMethod(int value, bool otherValue)
{
    ...
}

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

ฉันจะบอกว่าการบรรทุกเกินพิกัดมีความเหมาะสมเมื่อทั้งสองวิธีมีความหมายเทียบเท่ากัน หากต้องการขโมยจากตัวอย่างของ dukeofgaming:

สิ่งเหล่านี้มากเกินไปอย่างเหมาะสม:

public int sum(int a, int b){
    return a+b;
}

public double sum(double a, double b){
    return a+b;
}

สิ่งเหล่านี้ไม่ใช่:

public int sum(int a, int b){
    return a+b;
}

public double sum(double a, double b){
    return a-b;
}

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

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

เป็นหลักที่จะมีพารามิเตอร์ของวิธีการกำหนดวิธีการที่จะประพฤติ

ตัวอย่างรวดเร็วจะเป็น:

class Calc{
    //...
    public int sum(int a, int b){
        return a+b;
    }
    public double sum(double a, double b){
        return a+b;
    }
    //...
}

หากคุณผ่านเมธอดผลรวม (a, b) คู่ของจำนวนเต็มจะรู้ว่าควรเรียกใช้งานครั้งแรกเนื่องจากเมธอด call เกิดขึ้นพร้อมกับลายเซ็นเมธอด (เช่น double sum (double, double) จะไม่ทำงานหากคุณให้ ผลรวมวิธีสองจำนวนเต็ม)

ลายเซ็นของการโทรจะต้องตรงกับการใช้งานที่มีอยู่ดังนั้นการพยายามโทรหาผลรวม (สตริง, สตริง) จะไม่ทำงานจนกว่าคุณจะมีสิ่งนี้:

class Calc{
    //...
    public int sum(int a, int b){
        return a+b;
    }
    public double sum(double a, double b){
        return a+b;
    }
    public string sum(String a, String b){
        return "" + (Double.parseDouble(a) + Double.parseDouble(b));
    }
    //...
}

tl; dr: เพื่อให้คลาสจัดการวิธีการที่ถูกต้องตามพารามิเตอร์ใด ๆ ที่คุณให้วิธีการที่มีชื่อเดียวกัน

เมื่อรับช่วงจะเรียกว่าการเอาชนะ

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

ลองนึกภาพว่าคุณมีclass Robotและวิธีการที่เรียกว่าfireAtTarget(Target target)... ซึ่งจะโทรหาfireWeaponA(target); fireWeaponB(target); fireWeaponC(target);กัน นอกจากนี้คุณยังต้องการมีคอลเลกชันที่ชื่อว่า robot_army ซึ่งคุณสามารถเพิ่มวัตถุของคลาสหุ่นยนต์ได้เท่านั้น หุ่นยนต์ยิงปืนกลตามค่าเริ่มต้นในfireWeaponX()วิธีการ

แล้วคุณต้องการที่จะมีclass LazorRobotและclass MissileRobotคุณจะใช้หุ่นยนต์ทั้งหมดอีกครั้ง ?, ไม่เพียงมี LazorRobot และ MissileRobot สืบทอดหุ่นยนต์และเกินแต่ละfireWeaponX()วิธีการในการใช้ lazorz หรือขีปนาวุธและคุณจะมีพฤติกรรมเดียวกันด้วยอาวุธที่แตกต่างกันได้โดยไม่ต้อง reimplement ส่วนที่เหลือของวิธีการ

tl; dr: เพื่อให้พฤติกรรมของเมธอดนั้นขึ้นอยู่กับคลาสโดยไม่ทำลายอินเตอร์เฟส (robot_army ยอมรับเฉพาะ Robot แต่ยอมรับโดยการขยายคลาสใด ๆ ที่สืบทอด Robot)