คำถามติดแท็ก abstract-class

"คลาสนามธรรม" และ "อินเทอร์เฟซ" เป็นแนวคิดที่คล้ายกันโดยอินเทอร์เฟซเป็นนามธรรมของทั้งสอง ปัจจัยที่แตกต่างอย่างหนึ่งคือคลาสนามธรรมจะจัดเตรียมวิธีการใช้งานสำหรับคลาสที่ได้รับเมื่อต้องการ อย่างไรก็ตามใน C # ปัจจัยที่มีความแตกต่างนี้ได้รับการลดลงโดยการแนะนำวิธีการขยายล่าสุดซึ่งช่วยให้การใช้งานมีไว้สำหรับวิธีการอินเทอร์เฟซ ปัจจัยที่มีความแตกต่างอีกอย่างหนึ่งคือคลาสสามารถสืบทอดคลาสนามธรรมเพียงคลาสเดียวเท่านั้น (กล่าวคือไม่มีการสืบทอดหลายคลาส) แต่สามารถใช้หลายอินเตอร์เฟสได้ ทำให้ส่วนต่อประสานที่ จำกัด น้อยลงและมีความยืดหยุ่นมากขึ้น ดังนั้นใน C # เราควรใช้คลาสนามธรรมแทนอินเทอร์เฟซกับวิธีการส่วนขยายหรือไม่ ตัวอย่างที่น่าสังเกตของโมเดลวิธีส่วนต่อประสาน + ส่วนต่อขยายคือ LINQ โดยที่ฟังก์ชันการสืบค้นมีให้สำหรับประเภทใดก็ตามที่ใช้IEnumerableวิธีการขยายจำนวนมาก

70 c#  design  interfaces  inheritance  abstract-class 

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

40 java  object-oriented  abstract-class 

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

38 c++  functions  pointers  abstract-class 

แม้ว่าสิ่งนี้จะไม่ได้บังคับในมาตรฐาน C ++ แต่ดูเหมือนว่าวิธี GCC เช่นใช้คลาสผู้ปกครองรวมถึงนามธรรมที่บริสุทธิ์คือการรวมตัวชี้ไปยังตาราง v สำหรับคลาสนามธรรมนั้นในทุกอินสแตนซ์ของคำถาม . โดยปกติแล้วสิ่งนี้จะขยายขนาดของอินสแตนซ์ของคลาสนี้โดยตัวชี้สำหรับคลาสพาเรนต์ทั้งหมดที่มี แต่ฉันสังเกตเห็นว่าคลาส C และโครงสร้างจำนวนมากมีอินเทอร์เฟซหลักมากมายซึ่งโดยทั่วไปแล้วเป็นคลาสนามธรรมที่บริสุทธิ์ ฉันจะแปลกใจถ้าทุกครั้งที่พูดDecimalถูกป่องด้วย 6 ตัวชี้ไปยังทุกมันเป็นอินเทอร์เฟซต่าง ๆ ดังนั้นถ้า C # ทำอินเตอร์เฟสแตกต่างกันอย่างน้อยในการใช้งานทั่วไป (ฉันเข้าใจว่ามาตรฐานตัวเองอาจไม่ได้กำหนดการนำไปใช้) และการใช้งาน C ++ มีวิธีหลีกเลี่ยงการขยายขนาดวัตถุเมื่อเพิ่มผู้ปกครองเสมือนบริสุทธิ์ให้กับชั้นเรียนหรือไม่?

27 c#  c++  interfaces  optimization  abstract-class 

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

21 c#  c++  object-oriented-design  abstract-class 

