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

ตามที่เป็นอยู่ในปัจจุบันคำถามนี้ไม่เหมาะสำหรับรูปแบบคำถาม & คำตอบของเรา เราคาดหวังคำตอบที่จะได้รับการสนับสนุนจากข้อเท็จจริงการอ้างอิงหรือความเชี่ยวชาญ แต่คำถามนี้อาจเรียกร้องให้มีการถกเถียงโต้แย้งโต้แย้งหรือการอภิปรายเพิ่มเติม หากคุณรู้สึกว่าคำถามนี้สามารถปรับปรุงและเปิดใหม่ได้โปรดไปที่ศูนย์ช่วยเหลือเพื่อขอคำแนะนำ ปิดให้บริการใน8 ปีที่ผ่านมา ฉันตัดสินใจถามคำถามนี้ที่นี่แทนที่จะเป็นแบบล้นสแต็กเพราะมันค่อนข้างเป็นอัตนัย ใน C # ปกติฉันเห็นประเภททั่วไปที่มีชื่อไม่ดี โดยทั่วไปมักใช้ "T" แต่ไม่ใช่ชื่อที่สื่อความหมายด้วยตัวเอง ตัวอย่างเช่น: class Fruit<T> { T fruit; } ในขณะที่นี่เป็นวิธีการทั่วไปใครจะแนะนำต่อต้านนี้ และถ้าเป็นเช่นนั้นแผนการตั้งชื่อที่สมเหตุสมผลจะเป็นประเภททั่วไปในบริบทของ C # สำหรับฟังก์ชันและคลาสทั่วไป ในตัวอย่างก่อนหน้านี้สมมติว่าประเภททั่วไปTมักจะต้องเป็นชนิดของผลไม้เช่นหรือApple OrangeประเภทTต้องทำให้ชัดเจนว่าเป็นผลไม้ชนิดหนึ่งดังนั้นอาจเป็นชื่อที่ดีกว่าFruitTypeดังนั้นเราจึงจบลงด้วย: class Fruit<FruitType> { FruitType fruit; } นี่เป็นเพียงเพื่อให้พวกคุณได้คิดในสิ่งที่ฉันกำลังมอง "กฎง่ายๆ" ที่ยอมรับได้สำหรับปัญหานี้คืออะไร

16 c#  naming  generics 

ในภาษาเชิงวัตถุที่สนับสนุนพารามิเตอร์ประเภททั่วไป (เรียกอีกอย่างว่าคลาสเทมเพลตและตัวแปรหลายรูปแบบ แต่แน่นอนว่าชื่อแต่ละชื่อมีความหมายที่แตกต่างกัน) มันมักจะเป็นไปได้ที่จะระบุข้อ จำกัด ประเภทในพารามิเตอร์ประเภทเช่นนั้น จากประเภทอื่น ตัวอย่างเช่นนี่คือไวยากรณ์ใน C #: //for classes: class ExampleClass<T> where T : I1 { } //for methods: S ExampleMethod<S>(S value) where S : I2 { ... } อะไรคือเหตุผลที่ใช้ประเภทอินเตอร์เฟสจริงมากกว่าชนิดที่ จำกัด โดยอินเตอร์เฟสเหล่านั้น ตัวอย่างเช่นอะไรคือเหตุผลในการสร้างวิธีการเซ็นชื่อI2 ExampleMethod(I2 value)?

15 object-oriented  type-systems  generics 

ตามกฎข้อที่ 4 ของObject Calisthenics โดย Jeff Bay (RTF)ใน The ThoughtWorks Anthology ขอแนะนำว่าควร " ใช้คอลเลกชันชั้นหนึ่ง " กฎข้อที่ 4: คอลเลกชันชั้นหนึ่ง แอ็พพลิเคชันของกฎนี้ง่าย: คลาสใด ๆ ที่มีคอลเล็กชันควรไม่มีตัวแปรสมาชิกอื่น คอลเลกชันแต่ละรายการจะถูกห่อหุ้มในคลาสของตัวเองดังนั้นตอนนี้พฤติกรรมที่เกี่ยวข้องกับคอลเลกชันจะมีบ้าน คุณอาจพบว่าฟิลเตอร์กลายเป็นส่วนหนึ่งของคลาสใหม่นี้ นอกจากนี้คลาสใหม่ของคุณสามารถจัดการกิจกรรมต่างๆเช่นการเข้าร่วมกลุ่มสองกลุ่มด้วยกันหรือใช้กฎกับองค์ประกอบของกลุ่มแต่ละกลุ่ม สิ่งที่ฉันสามารถเข้าใจได้จากสิ่งนี้คือเราควรใช้คลาสแยกการรวบรวมคอลเลกชันและด้วยวิธีการเพิ่มลบแก้ไขข้อมูลของคอลเลกชันนั้น และเราต้องการสิ่งนี้เพื่อให้เราแน่ใจว่าประเภทข้อมูลใดที่จะเข้าสู่การรวบรวมและสิ่งที่ออกมา ในกรณีที่เราใช้การรวบรวมทั่วไป (ในภาษาที่ใช้ได้) เราจำเป็นต้องปฏิบัติตามกฎนี้หรือไม่? หากฉันขาดความสำคัญที่สำคัญโปรดชี้แจง

