คำถามติดแท็ก object-oriented

สองสามเดือนที่ผ่านมาฉันเริ่มทำงานในโครงการใหม่และเมื่อผ่านรหัสมันทำให้ฉันจำนวนคงที่วิธีการแบบคงที่ ไม่เพียง แต่วิธีการใช้งานยูทิลิตี้collectionToCsvString(Collection<E> elements)แต่ยังมีตรรกะทางธุรกิจมากมาย เมื่อผมถามคนที่มีความรับผิดชอบสำหรับเหตุผลที่อยู่เบื้องหลังนี้เขาบอกว่ามันเป็นวิธีการหนีออกจากการปกครองแบบเผด็จการของฤดูใบไม้ผลิ มันมีบางสิ่งที่อยู่รอบกระบวนการคิดนี้: เพื่อใช้วิธีการสร้างการรับลูกค้าเราอาจมีบริการ @Service public class CustomerReceiptCreationService { public CustomerReceipt createReceipt(Object... args) { CustomerReceipt receipt = new CustomerReceipt(); // creation logic return receipt; } } ตอนนี้ผู้ชายคนนั้นบอกว่าเขาไม่ชอบที่จะมีคลาสที่จัดการโดยสปริงโดยไม่จำเป็นเพราะมันมีข้อ จำกัด ว่าคลาสไคลเอนต์จะต้องเป็นสปริงบีนเอง เราจบลงด้วยการจัดการทุกอย่างในฤดูใบไม้ผลิซึ่งบังคับให้เราทำงานกับวัตถุไร้สัญชาติอย่างเป็นขั้นตอน มากหรือน้อยที่ระบุไว้ที่นี่https://www.javacodegeeks.com/2011/02/domain-driven-design-spring-aspectj.html ดังนั้นแทนที่จะเป็นรหัสข้างต้นเขามี public class CustomerReceiptCreator { public static CustomerReceipt createReceipt(Object... args) { CustomerReceipt receipt = new CustomerReceipt(); …

13 java  object-oriented  state  static-methods  static 

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

13 object-oriented  assembly 

ฉันเขียนโปรแกรมเป็นภาษาต่างๆเช่น Java, Ruby, Haskell และ Python ฉันต้องสลับไปมาระหว่างหลายภาษาต่อวันเนื่องจากโครงการที่ฉันทำงานอยู่ ตอนนี้ปัญหาคือฉันมักจะลืมที่จะเขียนselfเป็นพารามิเตอร์แรกในนิยามฟังก์ชั่นใน Python เดียวกันกับวิธีการโทรบนวัตถุเดียวกัน ที่กล่าวว่าฉันค่อนข้างประหลาดใจกับวิธีการของ Python นี้ โดยทั่วไปเราต้องพิมพ์ให้มากขึ้นเพื่อทำสิ่งต่าง ๆ ในภาษาอย่าง Java และ Ruby สิ่งต่าง ๆ ทำได้ง่ายโดยอ้างอิงตัวแปรในวัตถุปัจจุบันโดยอัตโนมัติ คำถามของฉันคือเหตุใดจึงselfจำเป็น มันเป็นตัวเลือกสไตล์อย่างหมดจดหรือมีสาเหตุที่ Python ไม่สามารถให้คุณละเว้นselfวิธีที่ Java และ C ++ ปล่อยให้คุณละเว้นได้this?

13 object-oriented  python  language-design  language-features 

ฉันพยายามสอนตัวเองเกี่ยวกับวิศวกรรมซอฟต์แวร์และการหาข้อมูลที่ขัดแย้งกันซึ่งทำให้ฉันสับสน ฉันได้เรียนรู้เกี่ยวกับ OOP และคลาสนามธรรม / อินเทอร์เฟซคืออะไรและใช้งานอย่างไร แต่จากนั้นฉันก็อ่านว่าควรจะ 'สนับสนุนองค์ประกอบเหนือมรดก' ฉันเข้าใจการจัดองค์ประกอบคือเมื่อคลาสหนึ่งประกอบ / สร้างวัตถุของคลาสอื่นเพื่อใช้ / โต้ตอบกับฟังก์ชันการทำงานของวัตถุใหม่นั้น ดังนั้นคำถามของฉันคือ ... ฉันควรจะไม่ใช้คลาสหรืออินเตอร์เฟสแบบนามธรรมหรือไม่? หากไม่ต้องการสร้างคลาสนามธรรมและขยาย / สืบทอดฟังก์ชันการทำงานของคลาสนามธรรมในคลาสที่เป็นรูปธรรมและแทนที่จะสร้างวัตถุใหม่เพื่อใช้ฟังก์ชันของคลาสอื่น หรือฉันควรใช้องค์ประกอบและสืบทอดจากคลาสนามธรรม; ใช้พวกเขาทั้งสองร่วมกัน? ถ้าเป็นเช่นนั้นคุณช่วยยกตัวอย่างว่ามันจะทำงานอย่างไรและมีประโยชน์อย่างไร เนื่องจากฉันคุ้นเคยกับ PHP มากที่สุดฉันจึงใช้มันเพื่อพัฒนาทักษะ OOP / SE ของฉันก่อนที่จะย้ายไปใช้ภาษาอื่นและถ่ายโอนทักษะ SE ที่เพิ่งได้รับมาดังนั้นตัวอย่างการใช้ PHP จะได้รับการชื่นชมมากที่สุด

13 object-oriented  php  interfaces  inheritance  composition 

ฉันกำลังอ่านหนังสือหลักการพึ่งพาวิธีปฏิบัติและรูปแบบการพึ่งพาหนังสือและฉันอ่านเกี่ยวกับแนวคิดของสิ่งที่เป็นนามธรรมซึ่งอธิบายไว้ในหนังสือ วันนี้ฉันกำลังสร้างฐานรหัส C # ขึ้นใหม่โดยใช้การฉีดอ้างอิงเพื่อให้มีการใช้การโทรแบบ async แทนการบล็อก การทำเช่นนี้ฉันกำลังพิจารณาอินเทอร์เฟซบางตัวที่เป็นนามธรรมในรหัสฐานของฉันและต้องได้รับการออกแบบใหม่เพื่อให้สามารถใช้การโทรแบบ async ได้ เป็นตัวอย่างให้พิจารณาอินเตอร์เฟสต่อไปนี้ที่แสดงถึงที่เก็บสำหรับผู้ใช้แอ็พพลิเคชัน: public interface IUserRepository { Task<IEnumerable<User>> GetAllAsync(); } ตามคำนิยามของหนังสือสิ่งที่เป็นนามธรรมคือสิ่งที่เป็นนามธรรมที่ได้รับการออกแบบมาโดยเฉพาะในใจนามธรรมเพื่อให้รายละเอียดของการดำเนินการ "รั่ว" ผ่านสิ่งที่เป็นนามธรรมเอง คำถามของฉันมีดังต่อไปนี้: เราสามารถพิจารณาอินเทอร์เฟซที่ออกแบบโดยคำนึงถึง async เช่น IUserRepository เป็นตัวอย่างของ Leaky Abstraction ได้หรือไม่? แน่นอนว่าการใช้งานที่เป็นไปไม่ได้ทั้งหมดมีบางอย่างที่เกี่ยวข้องกับ asynchrony: มีเพียงการติดตั้งแบบไม่ใช้กระบวนการ (เช่นการใช้ SQL) แต่การเก็บข้อมูลในหน่วยความจำไม่จำเป็นต้องใช้แบบอะซิงโครนัส ยากถ้าอินเทอร์เฟซถูกเปิดเผยเมธอด async ตัวอย่างเช่นคุณอาจต้องส่งคืนสิ่งที่ต้องการเช่น Task.CompletedTask หรือ Task.FromResult (ผู้ใช้) ในการประยุกต์ใช้เมธอด) คุณคิดยังไงเกี่ยวกับที่ ?

13 c#  object-oriented  api-design  interfaces  dependency-injection 

ในการออกแบบการขับเคลื่อนโดเมน Domain Layer สามารถมีบริการ (ดั้งเดิม) หลายอย่าง ตัวอย่างเช่นสำหรับโดเมนผู้ใช้เราอาจมี: UserFactory ที่สร้างวัตถุผู้ใช้ด้วยวิธีที่ต่างกัน UserRepository ซึ่งรับผิดชอบในการโต้ตอบกับ Persistence Services ในชั้นโครงสร้างพื้นฐาน UserService ใน Domain Layer นั้นเป็นเพียงแค่ผู้ไกล่เกลี่ยและ / หรือส่วนหน้าของบริการทั้งสองและโครงสร้างพื้นฐานของเลเยอร์หรือมีมากกว่านั้นหรือไม่

13 object-oriented  object-oriented-design  domain-driven-design 

การแยกฟังก์ชั่นลงในวิธีการหรือฟังก์ชั่นเป็นสิ่งจำเป็นสำหรับรหัสแบบแยกส่วนการอ่านและการทำงานร่วมกันโดยเฉพาะอย่างยิ่งใน OOP แต่นี่หมายถึงจะมีการเรียกใช้ฟังก์ชันเพิ่มเติม การแยกรหัสของเราออกเป็นวิธีการหรือฟังก์ชั่นส่งผลกระทบต่อประสิทธิภาพการทำงานในภาษา* สมัยใหม่ได้อย่างไร? * รายการยอดนิยม: C, Java, C ++, C #, Python, JavaScript, Ruby ...

13 object-oriented  programming-languages  performance 

การใช้งานทั่วไปของแหล่งเก็บข้อมูล DDD ดูไม่ OO มากเช่นsave()วิธีการ: package com.example.domain; public class Product { /* public attributes for brevity */ public String name; public Double price; } public interface ProductRepo { void save(Product product); } ส่วนโครงสร้างพื้นฐาน: package com.example.infrastructure; // imports... public class JdbcProductRepo implements ProductRepo { private JdbcTemplate = ... public void save(Product …

12 design-patterns  object-oriented  domain-driven-design 

ดังนั้นฉันสังเกตเห็นว่าเป็นไปได้ที่จะหลีกเลี่ยงการใส่ฟังก์ชั่นส่วนตัวไว้ในส่วนหัวโดยทำสิ่งนี้: // In file pred_list.h: class PredicateList { int somePrivateField; friend class PredicateList_HelperFunctions; public: bool match(); } // In file pred_list.cpp: class PredicateList_HelperFunctions { static bool fullMatch(PredicateList& p) { return p.somePrivateField == 5; // or whatever } } bool PredicateList::match() { return PredicateList_HelperFunctions::fullMatch(*this); } ฟังก์ชั่นส่วนตัวไม่เคยประกาศในส่วนหัวและผู้บริโภคของชั้นเรียนที่นำเข้าส่วนหัวไม่จำเป็นต้องรู้ว่ามันมีอยู่ นี่เป็นสิ่งจำเป็นหากฟังก์ชันตัวช่วยเป็นเทมเพลต (ทางเลือกคือใส่รหัสเต็มในส่วนหัว) ซึ่งเป็นวิธีที่ฉัน "ค้นพบ" สิ่งนี้ …

12 design-patterns  object-oriented  c++  encapsulation 

ในระบบของฉันฉันมักทำงานกับรหัสสนามบิน ( "YYZ", "LAX", "SFO"ฯลฯ ) พวกเขามักจะอยู่ในรูปแบบเดียวกันแน่นอน (3 ตัวอักษรแสดงเป็นตัวพิมพ์ใหญ่) โดยทั่วไประบบจะจัดการกับ 25-50 ของรหัส (ต่างกัน) ต่อคำขอ API ด้วยการจัดสรรรวมกว่าพันรายการระบบจะส่งผ่านแอปพลิเคชันของเราหลายเลเยอร์และเปรียบเทียบกับความเท่าเทียมกันบ่อยครั้ง เราเริ่มต้นด้วยการส่งสายไปรอบ ๆ ซึ่งใช้งานได้ดี แต่เราก็สังเกตเห็นข้อผิดพลาดในการเขียนโปรแกรมจำนวนมากได้อย่างรวดเร็วโดยการส่งรหัสผิดไปที่ไหนสักแห่งคาดว่ารหัส 3 หลัก นอกจากนี้เรายังพบปัญหาที่เราควรทำการเปรียบเทียบแบบตัวพิมพ์เล็กและตัวพิมพ์ใหญ่ แต่ไม่ได้ทำให้เกิดข้อบกพร่อง จากนี้ฉันตัดสินใจที่จะหยุดการส่งผ่านสายไปรอบ ๆ และสร้างAirportชั้นเรียนซึ่งมีตัวสร้างเดียวที่ใช้และตรวจสอบรหัสสนามบิน public sealed class Airport { public Airport(string code) { if (code == null) { throw new ArgumentNullException(nameof(code)); } if (code.Length != 3 || …

12 c#  object-oriented  strings 

คำถามนี้เกี่ยวกับเวลาที่จะใช้ส่วนตัวและเมื่อใดควรใช้การป้องกันในชั้นเรียนทำให้ฉันคิด (ฉันจะขยายคำถามนี้ไปยังคลาสและวิธีการขั้นสุดท้ายเนื่องจากมีความเกี่ยวข้องฉันกำลังเขียนโปรแกรมใน Java แต่ฉันคิดว่านี่เกี่ยวข้องกับทุกภาษา OOP) คำตอบที่ได้รับการยอมรับ: กฎง่ายๆคือทำทุกอย่างให้เป็นส่วนตัวที่สุด และอีกหนึ่ง: ทำให้คลาสทั้งหมดจบลงเว้นแต่ว่าคุณจะต้องการคลาสย่อยเหล่านั้นในทันที ทำให้วิธีการทั้งหมดเป็นขั้นสุดท้ายเว้นแต่ว่าคุณจะต้อง subclass และแทนที่พวกเขาทันที ทำพารามิเตอร์เมธอดทั้งหมดให้เป็นที่สุดเว้นแต่คุณจำเป็นต้องเปลี่ยนพารามิเตอร์ภายในเนื้อความของเมธอดซึ่งค่อนข้างน่าอึดอัดใจเกือบทุกครั้ง ค่อนข้างตรงไปตรงมาและชัดเจน แต่ถ้าฉันส่วนใหญ่เขียนไลบรารี่ (Open Source บน GitHub) แทนที่จะเป็นแอพพลิเคชั่น ฉันสามารถตั้งชื่อห้องสมุดและสถานการณ์มากมายได้ที่ไหน ห้องสมุดได้ขยายออกไปอย่างที่นักพัฒนาไม่เคยคิดมาก่อน สิ่งนี้จะต้องทำด้วย "class loader magic" และแฮ็กอื่น ๆ เนื่องจากข้อ จำกัด ในการมองเห็น ไลบรารี่ถูกนำไปใช้ในวิธีที่พวกเขาไม่ได้สร้างขึ้นมา ไม่สามารถใช้ไลบรารีเนื่องจากปัญหาเล็ก ๆ (ข้อผิดพลาดฟังก์ชันการทำงานที่ขาดหายไปพฤติกรรม "ผิด") ที่ไม่สามารถเปลี่ยนแปลงได้เนื่องจากการมองเห็นลดลง ปัญหาที่ไม่สามารถแก้ไขได้นำไปสู่การแก้ไขปัญหาขนาดใหญ่ที่น่าเกลียดและบั๊กกี้ซึ่งการแทนที่ฟังก์ชั่นที่เรียบง่าย และฉันก็เริ่มตั้งชื่อเหล่านี้จนกระทั่งคำถามยาวเกินไปและฉันตัดสินใจที่จะลบออก ฉันชอบความคิดที่ว่าไม่มีโค้ดเกินความจำเป็นการมองเห็นได้มากกว่าที่จำเป็นและสิ่งที่เป็นนามธรรมมากกว่าที่จำเป็น และสิ่งนี้อาจใช้ได้เมื่อเขียนแอปพลิเคชันสำหรับผู้ใช้ปลายทางโดยที่รหัสจะถูกใช้โดยผู้ที่เขียนเท่านั้น แต่สิ่งนี้จะเกิดขึ้นได้อย่างไรหากผู้พัฒนารายอื่นใช้โค้ดนี้ในกรณีที่เป็นไปไม่ได้ที่ผู้พัฒนาดั้งเดิมจะนึกถึงกรณีการใช้งานที่เป็นไปได้ล่วงหน้าและการเปลี่ยนแปลง / การสร้างซ้ำนั้นยาก / เป็นไปไม่ได้ เนื่องจากไลบรารีโอเพ่นซอร์สขนาดใหญ่ไม่ใช่สิ่งใหม่อะไรคือวิธีที่พบได้บ่อยที่สุดในการจัดการการมองเห็นในโครงการดังกล่าวด้วยภาษาเชิงวัตถุ

12 object-oriented  language-agnostic  open-source 

มันยุติธรรมที่จะบอกว่ามันเป็นวิธีที่ดีในการเริ่มต้นทุกอย่างให้privateล่วงหน้าเมื่อเขียนโค้ดบางอย่าง? จากนั้นอัปเกรดprotectedเป็นคลาสย่อยเท่านั้นpublicหากต้องการคลาสอื่นหรือไม่

12 java  design-patterns  object-oriented  encapsulation 

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

12 object-oriented  memory  language-features  smalltalk 

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

12 object-oriented  code-smell  coding-style 

คำถามของฉันเกี่ยวกับกรณีพิเศษของ Animal super class ฉันAnimalสามารถและ moveForward()eat() SealAnimalขยาย DogAnimalขยาย และมีสิ่งมีชีวิตพิเศษที่ยังขยายที่เรียกว่าAnimalHuman Humanใช้วิธีการspeak()(ไม่ได้ใช้Animal) ในการใช้วิธีนามธรรมซึ่งยอมรับAnimalฉันต้องการใช้speak()วิธี ดูเหมือนว่าจะเป็นไปไม่ได้หากไม่มีการลดทอนลง Jeremy Miller เขียนไว้ในบทความของเขาว่ามีกลิ่นเหม็น อะไรจะเป็นวิธีการแก้ปัญหาเพื่อหลีกเลี่ยง downcasting ในสถานการณ์นี้?

12 java  object-oriented  type-casting