คำถามติดแท็ก interfaces

ฉันมีโมดูลพูดว่า 'M' ซึ่งมีลูกค้าไม่กี่คนให้พูดว่า 'C1', 'C2', 'C3' ฉันต้องการที่จะแบ่งปัน namespace ของโมดูล M คือการประกาศของ API และข้อมูลที่มันเปิดเผยลงในไฟล์ส่วนหัวในลักษณะที่ - สำหรับลูกค้าใด ๆ จะเห็นเฉพาะข้อมูลและ API ที่ต้องการเท่านั้น ส่วนที่เหลือของเนมสเปซของโมดูลถูกซ่อนจากไคลเอนต์เช่นเป็นไปตามหลักการแยกส่วน การประกาศไม่ซ้ำในหลายไฟล์ส่วนหัวเช่นไม่ละเมิด แห้ง โมดูล M ไม่มีการพึ่งพาลูกค้า ลูกค้าไม่ได้รับผลกระทบจากการเปลี่ยนแปลงที่เกิดขึ้นในส่วนของโมดูล M ที่ไม่ได้ใช้ ลูกค้าที่มีอยู่ไม่ได้รับผลกระทบจากการเพิ่ม (หรือลบ) ของลูกค้าเพิ่มเติม ขณะนี้ฉันจัดการเรื่องนี้โดยการแบ่งเนมสเปซของโมดูลขึ้นอยู่กับความต้องการของลูกค้า ตัวอย่างเช่นในภาพด้านล่างส่วนต่างๆของเนมสเปซของโมดูลที่ลูกค้า 3 รายต้องการ ความต้องการของลูกค้ามีการทับซ้อนกัน namespace โมดูลแบ่งออกเป็น 4 ส่วนหัวของไฟล์ที่แยกต่างหาก - 'a', '1', '2' และ '3' อย่างไรก็ตามสิ่งนี้เป็นการละเมิดข้อกำหนดดังกล่าวบางประการเช่น R3 และ R5 …

15 c  interfaces  solid 

บริบท: ฉันใช้ C # ฉันออกแบบชั้นเรียนและเพื่อแยกมันออกและทำให้การทดสอบหน่วยง่ายขึ้นฉันกำลังผ่านการพึ่งพาทั้งหมด มันไม่สร้างอินสแตนซ์ของวัตถุภายใน อย่างไรก็ตามแทนที่จะอ้างอิงอินเทอร์เฟซเพื่อรับข้อมูลที่ต้องการฉันขอให้อ้างอิงวัตถุประสงค์ทั่วไป Funcs ที่ส่งคืนข้อมูล / พฤติกรรมที่ต้องการ เมื่อฉันฉีดการพึ่งพาของฉันฉันสามารถทำได้ด้วยการแสดงออกแลมบ์ดา สำหรับฉันดูเหมือนว่าจะเป็นวิธีที่ดีกว่าเพราะฉันไม่ต้องล้อเลียนเรื่องน่าเบื่อใด ๆ ระหว่างการทดสอบหน่วย นอกจากนี้หากการดำเนินการโดยรอบมีการเปลี่ยนแปลงพื้นฐานฉันจะต้องเปลี่ยนระดับโรงงานเท่านั้น ไม่มีการเปลี่ยนแปลงในชั้นเรียนที่มีตรรกะจะต้อง อย่างไรก็ตามฉันไม่เคยเห็น IoC ทำแบบนี้มาก่อนซึ่งทำให้ฉันคิดว่าอาจมีข้อผิดพลาดที่อาจเกิดขึ้น สิ่งเดียวที่ฉันคิดได้คือความไม่ลงรอยกันเล็กน้อยกับ C # รุ่นก่อนหน้าซึ่งไม่ได้กำหนด Func และนี่ไม่ใช่ปัญหาในกรณีของฉัน มีปัญหาใด ๆ หรือไม่ที่มีการใช้งานผู้รับมอบสิทธิ์ทั่วไป / ฟังก์ชั่นการสั่งซื้อที่สูงขึ้นเช่น Func สำหรับ IoC ซึ่งตรงข้ามกับส่วนต่อประสานที่เฉพาะเจาะจงมากขึ้น?

15 architecture  interfaces  inversion-of-control  delegates 