ย้อนกลับไปในยุค 2000 เพื่อนร่วมงานคนหนึ่งของฉันบอกฉันว่ามันเป็นรูปแบบการต่อต้านเพื่อทำให้วิธีการสาธารณะเสมือนหรือนามธรรม ตัวอย่างเช่นเขาถือว่าคลาสเช่นนี้ไม่ได้ออกแบบมาอย่างดี: public abstract class PublicAbstractOrVirtual { public abstract void Method1(string argument); public virtual void Method2(string argument) { if (argument == null) throw new ArgumentNullException(nameof(argument)); // default implementation } } เขากล่าวว่า นักพัฒนาของคลาสที่ได้รับที่ใช้Method1และการแทนที่Method2มีการทำซ้ำการตรวจสอบอาร์กิวเมนต์ ในกรณีที่ผู้พัฒนาคลาสพื้นฐานตัดสินใจที่จะเพิ่มบางสิ่งรอบ ๆ ส่วนที่กำหนดเองได้Method1หรือMethod2ใหม่กว่าเขาจะไม่สามารถทำได้ เพื่อนร่วมงานของฉันเสนอวิธีการนี้แทน: public abstract class ProtectedAbstractOrVirtual { public void Method1(string argument) { if (argument …

20 c#  design  object-oriented-design  abstract-class  virtual-functions 

ลองพิจารณาตัวอย่างด้านล่าง การเปลี่ยนแปลงใด ๆ กับ 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 

หากการขว้างปาSystem.Exceptionถือว่าแย่มากทำไมไม่Exceptionทำabstractในตอนแรก? ด้วยวิธีนี้มันเป็นไปไม่ได้ที่จะโทร: throw new Exception("Error occurred."); สิ่งนี้จะบังคับใช้การยกเว้นที่ได้รับเพื่อให้รายละเอียดเพิ่มเติมเกี่ยวกับข้อผิดพลาดที่เกิดขึ้น ตัวอย่างเช่นเมื่อฉันต้องการให้ลำดับชั้นข้อยกเว้นที่กำหนดเองสำหรับห้องสมุดฉันมักจะประกาศคลาสฐานนามธรรมสำหรับข้อยกเว้นของฉัน: public abstract class CustomExceptionBase : Exception { /* some stuff here */ } แล้วมีข้อยกเว้นบางอย่างที่มีจุดประสงค์เฉพาะเจาะจงมากขึ้น: public class DerivedCustomException : CustomExceptionBase { /* some more specific stuff here */ } จากนั้นเมื่อเรียกเมธอดไลบรารี่ใด ๆ เราสามารถลอง / แทร็กบล็อคทั่วไปเพื่อดักจับข้อผิดพลาดที่มาจากไลบรารีโดยตรง: try { /* library calls here */ } catch …

17 c#  exception-handling  abstract-class 

ขณะนี้ฉันมีคลาสที่ได้รับสองคลาสAและBที่ทั้งสองมีเขตข้อมูลร่วมกันและฉันพยายามที่จะตรวจสอบว่ามันควรจะขึ้นไปในชั้นฐาน มันไม่เคยอ้างถึงจากชั้นฐานและบอกว่าในบางจุดลงมาที่ถนนอีกชั้นจะได้รับCที่ไม่ได้_field1แล้วจะไม่เป็นหลักของ "สิทธิพิเศษน้อย" (หรือบางสิ่งบางอย่าง) ถ้ามันถูกละเมิด เป็น? public abstract class Base { // Should _field1 be brought up to Base? //protected int Field1 { get; set; } } public class A : Base { private int _field1; } public class B : Base { private int _field1; } public class C …

16 object-oriented  inheritance  abstract-class 

เมื่อเร็ว ๆ นี้ฉันเริ่มคลุมหัวของฉันรอบ ๆ 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 

มีความแตกต่างระหว่าง 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 

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

13 object-oriented-design  abstract-class  static-methods 

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

13 java  c++  interfaces  abstract-class 

ฉันกำลังศึกษา OOP ใน C ++ และแม้ว่าฉันตระหนักถึงคำจำกัดความของแนวคิดทั้งสามนี้ฉันก็ไม่สามารถรู้ได้เลยว่าจะใช้เมื่อไหร่หรืออย่างไร ลองใช้คลาสนี้เป็นตัวอย่าง: class Person{ private: string name; int age; public: Person(string p1, int p2){this->name=p1; this->age=p2;} ~Person(){} void set_name (string parameter){this->name=parameter;} void set_age (int parameter){this->age=parameter;} string get_name (){return this->name;} int get_age (){return this->age;} }; 1. ซิงเกิล วิธีไม่ข้อ จำกัด ของการเรียนที่จะมีเพียงหนึ่งในการทำงานของวัตถุ? คุณสามารถออกแบบคลาสที่มีเพียง 2 อินสแตนซ์ได้หรือไม่ หรืออาจจะ 3? เมื่อใดที่แนะนำ / …

13 c++  object-oriented  singleton  class  abstract-class