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

ฉันจำไม่ได้เมื่อฉันเขียนชั้นเรียนทั่วไปครั้งที่แล้ว ทุกครั้งที่ฉันคิดว่าฉันต้องการมันหลังจากที่ฉันคิดว่าจะทำข้อสรุปที่ฉันทำไม่ได้ คำตอบที่สองสำหรับคำถามนี้ทำให้ฉันต้องขอคำชี้แจง (เนื่องจากฉันยังไม่สามารถแสดงความคิดเห็นได้ฉันจึงได้ตั้งคำถามใหม่) ดังนั้นลองใช้โค้ดที่ได้รับเป็นตัวอย่างของกรณีที่ใครต้องการยาชื่อสามัญ: public class Repository<T> where T : class, IBusinessOBject { T Get(int id) void Save(T obj); void Delete(T obj); } มันมีข้อ จำกัด ประเภท: IBusinessObject วิธีคิดตามปกติของฉันคือคลาสมีข้อ จำกัด ในการใช้IBusinessObjectดังนั้นคลาสที่ใช้สิ่งนี้Repositoryคือ พื้นที่เก็บข้อมูลเก็บลูกค้าเหล่านี้IBusinessObjectส่วนใหญ่ของสิ่งนี้Repositoryจะต้องการรับและใช้วัตถุผ่านIBusinessObjectอินเตอร์เฟซ ดังนั้นทำไมไม่เพียงเพื่อ public class Repository { IBusinessOBject Get(int id) void Save(IBusinessOBject obj); void Delete(IBusinessOBject obj); } ถึงแม้ว่าตัวอย่างจะไม่ดีเนื่องจากเป็นเพียงคอลเล็กชันอื่นและคอลเล็กชันทั่วไปคือคลาสสิก ในกรณีนี้ประเภทของข้อ จำกัด …

20 c#  object-oriented  interfaces  generics 

AFAIK คลาสextendsแม่และคลาสimplementsอินเทอร์เฟซของฉัน implements SomeInterfaceแต่ผมทำงานในสถานการณ์ที่ฉันไม่สามารถใช้ มันคือการประกาศประเภททั่วไป ตัวอย่างเช่น: public interface CallsForGrow {...} public class GrowingArrayList <T implements CallsForGrow> // BAD, won't work! extends ArrayList<T> ที่นี่ใช้implementsเป็นสิ่งต้องห้าม syntactically ฉันคิดก่อนว่าการใช้อินเทอร์เฟซภายใน <> นั้นเป็นสิ่งต้องห้าม แต่ไม่ใช่ มันเป็นไปได้ฉันมีเพียงแค่ใช้ แทนextends implementsเป็นผลให้ฉัน "ขยาย" อินเทอร์เฟซ ตัวอย่างอื่นนี้ใช้งานได้: public interface CallsForGrow {...} public class GrowingArrayList <T extends CallsForGrow> // this works! extends ArrayList<T> สำหรับฉันดูเหมือนว่าจะไม่สอดคล้องกันทางไวยากรณ์ …

20 java  interfaces  generics 

ผมอยู่ในขั้นตอนของการพยายามที่จะโท C # ดังนั้นฉันอ่านรหัสผ่าน Adaptive C #โดยแกรี่แมคลีนฮอลล์ เขาเขียนเกี่ยวกับรูปแบบและรูปแบบการต่อต้าน ในการใช้งานกับส่วนต่อประสานเขาเขียนต่อไปนี้: นักพัฒนาที่ยังใหม่กับแนวคิดของการเขียนโปรแกรมไปยังอินเทอร์เฟซมักมีปัญหาในการปล่อยสิ่งที่อยู่เบื้องหลังอินเทอร์เฟซ ณ เวลารวบรวมไคลเอนต์ของอินเทอร์เฟซใด ๆ ควรมีความคิดที่ไม่มีการใช้งานของอินเทอร์เฟซที่ใช้ ความรู้ดังกล่าวสามารถนำไปสู่ข้อสันนิษฐานที่ไม่ถูกต้องซึ่งทำให้คู่ลูกค้าใช้งานอินเทอร์เฟซเฉพาะ ลองนึกภาพตัวอย่างทั่วไปที่คลาสต้องการบันทึกเรกคอร์ดในที่เก็บข้อมูลถาวร ในการทำเช่นนั้นจะมอบสิทธิ์อย่างถูกต้องให้กับส่วนต่อประสานซึ่งซ่อนรายละเอียดของกลไกการจัดเก็บข้อมูลถาวรที่ใช้ อย่างไรก็ตามมันจะไม่ถูกต้องที่จะตั้งสมมติฐานใด ๆ เกี่ยวกับการใช้งานของอินเตอร์เฟซที่ถูกใช้ในเวลาทำงาน ยกตัวอย่างเช่นการหล่ออ้างอิงอินเตอร์เฟซในการดำเนินการใด ๆ ที่เป็นเสมอความคิดที่ดี อาจเป็นกำแพงภาษาหรือการขาดประสบการณ์ของฉัน แต่ฉันไม่เข้าใจความหมาย นี่คือสิ่งที่ฉันเข้าใจ: ฉันมีโครงการสนุก ๆ เพื่อฝึก C # ที่นั่นฉันมีชั้นเรียน: public class SomeClass... คลาสนี้ถูกใช้ในหลายสถานที่ ในขณะที่เรียนรู้ C # ฉันอ่านว่ามันเป็นนามธรรมที่ดีกว่าด้วยส่วนต่อประสานดังนั้นฉันจึงทำสิ่งต่อไปนี้ public interface ISomeClass <- Here I made a "contract" of …

