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

หนึ่งในคุณสมบัติที่เสนอสำหรับ "Project Coin" ของ Java 7 คือ "โอเปอเรเตอร์ Elvis" รายงานนำเสนอ 2,009 JavaOneโครงการเหรียญอธิบายว่ามันเป็นเช่น: หนึ่งใน "คุณสมบัติเล็ก ๆ " ที่กล่าวถึงในงานนำเสนอนี้คือสิ่งที่เรียกว่า "ผู้ดำเนินการ Elvis" ซึ่งเป็นผู้ประกอบการรุ่นที่สั้นกว่า ฉันพบว่าตัวเองขาดคุณสมบัติบางอย่างของ Groovy เมื่อใช้ Java แบบดั้งเดิมและนี่จะเป็นโอเปอเรเตอร์เดียวที่ฉันสามารถใช้ได้ทั้งสองภาษาหากมีการเพิ่มเข้ามา โอเปอเรเตอร์ "Elvis" มีประโยชน์สำหรับการระบุค่าเริ่มต้นที่สามารถใช้เมื่อนิพจน์ที่ประเมินเป็นโมฆะ เช่นเดียวกับโอเปอเรเตอร์ที่ปลอดภัยของ Groovy มันเป็นวิธีรัดกุมในการระบุวิธีหลีกเลี่ยงค่า null ที่ไม่จำเป็น ฉันบล็อกก่อนหน้านี้เกี่ยวกับวิธีที่ฉันต้องการหลีกเลี่ยง NullPointerException ในขณะที่แง่มุมอื่น ๆ ของ Project Coin ถูกนำไปใช้ในท้ายที่สุด เหตุใด Elvis Operator จึงปฏิเสธในที่สุดแม้ว่าจะถูกนำเสนอที่ JavaOne ในฐานะผู้สมัครที่น่าจะได้รับการคัดเลือก เพื่อความชัดเจนฉันถามเฉพาะผู้ดำเนินการนี้และเหตุผลที่ถูกปฏิเสธเนื่องจากเป็นส่วนหนึ่งของ "Project Coin" …

10 java  api-design 

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

10 java  patterns-and-practices  versioning  project-structure  dependencies 

