Java - ชื่อเมธอดชนกันในการใช้งานอินเตอร์เฟส

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

ใน C # สิ่งนี้ถูกเอาชนะโดยสิ่งที่เรียกว่าการใช้งานอินเทอร์เฟซที่ชัดเจน มีวิธีที่เทียบเท่าใน Java หรือไม่?

ไม่ไม่มีวิธีใดที่จะใช้วิธีเดียวกันในสองวิธีที่แตกต่างกันในคลาสเดียวใน Java

นั่นอาจนำไปสู่สถานการณ์ที่สับสนมากมายซึ่งเป็นสาเหตุที่ Java ไม่อนุญาต

interface ISomething {
    void doSomething();
}

interface ISomething2 {
    void doSomething();
}

class Impl implements ISomething, ISomething2 {
   void doSomething() {} // There can only be one implementation of this method.
}

สิ่งที่คุณทำได้คือสร้างคลาสจากสองคลาสที่แต่ละคลาสใช้อินเทอร์เฟซที่แตกต่างกัน จากนั้นคลาสหนึ่งจะมีลักษณะการทำงานของอินเทอร์เฟซทั้งสอง

class CompositeClass {
    ISomething class1;
    ISomething2 class2;
    void doSomething1(){class1.doSomething();}
    void doSomething2(){class2.doSomething();}
}

ไม่มีวิธีจริงในการแก้ปัญหานี้ใน Java คุณสามารถใช้คลาสภายในเป็นวิธีแก้ปัญหาได้:

interface Alfa { void m(); }
interface Beta { void m(); }
class AlfaBeta implements Alfa {
    private int value;
    public void m() { ++value; } // Alfa.m()
    public Beta asBeta() {
        return new Beta(){
            public void m() { --value; } // Beta.m()
        };
    }
}

แม้ว่ามันจะไม่อนุญาตให้ทำการร่ายจากAlfaBetaถึงBetaแต่การดาวน์คาสต์โดยทั่วไปก็เป็นสิ่งที่ชั่วร้ายและหากเป็นไปได้ว่าAlfaอินสแตนซ์มักจะมีBetaแง่มุมด้วยเช่นกันและด้วยเหตุผลบางประการ (โดยปกติการเพิ่มประสิทธิภาพเป็นเหตุผลที่ถูกต้องเท่านั้น) ที่คุณต้องการ ในการแปลงเป็นBetaคุณสามารถสร้างอินเทอร์เฟซย่อยAlfaด้วยBeta asBeta()ได้

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

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

สำหรับกรณีเดิม ... สมมติว่าคุณต้องการอาร์เรย์ของจำนวนเต็มและอาร์เรย์ของสตริง แทนที่จะรับช่วงจากทั้งสองList<Integer>และList<String>คุณควรมีสมาชิกประเภทหนึ่งList<Integer>และสมาชิกประเภทList<String>อื่นและอ้างถึงสมาชิกเหล่านั้นแทนที่จะพยายามสืบทอดจากทั้งสองอย่าง แม้ว่าคุณจะต้องการเพียงแค่รายการจำนวนเต็ม แต่ก็ควรใช้องค์ประกอบ / การมอบหมายมากกว่าการสืบทอดในกรณีนี้

ปัญหา Java "คลาสสิก" ยังส่งผลต่อการพัฒนา Android ของฉัน ...
เหตุผลดูเหมือนจะง่าย:
เฟรมเวิร์ก / ไลบรารีที่คุณต้องใช้มากขึ้นสิ่งต่าง ๆ ที่ควบคุมไม่ได้ง่ายขึ้น ...

ในกรณีของฉันฉันมีคลาสBootStrapperAppสืบทอดมาจากandroid.app.Application ,
ในขณะที่ชั้นเดียวกันก็ควรที่จะใช้แพลตฟอร์มอินเตอร์เฟซของกรอบ MVVM เพื่อให้ได้รับแบบบูรณาการ
เมธอดชนกันเกิดขึ้นบนเมธอดgetString ()ซึ่งประกาศโดยทั้งสองอินเทอร์เฟซและควรมีการใช้งานที่แตกต่างกันในบริบทที่แตกต่างกัน
วิธีแก้ปัญหา (น่าเกลียด .. IMO) กำลังใช้คลาสภายในเพื่อใช้งานแพลตฟอร์มทั้งหมดวิธีการเพียงเพราะความขัดแย้งของลายเซ็นของวิธีการเล็กน้อย ... ในบางกรณีวิธีการยืมดังกล่าวไม่ได้ใช้เลย (แต่ส่งผลต่อความหมายของการออกแบบที่สำคัญ)
ฉันมักจะเห็นด้วย C # - สไตล์การบ่งชี้บริบท / เนมสเปซที่ชัดเจนเป็นประโยชน์

วิธีแก้ปัญหาเดียวที่อยู่ในใจของฉันคือการใช้วัตถุอ้างอิงกับสิ่งที่คุณต้องการใช้อินเทอร์เฟซที่หลากหลาย

เช่นสมมติว่าคุณมี 2 อินเทอร์เฟซที่จะใช้

public interface Framework1Interface {

    void method(Object o);
}

และ

