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

ฉันกำลังพัฒนา RESTful API และฉันคิดว่ามันสะดวกที่จะใช้ DAO สำหรับทรัพยากรของฉันเพราะแม้ว่าฉันจะใช้หน่วยความจำเพื่อเก็บไว้ แต่ฉันไม่ต้องการปิดประตูให้ใครก็ตามที่ใช้ห้องสมุดของฉันถ้าพวกเขาตัดสินใจที่จะใช้ การใช้ฐานข้อมูลสำหรับ DAO คำถามของฉันคือว่า DAO ควรเป็นซิงเกิลตันหรือไม่ หากไม่ใช่บริการจะมีตัวอย่างของ DAO และจะมีลักษณะเช่นนี้: @Path("eventscheduler") public class EventSchedulerService { private IEventSchedulerDao dao = new EventSchedulerDao(); // in case a different implementation is to be used public void setEventSchedulerDao(IEventSchedulerDao dao) { this.dao = dao; } @Path("{uniqueName}") @GET @Produces(MediaType.APPLICATION_JSON) public Tournament …

14 java  design  design-patterns  singleton  dao 

ฉันเปลี่ยนมาใช้ Java จาก C # หลังจากได้รับคำแนะนำจาก CodeReview ดังนั้นเมื่อฉันมองไปที่ LWJGL สิ่งหนึ่งที่ฉันจำได้ก็คือทุกการเรียกจะDisplayต้องดำเนินการในเธรดเดียวกันกับDisplay.create()วิธีที่เรียกใช้ เมื่อนึกถึงสิ่งนี้ฉันได้สร้างคลาสที่มีลักษณะเช่นนี้ขึ้นมา public class LwjglDisplayWindow implements DisplayWindow { private final static int TargetFramesPerSecond = 60; private final Scheduler _scheduler; public LwjglDisplayWindow(Scheduler displayScheduler, DisplayMode displayMode) throws LWJGLException { _scheduler = displayScheduler; Display.setDisplayMode(displayMode); Display.create(); } public void dispose() { Display.destroy(); } @Override public …

14 java 

ฉันกำลังเขียนการทดสอบหน่วย JUnit สำหรับชั้นเรียนของฉัน มันจะดีกว่าถ้ามีคลาสแยกสำหรับแต่ละวิธีหรือมีคลาสทดสอบเพียงหนึ่งสำหรับทุกคลาสจริง

14 java  object-oriented  unit-testing  testing  junit 

ใน Java โดย getter การประชุมและตั้งค่าสำหรับเขตข้อมูลแบบบูลจะเป็นและisField() setField()นี้ทำงานได้อย่างสมบูรณ์ดีกับชื่อเขตที่มีคำคุณศัพท์ชอบactive, visible, closedฯลฯ แต่ฉันจะตั้งชื่อฟิลด์ที่มีความหมายของคำกริยาได้haveChildrenอย่างไร เพิ่ม“ _ing” ในคำกริยา ( ) หรืออาจ?havingChildren เพื่อชี้แจงฉันไม่สามารถควบคุมชื่อเมธอด (getter และ setter) เนื่องจากสร้างโดยอัตโนมัติโดย IDE ดังนั้นสิ่งที่ฉันต้องการคือชื่อเขตข้อมูลที่เหมาะสมเพื่อที่ว่าเมื่อ IDE สร้างผู้ทะเยอทะยานมันจะทำให้เกิดความรู้สึก ยกตัวอย่างเช่นhasChildrenเป็นชื่อเขตข้อมูลที่สมบูรณ์แบบ แต่เมื่อ IDE สร้าง getter isHasChildrenสำหรับฟิลด์มันจะ ฉันจะแก้ปัญหานี้ได้อย่างไร

14 java  naming 

ฉันกำลังทำงานในโครงการที่การโทรภายในคลาสเป็นปกติ แต่ผลลัพธ์จะมีค่าง่าย ๆ หลายครั้ง ตัวอย่าง ( ไม่ใช่รหัสจริง ): public boolean findError(Set<Thing1> set1, Set<Thing2> set2) { if (!checkFirstCondition(set1, set2)) { return false; } if (!checkSecondCondition(set1, set2)) { return false; } return true; } การเขียนการทดสอบหน่วยสำหรับรหัสประเภทนี้นั้นยากมากเพราะฉันแค่ต้องการทดสอบระบบเงื่อนไขและไม่ได้ใช้สภาพจริง (ฉันทำอย่างนั้นในการทดสอบแยก) ในความเป็นจริงมันจะดีกว่าถ้าฉันผ่านฟังก์ชั่นที่ใช้เงื่อนไขและในการทดสอบฉันเพียงแค่ให้ล้อเลียน ปัญหาด้วยวิธีนี้คือความฮือฮาไปนี้เราจะใช้ยาชื่อสามัญมาก วิธีการทำงาน; อย่างไรก็ตามคือการทำให้วัตถุที่ทดสอบเป็นสายลับและเยาะเย้ยการเรียกไปยังฟังก์ชันภายใน systemUnderTest = Mockito.spy(systemUnderTest); doReturn(true).when(systemUnderTest).checkFirstCondition(....); ข้อกังวลที่นี่คือการใช้งาน SUT นั้นมีการเปลี่ยนแปลงอย่างมีประสิทธิภาพและอาจเป็นปัญหาในการทดสอบให้สอดคล้องกับการใช้งาน มันเป็นเรื่องจริงเหรอ? มีวิธีปฏิบัติที่ดีที่สุดในการหลีกเลี่ยงความหายนะของการเรียกใช้เมธอดภายในหรือไม่? โปรดทราบว่าเรากำลังพูดถึงบางส่วนของอัลกอริทึมดังนั้นการแบ่งออกเป็นหลายคลาสอาจไม่ใช่การตัดสินใจที่ต้องการ

14 java  unit-testing 

ฉันพยายามเขียน servlet ซึ่งทำงานตามค่า "การกระทำ" ที่ส่งผ่านไปเป็นอินพุต นี่คือตัวอย่างที่ public class SampleClass extends HttpServlet { public static void action1() throws Exception{ //Do some actions } public static void action2() throws Exception{ //Do some actions } //And goes on till action9 public void doPost(HttpServletRequest req, HttpServletResponse res)throws ServletException, IOException { String action = req.getParameter("action"); …

14 java  design-patterns  object-oriented 

หลายครั้งที่ฉันเห็นคนใช้ตัวพิมพ์ชื่อเรื่องหรือแม้แต่การตั้งชื่อตัวพิมพ์เล็กทั้งหมดสำหรับค่าคงที่ enum ตัวอย่างเช่น: enum Color { red, yellow, green; } สิ่งนี้ทำให้การทำงานกับสตริงเป็นเรื่องง่ายและง่ายthrow new IllegalStateException("Light should not be " + color + ".")ตัวอย่างเช่นถ้าคุณต้องการทำ ดูเหมือนว่าจะยอมรับได้มากกว่านี้ถ้า Enum เป็นprivateแต่ฉันก็ยังไม่ชอบ ฉันรู้ว่าฉันสามารถสร้างตัวสร้าง enum ด้วยเขตข้อมูล String แล้วแทนที่ toString เพื่อคืนชื่อดังกล่าวดังนี้ enum Color { RED("red"), YELLOW("yellow"), GREEN("green"); private final String name; private Color(String name) { this.name = name } @Override …

14 java  conventions  enum 

สำหรับทศวรรษที่ผ่านมาจะได้รับกรณีที่อินเตอร์เฟซได้เพียง เท่านั้น (เท่านั้น) สำหรับการระบุลายเซ็นวิธี เราได้รับการบอกว่านี่เป็น "วิธีการทำสิ่งที่ถูกต้อง" จากนั้น Java 8 ออกมาและพูดว่า: เอ่อเอ่อตอนนี้คุณสามารถกำหนดวิธีการเริ่มต้น ต้องวิ่งลาก่อน ฉันอยากรู้ว่าสิ่งนี้ถูกย่อยโดยนักพัฒนา Java ที่มีประสบการณ์และผู้ที่เริ่มเมื่อเร็ว ๆ นี้ (ไม่กี่ปีที่ผ่านมา) พัฒนามัน ฉันยังสงสัยเกี่ยวกับความเหมาะสมของ Java Orthodoxy และการฝึกฝนอย่างไร ฉันกำลังสร้างรหัสทดลองและในขณะที่ฉันกำลังทำการปรับเปลี่ยนใหม่ฉันลงเอยด้วยอินเทอร์เฟซที่ขยายส่วนต่อประสานมาตรฐาน (Iterable) และเพิ่มวิธีการเริ่มต้นสองวิธี และฉันจะซื่อสัตย์ฉันรู้สึกดีกับมัน ฉันรู้ว่านี่เป็นแบบปลายเปิดเล็ก ๆ น้อย ๆ แต่ตอนนี้มีเวลาสำหรับ Java 8 ที่จะใช้ในโครงการจริงมี orthodoxy รอบการใช้วิธีการเริ่มต้นหรือยัง สิ่งที่ฉันเห็นเป็นส่วนใหญ่เมื่อพูดถึงคือวิธีการเพิ่มวิธีการใหม่ในอินเทอร์เฟซโดยไม่ทำลายผู้บริโภค แต่สิ่งที่เกี่ยวกับการใช้สิ่งนี้ตั้งแต่เริ่มต้นเหมือนตัวอย่างที่ฉันให้ไว้ข้างต้น มีใครประสบปัญหาใด ๆ กับการให้การใช้งานในส่วนต่อประสานของพวกเขา?

13 java  interfaces  default-method 

ฉันกำลังสร้างเกมกระดาน (เช่นหมากรุก) ใน Java ซึ่งแต่ละชิ้นเป็นชนิดของตัวเอง (เช่นPawn, Rookฯลฯ ) สำหรับส่วน GUI ของแอปพลิเคชันฉันต้องการรูปภาพสำหรับแต่ละส่วนเหล่านี้ ตั้งแต่ทำไปคิดเหมือน rook.image(); ละเมิดการแยก UI และตรรกะทางธุรกิจฉันจะสร้างผู้นำเสนอที่แตกต่างกันสำหรับแต่ละชิ้นแล้วแมปประเภทชิ้นส่วนกับผู้นำเสนอที่สอดคล้องกันเช่น private HashMap<Class<Piece>, PiecePresenter> presenters = ... public Image getImage(Piece piece) { return presenters.get(piece.getClass()).image(); } จนถึงตอนนี้ดีมาก อย่างไรก็ตามฉันรู้สึกว่าปรมาจารย์ OOP ที่ชาญฉลาดจะขมวดคิ้วเมื่อเรียกgetClass()วิธีการและแนะนำให้ใช้ผู้เยี่ยมชมเช่นนี้: class Rook extends Piece { @Override public <T> T accept(PieceVisitor<T> visitor) { return visitor.visitRook(this); } } …

13 java  design  object-oriented 

ฉันเพิ่งสังเกตเห็นว่ามีตัวเลือกให้มีวิธีการคงที่ในส่วนต่อประสาน เช่นเดียวกับฟิลด์คงที่ของอินเตอร์เฟสมีพฤติกรรมที่น่าสนใจ: สิ่งเหล่านี้ไม่ได้รับการสืบทอด ฉันไม่แน่ใจว่ามีประโยชน์ใด ๆ ในส่วนต่อประสานที่เกิดขึ้นจริง อย่างไรก็ตามมันทำให้โปรแกรมเมอร์สามารถสร้างส่วนต่อประสานที่เป็นเพียงซองจดหมายสำหรับสิ่งของแบบคงที่เช่นคลาสยูทิลิตี้ ตัวอย่างง่ายๆเป็นเพียงซองจดหมายสำหรับค่าคงที่ทั่วโลก เมื่อเทียบกับชั้นเรียนคุณสามารถสังเกตเห็นว่าแผ่นที่ขาดหายไปpublic static finalนั้นง่ายกว่าที่คิด (ทำให้มันน้อยลง) public interface Constants { String LOG_MESSAGE_FAILURE = "I took an arrow to the knee."; int DEFAULT_TIMEOUT_MS = 30; } คุณสามารถสร้างบางสิ่งที่ซับซ้อนกว่านี้ได้เช่นคีย์หลอกหลอก enum ของ config public interface ConfigKeys { static createValues(ConfigKey<?>... values) { return Collections.unmodifiableSet(new HashSet(Arrays.asList(values))); } static ConfigKey<T> key(Class<T> …

13 java  java8 

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 

ฉันทำงานกับ บริษัท ใหญ่และฉันรับผิดชอบงานจาวาแอพพลิเคชั่นขนาดใหญ่ที่มีการทดสอบ Junit นับพัน ตั้งแต่ฉันย้ายไปที่บทนี้มีการทดสอบแตก 200-300 ครั้ง (น่าจะพังได้หลายปี) การทดสอบนั้นเก่าและเปราะบางและพวกเขากำลังยุ่งเหยิงของการพึ่งพาสปาเก็ตตี้ที่มักจะจบลงด้วยข้อมูลแซนด์บ็อกซ์สด เป้าหมายของฉันคือการผ่านการทดสอบ 100% เพื่อให้เราสามารถสร้างความล้มเหลวในการสร้างหน่วยทดสอบ แต่ฉันไม่สามารถทำได้จนกว่าฉันจะจัดการกับการทดสอบที่เสียหาย ฉันมีงบประมาณน้อยมากเพราะงบประมาณการบำรุงรักษาเป็นสิ่งสำคัญสำหรับการสนับสนุน แต่ทีมของฉันได้ระบุและแก้ไขการทดสอบผลไม้แขวนลอยต่ำ (ส่วนใหญ่เป็นปัญหาการกำหนดค่า / ปัญหาทรัพยากรในท้องถิ่น) และเราลงไปทดสอบที่น่าเกลียด 30-40 อะไรคือความคิดเห็นเกี่ยวกับแนวปฏิบัติที่ดีที่สุด ฉันไม่คิดว่าการทดสอบนั้นมีค่า แต่ฉันก็ไม่รู้ว่าพวกเขากำลังทดสอบอะไรหรือทำไมพวกเขาถึงไม่ทำงานโดยไม่ต้องขุดซึ่งต้องใช้เวลาและเงินที่เราอาจไม่มี ฉันคิดว่าเราควรบันทึกสถานะของการทดสอบที่เสียหายด้วยสิ่งใดก็ตามที่เรารู้จากนั้นลบหรือเพิกเฉยต่อการทดสอบที่เสียหายทั้งหมดและป้อนข้อบกพร่องที่มีลำดับความสำคัญต่ำกว่า / รายการงานเพื่อตรวจสอบและแก้ไข จากนั้นเราจะอยู่ที่ 100% และเริ่มได้รับมูลค่าที่แท้จริงจากการทดสอบอื่น ๆ และหากเรามีโชคลาภการบำรุงรักษา / การปรับโครงสร้างใหม่เราจะสามารถรับได้อีกครั้ง อะไรคือแนวทางที่ดีที่สุด แก้ไข: ฉันคิดว่านี่เป็นคำถามที่แตกต่างจากคำถามนี้เพราะฉันมีทิศทางที่ชัดเจนสำหรับการทดสอบที่เราควรจะเขียนต่อไป แต่ฉันได้รับมรดกการทดสอบที่ล้มเหลวแบบดั้งเดิมที่จะอยู่ก่อนการทดสอบชุดใหญ่ในปัจจุบันจะมีความหมาย

13 java  unit-testing  legacy 

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

13 java  coding-standards  variables 

ฉันใช้ห้องสมุดบุคคลที่สาม พวกเขาส่งPOJOให้ฉันซึ่งอาจนำไปใช้ในจุดประสงค์และวัตถุประสงค์ของเราเช่นนี้: public class OurData { private String foo; private String bar; private String baz; private String quux; // A lot more than this // IMPORTANT: NOTE THAT THIS IS A PACKAGE PRIVATE CONSTRUCTOR OurData(/* I don't know what they do */) { // some stuff } public String getFoo() …

13 java  design  third-party-libraries  constructors 

ฉันโพสต์คำถามนี้ไว้ใน SO แล้วและก็ใช้ได้ มันน่าเสียดายที่ปิด แต่ (ต้องการเพียงหนึ่งโหวตเพื่อเปิดใหม่) แต่มีคนแนะนำให้ฉันโพสต์ไว้ที่นี่เพราะมันเป็นแบบที่ดีกว่าดังนั้นต่อไปนี้เป็นสำเนาวางคำถามอย่างแท้จริง ฉันอ่านความคิดเห็นเกี่ยวกับคำตอบนี้และฉันเห็นข้อความนี้ การสร้างอินสแตนซ์ของวัตถุและคุณสมบัติเชิงวัตถุนั้นรวดเร็วในการใช้งาน (เร็วกว่า C ++ ในหลาย ๆ กรณี) เพราะพวกมันถูกออกแบบมาตั้งแต่ต้น และคอลเลกชันนั้นรวดเร็ว Java มาตรฐานชนะ C / C ++ มาตรฐานในพื้นที่นี้แม้สำหรับรหัส C ที่ปรับให้เหมาะสมที่สุด ผู้ใช้หนึ่งราย (ที่มีตัวแทนที่สูงมากฉันอาจเพิ่ม) ปกป้องข้อเรียกร้องนี้อย่างกล้าหาญโดยระบุว่า การจัดสรรฮีปใน java ดีกว่าของ C ++ และเพิ่มคำสั่งนี้เพื่อป้องกันการรวบรวมใน java และคอลเลกชัน Java นั้นเร็วกว่าคอลเลกชัน C ++ ซึ่งส่วนใหญ่จะเป็นระบบย่อยหน่วยความจำที่แตกต่างกัน ดังนั้นคำถามของฉันอาจเป็นจริงได้และถ้าเป็นเช่นนั้นเหตุใดการจัดสรรฮีปของ Java จึงเร็วขึ้นมาก

13 java  c++  performance  heap  collections