เริ่มต้นด้วย Java 8 defaultมีการนำวิธีการมาใช้ในอินเตอร์เฟส ได้อย่างมีประสิทธิภาพที่นี้หมายถึงว่าไม่ทุกวิธีการในการให้มีinterfaceabstract เริ่มต้นด้วย Java 9 (อาจ) privateวิธีการจะได้รับอนุญาต ซึ่งหมายความว่าไม่ทุกวิธีการในการให้มีinterfacepublic abstract คำถาม "ควรประกาศวิธีการในส่วนต่อประสาน Java โดยมีหรือไม่มีpublicตัวแก้ไขการเข้าถึงหรือไม่" ถูกถามที่ Stack Overflow ที่/programming/161633/should-methods-in-a-java-interface-be-declared-with-or-without-a-public-access-m คำตอบส่วนใหญ่แย้งว่าpublic abstractไม่ควรใช้เพราะไม่มีวิธีการใดที่interfaceสามารถเป็นอย่างอื่นpublic abstractได้ นี่ไม่ใช่กรณีอีกต่อไป ดังนั้นด้วยคุณสมบัติใหม่ของอินเทอร์เฟซเหล่านี้ควรใช้public abstractคีย์เวิร์ดในการประกาศเมธอดของอินเตอร์เฟส Java หรือไม่? ในสภาพแวดล้อมเฉพาะของฉันเราจะมีคนที่มีประสบการณ์วิศวกรซอฟต์แวร์ แต่ไม่เคยมีประสบการณ์ใน Java อ่านโค้ด Java เป็นครั้งคราว ฉันรู้สึกว่าการละทิ้งpublic abstractคำหลักจะสร้างจุดสับสนเพิ่มเติมสำหรับผู้ที่ไม่คุ้นเคยกับประวัติว่าอินเตอร์เฟสมีกฎแตกต่างกันสำหรับการใช้คำหลักเหล่านี้อย่างไร

14 java  coding-style  interfaces  coding-standards  keywords 

ฉันออกแบบอินเทอร์เฟซด้วยสองวิธีที่เกี่ยวข้องคล้ายกับสิ่งนี้: public interface ThingComputer { default Thing computeFirstThing() { return computeAllThings().get(0); } default List<Thing> computeAllThings() { return ImmutableList.of(computeFirstThing()); } } การใช้งานประมาณครึ่งหนึ่งจะคำนวณสิ่งหนึ่งเท่านั้นในขณะที่อีกครึ่งหนึ่งอาจคำนวณเพิ่มเติมได้ สิ่งนี้มีแบบอย่างใด ๆ ในโค้ด Java 8 ที่ใช้กันอย่างแพร่หลายหรือไม่? ฉันรู้ว่า Haskell ทำสิ่งที่คล้ายกันในบางประเภทEqของตัวอย่าง( เช่น) ข้อเสียคือฉันต้องเขียนโค้ดน้อยกว่าอย่างมากถ้าฉันมีบทคัดย่อสองคลาส ( SingleThingComputerและMultipleThingComputer) ข้อเสียก็คือการคอมไพล์การดำเนินงานที่ว่างเปล่า StackOverflowErrorแต่พัดขึ้นที่รันไทม์กับ เป็นไปได้ที่จะตรวจสอบการเรียกซ้ำซึ่งกันและกันด้วย a ThreadLocalและให้ข้อผิดพลาดที่ดีกว่า แต่นั่นเป็นการเพิ่มโอเวอร์เฮดให้กับโค้ดที่ไม่ใช่บั๊ก

14 java  design  interfaces  java8 

ฉันเข้าใจวิธีการทำงานกับอินเตอร์เฟสและการใช้อินเตอร์เฟสอย่างชัดเจนใน C # แต่ฉันสงสัยว่ามันถือว่าเป็นรูปแบบที่ไม่ดีเพื่อซ่อนสมาชิกบางคนที่ไม่ได้ใช้บ่อย ตัวอย่างเช่น: public interface IMyInterface { int SomeValue { get; set; } int AnotherValue { get; set; } bool SomeFlag { get; set; } event EventHandler SomeValueChanged; event EventHandler AnotherValueChanged; event EventHandler SomeFlagChanged; } ฉันรู้ล่วงหน้าว่ากิจกรรมในขณะที่มีประโยชน์จะไม่ค่อยได้ใช้ ดังนั้นฉันคิดว่ามันจะสมเหตุสมผลที่จะซ่อนพวกเขาออกจากชั้นเรียนการใช้งานผ่านการใช้งานอย่างชัดเจนเพื่อหลีกเลี่ยงความไม่เป็นระเบียบของ IntelliSense

14 c#  interfaces  implementations 

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

14 c#  design  interfaces  third-party-libraries  inversion-of-control 