17 c#  interfaces  implementations 

ไตรมาสที่ดีของศตวรรษที่ผ่านมาเมื่อฉันเรียนรู้ C ++ ฉันได้รับการสอนว่าอินเตอร์เฟสควรจะให้อภัยและเท่าที่เป็นไปได้ไม่สนใจเกี่ยวกับลำดับที่วิธีการนั้นถูกเรียกเนื่องจากผู้บริโภคอาจไม่สามารถเข้าถึงแหล่งข้อมูลหรือเอกสารแทน นี้. อย่างไรก็ตามเมื่อใดก็ตามที่ฉันให้คำปรึกษาผู้เขียนโปรแกรมรุ่นเยาว์และผู้พัฒนาระดับสูงจะได้ยินฉันพวกเขามีปฏิกิริยากับความประหลาดใจซึ่งทำให้ฉันสงสัยว่านี่เป็นเรื่องจริงหรือไม่ ชัดเจนเหมือนโคลน พิจารณาอินเทอร์เฟซด้วยวิธีการเหล่านี้ (สำหรับการสร้างไฟล์ข้อมูล): OpenFile SetHeaderString WriteDataLine SetTrailerString CloseFile ตอนนี้คุณสามารถแน่นอนเพียงไปถึงเหล่านี้ในการสั่งซื้อ แต่บอกว่าคุณไม่สนใจเกี่ยวกับชื่อไฟล์ (คิดว่าa.out) AddDataLineหรือสิ่งที่หัวและสตริงรถพ่วงถูกรวมคุณสามารถเพียงแค่โทร ตัวอย่างที่มีความรุนแรงน้อยกว่าอาจมองข้ามส่วนหัวและส่วนท้าย อาจมีอีกอย่างหนึ่งอาจตั้งค่าสตริงส่วนหัวและส่วนท้ายก่อนที่จะเปิดไฟล์ นี่เป็นหลักการของการออกแบบส่วนต่อประสานที่ได้รับการยอมรับหรือเป็นวิธี POLA ก่อนที่จะได้รับชื่อหรือไม่? NB ไม่จมลงในส่วนย่อยของอินเทอร์เฟซนี้มันเป็นเพียงตัวอย่างเพื่อประโยชน์ของคำถามนี้

17 design  design-patterns  interfaces 

