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

" Heap Pollution " ในรูปแบบที่ไม่สามารถนำกลับมาใช้ใหม่ได้ (บทเรียน Java ™> การเรียนรู้ภาษา Java> Generics (อัปเดต)) ทำไมถึงเรียกว่าเป็นอย่างนั้น?

63 java  terminology  specifications  languages  generics 

ฉันเคยเห็นหลายครั้งในเว็บไซต์นี้โพสต์ที่ประณามการใช้งานจาวาทั่วไป ตอนนี้ฉันสามารถพูดได้อย่างตรงไปตรงมาว่าฉันไม่ได้มีปัญหาใด ๆ กับการใช้พวกเขา อย่างไรก็ตามฉันไม่ได้พยายามที่จะสร้างชั้นเรียนตัวเอง ดังนั้นปัญหาของคุณกับการสนับสนุนทั่วไปของ Java คืออะไร

49 java  generics 

เมื่อเร็ว ๆ นี้ฉันเคยติดนิสัยคอลเลกชัน Java "กำบัง" ที่มีชื่อคลาสที่เป็นมิตรกับมนุษย์ ตัวอย่างง่ายๆ: // Facade class that makes code more readable and understandable. public class WidgetCache extends Map<String, Widget> { } หรือ: // If you saw a ArrayList<ArrayList<?>> being passed around in the code, would you // run away screaming, or would you actually understand what …

46 java  anti-patterns  generics  collections 

ในขณะที่ตรวจสอบรหัสบางอย่างฉันสังเกตเห็นโอกาสที่จะเปลี่ยนเป็นใช้ชื่อสามัญ โค้ด (obfuscated) ดูเหมือนว่า: public void DoAllTheThings(Type typeOfTarget, object[] possibleTargets) { var someProperty = typeOfTarget.GetProperty(possibleTargets[0]); ... } รหัสนี้อาจถูกแทนที่ด้วย generics เช่น: public void DoAllTheThings<T>(object[] possibleTargets[0]) { var someProperty = type(T).getProperty(possibleTargets[0]); ... } ในการวิจัยถึงประโยชน์และข้อบกพร่องของวิธีการนี้ผมพบว่าในระยะที่เรียกว่าการทำผิดกฎทั่วไป ดู: ปกป้องมือใหม่ (ผู้พัฒนา) จากยาชื่อสามัญ https://stackoverflow.com/questions/28203199/is-this-an-abuse-of-generics https://codereview.stackexchange.com/q/60695 คำถามของฉันมีสองส่วน: จะมีประโยชน์ใด ๆ ในการย้ายไปยาสามัญเช่นนี้? (ประสิทธิภาพอ่านง่าย) การละเมิดทั่วไปคืออะไร และใช้งานทั่วไปทุกครั้งที่มีพารามิเตอร์ประเภทเป็นการละเมิด ?

35 generics 

ตัวอย่างเช่นฉันมีเกมที่มีเครื่องมือบางอย่างเพื่อเพิ่มความสามารถของผู้เล่น: Tool.h class Tool{ public: std::string name; }; และเครื่องมือบางอย่าง: Sword.h class Sword : public Tool{ public: Sword(){ this->name="Sword"; } int attack; }; Shield.h class Shield : public Tool{ public: Shield(){ this->name="Shield"; } int defense; }; MagicCloth.h class MagicCloth : public Tool{ public: MagicCloth(){ this->name="MagicCloth"; } int attack; int defense; }; …

34 design-patterns  c++  generics 