มีความแตกต่างระหว่าง public class A extends AbstractB implements C {...} เมื่อเทียบกับ ... public class A extends AbstractB {...} abstract class AbstractB implements C {...} ฉันเข้าใจว่าในทั้งสองกรณีคลาส A จะจบลงที่สอดคล้องกับส่วนต่อประสาน ในกรณีที่สองสามารถให้การดำเนินงานสำหรับวิธีการในอินเตอร์เฟซAbstractB Cนั่นคือความแตกต่างเท่านั้น? ถ้าฉันไม่ต้องการที่จะให้การดำเนินการใด ๆ ของวิธีการอินเตอร์เฟซใน AbstractB , รูปแบบที่ฉันควรจะใช้ ? การใช้รายการใดรายการหนึ่งมีวัตถุประสงค์ 'เอกสาร' ที่ซ่อนอยู่หรือไม่

14 java  interfaces  abstract-class 

เมื่อพัฒนาใน OOP บางครั้งจะมีการกำหนดอินเทอร์เฟซ / สัญญาโดยห้องสมุดที่คุณไม่สามารถเปลี่ยนแปลงได้ มาเรียกอินเตอร์เฟสนี้ว่า J ตอนนี้คุณมีออบเจ็กต์คลาส A ที่ใช้วัตถุที่ใช้อินเทอร์เฟซนี้ ข้างในจำเป็นต้องมีข้อกำหนดของอินเตอร์เฟสเพียงเล็กน้อย ฉันสร้างคลาสวัตถุบางอย่างในระหว่างโครงการ (ลองเรียกหนึ่งในประเภท D) ดังนั้นจึงมีค่าใช้จ่ายในการดำเนินการทุกอย่างภายในส่วนติดต่อ J ฉันต้องการใช้ฟังก์ชั่นย่อยในอินเตอร์เฟส J แต่โซลูชันของฉันยังไม่เป็นที่พอใจ: การนำทุกแง่มุมของ J ไปใช้แล้วโยน "notImplementedExceptions" ให้ผู้ใช้วัตถุของฉันเข้าใจผิด: ดูเหมือนว่าวัตถุประเภท D ของฉันจะสอดคล้องกับส่วนต่อประสาน J แต่พวกเขาทำไม่ได้ - และผู้บริโภควัตถุอื่นของฉัน J) ไม่สามารถพึ่งพาความสมบูรณ์ของวัตถุของฉัน การใช้อินเทอร์เฟซที่กำหนดใหม่ห้ามไม่ให้ฉันใช้วัตถุที่ใช้เฉพาะอินเตอร์เฟส J แม้ว่าอินเตอร์เฟส J จะเข้ากันได้กับส่วนต่อประสานของฉันเอง การปล่อยให้วัตถุที่กำหนดเองของฉันใช้อินเตอร์เฟส J จะสร้างค่าใช้จ่ายที่สำคัญเพราะพวกเขาไม่ต้องการฟังก์ชันทั้งหมดนี้ เมื่อฉันสามารถเปลี่ยนอินเตอร์เฟส J ได้ฉันจะสร้าง "super-interface" K ที่มีชุดย่อยของฟังก์ชัน J interface นี้และทำให้ …

14 object-oriented  interfaces 

สำหรับทศวรรษที่ผ่านมาจะได้รับกรณีที่อินเตอร์เฟซได้เพียง เท่านั้น (เท่านั้น) สำหรับการระบุลายเซ็นวิธี เราได้รับการบอกว่านี่เป็น "วิธีการทำสิ่งที่ถูกต้อง" จากนั้น Java 8 ออกมาและพูดว่า: เอ่อเอ่อตอนนี้คุณสามารถกำหนดวิธีการเริ่มต้น ต้องวิ่งลาก่อน ฉันอยากรู้ว่าสิ่งนี้ถูกย่อยโดยนักพัฒนา Java ที่มีประสบการณ์และผู้ที่เริ่มเมื่อเร็ว ๆ นี้ (ไม่กี่ปีที่ผ่านมา) พัฒนามัน ฉันยังสงสัยเกี่ยวกับความเหมาะสมของ Java Orthodoxy และการฝึกฝนอย่างไร ฉันกำลังสร้างรหัสทดลองและในขณะที่ฉันกำลังทำการปรับเปลี่ยนใหม่ฉันลงเอยด้วยอินเทอร์เฟซที่ขยายส่วนต่อประสานมาตรฐาน (Iterable) และเพิ่มวิธีการเริ่มต้นสองวิธี และฉันจะซื่อสัตย์ฉันรู้สึกดีกับมัน ฉันรู้ว่านี่เป็นแบบปลายเปิดเล็ก ๆ น้อย ๆ แต่ตอนนี้มีเวลาสำหรับ Java 8 ที่จะใช้ในโครงการจริงมี orthodoxy รอบการใช้วิธีการเริ่มต้นหรือยัง สิ่งที่ฉันเห็นเป็นส่วนใหญ่เมื่อพูดถึงคือวิธีการเพิ่มวิธีการใหม่ในอินเทอร์เฟซโดยไม่ทำลายผู้บริโภค แต่สิ่งที่เกี่ยวกับการใช้สิ่งนี้ตั้งแต่เริ่มต้นเหมือนตัวอย่างที่ฉันให้ไว้ข้างต้น มีใครประสบปัญหาใด ๆ กับการให้การใช้งานในส่วนต่อประสานของพวกเขา?

