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

Java เป็นภาษาการเขียนโปรแกรมเชิงวัตถุในระดับสูงที่พัฒนาโดย Sun Microsystems ปัจจุบัน Java เป็นเจ้าของโดย Oracle ซึ่งซื้อ Sun ในปี 2010

5
การสืบทอด vs คุณสมบัติเพิ่มเติมที่มีค่า Null
สำหรับคลาสที่มีฟิลด์เป็นตัวเลือกจะดีกว่าถ้าใช้การสืบทอดหรือคุณสมบัติที่เป็นโมฆะ? ลองพิจารณาตัวอย่างนี้: class Book { private String name; } class BookWithColor extends Book { private String color; } หรือ class Book { private String name; private String color; //when this is null then it is "Book" otherwise "BookWithColor" } หรือ class Book { private String name; private Optional<String> color; //when …
12 java  inheritance  class  null 

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

2
อินสแตนซ์ Java 8 Stream ควรจะปิด () เสมอหรือไม่
Quad the Javadoc : สตรีมมีเมธอด BaseStream.close () และใช้ AutoCloseable แต่อินสแตนซ์สตรีมเกือบทั้งหมดไม่จำเป็นต้องปิดจริงหลังการใช้งาน โดยทั่วไปเฉพาะสตรีมที่มีแหล่งที่มาเป็นแชนเนล IO (เช่นที่ส่งคืนโดย Files.lines (Path, Charset)) เท่านั้นที่จะต้องปิด สตรีมส่วนใหญ่ได้รับการสนับสนุนโดยคอลเลกชันอาร์เรย์หรือการสร้างฟังก์ชั่นซึ่งไม่จำเป็นต้องมีการจัดการทรัพยากรพิเศษ (หากกระแสต้องปิดก็สามารถประกาศเป็นทรัพยากรในงบลองกับทรัพยากร) "เกือบทั้งหมด" และ "โดยทั่วไป" นั้นคลุมเครือ - ถ้าคุณกำลังเขียนไลบรารีและคุณกำลังสรุปแหล่งที่มาของสตรีมของคุณจากผู้ใช้สตรีมนั้นคุณต้องถามตัวเองเสมอ - "ฉันควรปิดหรือไม่ นี้?" IO-ได้รับการสนับสนุนสตรีมจะต้องมีการปิดเพราะการดำเนินงานสถานีไม่ได้เรียกcloseเพื่อให้ได้อย่างมีประสิทธิภาพฉันมักจะมีทั้งจำ / เอกสารที่สตรีมของฉันมาจากหรือฉันมักจะต้องcloseมัน ตัวเลือกนิวเคลียร์ที่ฉันคิดว่าน่าจะไม่ส่งคืนสตรีมจากวิธีการหรือยอมรับพารามิเตอร์สตรีมซึ่งเป็นความเชื่อมั่นที่บางคนสะท้อนในทีม JDK ฉันพบว่ามัน จำกัด มากเกินไปเมื่อพิจารณาถึงประโยชน์ในทางปฏิบัติของสตรีม อะไรคือวิธีปฏิบัติที่ดีที่สุดของคุณเกี่ยวกับการปิดสายธาร ฉันดูออนไลน์เพื่อหาคำตอบสำหรับเรื่องนี้จากบางคนของ JDK ที่มักจะใช้งานกับคำถามชุมชนที่คล้ายกัน แต่ไม่พบสิ่งใดที่เกี่ยวข้อง
12 java  resources  java8 

2
UnsupportedOperationException ในอินเตอร์เฟสเฟรมเวิร์กของ Java คอลเล็กชัน
มองผ่าน Java (optional operation)คอลเลกชันกรอบฉันพบค่อนข้างน้อยของอินเตอร์เฟซที่มีการแสดงความคิดเห็น วิธีการเหล่านี้อนุญาตให้นำคลาสไปใช้ผ่านUnsupportedOperationExceptionหากพวกเขาไม่ต้องการใช้วิธีนั้น ตัวอย่างนี้เป็นวิธีการในaddAllSet Interface ตอนนี้ตามที่ระบุไว้ในชุดคำถามนี้อินเทอร์เฟซเป็นสัญญาที่กำหนดสำหรับสิ่งที่ผู้ใช้สามารถคาดหวังได้ อินเทอร์เฟซมีความสำคัญเนื่องจากแยกสิ่งที่คลาสทำจากวิธีการใช้งาน สัญญาที่กำหนดสิ่งที่ลูกค้าสามารถคาดหวังปล่อยให้นักพัฒนาสามารถนำไปใช้ได้ทุกวิธีที่พวกเขาเลือกตราบใดที่พวกเขารักษาสัญญา และ อินเทอร์เฟซคือคำอธิบายของการกระทำที่วัตถุสามารถทำได้ ... ตัวอย่างเช่นเมื่อคุณพลิกสวิตช์ไฟแสงจะสว่างขึ้นคุณไม่สนใจว่ามันจะทำอย่างไร ในการเขียนโปรแกรมเชิงวัตถุอินเทอร์เฟซคือคำอธิบายของฟังก์ชันทั้งหมดที่วัตถุต้องมีเพื่อให้เป็น "X" และ ฉันคิดว่าวิธีการทำงานบนอินเตอร์เฟสนั้นดีกว่าอย่างมาก จากนั้นคุณสามารถเยาะเย้ยการพึ่งพาของคุณได้อย่างดีและทุกอย่างก็น้อยกว่ากันอย่างแน่นหนา จุดประสงค์ของอินเทอร์เฟซคืออะไร อินเตอร์เฟสคืออะไร อินเตอร์เฟส + ส่วนขยาย (มิกซ์อิน) เทียบกับคลาสพื้นฐาน ระบุว่าวัตถุประสงค์ของอินเทอร์เฟซคือการกำหนดสัญญาและทำให้การพึ่งพาของคุณควบคู่กันอย่างอิสระไม่ได้มีวิธีการบางอย่างที่จะUnsupportedOperationExceptionทำลายวัตถุประสงค์ มันหมายความว่าฉันไม่สามารถผ่านSetและใช้งานaddAllได้อีกต่อไป แต่ฉันต้องรู้ว่าSetฉันใช้งานอะไรบ้างฉันจึงสามารถรู้ได้ว่าฉันสามารถใช้addAllหรือไม่ นั่นดูเหมือนจะไร้ค่าสำหรับฉัน แล้วประเด็นUnsupportedOperationExceptionคืออะไร มันเป็นเพียงการสร้างรหัสดั้งเดิมและพวกเขาจำเป็นต้องทำความสะอาดอินเตอร์เฟสของพวกเขา? หรือว่ามันมีจุดประสงค์ที่ละเอียดอ่อนกว่าที่ฉันหลงหายไป?

2
โครงสร้างบรรจุภัณฑ์ของคอลเลกชัน Java (java.util) - ทำไม Iterable sit ใน java.lang
ตามแผนภาพด้านล่างยกเว้นส่วนต่อประสานส่วนIterableที่เหลือทั้งหมดที่สร้างขึ้น (คลาสอินเตอร์เฟส / คลาส / นามธรรม) จะอยู่ในแพ็คเกจเดียวกันjava.util ทำไมต้องIterableนั่งในjava.langแพ็คเกจ? หมายเหตุ: ความตั้งใจคือการทำความเข้าใจกับแง่มุมของบรรจุภัณฑ์ของการเขียนโปรแกรมจาวา

3
การแข่งขันทดสอบหน่วย
นายจ้างของฉันใช้การแข่งขันแบบทดสอบรายวัน หนึ่งวันเต็มจะทุ่มเทให้กับการเขียนแบบทดสอบหน่วย - แน่นอนเราทำการทดสอบเพิ่มเติมตลอดทั้งเดือน แต่นี่เป็นทั้งวัน - และ "ผู้ชนะ" ของการแข่งขันจะได้รับรางวัล อย่างไรก็ตามเราพบว่ามันยากที่จะตัดสินว่าใครเป็นผู้ชนะ เรากำหนดคะแนนสำหรับแต่ละกรณีทดสอบ ดังนั้นถ้าคุณเขียนการทดสอบหน่วยเช่นนี้ ... for (int i = 0; i < 100; i++) { assertTrue(i*i, square(i)); } คุณจะได้รับ 100 คะแนน เห็นได้ชัดว่านี่เป็นตัวอย่างง่าย ๆ แต่มันแสดงให้เห็นถึงปัญหากับการกำหนด "คะแนน" ให้กับแต่ละกรณีทดสอบ เราเป็นร้านค้า Java & Javascript เป็นหลัก ดังนั้นฉันจึงแนะนำการนับจำนวนสาขารหัสที่ทดสอบเป็นเมตริก เราสามารถนับจำนวนสาขาที่ทดสอบผ่านเครื่องมือครอบคลุมรหัสได้อย่างง่ายดาย (เช่น EclEmma) อย่างไรก็ตามไม่แน่ใจว่าเราจะทำอย่างไรกับการทดสอบซีลีเนียมของเราและรับรหัสที่ครอบคลุมในแหล่ง Javascript (ความคิดใด ๆ ?) ไม่มีใครมีข้อเสนอแนะใด ๆ …

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

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

5
การแปลงพา ธ ของไฟล์ Windows เป็นพา ธ ของไฟล์ Unix นั้นปลอดภัยหรือไม่?
ตัวอย่างเช่นบอกว่าฉันมีมันเพื่อให้ไฟล์ทั้งหมดของฉันจะถูกถ่ายโอนจากเครื่อง windows ไปยังเครื่องยูนิกซ์เช่น: C:\test\myFile.txtไปที่{somewhere}/test/myFile.txt(ตัวอักษรไดรฟ์ไม่เกี่ยวข้องในจุดนี้) ขณะนี้ไลบรารียูทิลิตี้ของเราที่เราเขียนเองให้วิธีที่ง่าย ๆ ในการแทนที่แบ็กสแลชทั้งหมดด้วยสแลชสแลช: public String normalizePath(String path) { return path.replaceAll("\\", "/"); } เครื่องหมายทับถูกสงวนไว้และไม่สามารถเป็นส่วนหนึ่งของชื่อไฟล์ได้ดังนั้นโครงสร้างไดเรกทอรีควรถูกสงวนไว้ อย่างไรก็ตามฉันไม่แน่ใจว่ามีภาวะแทรกซ้อนอื่น ๆ ระหว่าง windows และเส้นทาง unix ที่ฉันอาจต้องกังวลเกี่ยวกับ (เช่น: ไม่ใช่ชื่อ ASCII ฯลฯ )

2
ทำไม Java ไม่สนับสนุนการสืบทอดส่วนตัว / ที่ป้องกันเช่น C ++ [ปิด]
ตามที่เป็นอยู่ในปัจจุบันคำถามนี้ไม่เหมาะสำหรับรูปแบบคำถาม & คำตอบของเรา เราคาดหวังคำตอบที่จะได้รับการสนับสนุนจากข้อเท็จจริงการอ้างอิงหรือความเชี่ยวชาญ แต่คำถามนี้มีแนวโน้มที่จะเรียกร้องให้มีการอภิปรายโต้แย้งโต้แย้งหรือการอภิปรายเพิ่มเติม หากคุณรู้สึกว่าคำถามนี้สามารถปรับปรุงและเปิดใหม่ได้โปรดไปที่ศูนย์ช่วยเหลือเพื่อขอคำแนะนำ ปิดให้บริการใน7 ปีที่ผ่านมา ในขณะที่สืบทอดคลาสใน C ++ ผู้ใช้สามารถระบุตัวระบุการเข้าถึงเช่น class Base { public int mem1; protected in mem2; }; class Derived1 : **private** Base { // mem1 will be private here. // mem2 will be private here. }; class Derived2 : **protected** Base { // mem1 will …

10
วิธีเขียนโปรแกรม Java ที่มีประโยชน์โดยไม่ใช้ตัวแปรที่ไม่แน่นอน
ฉันอ่านบทความเกี่ยวกับการเขียนโปรแกรมการทำงานที่ผู้เขียนระบุ (take 25 (squares-of (integers))) ขอให้สังเกตว่ามันไม่มีตัวแปร แน่นอนมันมีอะไรมากกว่าสามฟังก์ชั่นและหนึ่งคงที่ ลองเขียนกำลังสองของจำนวนเต็มใน Java โดยไม่ต้องใช้ตัวแปร โอ้มีวิธีที่จะทำ แต่แน่นอนมันไม่เป็นธรรมชาติและมันจะไม่อ่านอย่างที่โปรแกรมของฉันข้างต้น เป็นไปได้ไหมที่จะบรรลุสิ่งนี้ใน Java? สมมติว่าคุณจำเป็นต้องพิมพ์สแควร์ของจำนวนเต็ม 15 ตัวแรกคุณสามารถเขียน a for หรือ while loop โดยไม่ใช้ตัวแปรได้หรือไม่? แจ้งให้ทราบล่วงหน้า mod คำถามนี้ไม่ใช่การแข่งขันกอล์ฟรหัส เรากำลังมองหาคำตอบที่อธิบายแนวคิดที่เกี่ยวข้อง (นึกคิดโดยไม่ต้องทำซ้ำคำตอบก่อนหน้า) และไม่เพียง แต่สำหรับรหัสอื่น

1
เหตุผลในการลบประเภทฟังก์ชั่นใน Java 8
ฉันพยายามเข้าใจว่าเพราะเหตุใด JDK 8 Lambda Expert Group (EG) จึงตัดสินใจไม่รวมฟังก์ชันประเภทใหม่ลงในภาษาการเขียนโปรแกรม Java ไปกว่ารายการทางผมพบว่าหัวข้อที่มีการอภิปรายเกี่ยวกับการกำจัดของประเภทฟังก์ชั่น ข้อความหลายข้อคลุมเครือสำหรับฉันอาจเป็นเพราะการขาดบริบทและในบางกรณีเนื่องจากความรู้ที่ จำกัด ของฉันเกี่ยวกับการใช้งานระบบพิมพ์ อย่างไรก็ตามมีคำถามสองสามข้อที่ฉันเชื่อว่าฉันสามารถกำหนดได้อย่างปลอดภัยในไซต์นี้เพื่อช่วยให้ฉันเข้าใจได้ดีขึ้นว่าพวกเขาหมายถึงอะไร ฉันรู้ว่าฉันสามารถถามคำถามในรายการส่งเมลได้ แต่เธรดเก่าและการตัดสินใจทั้งหมดได้ทำไปแล้วดังนั้นโอกาสที่ฉันจะถูกเพิกเฉยเหนือสิ่งอื่นใดที่เห็นว่าคนเหล่านี้มีแผนล่าช้าอยู่แล้ว ในคำตอบของเขาที่ให้การสนับสนุนการลบประเภทฟังก์ชั่นและรับรองการใช้งาน SAM ประเภท Brian Goetz พูดว่า: ไม่มีการดัดแปลง มีเธรดที่ยาวเกี่ยวกับประโยชน์ของการปรับประเภทของฟังก์ชัน ประเภทฟังก์ชั่นจะ hobbled ฉันไม่พบกระทู้ที่เขาพูดถึง ตอนนี้ฉันสามารถเข้าใจได้ว่าการแนะนำฟังก์ชั่นโครงสร้างอาจหมายถึงภาวะแทรกซ้อนบางอย่างในระบบจาวาส่วนใหญ่ที่ระบุสิ่งที่ฉันไม่เข้าใจคือประเภท SAM parametrized แตกต่างกันในแง่ของการทำให้ใหม่ พวกเขาทั้งคู่ต่างก็ประสบปัญหาการทำให้เหมือนกันหรือไม่? ใครบ้างเข้าใจว่าประเภทฟังก์ชั่นแตกต่างจากประเภท SAM parametrized ในแง่ของการทำให้ใหม่? ในความคิดเห็นอื่น Goetz พูดว่า: มีสองวิธีพื้นฐานในการพิมพ์: ชื่อและโครงสร้าง ตัวตนของชื่อจะขึ้นอยู่กับชื่อของมัน ตัวตนของโครงสร้างประเภทนั้นขึ้นอยู่กับสิ่งที่มันประกอบไปด้วย (เช่น "tuple of int, int" หรือ "ฟังก์ชั่นจาก …

2
คำถามสัมภาษณ์ขั้นสูง / ไม่เป็นธรรมเหล่านี้เกี่ยวกับ Java concurrency หรือไม่ [ปิด]
ตามที่เป็นอยู่ในปัจจุบันคำถามนี้ไม่เหมาะสำหรับรูปแบบคำถาม & คำตอบของเรา เราคาดหวังคำตอบที่จะได้รับการสนับสนุนจากข้อเท็จจริงการอ้างอิงหรือความเชี่ยวชาญ แต่คำถามนี้มีแนวโน้มที่จะเรียกร้องให้มีการอภิปรายโต้แย้งโต้แย้งหรือการอภิปรายเพิ่มเติม หากคุณรู้สึกว่าคำถามนี้สามารถปรับปรุงและเปิดใหม่ได้โปรดไปที่ศูนย์ช่วยเหลือเพื่อขอคำแนะนำ ปิดให้บริการใน7 ปีที่ผ่านมา ต่อไปนี้เป็นคำถามที่ฉันถามผู้สัมภาษณ์เมื่อเร็ว ๆ นี้ว่าพวกเขารู้จักการทำงานพร้อมกันของ Java: อธิบายถึงอันตรายของ "การมองเห็นของหน่วยความจำ" - วิธีที่ JVM สามารถเรียงลำดับการดำเนินการบางอย่างกับตัวแปรที่ไม่ได้รับการป้องกันโดยจอภาพและไม่ได้ประกาศvolatileเช่นว่าเธรดหนึ่งอาจไม่เห็นการเปลี่ยนแปลงของเธรดอื่น ฉันมักจะถามรหัสนี้โดยแสดงรหัสที่อันตรายนี้มีอยู่ ( NoVisibilityตัวอย่างเช่นในรายการ 3.1 จาก "Java Concurrency in Practice" โดย Goetz et al) และถามสิ่งที่ผิด อธิบายว่าvolatileมีผลกระทบอย่างไรกับตัวแปรที่เกิดขึ้นจริงที่ประกาศvolatileแต่ยังรวมถึงการเปลี่ยนแปลงตัวแปรที่ทำโดยเธรดก่อนที่จะเปลี่ยนแปลงvolatileตัวแปร ทำไมคุณอาจใช้volatileแทนsynchronized? ใช้ตัวแปรสภาพด้วยและwait() อธิบายว่าทำไมคุณควรใช้notifyAll() notifyAll()อธิบายว่าทำไมตัวแปรเงื่อนไขควรทดสอบด้วยการwhileวนซ้ำ คำถามของฉันคือ - สิ่งเหล่านี้เหมาะสมหรือสูงเกินไปที่จะถามคนที่บอกว่าพวกเขารู้จักการทำงานพร้อมกันของ Java หรือไม่ และในขณะที่เราอยู่ที่นี่คุณคิดว่าคนที่ทำงานใน Java เห็นพ้องด้วยควรคาดว่าจะมีความรู้สูงกว่าค่าเฉลี่ยของการเก็บขยะ Java?

7
ฟังก์ชั่นวนซ้ำสามารถมีการวนซ้ำ / ลูปได้หรือไม่?
ฉันกำลังศึกษาเกี่ยวกับฟังก์ชั่นวนซ้ำและเห็นได้ชัดว่าพวกมันเป็นฟังก์ชันที่เรียกตัวเองและไม่ใช้การวนซ้ำ / วนซ้ำ อย่างไรก็ตามในขณะที่ท่องเว็บเพื่อดูตัวอย่าง (ปัญหา 8-queens-recursive) ฉันพบฟังก์ชันนี้: private boolean placeQueen(int rows, int queens, int n) { boolean result = false; if (row < n) { while ((queens[row] < n - 1) && !result) { queens[row]++; if (verify(row,queens,n)) { ok = placeQueen(row + 1,queens,n); } } if (!result) { queens[row] = …
12 java  recursion 

2
การแยกโปรเจ็กต์ java
ฉันมีโปรเจ็กต์ java ขนาดใหญ่และเราใช้ maven สำหรับวงรอบการสร้างของเรา โครงการนี้มีการใช้อย่างกว้างขวาง - ในโครงการอื่น ๆ ในแอปพลิเคชั่นต่าง ๆ ซึ่งบางส่วนอยู่ในนั้นและบางส่วนอยู่ที่อื่น ... พูดตามตรงแล้วมันเป็นระเบียบนิดหน่อย วัตถุประสงค์) และฉันต้องการทำความสะอาดสักหน่อย นอกจากนี้ยังไม่ผ่านการทดสอบอย่างสมบูรณ์ (มีการเพิ่มบิตจำนวนมากโดยไม่มีหน่วยที่เหมาะสมและการทดสอบการรวม) และมีการทดสอบบางอย่างที่ใช้เวลานานในการรันหรือไม่ผ่านจริง ... (uh-oh) - ดังนั้น การทดสอบจะถูกปิดในวงจรสร้าง maven (อีกครั้ง uh-oh) ฉันกำลังคิดที่จะแยกโครงการขนาดใหญ่นี้ออกเป็นโครงการขนาดเล็กโดยเฉพาะเช่นโครงการย่อย 'สุดท้าย' (หรือโครงการย่อยหลายโครงการ) จะรับโครงการย่อยต่าง ๆ ที่มันต้องการ ความคิดของฉันเป็นดังนี้: ถ้าฉันแยกโครงการใหญ่ออกเป็นโครงการย่อยต่าง ๆ นี่จะทำให้ชัดเจนว่าความรับผิดชอบของแต่ละโครงการคืออะไร โดยแยกเป็นโครงการย่อยฉันสามารถล้างการทดสอบของแต่ละโครงการย่อยทีละรายการและเปิดการทดสอบสำหรับโครงการย่อยนั้นในวงจรการสร้าง maven ฉันกังวลเล็กน้อยเกี่ยวกับผลกระทบที่อาจเกิดขึ้นกับเวลาสร้าง การวางโครงสร้างในโครงการขนาดใหญ่ (เช่นเป็นโครงการย่อยขนาดเล็ก) จะทำให้คอมไพเลอร์ช้าลงหรือไม่ นอกจากนี้ฉันมีข้อกังวลเล็กน้อยเกี่ยวกับผลกระทบที่อาจเกิดขึ้นกับการแก้ไขเวลาใน IDEs (เราใช้ Intellij เป็นหลัก) Intellij ดูเหมือนว่าจะสร้างแต่ละโครงการผ่านแผนผังการพึ่งพา …

โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.