เป็นที่ยอมรับกันโดยทั่วไปว่า Java generics ล้มเหลวในบางวิธีที่สำคัญ การรวมกันของ wildcard และขอบเขตทำให้รหัสบางอย่างไม่สามารถอ่านได้อย่างจริงจัง อย่างไรก็ตามเมื่อฉันดูภาษาอื่น ๆ ฉันก็ดูเหมือนจะไม่พบระบบแบบทั่วไปที่โปรแกรมเมอร์มีความสุข ถ้าเราทำสิ่งต่อไปนี้เป็นเป้าหมายการออกแบบของระบบประเภท: สร้างการประกาศประเภทที่อ่านง่ายเสมอ ง่ายต่อการเรียนรู้ (ไม่จำเป็นต้องปัดเรื่องความแปรปรวนร่วมความแปรปรวน ฯลฯ ) เพิ่มจำนวนข้อผิดพลาดในการคอมไพล์ให้สูงสุด มีภาษาใดบ้างที่ทำให้ถูกต้อง? ถ้าฉัน google สิ่งเดียวที่ฉันเห็นคือการร้องเรียนเกี่ยวกับวิธีที่ระบบประเภทดูดในภาษา X. ความซับซ้อนแบบนี้มีอยู่ในการพิมพ์ทั่วไปหรือไม่? เราควรยอมแพ้ในการพยายามตรวจสอบความปลอดภัย 100% ณ เวลารวบรวมหรือไม่? คำถามหลักของฉันคือภาษาใดที่ "เข้าใจถูกต้อง" ที่สุดด้วยความเคารพต่อเป้าหมายทั้งสามนี้ ฉันรู้ว่ามันเป็นแบบอัตนัย แต่จนถึงตอนนี้ฉันไม่สามารถหาภาษาใดภาษาหนึ่งได้ที่โปรแกรมเมอร์ไม่ใช่ทุกคนยอมรับว่าระบบประเภททั่วไปนั้นเป็นระเบียบ ภาคผนวก: ดังที่กล่าวไว้การรวมกันของการพิมพ์ย่อย / การสืบทอดและข้อมูลทั่วไปเป็นสิ่งที่สร้างความซับซ้อนดังนั้นฉันจึงกำลังมองหาภาษาที่ผสมผสานทั้งสองอย่างและหลีกเลี่ยงการระเบิดของความซับซ้อน

29 type-systems  generics 