13 java  interfaces  default-method 

ฉันกำลังออกแบบโปรแกรม OOP ตัวเล็ก ๆ ของฉันเพื่อจำลอง Vampires, Wolves, Human และ Trucks และกำลังพยายามใช้ความเข้าใจที่ จำกัด ของตัวเองเกี่ยวกับการเชื่อมต่อ ( ฉันยังคงสรุปอยู่ที่นี่และยังไม่มีการติดตั้งโค้ดดังนั้นจึงเป็นคำถามของการออกแบบ OOP ... ฉันคิดว่า!) ฉันกำลังมองหา'พฤติกรรมทั่วไป'ระหว่างชั้นเรียนเหล่านี้และนำไปใช้เป็นส่วนต่อประสานหรือไม่ ตัวอย่างเช่น Vampires and Wolves กัด ... ดังนั้นฉันควรมีส่วนต่อประสานกัดหรือไม่ public class Vampire : Villain, IBite, IMove, IAttack เช่นเดียวกันสำหรับรถบรรทุก ... public class Truck : Vehicle, IMove และสำหรับมนุษย์ ... public class Man : Human, IMove, …

13 object-oriented  interfaces 

ฉันพยายามจำลองเกมการ์ดโดยที่การ์ดมีคุณสมบัติที่สำคัญสองชุด: ที่แรกก็คือผลกระทบ นี่คือการเปลี่ยนแปลงสถานะเกมที่เกิดขึ้นเมื่อคุณเล่นไพ่ อินเตอร์เฟสสำหรับเอฟเฟกต์มีดังนี้: boolean isPlayable(Player p, GameState gs); void play(Player p, GameState gs); และคุณสามารถพิจารณาว่าการ์ดนั้นสามารถเล่นได้ถ้าหากคุณมีราคาที่เหมาะสมและเอฟเฟกต์ทั้งหมดสามารถเล่นได้ ชอบมาก // in Card class boolean isPlayable(Player p, GameState gs) { if(p.resource < this.cost) return false; for(Effect e : this.effects) { if(!e.isPlayable(p,gs)) return false; } return true; } โอเคจนถึงตอนนี้ค่อนข้างง่าย ฟีเจอร์ชุดอื่น ๆ ในการ์ดคือความสามารถ ความสามารถเหล่านี้เป็นการเปลี่ยนแปลงสถานะของเกมที่คุณสามารถเปิดใช้งานได้ตามต้องการ เมื่อมากับอินเทอร์เฟซสำหรับสิ่งเหล่านี้ฉันรู้ว่าพวกเขาต้องการวิธีในการพิจารณาว่าสามารถเปิดใช้งานหรือไม่และวิธีการเปิดใช้งาน มันจบลงด้วยการเป็น …

13 interfaces 

