การพึ่งพาการฉีดในบริบทของสองคลาสง่าย ๆ

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

ดังนั้นฉันจึงมีคลาส A

public class A {
    public void foo(){
        B b = new B();
        b.fooB();
    }
}

ดังที่เห็นด้านบน A ขึ้นอยู่กับ B, B ซึ่งก็คือ

public class B {
    public void fooB(){
        Log.e("s", "y");
    }
}

และเราสามารถใช้ A like

public void do(){
    A a = new A();
    a.foo();
}

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

ดังนั้นขอให้มีอินเทอร์เฟซ BService

public interface BService {
    void fooB();
}

และ B กลายเป็น DiB

public class DiB implements BService {
    @Override
    public void fooB(){
        Log.e("s", "y");
    }
}

และ A จะกลายเป็น DiA

public class DiA {
    BService bService;

    public DiA(BService bService){
        this.bService = bService;
    }

    public void foo(){
        bService.fooB();
    }
}

และเราสามารถใช้ A like

public void dIdo(){
        BService service = new diB();
        diA a = new diA(service);
        a.foo();
}

ดังนั้นฉันอ่านประโยชน์ของ DI คือ:

• รหัสที่สามารถทดสอบได้: เพราะฉันสามารถทดสอบทั้งสองรหัสใน JUnit ได้ (ฉันไม่ต้องการโพสต์การทดสอบที่นี่เพื่อหลีกเลี่ยงคำถามยาว ๆ )
• Decoupling: มันบอกว่าถ้าคลาส B เปลี่ยนไปแล้ว A ไม่ควรได้รับผลกระทบและฉันไม่สามารถเข้าใจได้เพราะถ้าฉันเปลี่ยน fooB () ในคลาส B เป็น fooB2 () ฉันจะต้องเปลี่ยนวิธีการแทนที่ใน BService ซึ่งในทางกลับกัน หมายความว่าฉันจะต้องเปลี่ยนมันในชั้นเรียน

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

ในบันทึกแรกฉันไม่เห็นด้วยกับคุณ "ว่ากันว่า A ไม่ควรเริ่มต้น B เพราะมันขึ้นอยู่กับมัน" .. เพราะรหัสเดียวกันทำงานได้ดีสำหรับฉันใน. NET

    class Program
{
    static void Main(string[] args)
    {
        A aobj = new A();
        aobj.foo();
    }
}
public class A {
    public void foo()
    {
        B bojb = new B();
        bojb.fooB();
        Console.WriteLine("From A.foo() ..");
        Console.ReadLine();
    }

}
public class B {
    public void fooB()
    {
        Console.WriteLine("From B.fooB() ..");
        Console.ReadLine();
    }
}

นอกจากนี้เดาว่าคุณสับสนกับพื้นฐานการพึ่งพาการฉีด คำที่พึ่งพานั้นสื่อถึงแหล่งที่มาของการฉีดสำหรับชั้นเรียนใด ๆ

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

แนะนำให้คุณอ่านเพิ่มเติมก่อนตัดสินใจ