สมมติว่าฉันมีสองคลาสที่มีลักษณะเช่นนี้ (บล็อกแรกของรหัสและปัญหาทั่วไปเกี่ยวข้องกับ C #): class A { public int IntProperty { get; set; } } class B { public int IntProperty { get; set; } } คลาสเหล่านี้ไม่สามารถเปลี่ยนแปลงได้ แต่อย่างใด (เป็นส่วนหนึ่งของการประชุมของบุคคลที่สาม) ดังนั้นฉันไม่สามารถทำให้พวกเขาใช้อินเทอร์เฟซเดียวกันหรือสืบทอดคลาสเดียวกันที่จะมี IntProperty ฉันต้องการใช้ตรรกะบางอย่างกับIntPropertyคุณสมบัติของทั้งสองคลาสและใน C ++ ฉันสามารถใช้คลาสเทมเพลตเพื่อทำสิ่งนั้นได้อย่างง่ายดาย: template <class T> class LogicToBeApplied { public: void T CreateElement(); }; template <class T> T …

28 c#  generics 

ฉันดูเหมือนจะมีความเข้าใจผิดเกี่ยวกับความแตกต่างระหว่างและ<Foo> <? extends Foo>จากความเข้าใจของฉันถ้าเรามี ArrayList<Foo> foos = new ArrayList<>(); สิ่งนี้บ่งชี้ว่าวัตถุประเภทFooสามารถเพิ่มในรายการอาร์เรย์นี้ เนื่องจากคลาสย่อยของFooยังเป็นประเภทFooจึงสามารถเพิ่มได้โดยไม่มีข้อผิดพลาดตามที่แสดงใน ArrayList<Foo> foos = new ArrayList<>(); foos.add(new Foo()); foos.add(new Bar()); Bar extends Fooที่ไหน ตอนนี้พูดว่าฉันได้กำหนดไว้foosเป็น ArrayList<? extends Foo> foos = new ArrayList<>(); some unknown type that extends Fooเข้าใจในปัจจุบันของฉันคือเป็นการแสดงออกที่ว่านี้ ฉันใช้สิ่งนี้เพื่อหมายความว่าวัตถุใด ๆ ที่เป็น subclass ของFooสามารถเพิ่มลงในรายการนี้; หมายความว่ามีความแตกต่างระหว่างไม่มีและArrayList<Foo>ArrayList<? extends Foo> เพื่อทดสอบสิ่งนี้ฉันพยายามเขียนรหัสต่อไปนี้ ArrayList<? extends Foo> subFoos …

20 java  generics 

ฉันจำไม่ได้เมื่อฉันเขียนชั้นเรียนทั่วไปครั้งที่แล้ว ทุกครั้งที่ฉันคิดว่าฉันต้องการมันหลังจากที่ฉันคิดว่าจะทำข้อสรุปที่ฉันทำไม่ได้ คำตอบที่สองสำหรับคำถามนี้ทำให้ฉันต้องขอคำชี้แจง (เนื่องจากฉันยังไม่สามารถแสดงความคิดเห็นได้ฉันจึงได้ตั้งคำถามใหม่) ดังนั้นลองใช้โค้ดที่ได้รับเป็นตัวอย่างของกรณีที่ใครต้องการยาชื่อสามัญ: 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 

ฉันอยู่ในสภาพแวดล้อมที่ผู้คนเชื่อว่า: Java generics เป็นคุณสมบัติที่ใช้สำหรับการเขียนไลบรารีโดยเฉพาะและไม่ใช่การเข้ารหัสที่แท้จริง C ++ เป็นภาษาการเขียนโปรแกรม OO; templateเป็นคุณสมบัติเสริมและหลีกเลี่ยงได้ แม้ว่าคนเหล่านี้จะพึ่งพาไลบรารีที่เขียนโดยใช้โปรแกรมทั่วไป (เช่น STL, คอนเทนเนอร์ Java) ถ้าผมเขียนโค้ดที่ใช้templateหรือgenericsรหัสวิจารณ์มีแนวโน้มที่จะปฏิเสธมันและจะแสดงความคิดเห็นที่จะเขียนมันใน"เหมาะสม / เข้าใจ / สง่างาม"วิธี ความคิดดังกล่าวสามารถใช้งานได้จากโปรแกรมเมอร์ปกติถึงผู้จัดการส่วนใหญ่อาวุโส ไม่มีทางออกเพราะ 90% ของเวลาคนเหล่านี้มีการวิ่งเต้น เป็นวิธีที่ดีที่สุด ( ไม่ถูกตัดคอ ) ของการอธิบายพวกเขาวิธีการปฏิบัติของการเขียนโค้ดซึ่งประกอบด้วย OO และการเขียนโปรแกรมทั่วไปทั้งสองในเวลาเดียวกันคืออะไร?

20 java  c++  templates  generics 

ใน C # generics เราสามารถประกาศข้อ จำกัด สำหรับพารามิเตอร์ชนิดจะมีคอนสตรัคเริ่มต้นด้วยการพูดว่าT where T : new()อย่างไรก็ตามไม่มีข้อ จำกัด อื่น ๆ เช่นนี้ที่ถูกต้อง - new(string)ตัวอย่างเช่น ฯลฯ จากมุมมองของการออกแบบภาษาและ / หรือการนำไปใช้งานอะไรคือสาเหตุของสิ่งนี้? มีบางอย่างในการทำงานของคอนสตรัคเตอร์หรือวิธีการใช้งานระบบพิมพ์ที่ห้ามสิ่งนี้ (หรืออย่างน้อยก็ทำให้ยากขึ้น)? ถ้าเป็นเช่นนั้นมันคืออะไร? ผมจำได้อ่านบางที่default(T)จริงคอมไพล์สำหรับnew T() T : structมันเกี่ยวข้องกับสิ่งนี้หรือเปล่า? หรือเป็นเพียงการตัดสินใจออกแบบเพื่อหลีกเลี่ยงการทำให้ภาษาซับซ้อนเกินไป?

19 c#  language-design  generics 

สมมติว่าฉันมีลำดับชั้นเรียนนี้ ... public abstract class Animal { public abstract void eat(); public abstract void talk(); } class Dog extends Animal { @Override public void eat() { } @Override public void talk() { } } class Cat extends Animal { @Override public void eat() { } @Override public void talk() { …

17 java  polymorphism  generics 

ฉันค่อนข้างมั่นใจว่าทุกคนคุ้นเคยกับวิธีการทั่วไปของแบบฟอร์ม: T DoSomething<T>(T item) ฟังก์ชั่นนี้เรียกว่า parametrically polymorphic (PP) โดยเฉพาะอันดับ 1 PP สมมติว่าวิธีนี้สามารถแสดงโดยใช้ฟังก์ชั่นวัตถุของรูปแบบ: <T> : T -> T นั่นคือ<T>หมายความว่าใช้พารามิเตอร์ประเภทเดียวและT -> Tหมายความว่าใช้พารามิเตอร์ประเภทเดียวTและส่งกลับค่าประเภทเดียวกัน ต่อไปนี้จะเป็นฟังก์ชัน PP อันดับ 2: (<T> : T -> T) -> int ฟังก์ชั่นไม่มีพารามิเตอร์ประเภทตัวเอง แต่ใช้ฟังก์ชั่นซึ่งใช้พารามิเตอร์ประเภท คุณสามารถทำสิ่งนี้ซ้ำ ๆ ได้โดยทำรังให้ลึกและลึกขึ้นรับ PP ในระดับที่สูงกว่าและสูงกว่า คุณลักษณะนี้หายากมากในบรรดาภาษาการเขียนโปรแกรม แม้แต่ Haskell ก็ไม่อนุญาตตามค่าเริ่มต้น มันมีประโยชน์หรือไม่ มันสามารถอธิบายพฤติกรรมที่ยากที่จะอธิบายเป็นอย่างอื่นได้หรือไม่? นอกจากนี้มันหมายความว่าอะไรที่จะต้องมีความคิดมาก ? (ในบริบทนี้)

16 programming-languages  functional-programming  type-systems  generics 

นี่คือคำถามจากมุมมองภายในของคอมไพเลอร์ ฉันสนใจ generics ไม่ใช่แม่แบบ (C ++) ดังนั้นฉันจึงทำเครื่องหมายคำถามด้วย C # ไม่ใช่ Java เพราะ AFAIK ข้อมูลทั่วไปในทั้งสองภาษานั้นแตกต่างกันในการนำไปใช้งาน เมื่อฉันดูภาษาที่ไม่มี generics มันค่อนข้างตรงไปตรงมาคุณสามารถตรวจสอบคำจำกัดความของคลาสเพิ่มลงในลำดับชั้นและนั่นคือมัน แต่จะทำอย่างไรกับชั้นเรียนทั่วไปและที่สำคัญกว่านั้นจัดการกับการอ้างอิงได้อย่างไร วิธีตรวจสอบให้แน่ใจว่าฟิลด์คงที่นั้นเป็นเอกพจน์ต่ออินสแตนซ์ (เช่นแต่ละครั้งที่พารามิเตอร์ทั่วไปได้รับการแก้ไข) สมมติว่าฉันเห็นสาย: var x = new Foo<Bar>(); ฉันจะเพิ่มFoo_Barคลาสใหม่ให้กับลำดับชั้นหรือไม่ อัปเดต:จนถึงตอนนี้ฉันพบเพียง 2 โพสต์ที่เกี่ยวข้อง แต่ถึงแม้ว่าพวกเขาจะไม่ได้ลงรายละเอียดมากในแง่ "วิธีการทำด้วยตัวเอง": http://www.jprl.com/Blog/archive/development/2007/Aug-31.html http://www.artima.com/intv/generics2.html

16 c#  generics