แม้ว่านี่จะเป็นคำถามทั่วไป แต่ก็เป็นปัญหาเฉพาะที่ฉันกำลังประสบอยู่ ขณะนี้ฉันมีส่วนต่อประสานที่ระบุในโซลูชันของฉันที่เรียกว่า public interface IContextProvider { IDataContext { get; set; } IAreaContext { get; set; } } อินเทอร์เฟซนี้มักใช้ตลอดโปรแกรมและด้วยเหตุนี้ฉันจึงเข้าถึงวัตถุที่ต้องการได้ง่าย อย่างไรก็ตามในส่วนของโปรแกรมของฉันค่อนข้างต่ำฉันต้องการเข้าถึงคลาสอื่นที่จะใช้IAreaContextและดำเนินการบางอย่างกับมัน ดังนั้นฉันจึงสร้างส่วนต่อประสานจากโรงงานอีกอันเพื่อสร้างสิ่งนี้ที่เรียกว่า: public interface IEventContextFactory { IEventContext CreateEventContext(int eventId); } ฉันมีคลาสที่ใช้IContextProviderและฉีดโดยใช้ NinJect ปัญหาที่ฉันมีคือพื้นที่ที่ฉันต้องการใช้IEventContextFactoryนี้มีการเข้าถึงIContextProviderเท่านั้นและตัวเองใช้คลาสอื่นซึ่งจะต้องใช้อินเทอร์เฟซใหม่นี้ ฉันไม่ต้องการให้อินสแตนซ์ของการใช้งานIEventContextFactoryในระดับต่ำและต้องการทำงานกับอินเตอร์เฟสIEventContextFactoryตลอด อย่างไรก็ตามฉันยังไม่ต้องการที่จะฉีดพารามิเตอร์อื่นผ่านตัวสร้างเพียงเพื่อให้มันผ่านไปยังชั้นเรียนที่ต้องการมันคือ // example of problem public class MyClass { public MyClass(IContextProvider context, IEventContextFactory event) { _context = …

13 c#  design  interfaces 

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

13 java  c++  interfaces  abstract-class 

ตัวอย่างเช่นมันเป็นการละเมิดลิขสิทธิ์หรือไม่ถ้าฉันเขียนคลาสที่ชื่อว่า Random โดยมีจุดประสงค์และลายเซ็นของวิธีการเดียวกันกับ. Net System.Random class ของ Microsoft หรือไม่ มันสร้างความแตกต่างในภาษาที่ใช้เขียนหรือไม่? ในกรณีนี้ฉันต้องการเขียนคลาส Random สำหรับใช้ใน ActionScript ซึ่งไม่มีคลาส PRNG ในตัว หากใครมีลิงค์หรือคำแนะนำอ้างอิงที่ดีเพื่อทำความเข้าใจว่าซอฟต์แวร์ได้รับการปกป้องในด้านใดบ้าง และใช่ฉันรู้ว่านี่ไม่ใช่ที่สำหรับคำแนะนำทางกฎหมาย "ของจริง" หากมีใครไปศาลชี้ไปที่กระดานข้อความสาธารณะว่าเป็นเรื่องน่าละอาย

13 interfaces  copyright 

ฉันพยายามสอนตัวเองเกี่ยวกับวิศวกรรมซอฟต์แวร์และการหาข้อมูลที่ขัดแย้งกันซึ่งทำให้ฉันสับสน ฉันได้เรียนรู้เกี่ยวกับ OOP และคลาสนามธรรม / อินเทอร์เฟซคืออะไรและใช้งานอย่างไร แต่จากนั้นฉันก็อ่านว่าควรจะ 'สนับสนุนองค์ประกอบเหนือมรดก' ฉันเข้าใจการจัดองค์ประกอบคือเมื่อคลาสหนึ่งประกอบ / สร้างวัตถุของคลาสอื่นเพื่อใช้ / โต้ตอบกับฟังก์ชันการทำงานของวัตถุใหม่นั้น ดังนั้นคำถามของฉันคือ ... ฉันควรจะไม่ใช้คลาสหรืออินเตอร์เฟสแบบนามธรรมหรือไม่? หากไม่ต้องการสร้างคลาสนามธรรมและขยาย / สืบทอดฟังก์ชันการทำงานของคลาสนามธรรมในคลาสที่เป็นรูปธรรมและแทนที่จะสร้างวัตถุใหม่เพื่อใช้ฟังก์ชันของคลาสอื่น หรือฉันควรใช้องค์ประกอบและสืบทอดจากคลาสนามธรรม; ใช้พวกเขาทั้งสองร่วมกัน? ถ้าเป็นเช่นนั้นคุณช่วยยกตัวอย่างว่ามันจะทำงานอย่างไรและมีประโยชน์อย่างไร เนื่องจากฉันคุ้นเคยกับ PHP มากที่สุดฉันจึงใช้มันเพื่อพัฒนาทักษะ OOP / SE ของฉันก่อนที่จะย้ายไปใช้ภาษาอื่นและถ่ายโอนทักษะ SE ที่เพิ่งได้รับมาดังนั้นตัวอย่างการใช้ PHP จะได้รับการชื่นชมมากที่สุด

13 object-oriented  php  interfaces  inheritance  composition