เหตุใดจึงต้องใช้อินเตอร์เฟสที่ซ้อนกันแบบคงที่ใน Java

ฉันเพิ่งพบอินเทอร์เฟซซ้อนแบบคงที่ในรหัสฐานของเรา

class Foo {
    public static interface Bar {
        /* snip */
    }
    /* snip */
}

ฉันไม่เคยเห็นสิ่งนี้มาก่อน นักพัฒนาดั้งเดิมไม่สามารถเข้าถึงได้ ดังนั้นฉันต้องถามดังนั้น:

ความหมายอะไรที่อยู่เบื้องหลังส่วนต่อประสานคงที่ สิ่งที่จะเปลี่ยนถ้าผมเอาstatic? ทำไมทุกคนจะทำเช่นนี้?

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

ไม่ว่าจะด้วยวิธีใดผู้พัฒนาจะประกาศเพียงอินเทอร์เฟซชื่อ Foo.Bar ไม่มีการเชื่อมโยงเพิ่มเติมกับคลาสที่ปิดล้อมยกเว้นรหัสที่ไม่สามารถเข้าถึง Foo จะไม่สามารถเข้าถึง Foo.Bar ได้เช่นกัน (จากซอร์สโค้ด - ไบต์หรือการสะท้อนสามารถเข้าถึง Foo.Bar แม้ว่า Foo จะเป็นแพ็คเกจส่วนตัว!)

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

public class Foo {
    public interface Bar {
        void callback();
    }
    public static void registerCallback(Bar bar) {...}
}
// ...elsewhere...
Foo.registerCallback(new Foo.Bar() {
    public void callback() {...}
});

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

ส่วนต่อประสานสมาชิกนั้นคงที่โดยปริยาย ตัวดัดแปลงแบบคงที่ในตัวอย่างของคุณสามารถลบออกได้โดยไม่ต้องเปลี่ยนซีแมนทิกส์ของรหัส ดูเพิ่มเติม Java Language Specification 8.5.1 ประกาศประเภทสมาชิกคงที่

อินเทอร์เฟซภายในจะต้องคงที่เพื่อให้สามารถเข้าถึงได้ อินเทอร์เฟซไม่เกี่ยวข้องกับอินสแตนซ์ของคลาส แต่กับคลาสเองดังนั้นจะสามารถเข้าถึงได้ด้วยFoo.Barเช่น:

public class Baz implements Foo.Bar {
   ...
}

ในวิธีส่วนใหญ่สิ่งนี้ไม่แตกต่างจากคลาสภายในแบบคงที่

คำตอบของ Jesse นั้นใกล้เคียงกัน แต่ฉันคิดว่ามีรหัสที่ดีกว่าเพื่อแสดงว่าทำไมอินเทอร์เฟซภายในอาจมีประโยชน์ ดูรหัสด้านล่างก่อนที่จะอ่าน คุณสามารถค้นหาสาเหตุที่อินเทอร์เฟซภายในมีประโยชน์หรือไม่ คำตอบคือคลาส DoSomethingAlready สามารถอินสแตนซ์ภายในได้ช่วยให้สามารถสร้างประเภทที่กำหนดเองและปรับปรุงการห่อหุ้มได้คลาสใดก็ได้ที่ใช้ A และ C ไม่ใช่แค่สวนสัตว์ระดับคอนกรีต แน่นอนว่าสิ่งนี้สามารถทำได้แม้ว่า AC จะไม่ได้อยู่ข้างใน แต่ลองนึกภาพการต่อชื่อที่ยาวกว่า (ไม่ใช่แค่ A และ C) และทำสิ่งนี้สำหรับการผสมอื่น ๆ (พูด A และ B, C และ B ฯลฯ ) และคุณได้อย่างง่ายดาย ดูว่าสิ่งต่าง ๆ อยู่นอกเหนือการควบคุม ไม่ต้องพูดถึงว่าคนที่ตรวจสอบซอร์สโค้ดของคุณจะถูกครอบงำด้วยอินเทอร์เฟซที่มีความหมายเฉพาะในหนึ่งคลาสดังนั้นเพื่อสรุป

class ConcreteA implements A {
 :
}

class ConcreteB implements B {
 :
}

class ConcreteC implements C {
 :
}

class Zoo implements A, C {
 :
}

class DoSomethingAlready {
  interface AC extends A, C { }

  private final AC ac;

  DoSomethingAlready(AC ac) {
    this.ac = ac;
  }
}

หากต้องการตอบคำถามของคุณโดยตรงให้ดูที่ Map.Entry

Map.Entry

นอกจากนี้อาจมีประโยชน์

บล็อก Inerfaces ซ้อนกันแบบคงที่

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

หากคุณจะเปลี่ยนคลาส Foo เป็นอินเตอร์เฟส Foo คำหลัก "สาธารณะ" ในตัวอย่างด้านบนจะซ้ำซ้อนเช่นกันเพราะ

อินเตอร์เฟซที่กำหนดไว้ในอินเทอร์เฟซอื่นจะคงที่สาธารณะโดยปริยาย

ในปี 1998 Philip Wadler เสนอความแตกต่างระหว่างส่วนต่อประสานแบบคงที่และส่วนต่อประสานแบบไม่คงที่

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

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

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

// This code does NOT compile
class LangF<This extends LangF<This>> {
    interface Visitor<R> {
        public R forNum(int n);
    }

    interface Exp {
        // since Exp is non-static, it can refer to the type bound to This
        public <R> R visit(This.Visitor<R> v);
    }
}

ข้อเสนอแนะของเขาไม่เคยทำใน Java 1.5.0 ดังนั้นคำตอบอื่น ๆ ทั้งหมดถูกต้อง: ไม่มีความแตกต่างกับส่วนต่อประสานแบบคงที่และไม่คงที่

ใน Java ส่วนต่อประสานคงที่ / คลาสอนุญาตให้ส่วนต่อประสาน / คลาสใช้เช่นคลาสระดับบนสุดนั่นคือสามารถประกาศโดยคลาสอื่น ๆ ดังนั้นคุณสามารถทำได้:

class Bob
{
  void FuncA ()
  {
    Foo.Bar foobar;
  }
}

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

รายละเอียดของประเภทชั้นในชวา

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

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

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

วิธีการคงที่ดีสำหรับผลตอบแทนครั้งเดียวและการคำนวณอย่างรวดเร็วหรือข้อมูลที่ได้รับง่าย