ลองพิจารณาตัวอย่างด้านล่าง การเปลี่ยนแปลงใด ๆ กับ ColorChoice enum จะส่งผลกระทบต่อคลาสย่อย IWindowColor ทั้งหมด enums มีแนวโน้มที่จะทำให้เกิดการเชื่อมต่อที่เปราะหรือไม่? มีอะไรดีไปกว่า Enum ที่จะยอมให้มีความยืดหยุ่นแบบ polymorphic มากขึ้นหรือไม่? enum class ColorChoice { Blue = 0, Red = 1 }; class IWindowColor { public: ColorChoice getColor() const=0; void setColor( const ColorChoice value )=0; }; แก้ไข: ขออภัยที่ใช้สีเป็นตัวอย่างของฉันนั่นไม่ใช่สิ่งที่เป็นคำถาม นี่คือตัวอย่างอื่นที่หลีกเลี่ยงปลาเฮอริ่งแดงและให้ข้อมูลเพิ่มเติมเกี่ยวกับสิ่งที่ฉันหมายถึงโดยความยืดหยุ่น enum class CharacterType { orc = …

17 design-patterns  c++  interfaces  enum  abstract-class 

ฉันใช้บทบาทส่วนหน้าในโครงการ ฉันควรระบุเพื่อนร่วมทีม back-end ของฉันในรูปแบบที่แน่นอนของ JSON ที่ PHP ของพวกเขากลับไปที่ JavaScript ของฉันหรือไม่ ตัวอย่างเช่นฉันควรบอกพวกเขาว่าพวกเขาควรใช้รูปแบบคล้ายกับที่อธิบายไว้ที่นี่: วิธีที่เหมาะสมในการจัดโครงสร้าง JSON สำหรับการใช้งานส่วนหน้า หรือฉันควรจะรักษาบทบาทของตัวเองให้ปลอดเชื้อมากที่สุดและอธิบายด้วยคำพูดที่ว่าอินพุตและเอาท์พุตที่ฉันต้องการจากอินเทอร์เฟซส่วนหลัง (แน่นอนถ้าเกิดเหตุการณ์นี้มันอาจเป็นเรื่องยากสำหรับฉันในการจัดการรูปแบบโครงสร้างข้อมูลที่แตกต่างกัน)

17 development-process  teamwork  interfaces  json  front-end 

ฉันสงสัยว่าฉันทำผิดพลาดกับเด็กนักเรียนที่นี่และกำลังมองหาการชี้แจง เรียนจำนวนมากในโซลูชันของฉัน (C #) - ฉันกล้าพูดส่วนใหญ่ - ฉันสิ้นสุดการเขียนอินเทอร์เฟซที่สอดคล้องกันสำหรับ เช่นอินเทอร์เฟซ "ICalculator" และคลาส "เครื่องคิดเลข" ที่ใช้งานแม้ว่าฉันจะไม่เคยเปลี่ยนเครื่องคิดเลขนั้นด้วยการใช้งานที่แตกต่างกัน นอกจากนี้คลาสเหล่านี้ส่วนใหญ่อาศัยอยู่ในโครงการเดียวกันกับการพึ่งพาของพวกเขา - พวกเขาเพียง แต่จะต้องเป็นinternalจริง แต่ได้กลายpublicเป็นผลข้างเคียงของการใช้อินเทอร์เฟซที่เกี่ยวข้องของพวกเขา ฉันคิดว่าวิธีนี้ในการสร้างส่วนต่อประสานสำหรับทุกสิ่งที่เกิดขึ้นจากความผิดพลาดเล็กน้อย: - 1) ตอนแรกฉันคิดว่าอินเตอร์เฟสจำเป็นต้องสร้างหน่วยทดสอบ mocks (ฉันใช้ Moq) แต่ตั้งแต่ฉันค้นพบว่าคลาสสามารถเยาะเย้ยถ้าสมาชิกเป็นสมาชิกvirtualและมีคอนสตรัคเตอร์แบบไม่ใช้พารามิเตอร์ (แก้ไขฉันถ้า ฉันผิด). 2) ตอนแรกฉันคิดว่าจำเป็นต้องใช้อินเทอร์เฟซในการลงทะเบียนชั้นเรียนด้วยกรอบ IoC (Castle Windsor) เช่น Container.Register(Component.For<ICalculator>().ImplementedBy<Calculator>()... เมื่อในความเป็นจริงฉันสามารถลงทะเบียนประเภทคอนกรีตกับตัวเอง: Container.Register(Component.For<Calculator>().ImplementedBy<Calculator>()... 3) การใช้อินเตอร์เฟสเช่นพารามิเตอร์คอนสตรัคเตอร์สำหรับการฉีดแบบพึ่งพาผลลัพธ์ใน "การเชื่อมต่อแบบหลวม" ดังนั้นฉันจึงโกรธกับอินเทอร์เฟซ! ฉันตระหนักถึงสถานการณ์ที่คุณจะ "ปกติ" ใช้อินเทอร์เฟซเช่นเปิดเผย API สาธารณะหรือสิ่งต่าง ๆ เช่นฟังก์ชัน "เสียบได้" โซลูชันของฉันมีคลาสจำนวนเล็กน้อยที่เหมาะสมกับกรณีการใช้งานดังกล่าว …

17 object-oriented  interfaces  dependency-injection 

ตกลง .. หลังจากการสนทนาทั้งหมดฉันเปลี่ยนคำถามเล็กน้อยเพื่อให้สะท้อนตัวอย่างที่เป็นรูปธรรมที่ฉันจัดการดีขึ้น ฉันมีสองคลาสModelOneและคลาสModelTwoเหล่านี้มีฟังก์ชันการทำงานที่คล้ายกัน แต่ไม่เกี่ยวข้องกัน แต่ฉันมีชั้นที่สามCommonFuncที่มีบางฟังก์ชันการทำงานของประชาชนที่จะดำเนินการทั้งในModelOneและและได้รับปัจจัยจากการเป็นต่อModelTwo DRYทั้งสองรุ่นมีอินสแตนซ์ภายในModelMainคลาส (ซึ่งเป็นอินสแตนซ์ในระดับที่สูงขึ้น ฯลฯ - แต่ฉันหยุดที่ระดับนี้) ภาชนะ IoC ว่าฉันใช้เป็นไมโครซอฟท์สามัคคี ฉันไม่แกล้งทำเป็นผู้เชี่ยวชาญ แต่ฉันเข้าใจว่าคุณลงทะเบียน tuple ของ interface และ class กับ container และเมื่อคุณต้องการ class คอนกรีตคุณถาม IoC container สำหรับวัตถุใด ๆ ที่ตรงกับ interface เฉพาะ นี่ก็หมายความว่าสำหรับทุกวัตถุที่ฉันต้องการยกตัวอย่างจาก Unity จะต้องมีอินเตอร์เฟสที่ตรงกัน เพราะแต่ละชั้นเรียนของฉันดำเนินการที่แตกต่างกัน (และไม่ทับซ้อนกัน) ฟังก์ชั่นนี้หมายถึงว่ามีอัตราส่วน 1: ระหว่างอินเตอร์เฟซและชั้น 1 1 อย่างไรก็ตามมันไม่ได้หมายความว่าฉันกำลังเขียนอินเทอร์เฟซสำหรับแต่ละคลาสที่ฉันเขียน ดังนั้นรหัสฉลาดฉันท้ายด้วย2 : public interface ICommonFunc { …

17 c#  interfaces  class  code-organization 

เมื่อฉันใช้ C # เพื่อเขียนโค้ดบางส่วนและฉันกำหนดอินเทอร์เฟซโดยใช้ Visual Studio 2010 จะมีคำสั่ง "ใช้" จำนวนมาก (ดังแสดงในตัวอย่าง) using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace TestEngine.TestNameSpace { interface ITest1 { bool testMethod(int xyz); } } ฉันสงสัยว่าสิ่งเหล่านี้มีไว้เพื่ออะไรและหากจำเป็นจริงๆ ฉันจะออกไปได้ไหม? จำเป็นหรือไม่เมื่อฉันใช้ส่วนเหล่านั้นในคำอธิบายส่วนต่อประสานของฉัน

16 c#  interfaces  keywords 

การสืบทอดส่วนต่อประสานด้านล่างนั้นผิดกฎหมายใน PHP แต่ฉันคิดว่ามันจะมีประโยชน์พอสมควรในชีวิตจริง มี antipattern จริงหรือมีปัญหาเกี่ยวกับการออกแบบเอกสารด้านล่าง PHP นั้นปกป้องฉันหรือไม่ <?php /** * Marker interface */ interface IConfig {} /** * An api sdk tool */ interface IApi { public __construct(IConfig $cfg); } /** * Api configuration specific to http */ interface IHttpConfig extends IConfig { public getSomeNiceHttpSpecificFeature(); } /** * Illegal, …

16 php  object-oriented-design  interfaces 

ฉันมีวิธีที่สร้างไฟล์ข้อมูลหลังจากคุยกับกระดานดิจิตอล: CreateDataFile(IFileAccess boardFileAccess, IMeasurer boardMeasurer) ที่นี่boardFileAccessและboardMeasurerเป็นเช่นเดียวกันของBoardวัตถุว่าการดำเนินการทั้งในและIFileAccess ใช้ในกรณีนี้สำหรับวิธีการเดียวที่จะตั้งหนึ่งพินบนกระดานเพื่อให้การวัดง่าย ข้อมูลที่ได้จากการวัดนี้จะถูกเก็บไว้แล้วไว้บนกระดานโดยใช้ ตั้งอยู่ในโครงการแยกต่างหากIMeasurerIMeasurerIFileAccessBoard ฉันมาถึงข้อสรุปที่CreateDataFileทำสิ่งหนึ่งโดยทำการวัดอย่างรวดเร็วแล้วเก็บข้อมูลและการทำทั้งสองอย่างในวิธีเดียวกันนั้นง่ายกว่าสำหรับคนอื่นที่ใช้รหัสนี้จากนั้นจึงต้องทำการวัดและเขียนไฟล์ เป็นการเรียกเมธอดแยกต่างหาก สำหรับฉันดูเหมือนว่าไม่เหมาะสมที่จะส่งวัตถุเดียวกันไปยังวิธีการสองครั้ง ฉันได้พิจารณาการทำอินเตอร์เฟซในท้องถิ่นIDataFileCreatorที่จะขยายIFileAccessและIMeasurerแล้วมีการดำเนินการที่มีBoardอินสแตนซ์ที่เพิ่งจะโทรที่จำเป็นต้องใช้Boardวิธีการ พิจารณาว่าวัตถุบอร์ดเดียวกันจะใช้สำหรับการวัดและการเขียนไฟล์เสมอหรือไม่มันเป็นวิธีที่ไม่ถูกต้องหรือไม่ที่จะส่งวัตถุเดียวกันไปยังวิธีการสองครั้ง? ถ้าเป็นเช่นนั้นใช้อินเทอร์เฟซท้องถิ่นและการใช้งานโซลูชันที่เหมาะสมหรือไม่

15 c#  interfaces  methods  parameters 

( สำหรับจุดประสงค์ของคำถามนี้เมื่อฉันพูดว่า 'ส่วนต่อประสาน' ฉันหมายถึงโครงสร้างของภาษาinterfaceและไม่ใช่ 'ส่วนต่อประสาน' ในแง่อื่น ๆ ของคำเช่นวิธีสาธารณะที่ชั้นเรียนเสนอโลกภายนอกเพื่อสื่อสารกับและ จัดการมัน. ) การมีเพศสัมพันธ์แบบหลวมสามารถทำได้โดยการมีวัตถุขึ้นอยู่กับสิ่งที่เป็นนามธรรมแทนประเภทคอนกรีต วิธีนี้ช่วยให้การแต่งงานกันแบบหลวม ๆ ด้วยเหตุผลหลักสองประการ: 1-นามธรรมมีแนวโน้มที่จะเปลี่ยนแปลงน้อยกว่าประเภทคอนกรีตซึ่งหมายความว่ารหัสที่ขึ้นต่อกันมีโอกาสน้อยที่จะแตก คอนกรีตที่แตกต่างกัน2ประเภทสามารถใช้งานได้ที่รันไทม์เพราะมันเหมาะสมกับสิ่งที่เป็นนามธรรม คอนกรีตชนิดใหม่สามารถเพิ่มได้ในภายหลังโดยไม่จำเป็นต้องแก้ไขรหัสที่มีอยู่เดิม ตัวอย่างเช่นพิจารณาชั้นCarและสอง subclasses และVolvoMazda หากรหัสของคุณขึ้นอยู่กับ a Carมันสามารถใช้ a Volvoหรือ a Mazdaในระหว่างรันไทม์ ในภายหลังในคลาสย่อยเพิ่มเติมสามารถเพิ่มได้โดยไม่จำเป็นต้องเปลี่ยนรหัสที่ต้องพึ่งพา นอกจากนี้Car- ซึ่งเป็นนามธรรม - มีโอกาสน้อยที่จะมีการเปลี่ยนแปลงกว่าหรือVolvo Mazdaโดยทั่วไปรถยนต์มักจะเหมือนกันมาระยะหนึ่งแล้ว แต่ Volvos และ Mazdas มีแนวโน้มที่จะเปลี่ยนไป I abstractions มีความเสถียรมากกว่าแบบคอนกรีต ทั้งหมดนี้เพื่อแสดงให้เห็นว่าฉันเข้าใจว่าข้อต่อหลวมคืออะไรและจะบรรลุผลได้อย่างไรโดยขึ้นอยู่กับนามธรรมและไม่ใช่ข้อสรุป (ถ้าฉันเขียนบางอย่างไม่ถูกต้องโปรดพูดอย่างนั้น) สิ่งที่ฉันไม่เข้าใจคือ: Abstractions สามารถเป็น superclasses หรืออินเทอร์เฟซ ถ้าเป็นเช่นนั้นเหตุใดอินเทอร์เฟซที่ได้รับการยกย่องโดยเฉพาะสำหรับความสามารถในการยอมให้มีเพศสัมพันธ์แบบหลวม? ฉันไม่เห็นความแตกต่างจากการใช้ซูเปอร์คลาส …

15 design  object-oriented  interfaces 

หากฉันต้องการตั้งโปรแกรมในรูปแบบ "ฟังก์ชั่น" ฉันจะใช้อะไรแทนอินเตอร์เฟสได้บ้าง? interface IFace { string Name { get; set; } int Id { get; } } class Foo : IFace { ... } อาจจะTuple<>? Tuple<Func<string> /*get_Name*/, Action<String> /*set_Name*/, Func<int> /*get_Id*/> Foo; เหตุผลเดียวที่ฉันใช้อินเทอร์เฟซตั้งแต่แรกก็เพราะฉันต้องการให้มีคุณสมบัติ / วิธีการบางอย่างอยู่เสมอ แก้ไข:รายละเอียดเพิ่มเติมบางอย่างเกี่ยวกับสิ่งที่ฉันคิด / พยายาม บอกว่าฉันมีวิธีที่ใช้สามฟังก์ชั่น: static class Blarf { public static void DoSomething(Func<string> getName, Action<string> …

15 c#  functional-programming  interfaces  paradigms 

เมื่อเร็ว ๆ นี้ฉันเริ่มคลุมหัวของฉันรอบ ๆ OOP และตอนนี้ฉันมาถึงจุดที่ยิ่งฉันอ่านความแตกต่างระหว่างคลาสนามธรรมและอินเทอร์เฟซมากเท่าไหร่ฉันก็ยิ่งสับสนมากขึ้น จนถึงตอนนี้ไม่สามารถยกตัวอย่างได้ อินเทอร์เฟซเป็นพิมพ์เขียวโครงสร้างมากขึ้นหรือน้อยลงที่กำหนดโครงกระดูกและบทคัดย่อต่างกันโดยสามารถใช้โค้ดบางส่วนได้ ฉันต้องการเรียนรู้เพิ่มเติมเกี่ยวกับสิ่งเหล่านี้ผ่านสถานการณ์เฉพาะของฉัน นี่คือลิงค์ไปยังคำถามแรกของฉันหากคุณต้องการข้อมูลพื้นฐานเพิ่มเติมเล็กน้อย: โมเดลการออกแบบที่ดีสำหรับคลาสใหม่ของฉันคืออะไร นี่คือสองคลาสที่ฉันสร้าง: class Ad { $title; $description $price; function get_data($website){ } function validate_price(){ } } class calendar_event { $title; $description $start_date; function get_data($website){ //guts } function validate_dates(){ //guts } } ดังนั้นอย่างที่คุณเห็นคลาสเหล่านี้เกือบจะเหมือนกัน ไม่ได้แสดงที่นี่ แต่มีฟังก์ชั่นอื่น ๆlike get_zip(), save_to_database()ที่มีร่วมกันข้ามชั้นเรียนของฉัน ฉันยังได้เพิ่มคลาสรถยนต์และสัตว์เลี้ยงอื่น ๆ ซึ่งมีวิธีการทั่วไปและคุณสมบัติของหลักสูตรเฉพาะสำหรับคลาสเหล่านั้น (เช่นระยะทางน้ำหนักและอื่น …

15 object-oriented-design  interfaces  abstract-class 

ฉันกำลังคิดเกี่ยวกับสิ่งนั้นและฉันมีข้อสงสัย เมื่อฉันประกาศอินเทอร์เฟซตัวอย่างเช่น: public interface MyInterface { public void method1(); public void method2(); } วิธีการอินเตอร์เฟสเหล่านี้ถือเป็นนามธรรมหรือไม่ สิ่งที่ฉันหมายถึงคือแนวคิดของวิธีนามธรรมคือ: วิธีนามธรรมเป็นวิธีการที่ประกาศ แต่ไม่มีการใช้งาน ดังนั้นวิธีการเหล่านี้ถือว่าเป็นนามธรรมหรือไม่ พวกเขาไม่ใช่วิธีนามธรรมที่ "บริสุทธิ์" เนื่องจากฉันไม่ได้ใช้abstractคำ แต่แนวคิด แต่ดูเหมือนว่าพวกเขาเป็น คุณบอกอะไรฉันได้บ้าง ขอบคุณ

15 object-oriented-design  interfaces  abstract-class