15 object-oriented  generics 

ในคำถาม StackExchange ที่แตกต่างกันฉันสังเกตเห็นคนที่ใช้ต้นแบบนี้: void DoSomething<T>(T arg) where T: SomeSpecificReferenceType { //Code.... } โปรดจำไว้ว่ามีข้อ จำกัด ประเภทเดียว ( SomeSpecificReferenceType) ข้อแตกต่างและความได้เปรียบของการเขียนแบบนี้คืออะไรแทนที่จะเป็นเพียง: void DoSomething(SomeSpecificReferenceType arg) { //Code.... } ในทั้งสองกรณีargจะต้องมีการตรวจสอบประเภทเวลาคอมไพล์ ในทั้งสองกรณีเนื้อความของวิธีการนั้นสามารถพึ่งพาความรู้ที่argเป็นของ (หรือเป็นผู้สืบทอด) ประเภทที่เฉพาะเจาะจงซึ่งรู้จักกันในเวลารวบรวม นี่เป็นกรณีของผู้พัฒนา overzealous การเรียนรู้เกี่ยวกับ generics ก่อนที่จะเรียนรู้เกี่ยวกับมรดกธรรมดาหรือไม่? หรือมีเหตุผลที่ถูกต้องว่าทำไมลายเซ็นวิธีการที่จะเขียนด้วยวิธีนี้?

14 c#  .net  generics 

My IDE ( NetBeans ) ประเภทของฉันตรวจสอบCollectionsขณะที่ฉันพิมพ์รหัส แต่ทำไมฉันต้องโยนวัตถุคืนกลับมาObject.clone()? ซึ่งเป็นเรื่องปกติ ไม่เป็นอันตรายไม่มีเหม็น แต่ถึงกระนั้นฉันไม่เข้าใจ การตรวจสอบประเภทObject.clone()เป็นไปได้หรือไม่โดยไม่ต้องทำการคัดลอกวัตถุที่ส่งคืนเป็นไปไม่ได้? genericsกรอบทำให้ฉันคิดว่า IDE สามารถตรวจสอบประเภทของการอ้างอิงวัตถุบนด้านขวาของ " =เครื่องหมาย" โดยไม่ต้องหล่อในขณะที่ฉันพิมพ์? ฉันไม่เข้าใจ ภาคผนวก กรณีการใช้งานของฉันเป็นเพียงแค่ว่าผมมีความส่วนตัวCalendarฟิลด์pubDate ฉันกำลังจะเขียน: Calendar getPubdate() { return pubdate; } แต่มีความเสี่ยงที่ผู้บุกรุกสามารถแก้ไขpubdateของฉันได้ดังนั้นฉันจึงส่งสำเนา: Calendar getPubdate() { return (Calendar) pubdate.clone(); } pubdate.clone()แล้วฉันสงสัยว่าทำไมผมต้องหล่อ ลายเซ็นวิธีมีประเภทที่นั่น NetBeansน่าจะสามารถเข้าใจได้ และNetBeansCollectionsดูเหมือนจะทำอะไรบางอย่างที่คล้ายกันในเรื่องเกี่ยวกับ

13 java  generics  netbeans 

บางภาษาอนุญาตให้มีการเรียนและฟังก์ชั่นที่มีพารามิเตอร์ชนิด (เช่นList<T>ที่Tอาจจะเป็นประเภทพล) ตัวอย่างเช่นคุณสามารถมีฟังก์ชั่นเช่น: List<S> Function<S, T>(List<T> list) อย่างไรก็ตามบางภาษาอนุญาตให้แนวคิดนี้ขยายได้สูงกว่าหนึ่งระดับช่วยให้คุณมีฟังก์ชั่นที่มีลายเซ็น: K<S> Function<K<_>, S, T>(K<T> arg) โดยที่K<_>ตัวเองเป็นประเภทเช่นList<_>นั้นมีพารามิเตอร์ประเภท "บางส่วนประเภท" นี้เรียกว่าตัวสร้างประเภท คำถามของฉันคือทำไมคุณถึงต้องการความสามารถนี้ มันสมเหตุสมผลที่จะมีรูปแบบเหมือนกันList<T>เพราะทุกอย่างList<T>เกือบจะเหมือนกัน แต่สิ่งที่K<_>แตกต่างกันอย่างสิ้นเชิง คุณสามารถมีOption<_>และ a List<_>ที่ไม่มีฟังก์ชั่นทั่วไปเลย

13 programming-languages  type-systems  generics 

ในบทความ“ การศึกษาเปรียบเทียบเปรียบเทียบเพิ่มเติมของการสนับสนุนภาษาสำหรับการเขียนโปรแกรมทั่วไป” โดย Garcia และคณะ มีการเปรียบเทียบคุณสมบัติภาษาโปรแกรมที่น่าสนใจสำหรับการเขียนโปรแกรมทั่วไป: ด้วยคำอธิบายสั้น ๆ ของคำศัพท์: ทุกคนสามารถทดสอบสกาล่าสนับสนุนการเขียนโปรแกรมทั่วไปภายในกรอบนี้ได้หรือไม่ คือเพิ่มคอลัมน์ในตารางแรกพร้อมคำอธิบายถ้าเป็นไปได้

13 scala  comparison  generics 

ฉันมีอินเทอร์เฟซบางอย่างที่ฉันต้องการให้บุคคลที่สามนำไปใช้ในอนาคตและฉันได้เตรียมการติดตั้งพื้นฐานด้วยตนเอง ฉันจะใช้คู่เพื่อแสดงตัวอย่างเท่านั้น ปัจจุบันพวกเขาถูกกำหนดเป็น สิ่งของ: public interface Item { String getId(); String getName(); } ItemStack: public interface ItemStackFactory { ItemStack createItemStack(Item item, int quantity); } ItemStackContainer: public interface ItemStackContainer { default void add(ItemStack stack) { add(stack, 1); } void add(ItemStack stack, int quantity); } ตอนนี้ItemและItemStackFactoryฉันสามารถคาดการณ์ได้อย่างแน่นอนว่าบุคคลที่สามบางคนจำเป็นต้องขยายในอนาคต ItemStackContainerอาจขยายได้ในอนาคต แต่ไม่ใช่ในลักษณะที่ฉันสามารถคาดการณ์ได้นอกเหนือจากการใช้งานเริ่มต้นที่ให้ไว้ ตอนนี้ฉันพยายามทำให้ห้องสมุดนี้แข็งแกร่งที่สุด นี่ยังอยู่ในช่วงเริ่มต้น (pre-pre-alpha) ดังนั้นนี่อาจเป็นการกระทำของวิศวกรรมมากกว่า …

11 java  generics 

ฉันได้เล่นกับ C # สำหรับ Windows และ ASP.net MVC พัฒนามาระยะหนึ่งแล้ว แต่ฉันยังไม่ชัดเจนในบางพื้นที่ ฉันกำลังพยายามที่จะเข้าใจความแตกต่างขั้นพื้นฐานระหว่างและปัญหาการปฏิบัติงานเกี่ยวกับการใช้และการสับเปลี่ยนชนิดที่คล้ายกันของทั่วไปการเก็บการเชื่อมต่อ คือความแตกต่างระหว่างสิ่งที่พื้นฐานIEnumerable<T>, ICollection<T>, List<T>(Class)? ฉันดูเหมือนจะใช้และแลกเปลี่ยนโดยไม่เห็นปัญหาใด ๆ ในแอปพลิเคชันของฉัน นอกจากนี้ยังมีคอลเลกชันทั่วไปที่คล้ายกันมากกว่านี้ที่สามารถแลกเปลี่ยนกับสามเหล่านี้ได้หรือไม่

11 c#  generics  interfaces 

ฉันกำลังเขียนโปรแกรมในสภาพแวดล้อมทางวิชาการในขณะนี้ดังนั้นฉันสามารถใช้สิ่งที่ฉันต้องการ ฉันใช้ห้องสมุดกราฟเพิ่มสำหรับบางสิ่งและฉันสงสัยว่าการลงทุนเพื่อทำความเข้าใจ GP ยิ่งลึกคุ้มค่าหรือไม่ ฉันอยากรู้อยากเห็น - การเขียนโปรแกรมทั่วไป (GP) มีการใช้งานมากในอุตสาหกรรมหรือไม่ ฉันเดาว่าโปรแกรมเมอร์ส่วนใหญ่คุ้นเคยกับ OOP หรือใช้ภาษาที่ไม่เน้นหรือสนับสนุน GP ดังนั้นนอกการเรียก STL โครงสร้างข้อมูล / ฟังก์ชั่นใน C ++ ความประทับใจของฉันคือ GP ไม่ได้ใช้ทั้งหมดบ่อยนัก ในทางปฏิบัติ แต่การอยู่นอกอุตสาหกรรมในขณะนี้เป็นเรื่องดีที่ได้ยินจากผู้ฝึกสอนในเรื่องนี้ (ขณะที่ฉันกำลังเขียนสิ่งนี้ฉันเห็นว่าการเขียนโปรแกรมทั่วไปไม่ใช่แท็กที่ถูกต้อง!)

11 c++  object-oriented  generics 

ฉันต้องการอินเทอร์เฟซที่ทำให้ฉันมั่นใจว่ามีวิธีการบางอย่างรวมถึงลายเซ็นเฉพาะ จนถึงตอนนี้เขาคือสิ่งที่ฉันมี: public interface Mappable<M> { M mapTo(M mappableEntity); } ปัญหาเกิดขึ้นเมื่อคลาสควรแม็พกับเอนทิตีอื่น ๆ กรณีที่เหมาะสมที่สุดคือ (ไม่ใช่ java): public class Something implements Mappable<A>, Mappable<B> { public A mapTo(A someObject) {...} public B mapTo(B someOtherObject) {...} } อะไรจะเป็นวิธีที่ดีที่สุดในการบรรลุถึงสิ่งที่เหลืออยู่นี้ให้เป็น "สามัญ" ที่สุด

10 java  generics 

ทำไมเมื่อฉันพยายามสร้าง ArrayLists: ArrayList<Integer>[] arr=new ArrayList<Integer>[40];มีข้อผิดพลาดและ java ไม่อนุญาตสิ่งนี้ มีเหตุผลที่เกี่ยวข้องกับการใช้งาน generics ของจาวา, generics ในภาษาใด ๆ หรือบางสิ่งบางอย่างโดยพลการ?

10 java  language-design  generics 

ตั้งค่า:สมมติว่าเรามีประเภทที่เรียกว่าIteratorซึ่งมีพารามิเตอร์ประเภทElement: interface Iterator<Element> {} แล้วเรามีอินเตอร์เฟซที่มีวิธีการหนึ่งที่จะกลับIterableIterator // T has an upper bound of Iterator interface Iterable<T: Iterator> { getIterator(): T } ปัญหาของIteratorการเป็นแบบทั่วไปคือเราต้องระบุอาร์กิวเมนต์ประเภท แนวคิดหนึ่งในการแก้ไขปัญหานี้คือ "อนุมาน" ประเภทของตัววนซ้ำ หลอกรหัสต่อไปนี้เป็นการแสดงออกถึงความคิดที่ว่ามีตัวแปรประเภทElementซึ่งอนุมานว่าจะเป็นอาร์กิวเมนต์ประเภทไปที่Iterator: interface <Element> Iterable<T: Iterator<Element>> { getIterator(): T } จากนั้นเราก็ใช้มันในที่นี้: class Vec<Element> implements Iterable<VecIterator<Element>> {/*...*/} คำจำกัดความของคำIterableว่าไม่ใช้Elementที่อื่นในคำจำกัดความของมัน แต่กรณีใช้งานจริงของฉัน ฟังก์ชั่นบางอย่างที่ใช้Iterableยังจำเป็นต้องสามารถ จำกัด พารามิเตอร์ของตนเพื่อยอมรับIterables ซึ่งคืนค่าตัววนซ้ำบางชนิดเช่นตัววนซ้ำสองทิศทาง คำถาม: มีชื่อที่กำหนดขึ้นสำหรับตัวแปรประเภทอนุมานเหล่านี้หรือไม่ เทคนิคโดยรวมเป็นอย่างไร การไม่รู้ระบบการตั้งชื่อเฉพาะทำให้การค้นหาตัวอย่างของสิ่งนี้เป็นเรื่องยากหรือเรียนรู้เกี่ยวกับคุณลักษณะเฉพาะทางภาษา ไม่ใช่ทุกภาษาที่มีชื่อสามัญมีเทคนิคนี้ …

9 generics  language-agnostic  programming-languages  language-design