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

ฉันเริ่มที่จะเรียนรู้Haskell ฉันยังใหม่กับมันมากและฉันเพิ่งอ่านหนังสือออนไลน์สองสามเล่มเพื่อให้เข้าใจถึงโครงสร้างพื้นฐานของหนังสือเล่มนี้ หนึ่งใน 'มส์' ที่คนคุ้นเคยกับมันมักจะพูดถึงคือ "ถ้ามันรวบรวมมันจะทำงาน *" - ซึ่งฉันคิดว่าเกี่ยวข้องกับความแข็งแกร่งของระบบประเภท ฉันพยายามที่จะเข้าใจว่าทำไมตรง Haskell จะดีกว่าภาษาพิมพ์แบบคงที่อื่น ๆ ในเรื่องนี้ วางวิธีอื่นผมถือว่าใน Java คุณสามารถทำสิ่งชั่วร้ายเช่นฝังศพ จะมีอะไรบางอย่างที่มันควรจะเป็นArrayList<String>() ArrayList<Animal>()สิ่งที่ชั่วร้ายนี่คือสิ่งที่คุณstringมีelephant, giraffeฯลฯ และถ้ามีคนใส่เข้าไปMercedes- คอมไพเลอร์ของคุณจะไม่ช่วยคุณ ถ้าผมไม่ได้ทำArrayList<Animal>()แล้วในบางจุดในเวลาต่อมาถ้าผมตัดสินใจที่โปรแกรมของฉันไม่ได้จริงๆเกี่ยวกับสัตว์มันเป็นเรื่องของยานพาหนะแล้วฉันสามารถเปลี่ยนการพูด, ฟังก์ชั่นที่ผลิตArrayList<Animal>ในการผลิตArrayList<Vehicle>และ IDE ของฉันควรจะบอกฉันทุกที่มี เป็นการพักสะสม ข้อสันนิษฐานของฉันคือว่านี่คือสิ่งที่ผู้คนหมายถึงโดยระบบพิมพ์ที่แข็งแกร่งแต่ไม่ชัดเจนสำหรับฉันว่าทำไม Haskell ถึงดีกว่า อีกวิธีหนึ่งคุณสามารถเขียน Java ที่ดีหรือไม่ดีฉันคิดว่าคุณสามารถทำได้เหมือนกันใน Haskell (เช่นสิ่งต่าง ๆ เป็นสตริง / ints ที่ควรเป็นประเภทข้อมูลชั้นหนึ่ง) ฉันสงสัยว่าตัวเองขาดอะไร / สำคัญไป ฉันมีความสุขมากที่ได้เห็นข้อผิดพลาดในวิธีการของฉัน!

204 java  haskell  polymorphism 

ฉันเพิ่งจบปริญญาโท (ในการคำนวณ) และสมัครงาน ฉันสังเกตเห็นว่า บริษัท หลายแห่งร้องขอความเข้าใจเกี่ยวกับการวางแนววัตถุโดยเฉพาะ คำถามสัมภาษณ์ที่ได้รับความนิยมเกี่ยวกับการถ่ายทอดทางพันธุกรรม OO สำคัญจริง ๆ ไหม ฉันยังมีการสัมภาษณ์งานเขียนโปรแกรมใน C และอีกครึ่งหนึ่งการสัมภาษณ์คือ OO ในโลกแห่งความเป็นจริงการพัฒนาแอพพลิเคชั่นจริงการวางแนววัตถุมักจะถูกนำไปใช้หรือไม่? ฟีเจอร์สำคัญเช่น polymorphism ใช้ A LOT หรือไม่? ฉันคิดว่าคำถามของฉันมาจากหนึ่งในจุดอ่อนของฉัน แม้ว่าฉันจะรู้เกี่ยวกับ OO แต่ดูเหมือนว่าฉันจะไม่สามารถรวมเข้ากับโปรแกรมของฉันได้

55 object-oriented  inheritance  polymorphism 