public interface Framework2Interface {
    void method(Object o);
}

คุณสามารถใส่ไว้ในวัตถุ Facador สองชิ้น:

public class Facador1 implements Framework1Interface {

    private final ObjectToUse reference;

    public static Framework1Interface Create(ObjectToUse ref) {
        return new Facador1(ref);
    }

    private Facador1(ObjectToUse refObject) {
        this.reference = refObject;
    }

    @Override
    public boolean equals(Object obj) {
        if (obj instanceof Framework1Interface) {
            return this == obj;
        } else if (obj instanceof ObjectToUse) {
            return reference == obj;
        }
        return super.equals(obj);
    }

    @Override
    public void method(Object o) {
        reference.methodForFrameWork1(o);
    }
}

และ

public class Facador2 implements Framework2Interface {

    private final ObjectToUse reference;

    public static Framework2Interface Create(ObjectToUse ref) {
        return new Facador2(ref);
    }

    private Facador2(ObjectToUse refObject) {
        this.reference = refObject;
    }

    @Override
    public boolean equals(Object obj) {
        if (obj instanceof Framework2Interface) {
            return this == obj;
        } else if (obj instanceof ObjectToUse) {
            return reference == obj;
        }
        return super.equals(obj);
    }

    @Override
    public void method(Object o) {
        reference.methodForFrameWork2(o);
    }
}

ในที่สุดชั้นเรียนที่คุณต้องการควรเป็นอย่างไร

public class ObjectToUse {

    private Framework1Interface facFramework1Interface;
    private Framework2Interface facFramework2Interface;

    public ObjectToUse() {
    }

    public Framework1Interface getAsFramework1Interface() {
        if (facFramework1Interface == null) {
            facFramework1Interface = Facador1.Create(this);
        }
        return facFramework1Interface;
    }

    public Framework2Interface getAsFramework2Interface() {
        if (facFramework2Interface == null) {
            facFramework2Interface = Facador2.Create(this);
        }
        return facFramework2Interface;
    }

    public void methodForFrameWork1(Object o) {
    }

    public void methodForFrameWork2(Object o) {
    }
}

ตอนนี้คุณสามารถใช้เมธอด getAs * เพื่อ "เปิดเผย" ชั้นเรียนของคุณได้

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

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

public class MyClass{

    private String name;

    MyClass(String name){
        this.name = name;
    }

    public String getName(){
        return name;
    }
}

ตอนนี้คุณต้องส่งผ่านไปยัง WizzBangProcessor ซึ่งต้องใช้คลาสในการใช้ WBPInterface ... ซึ่งมีเมธอด getName () ด้วย แต่แทนที่จะใช้งานอย่างเป็นรูปธรรมอินเทอร์เฟซนี้คาดว่าเมธอดจะส่งคืนชื่อของประเภท ของ Wizz Bang Processing

ใน C # มันจะเป็นสามเท่า

public class MyClass : WBPInterface{

    private String name;

    String WBPInterface.getName(){
        return "MyWizzBangProcessor";
    }

    MyClass(String name){
        this.name = name;
    }

    public String getName(){
        return name;
    }
}

ใน Java Tough คุณจะต้องระบุทุกจุดในฐานรหัสที่ปรับใช้ที่มีอยู่ซึ่งคุณต้องแปลงจากอินเทอร์เฟซหนึ่งไปยังอีกอินเทอร์เฟซ แน่นอนว่า บริษัท WizzBangProcessor ควรใช้ getWizzBangProcessName () แต่พวกเขาก็เป็นนักพัฒนาเช่นกัน ในบริบท getName ก็ดี จริงๆแล้วนอก Java ภาษาที่ใช้ OO อื่น ๆ ส่วนใหญ่รองรับสิ่งนี้ Java มีน้อยมากในการบังคับให้ใช้อินเทอร์เฟซทั้งหมดด้วยวิธีการเดียวกัน NAME

ภาษาอื่น ๆ ส่วนใหญ่มีคอมไพเลอร์ที่ยินดีรับคำสั่งมากกว่าที่จะบอกว่า "วิธีนี้ในคลาสนี้ซึ่งตรงกับลายเซ็นของวิธีนี้ในอินเทอร์เฟซที่ใช้งานนี้คือการนำไปใช้งาน" หลังจากจุดรวมทั้งหมดของการกำหนดอินเทอร์เฟซคือการอนุญาตให้นิยามที่เป็นนามธรรมจากการนำไปใช้งาน (อย่าเพิ่งให้ฉันเริ่มใช้วิธีการเริ่มต้นในอินเทอร์เฟซใน Java นับประสาการลบล้างค่าเริ่มต้น .... เพราะแน่นอนว่าทุกส่วนประกอบที่ออกแบบมาสำหรับรถใช้งานบนท้องถนนควรจะกระแทกเข้ากับรถที่บินได้และใช้งานได้ - เฮ้ มันเป็นรถทั้งคู่ ... ฉันแน่ใจว่าฟังก์ชันการทำงานเริ่มต้นของ say sat nav ของคุณจะไม่ได้รับผลกระทบกับอินพุต pitch และ roll ที่เป็นค่าเริ่มต้นเพราะรถยนต์เท่านั้นที่หันเห!