ฉันกำลังติดตามคำถามนี้แต่ฉันเปลี่ยนโฟกัสจากโค้ดเป็นหลักการ จากความเข้าใจของฉันเกี่ยวกับหลักการทดแทน Liskov (LSP) ไม่ว่าวิธีการใดที่อยู่ในคลาสพื้นฐานของฉันพวกเขาจะต้องดำเนินการในคลาสย่อยของฉันและตามหน้านี้หากคุณแทนที่วิธีในคลาสพื้นฐานและไม่ทำอะไรเลย คุณกำลังละเมิดหลักการ ตอนนี้ปัญหาของฉันสามารถสรุปได้เช่นนี้ฉันมีนามธรรมWeapon classและสองชั้นและSword ReloadableหากReloadableมีข้อมูลเฉพาะที่methodเรียกว่าReload()ฉันจะต้องลดความเร็วเพื่อเข้าถึงmethodและถ้าคุณต้องการหลีกเลี่ยงปัญหานั้น Strategy Patternจากนั้นผมก็คิดของการใช้ วิธีนี้แต่ละอาวุธเป็นเพียงตระหนักถึงการกระทำที่มีความสามารถในการดำเนินการดังนั้นสำหรับตัวอย่างเช่นReloadableอาวุธอย่างเห็นได้ชัดสามารถโหลด แต่ไม่สามารถและไม่ได้ตระหนักถึงSword Reload class/methodตามที่ระบุไว้ในโพสต์ Stack Overflow ของฉันฉันไม่จำเป็นต้องลดความเร็วและฉันสามารถเก็บList<Weapon>สะสม ในฟอรัมอื่นคำตอบแรกที่แนะนำเพื่อให้SwordระวังReloadเพียงไม่ทำอะไรเลย ได้รับคำตอบเดียวกันนี้ในหน้า Stack Overflow ที่ฉันลิงค์ไปด้านบน ฉันไม่เข้าใจว่าทำไม ทำไมการละเมิดหลักการและอนุญาตให้ Sword ต้องระวังReloadและปล่อยให้มันว่างเปล่า อย่างที่ฉันบอกไว้ในโพสต์ Stack Overflow SP จะแก้ปัญหาของฉันได้ค่อนข้างมาก ทำไมมันไม่เป็นทางออกที่ทำงานได้? public final Weapon{ private final String name; private final int damage; private final List<AttackStrategy> validactions; private final …

10 java  design-patterns  inheritance 

แม้ว่าเอกสาร Javaระบุว่าลำดับที่อ่อนแอเป็นหลักสำหรับกำลังยอมรับแมปคุณจะพบจำนวนมาก , หลาย , หลายคนบนอินเทอร์เน็ตระบุว่า WeakHashMap ที่สมบูรณ์แบบสำหรับการจัดเก็บข้อมูลเมตาของวัตถุในช่วงชีวิตของมัน แต่ไม่มีใครรบกวนจิตใจที่จะทำให้เข้าใจและเหมาะสมตัวอย่างเช่น การใช้ WeakHashMap เพื่อเพิ่มคุณสมบัติบางอย่างของวัตถุหรือเก็บข้อมูลเมตาให้กับฉันเช่นการตัดสินใจตามอำเภอใจตามความตั้งใจที่จะใช้สิ่งแช่ง ในคำอื่น ๆ - เป็นการออกแบบที่ไม่ดี ฉันเข้าใจว่ามีสถานการณ์ที่การสืบทอดอาจไม่พร้อมใช้งาน (คลาสสุดท้ายอินเทอร์เฟซ) แต่สิ่งที่เกี่ยวกับการแต่ง ฉันไม่สามารถนึกถึงตัวอย่างหนึ่งที่องค์ประกอบจะไม่มีตัวเลือก และแน่นอนว่าเป็นสิ่งที่ดีกว่าเพราะมันขึ้นอยู่กับหลักการที่ดีขึ้นแทนที่จะเป็น "การเล่นโวหารของภาษา" ดังนั้นมีสถานการณ์ที่จะดีกว่าที่จะใช้การอ้างอิงที่อ่อนแอแทนการเรียบง่าย? ถ้าไม่ทำไมทุกคนบนอินเทอร์เน็ตดูเหมือนผิดพลาด?

10 java  inheritance  composition  metadata 

พื้นหลัง ฉันกำลังอ่าน "หนังสือรหัสสะอาด" และใน paralel ฉันกำลังทำงานกับวัตถุแบบคาลินิเทนิกกะตะเช่นบัญชีธนาคารและฉันติดอยู่กับกฎนั้น: กฎข้อที่ 9 ของวัตถุแบบคาลิสฟีนิกคือเราไม่ใช้ทะลุหรือเซ็ตเตอร์ ดูเหมือนจะสนุกมากและฉันเห็นด้วยกับหลักการนี้ ยิ่งไปกว่านั้นที่หน้า 98-99 ของ Clean Code ผู้เขียนอธิบายว่า getters / setters ทำลายสิ่งที่เป็นนามธรรมและเราไม่ต้องถามวัตถุของเรา แต่เราต้องบอกวัตถุของเรา มันทำให้รู้สึกที่สมบูรณ์แบบในใจของฉันและฉันเห็นด้วยกับหลักการนี้อย่างเต็มที่ ปัญหาเกิดขึ้นในทางปฏิบัติ บริบท ตัวอย่างเช่นฉันมีแอปพลิเคชันที่ฉันจะต้องแสดงรายชื่อผู้ใช้บางส่วนและเพื่อแสดงรายละเอียดผู้ใช้ ผู้ใช้ของฉันประกอบด้วย: -> Name --> Firstname --> String --> Lastname --> String -> PostalAddress --> Street --> String --> PostalCode --> String ปัญหา ฉันจะทำอย่างไรหรือฉันจะทำอย่างไรเพื่อหลีกเลี่ยง getters เมื่อฉันเพียงต้องการแสดงข้อมูลอย่างง่าย …

10 java  clean-code  software-craftsmanship 

ฉันกำลังใช้SonarLint สำหรับ Eclipseตั้งแต่เมื่อเร็ว ๆ นี้และมันช่วยฉันได้มาก อย่างไรก็ตามมันทำให้ฉันมีคำถามเกี่ยวกับความซับซ้อนของวัฏจักร SonarLint ถือว่า CC ที่ยอมรับได้ของ 10 และมีบางกรณีที่ฉันเกินกว่านั้นประมาณ 5 หรือ 6 หน่วย ชิ้นส่วนเหล่านั้นเกี่ยวข้องกับตัวทำแผนที่ที่ค่าอาศัยตัวแปรที่แตกต่างกันตัวอย่างเช่น ฟิลด์ A อาศัยสตริง sA; ฟิลด์ B อาศัยสตริง sB; ฟิลด์ C อาศัย String sC; ฯลฯ ... ฉันไม่มีทางเลือกอื่นที่วางifสำหรับแต่ละฟิลด์ นี่ไม่ใช่ตัวเลือกของฉัน (โชคดี) แต่เป็นระบบที่ซับซ้อนและมีอยู่แล้วที่ฉันไม่สามารถเปลี่ยนแปลงได้ด้วยตัวเอง หลักของคำถามของฉันคือเหตุผลที่มันเป็นสิ่งสำคัญมากที่จะได้มีซีซีสูงเกินไปในวิธีการเดียว ? หากคุณย้ายเงื่อนไขบางอย่างของคุณในวิธีย่อยอย่างน้อยหนึ่งวิธีเพื่อลดความซับซ้อนมันไม่ลดค่าใช้จ่ายโดยรวมของฟังก์ชั่นของคุณมันเป็นเพียงการเคลื่อนย้ายปัญหาที่อื่นฉันเดา? (ขออภัยในความผิดพลาดเล็กน้อยหากมี) แก้ไข คำถามของฉันไม่ได้อ้างถึงความซับซ้อนของวัฏจักรโลก แต่มีเพียงความซับซ้อนของวิธีการเดียวและวิธีการแยก (ฉันมีเวลาคร่าวๆอธิบายสิ่งที่ฉันหมายถึงขอโทษ) ฉันถามว่าเพราะเหตุใดจึงอนุญาตให้แบ่งเงื่อนไขของคุณเป็นวิธีที่เล็กกว่าถ้ามันยังเป็นของ 'วิธีสุดยอด' ซึ่งจะดำเนินการทุกวิธีย่อยจึงเพิ่มความซับซ้อนให้อัลกอริทึม อย่างไรก็ตามลิงค์ที่สอง ( เกี่ยวกับ …

10 java  eclipse  methods  cyclomatic-complexity 

ฉันใหม่สำหรับการเขียนโปรแกรมเชิงวัตถุและฉันไม่เข้าใจว่าจุดประสงค์หลักของอะไร ใช่ฉันอ่านว่ามันเป็น "จุดเริ่มต้น" ของโปรแกรม แต่สิ่งที่ฉันไม่เข้าใจคือสิ่งที่ควรจะเป็นในหลัก และความรับผิดชอบของมันคืออะไร? อาจเกิดขึ้นว่าสิ่งที่เขียนในหลักอาจถูกห่อหุ้มในวัตถุอื่น แต่คุณควรใช้วิธีการนี้มากแค่ไหน? นี่คือหลักแรกของฉันที่ฉันเขียนใน Java มันง่ายมาก แต่อาจทำให้คุณเข้าใจข้อสงสัยของฉันดีขึ้น ฉันมีสัตว์ที่เป็นนามธรรมซึ่งขยายโดย "Cat" และ "Dog" ฉันใช้หลักในการสร้างวัตถุบางอย่างและยังเป็น "ส่วนต่อประสาน" กับผู้ใช้ด้วยอย่างที่คุณเห็นฉันใช้คำสั่งแบบมีเงื่อนไขเพื่อ "ถามผู้ใช้" สิ่งที่เขาต้องการจะทำ คำถามของฉันเกิดขึ้นจากความจริงที่ว่าอินเทอร์เฟซสามารถถูกห่อหุ้มในวัตถุอื่นและไม่ให้ความรับผิดชอบหลัก public static void main(String[] args) { Scanner input = new Scanner(System.in); System.out.println("What type of animal do you want to create? \n dog cat"); String type = input.nextLine(); if …

10 java  object-oriented  programming-practices  single-responsibility  entry-point 

เมื่อฉันเรียกว่าStream.sort(..)มีอาร์เรย์ขององค์ประกอบใหม่ที่สร้างขึ้นและสตรีม iterates มากกว่าอาร์เรย์ที่เรียงใหม่ที่สร้างขึ้น? กล่าวอีกนัยหนึ่งว่า Java 8 Stream ทำsortอะไรได้บ้าง?

10 java  java8  stream-processing 

เมื่อเขียนสิ่งที่สร้างวัตถุขนาดเล็กจำนวนมาก (1,000s) บ่อยครั้งคุณควรพยายามลดประสิทธิภาพการทำงานลงหรือไม่ โดยเฉพาะอย่างยิ่งหากคุณไม่ทราบว่าระบบนั้นจะทำงานบนเดสก์ท็อประดับต่ำถึงสูงหรือแม้แต่มือถือ สำหรับมือถือฉันได้ยินมาว่าการสร้างวัตถุจำนวนมากเป็นอุปสรรคต่อประสิทธิภาพการทำงานที่ดีแม้ว่าฉันจะไม่รู้ว่ามันเป็นความจริงแค่ไหน ฉันมีตัวอย่างที่แสดงความคิดนี้ได้ดี drawPixel(Point)ในโปรแกรมกราฟิกบอกว่ามีวิธีการที่จะใช้สำหรับการวาดภาพทั้งหมดที่เรียกว่านึกคิด อาจมีการสร้างคะแนน 1,000 คะแนนและอาจเกิดซ้ำบ่อยเช่นในเกมที่สามารถเรียก 60+ ครั้งต่อวินาที หรือdrawPixel(int x, int y)อาจใช้เพื่อลดการสร้างออบเจ็กต์ Point จำนวนมาก ในการออกแบบเชิงวัตถุฉันคิดว่าการใช้ Point น่าจะเหมาะสมกว่า อย่างไรก็ตามการใช้ประเภทดั้งเดิมอาจเพิ่มประสิทธิภาพ การเพิ่มประสิทธิภาพอาจไม่ได้ผลในกรณีส่วนใหญ่ แต่ฉันไม่แน่ใจเกี่ยวกับสิ่งต่าง ๆ เช่นโทรศัพท์มือถือหรือเครื่องรุ่นเก่า ประสิทธิภาพการทำงานเพิ่มขึ้นจากการทำอะไรแบบนี้และมันเป็นสิ่งที่ควรนำมาพิจารณาด้วย?

10 java  performance  optimization 

ในหนังสือเรียนที่ฉันกำลังมองหาชั้นเรียนมีการระบุคำสั่งสามารถว่างเปล่า (คำสั่งโมฆะ) คำสั่ง null ถูกกำหนดเป็นเซมิโคลอน มันไม่ทำอะไรเลยในเวลาดำเนินการ คำสั่ง null ใช้ไม่ค่อย ในฐานะโปรแกรมเมอร์ที่มีประสบการณ์ในระดับปานกลางฉันพบว่ามันน่าสนใจที่พวกเขาพูดว่าไม่ค่อยได้ใช้นี่เป็นนัยที่บางแห่งมีประโยชน์สำหรับมัน สิ่งที่อาจเป็นการใช้คำสั่งดังกล่าวหรือไม่

10 java 

ฉันยังใหม่กับ Java และได้อ่านเอกสารเกี่ยวกับข้อยกเว้น และโดยเฉพาะอย่างยิ่งข้อยกเว้นที่ไม่ได้ตรวจสอบ -หน้าการโต้เถียง บรรทัดล่างพูดว่า: หากลูกค้าสามารถคาดว่าจะกู้คืนจากข้อยกเว้นให้มันเป็นข้อยกเว้นที่ตรวจสอบ หากลูกค้าไม่สามารถทำอะไรเพื่อกู้คืนจากข้อยกเว้นให้เป็นข้อยกเว้นที่ไม่ได้ตรวจสอบ ฉันไม่เข้าใจบทความ “ การโต้เถียง” คืออะไรเกี่ยวกับ? คุณอธิบายมันด้วยคำง่าย ๆ ได้ไหม?

10 java  api-design  exceptions 

พิจารณาสถานการณ์ที่คลาสใช้พฤติกรรมพื้นฐานวิธีการและอื่น ๆ แต่คลาสที่แตกต่างกันของคลาสนั้นอาจมีอยู่สำหรับการใช้ที่แตกต่างกัน ในกรณีเฉพาะของฉันฉันมีเวกเตอร์ (เวกเตอร์เรขาคณิตไม่ใช่รายการ) และเวกเตอร์นั้นสามารถใช้ได้กับพื้นที่ยูคลิดมิติ N- มิติใด ๆ (1 มิติ, 2 มิติ, ... ) คลาส / ประเภทนี้สามารถกำหนดได้อย่างไร? นี่จะเป็นเรื่องง่ายใน C ++ ที่เทมเพลตของคลาสสามารถมีค่าจริงเป็นพารามิเตอร์ได้ แต่เราไม่มีความหรูหราใน Java ทั้งสองวิธีที่ฉันสามารถคิดได้ว่าสามารถนำมาใช้เพื่อแก้ปัญหานี้คือ: มีการดำเนินการของแต่ละกรณีที่เป็นไปได้ในเวลารวบรวม public interface Vector { public double magnitude(); } public class Vector1 implements Vector { public final double x; public Vector1(double x) { this.x = …

10 java  design-patterns  code-generation 

Java เป็นเชิงวัตถุ แต่ทำไมเราต้องสร้างวัตถุจาก Scanner Class เพื่อรับอินพุต next()ยกตัวอย่างเช่นเมธอดไม่สามารถเป็นแบบคงที่ได้หรือไม่ C ดูเหมือนผมสวยเรียบง่ายที่คุณเพียงแค่ใช้scanf(), หรือgets() fgets()ฉันแน่ใจว่ามีเหตุผลสำหรับนักพัฒนา Java ในการสร้างคลาสสแกนเนอร์ แต่จะดีกว่าแค่มีฟังก์ชั่นปกติในการทำงานอย่างไร ฉันพบลิงค์นี้ที่อาจดูเหมือนถามคำถามเดียวกัน แต่คำตอบนั้นใกล้เคียงกัน "คุณต้องสร้างวัตถุเพราะไม่คงที่" ... ฉันเดา: เนื่องจาก Java เป็น Object Oriented พวกเขาตัดสินใจที่จะใส่วิธีการป้อนข้อมูลทั้งหมดในชั้นเรียน พวกเขาไม่ได้ทำวิธีการคงที่เพื่อให้คุณสามารถมีแหล่งที่แตกต่างกันทุกชนิด (คีย์บอร์ดอินพุตไฟล์อินพุต ... ) ในวัตถุที่แตกต่างกันอย่างไร ฉันจะขอบคุณถ้ามีคนสามารถแก้ไขคำถามเพื่อให้ชัดเจนยิ่งขึ้น!

10 java  object-oriented 

ฉันเพิ่งอ่านเกี่ยวกับ@ImplementedByคำอธิบายประกอบที่มีอยู่ในGoogle Guice อนุญาตให้โปรแกรมเมอร์ระบุการเชื่อมโยงระหว่างอินเตอร์เฟสและการนำไปใช้เพื่อใช้ในอนาคตในการฉีดพึ่งพา มันเป็นตัวอย่างของหนึ่งเพียงในเวลาที่มีผลผูกพัน ฉันค่อนข้างคุ้นเคยกับการกำหนดการผูกอย่างชัดเจนในโมดูลของฉันโดยใช้ไวยากรณ์ต่อไปนี้: bind(SomeInterface.class).to(SomeInterfaceImplementation.class); ตามเอกสารนี้เทียบเท่ากับการใช้@ImplementedByคำอธิบายประกอบต่อไปนี้: @ImplementedBy(SomeInterfaceImplementation.class) public interface SomeInterface { //method declarations } กำไรเดียวที่ฉันเห็นที่นี่คือรหัสสั้นลงเล็กน้อย ในเวลาเดียวกันวิธีการนี้มีข้อเสียเปรียบชี้ให้เห็นอย่างถูกต้องโดยเอกสารเดียวกัน: ใช้@ImplementedByอย่างระมัดระวัง มันเพิ่มการพึ่งพาเวลารวบรวมจากอินเทอร์เฟซเพื่อการใช้งาน การพึ่งพาดังกล่าวอาจไม่เป็นปัญหาในหลายกรณี แต่โดยส่วนตัวแล้วฉันเห็นว่ามันเป็นกลิ่นรหัส กรณีการใช้งานใดที่ทำให้การเพิ่มความคิดเห็นมี@ImplementedByค่าควรใช้ วิธีหนึ่งที่เป็นไปได้คือการใช้มันในโค้ดของไลบรารีหรือกรอบงาน ดังที่อธิบายไว้ในเอกสารคำอธิบายประกอบสามารถจัดเตรียมการโยงดีฟอลต์ได้ง่าย ๆ หากประเภทอยู่ในทั้งสองbind()คำสั่ง (เป็นอาร์กิวเมนต์แรก) และมี@ImplementedByคำอธิบายประกอบคำbind()สั่งจะถูกนำมาใช้ คำอธิบายประกอบแนะนำการใช้งานเริ่มต้นที่สามารถแทนที่ด้วยการผูก ด้วยวิธีนี้ในฐานะนักพัฒนาของห้องสมุดฉันสามารถให้ผู้ใช้ของฉันมีส่วนร่วมนอกกรอบที่สามารถปรับแต่งที่ไหนสักแห่งในรหัสลูกค้า นี่เป็นเหตุผลเดียวที่มีคำอธิบายประกอบอยู่หรือไม่ หรือมีบางอย่างที่ฉันขาดหายไป? ฉันจะได้อะไรจากการใช้มันในโค้ดที่เป็นเพียงแอปพลิเคชันที่ดูแลตรรกะทางธุรกิจบางอย่างและไม่สามารถขยายไลบรารี / กรอบงานได้หรือไม่?

10 java  dependency-injection 

ดังนั้นฉันเพิ่งทำ refactorings สำคัญบางอย่างกับรหัสของฉัน หนึ่งในสิ่งสำคัญที่ฉันพยายามทำคือแยกชั้นเรียนออกเป็นวัตถุข้อมูลและวัตถุผู้ปฏิบัติงาน สิ่งนี้ได้รับแรงบันดาลใจเหนือสิ่งอื่นใดตามมาตราของClean Code นี้ : ผสมผสาน ความสับสนนี้บางครั้งนำไปสู่โครงสร้างข้อมูลแบบไฮบริดที่โชคร้ายนั่นคือวัตถุครึ่งหนึ่งและโครงสร้างข้อมูลครึ่งหนึ่ง พวกเขามีฟังก์ชั่นที่ทำสิ่งที่สำคัญและพวกเขายังมีตัวแปรสาธารณะหรือสาธารณะ accessors และ mutators ที่สำหรับทุก intents และวัตถุประสงค์ทำให้ตัวแปรส่วนตัวสาธารณะสาธารณะดึงดูดฟังก์ชั่นภายนอกอื่น ๆ ที่จะใช้ตัวแปรเหล่านั้นวิธีที่โปรแกรมขั้นตอนจะใช้ โครงสร้างข้อมูล. ลูกผสมดังกล่าวทำให้ยากที่จะเพิ่มฟังก์ชั่นใหม่ แต่ก็ทำให้มันยากที่จะเพิ่มโครงสร้างข้อมูลใหม่ พวกเขาเลวร้ายที่สุดของทั้งสองโลก หลีกเลี่ยงการสร้างพวกเขา พวกเขาบ่งบอกถึงการออกแบบที่ยุ่งเหยิงซึ่งผู้เขียนไม่แน่ใจหรือแย่กว่านั้นไม่รู้ว่าพวกเขาต้องการการปกป้องจากฟังก์ชั่นหรือประเภทใด เมื่อเร็ว ๆ นี้ฉันกำลังดูรหัสไปยังหนึ่งในวัตถุงานของฉัน (ที่เกิดขึ้นกับรูปแบบผู้เข้าชม ) และเห็นสิ่งนี้: @Override public void visit(MarketTrade trade) { this.data.handleTrade(trade); updateRun(trade); } private void updateRun(MarketTrade newTrade) { if(this.data.getLastAggressor() != newTrade.getAggressor()) { this.data.setRunLength(0); …

10 java  object-oriented-design  data-structures  clean-code  code-smell