ปิด คำถามนี้เป็นคำถามความคิดเห็นตาม ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้สามารถตอบข้อเท็จจริงและการอ้างอิงได้โดยแก้ไขโพสต์นี้ ปิดให้บริการใน5 ปีที่ผ่านมา วิธีการบรรทุกเกินพิกัดชนิดของความหลากหลาย? สำหรับฉันดูเหมือนว่าการแยกความแตกต่างของวิธีการที่มีชื่อเดียวกันและพารามิเตอร์ที่แตกต่างกัน ดังนั้นstuff(Thing t)และstuff(Thing t, int n)เป็นวิธีการที่แตกต่างกันอย่างสิ้นเชิงเท่าที่รวบรวมและรันไทม์มีความกังวล มันสร้างภาพลวงตาบนฝั่งของผู้โทรว่ามันเป็นวิธีเดียวกันกับที่ทำหน้าที่แตกต่างกันในวัตถุชนิดต่าง ๆ - polymorphism แต่นั่นเป็นเพียงภาพลวงตาเพราะจริงstuff(Thing t)และstuff(Thing t, int n)วิธีการที่แตกต่างกันอย่างสิ้นเชิง วิธีการมากไปกว่าน้ำตาล syntactic? ฉันพลาดอะไรไปรึเปล่า? ความหมายทั่วไปสำหรับน้ำตาลประโยคคือว่ามันเป็นท้องถิ่นอย่างหมดจด ความหมายการเปลี่ยนชิ้นส่วนของรหัสให้เทียบเท่า 'หวาน' หรือในทางกลับกันเกี่ยวข้องกับการเปลี่ยนแปลงในท้องถิ่นที่ไม่ส่งผลกระทบต่อโครงสร้างโดยรวมของโปรแกรม และฉันคิดว่าวิธีการบรรทุกเกินพิกัดเหมาะสมกับเกณฑ์นี้อย่างแม่นยำ ลองดูตัวอย่างเพื่อสาธิต: พิจารณาชั้นเรียน: class Reader { public String read(Book b){ // .. translate the book to text } public String …

19 polymorphism  method-overloading 

ปิด คำถามนี้จะต้องมีมากขึ้นมุ่งเน้น ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้มุ่งเน้นที่ปัญหาเดียวโดยแก้ไขโพสต์นี้ ปิดเมื่อปีที่แล้ว ฉันพยายามที่จะเข้าใจว่า Polymorphism ใช้ในโครงการชีวิตจริง แต่ฉันสามารถหาตัวอย่างคลาสสิก (หรือบางอย่างที่คล้ายกัน) ของการมีAnimalคลาสผู้ปกครองด้วยวิธีการspeak()และชั้นเรียนเด็กจำนวนมากที่แทนที่วิธีนี้และตอนนี้ คุณสามารถเรียกใช้เมธอดspeak()บนอ็อบเจ็กต์ลูกใด ๆ ตัวอย่างเช่น: Animal animal; animal = dog; animal.speak(); animal = cat; animal.speak();

17 object-oriented  data-structures  polymorphism 

สมมติว่าฉันมีลำดับชั้นเรียนนี้ ... 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 

จากความหลากหลายในวิกิพีเดีย ในวิทยาการคอมพิวเตอร์ polymorphism เป็นคุณสมบัติภาษาการเขียนโปรแกรมที่ช่วยให้ค่าของชนิดข้อมูลที่แตกต่างกันได้รับการจัดการโดยใช้อินเตอร์เฟซที่เหมือนกัน จากการพิมพ์เป็ดบน Wikipedia ในการเขียนโปรแกรมคอมพิวเตอร์ด้วยภาษาการเขียนโปรแกรมเชิงวัตถุการพิมพ์เป็ดเป็นลักษณะของการพิมพ์แบบไดนามิกซึ่งชุดวิธีการและคุณสมบัติปัจจุบันของวัตถุกำหนดความหมายที่ถูกต้องมากกว่าการสืบทอดจากคลาสเฉพาะหรือการใช้อินเทอร์เฟซเฉพาะ การตีความของฉันนั้นขึ้นอยู่กับการพิมพ์เป็ดวิธีการ / คุณสมบัติของวัตถุกำหนดความหมายที่ถูกต้อง ความหมายที่วัตถุรูปร่างปัจจุบันกำหนดอินเทอร์เฟซมันรักษา จากหลากหลายคุณสามารถพูดฟังก์ชั่นเป็น polymorphic ถ้ามันยอมรับหลายชนิดข้อมูลที่แตกต่างกันตราบเท่าที่พวกเขารักษาอินเทอร์เฟซ ดังนั้นหากฟังก์ชั่นสามารถพิมพ์เป็ดมันสามารถยอมรับหลายชนิดข้อมูลที่แตกต่างกันและดำเนินการกับพวกเขาตราบเท่าที่ชนิดข้อมูลเหล่านั้นมีวิธีการที่ถูกต้อง / คุณสมบัติและทำให้การสนับสนุนอินเตอร์เฟซ (การใช้อินเทอร์เฟซของคำศัพท์ไม่ได้หมายถึงการสร้างโค้ด แต่เป็นการสร้างเอกสารที่มีความหมายและมีความหมายมากกว่า) ความสัมพันธ์ที่ถูกต้องระหว่าง ducktyping และ polymorphism คืออะไร? หากภาษาหนึ่งสามารถเป็ดชนิดนั่นหมายความว่ามันสามารถทำ polymorphism?

17 object-oriented  duck-typing  polymorphism 

สมมติว่าฉันมีตัวสร้างการทดสอบเพื่อให้ครูสามารถสร้างคำถามมากมายสำหรับการทดสอบ อย่างไรก็ตามไม่ใช่คำถามทุกข้อที่เหมือนกัน: คุณมีตัวเลือกหลายตัวกล่องข้อความการจับคู่และอื่น ๆ คำถามแต่ละประเภทต้องเก็บข้อมูลประเภทต่าง ๆ และต้องการ GUI ที่แตกต่างกันสำหรับทั้งผู้สร้างและผู้ทดสอบ ฉันต้องการหลีกเลี่ยงสองสิ่ง: ตรวจสอบประเภทหรือการคัดเลือกนักแสดง สิ่งใดที่เกี่ยวข้องกับ GUI ในรหัสข้อมูลของฉัน ในความพยายามครั้งแรกของฉันฉันจบด้วยคลาสต่อไปนี้: class Test{ List<Question> questions; } interface Question { } class MultipleChoice implements Question {} class TextBox implements Question {} อย่างไรก็ตามเมื่อฉันไปแสดงการทดสอบฉันจะจบลงด้วยรหัสเช่น: for (Question question: questions){ if (question instanceof MultipleChoice){ display.add(new MultipleChoiceViewer()); } //etc } นี่เป็นปัญหาที่พบบ่อยมาก มีรูปแบบการออกแบบบางอย่างที่ทำให้ฉันมีคำถามแบบ …

17 design-patterns  polymorphism 

เมื่อเรียนรู้เกี่ยวกับความแตกต่างคุณมักเห็นสิ่งนี้ class Base { int prv_member; virtual void fn(){} } class Derived : Base { int more_data; virtual void fn(){} } อัพซิสต์หรือดาวน์สตรีมคืออะไร? คือ(Derived*)base_ptr;upCast หรือเศร้าใจ? ฉันเรียกมันว่า upcast เพราะคุณกำลังออกจากฐานไปสู่สิ่งที่เฉพาะเจาะจงกว่านี้ คนอื่นบอกฉันว่ามันเป็นการลดทอนเพราะคุณจะลดระดับลงในบางสิ่งที่เฉพาะเจาะจงโดยที่ด้านบนเป็นราก แต่คนอื่น ๆ ดูเหมือนจะเรียกสิ่งที่ฉันเรียกมันว่า เมื่อแปลง ptr ฐานเป็น ptr ที่ได้รับมันเรียกว่า upcasting หรือ downcasting? และถ้าใครบางคนสามารถเชื่อมโยงไปยังแหล่งข้อมูลอย่างเป็นทางการหรืออธิบายว่าทำไมมันถึงเรียกว่ายิ่งใหญ่

16 polymorphism 

เมื่อคุณใช้แนวคิดของความหลากหลายที่คุณสร้างลำดับชั้นของชั้นเรียนและใช้การอ้างอิงผู้ปกครองที่คุณเรียกใช้ฟังก์ชั่นอินเทอร์เฟซโดยไม่ทราบว่าชนิดที่เฉพาะเจาะจงมีวัตถุ มันเยี่ยมมาก ตัวอย่าง: คุณมีคอลเลคชั่นสัตว์และเรียกร้องให้สัตว์ทุกตัวทำงานeatและคุณไม่สนใจว่ามันจะกินสุนัขหรือแมว แต่ในลำดับชั้นเดียวกับที่คุณมีสัตว์ที่มีเพิ่มเติม - อื่น ๆ กว่าสืบทอดและดำเนินการจากชั้นเรียนAnimalเช่นmakeEggs, getBackFromTheFreezedStateและอื่น ๆ ดังนั้นในบางกรณีในการทำงานของคุณคุณอาจต้องการทราบประเภทเฉพาะเพื่อเรียกใช้พฤติกรรมเพิ่มเติม ยกตัวอย่างเช่นในกรณีที่มันเป็นช่วงเวลาเช้าและถ้ามันเป็นเพียงสัตว์แล้วคุณเรียกeatมิฉะนั้นถ้ามันเป็นมนุษย์แล้วโทรครั้งแรกwashHands, และเพียงแล้วโทรgetDressed eatวิธีจัดการกรณีนี้? ความแตกต่างตาย คุณจำเป็นต้องค้นหาประเภทของวัตถุซึ่งฟังดูมีกลิ่นรหัส มีวิธีการทั่วไปในการจัดการกรณีนี้หรือไม่?

14 design-patterns  object-oriented  polymorphism  subtypes 

ก่อนอื่นฉันเป็นโปรแกรมเมอร์ระดับต้น ในความเป็นจริงฉันกำลังจบระดับ AS ด้วยโปรเจ็กต์สุดท้ายของฤดูร้อน ในงานใหม่ของฉันเมื่อไม่มีโครงการให้ฉันทำ (พวกเขากำลังรอที่จะเติมทีมด้วยการจ้างงานใหม่) ฉันได้รับหนังสือให้อ่านและเรียนรู้จากในขณะที่ฉันรอ - ตำราบางเล่มอื่น ๆ ไม่มาก (เช่น Code Complete) หลังจากอ่านหนังสือเหล่านี้ฉันได้หันไปใช้อินเทอร์เน็ตเพื่อเรียนรู้ให้มากที่สุดและเริ่มเรียนรู้เกี่ยวกับ SOLID และ DI (เราได้พูดถึงหลักการทดแทนของ Liskov แต่ไม่ได้มีแนวคิด SOLID อื่น) เพื่อที่ฉันจะได้เรียนรู้ฉันนั่งลงเพื่อเรียนรู้ให้ดีขึ้นและเริ่มเขียนโค้ดเพื่อใช้ DI ด้วยมือ (ไม่มีกรอบ DI บนคอมพิวเตอร์การพัฒนา) สิ่งที่ฉันทำมันฉันสังเกตเห็นว่ามันรู้สึกคุ้นเคย ... และดูเหมือนว่ามันเป็นเหมือนงานที่ฉันเคยทำในอดีตโดยใช้องค์ประกอบของคลาสนามธรรมโดยใช้ polymorphism ฉันคิดถึงภาพที่ใหญ่กว่านี้หรือไม่? มีบางอย่างเกี่ยวกับ DI (อย่างน้อยด้วยมือ) ที่ไปได้หรือไม่? ฉันเข้าใจถึงความเป็นไปได้ของการกำหนดค่าที่ไม่ได้อยู่ในรหัสของกรอบงาน DI บางอันที่มีประโยชน์มากพอ ๆ กับการเปลี่ยนแปลงสิ่งต่าง ๆ โดยไม่ต้องคอมไพล์ใหม่ แต่เมื่อทำด้วยมือฉันไม่แน่ใจว่ามันแตกต่างจากที่ระบุข้างต้น ... ข้อมูลเชิงลึกเกี่ยวกับเรื่องนี้จะมีประโยชน์มาก!

13 dependency-injection  abstraction  polymorphism  composition 

ฉันแค่เรียนรู้ Java และไม่ใช่โปรแกรมเมอร์ที่ฝึกหัด หนังสือที่ฉันกำลังติดตามกล่าวว่าเมื่อเอาชนะวิธีการประเภทอาร์กิวเมนต์จะต้องเหมือนกัน แต่ประเภทผลตอบแทนสามารถเข้ากันได้ polymorphically คำถามของฉันคือทำไมข้อโต้แย้งที่ส่งไปยังวิธีการเอาชนะไม่เป็นประเภทย่อยของประเภทซุปเปอร์ที่คาดไว้ ในเมธอดโอเวอร์โหลดวิธีใดก็ตามที่ฉันเรียกใช้ออบเจ็กต์นั้นรับประกันว่าจะถูกกำหนดไว้บนออบเจ็กต์ หมายเหตุเกี่ยวกับรายการที่แนะนำ: คำแนะนำแรกดูเหมือนจะเกี่ยวกับลำดับชั้นและสถานที่ที่จะนำการทำงาน คำถามของฉันเน้นที่ทำไมการ จำกัด ภาษาจึงมีอยู่มากขึ้น ข้อเสนอแนะที่สองอธิบายถึงวิธีการที่จะทำสิ่งที่ฉันขอ แต่ไม่ได้ว่าทำไมมันจะต้องมีการกระทำที่ทาง คำถามของฉันเน้นที่สาเหตุ

12 java  polymorphism 

ฉันไม่สามารถหาทางออกที่ดีกว่าสำหรับปัญหาของฉัน ฉันมีตัวควบคุมมุมมองที่นำเสนอรายการองค์ประกอบ องค์ประกอบเหล่านั้นเป็นแบบจำลองที่สามารถเป็นตัวอย่างของ B, C, D, ฯลฯ และสืบทอดจาก A. ดังนั้นในตัวควบคุมมุมมองแต่ละรายการควรไปที่หน้าจอที่แตกต่างกันของแอปพลิเคชันและส่งผ่านข้อมูลบางส่วนเมื่อผู้ใช้เลือกหนึ่งในนั้น . ทางเลือกสองทางที่อยู่ในใจของฉันคือ (กรุณาเพิกเฉยไวยากรณ์ไม่ใช่ภาษาที่เฉพาะเจาะจง) 1) สวิตช์ (ฉันรู้ว่า sucks) //inside the view controller void onClickItem(int index) { A a = items.get(index); switch(a.type) { case b: B b = (B)a; go to screen X; x.v1 = b.v1; // fill X with b data …

12 object-oriented  mvc  object-oriented-design  polymorphism  switch-statement 

ฉันเริ่มเขียนโปรแกรมใน C ++ 11 ที่จะวิเคราะห์คอร์ดเครื่องชั่งและความสามัคคี ปัญหาที่ใหญ่ที่สุดที่ฉันมีในขั้นตอนการออกแบบของฉันคือโน้ต 'C' คือโน้ตประเภทของคอร์ด (Cmaj, Cmin, C7, ฯลฯ ) และประเภทของคีย์ (คีย์ของ Cmajor, Cminor) ปัญหาเดียวกันเกิดขึ้นกับช่วงเวลา (เล็กน้อย 3, ใหญ่ 3) ฉันใช้คลาสพื้นฐานโทเค็นซึ่งเป็นคลาสพื้นฐานสำหรับ 'สัญลักษณ์' ทั้งหมดในโปรแกรม ตัวอย่างเช่น: class Token { public: typedef shared_ptr<Token> pointer_type; Token() {} virtual ~Token() {} }; class Command : public Token { public: Command() {} pointer_type execute(); …

12 c++  object-oriented  polymorphism 

ฉันรู้ว่าจาวาสคริปต์ใช้การพิมพ์เป็ดและตอนแรกฉันคิดว่านี่จะทำให้ความแตกต่างง่ายเมื่อเทียบกับภาษาที่พิมพ์อย่างยิ่งเช่น C # แต่ตอนนี้ฟังก์ชั่นของฉันที่รับการโต้แย้งจะเกลื่อนไปด้วยสิ่งต่าง ๆ เช่น: if(myObj.hasSomeProperty()) หรือ if(myObj.hasSomeMethod()) หรือ if(isNumber(myParam)) เป็นต้น นี่มันน่าเกลียดสำหรับฉันจริงๆ ฉันมาจากพื้นหลัง C # และฉันพบว่าอินเตอร์เฟสที่กำหนดไว้นั้นดีกว่ามาก ฉันสงสัยว่าฉันพยายามใช้กลยุทธ์ที่มีประสิทธิภาพในภาษาที่พิมพ์แบบคงที่หรือไม่และมีวิธีที่ดีกว่าในการทำเช่นนี้ใน javascript หรือไม่ ฉันรู้ว่าฉันไม่สามารถตรวจสอบได้ แต่การติดตามข้อผิดพลาดรันไทม์ของจาวาสคริปต์อาจเป็นฝันร้ายเพราะพวกเขามักจะไม่เกิดขึ้นเมื่อเกิดข้อผิดพลาดในรหัส

11 javascript  polymorphism  duck-typing 

ฉันอ่านข้อความในบล็อกเมื่อเช้านี้และพบสิ่งนี้ : ถ้าคลาสเดียวที่ใช้อินเทอร์เฟซลูกค้าคือ CustomerImpl คุณไม่มีความหลากหลายและความสามารถในการสับเปลี่ยนได้จริง ๆ เนื่องจากไม่มีวิธีใดที่จะทดแทน runtime ได้เลย มันเป็นเรื่องธรรมดาทั่วไป นั่นเป็นเหตุผลสำหรับฉันเมื่อการใช้งานอินเทอร์เฟซเพิ่มความซับซ้อนและหากมีเพียงการใช้เพียงครั้งเดียวอย่างใดอย่างหนึ่งอาจยืนยันว่ามันเพิ่มความซับซ้อนที่ไม่จำเป็น การเขียนโค้ดที่มีความเป็นนามธรรมมากกว่าที่ควรจะเป็นมักจะถูกพิจารณาว่าเป็นกลิ่นของรหัสที่เรียกว่า "การเก็งกำไรทั่วไป" (หรือที่กล่าวถึงในโพสต์) แต่ถ้าฉันติดตาม TDD ฉันไม่สามารถสร้างการทดสอบเป็นสองเท่าได้อย่างง่ายดายโดยไม่ต้องคำนึงถึงการเก็งกำไรไม่ว่าจะอยู่ในรูปแบบของการใช้อินเทอร์เฟซหรือตัวเลือก polymorphic อื่น ๆ ของเรา ดังนั้นเราจะคืนดีการแลกเปลี่ยนนี้ได้อย่างไร มันคุ้มค่าหรือไม่ที่จะเป็นการเก็งกำไรโดยทั่วไปเพื่ออำนวยความสะดวกในการทดสอบ / TDD? หากคุณใช้การทดสอบเป็นสองเท่าให้นับเป็นการนำไปใช้ครั้งที่สองและทำให้ความคิดทั่วๆไปไม่เป็นการเก็งกำไรอีกต่อไป? คุณควรพิจารณากรอบการเยาะเย้ยเฮฟวี่เวทที่ช่วยให้ผู้เยาะเย้ยเป็นรูปธรรมมากขึ้น (เช่นโมลเทียบกับ Moq ใน C # โลก) หรือไม่ หรือคุณควรทดสอบกับชั้นเรียนที่เป็นรูปธรรมและเขียนสิ่งที่อาจพิจารณาว่าเป็นการทดสอบ "การรวม" จนกว่าจะถึงเวลาที่การออกแบบของคุณต้องมีความหลากหลาย ฉันอยากรู้อยากเห็นที่จะอ่านคนอื่นจะใช้เวลาในเรื่องนี้ - ขอบคุณล่วงหน้าสำหรับความคิดเห็นของคุณ

11 design  unit-testing  code-smell  polymorphism