บทความนี้เป็นส่วนหนึ่งของหลักสูตรวิชาการ "Advanced Java" หลักสูตรนี้ออกแบบมาเพื่อช่วยให้คุณเรียนรู้วิธีใช้คุณสมบัติ Java อย่างมีประสิทธิภาพ เนื้อหาครอบคลุมหัวข้อ "ขั้นสูง" เช่น การสร้างวัตถุ การแข่งขัน การทำให้เป็นอนุกรม การสะท้อนกลับ ฯลฯ หลักสูตรนี้จะสอนวิธีเชี่ยวชาญเทคนิค Java อย่างมีประสิทธิภาพ รายละเอียด
ที่นี่
เนื้อหา
1. บทนำ 2. ขอบเขตของตัวแปร 3. ฟิลด์คลาสและตัวแปรท้องถิ่น 4. อาร์กิวเมนต์ของเมธอดและตัวแปรท้องถิ่น 5. Boxing และ Unboxing 6. อินเทอร์เฟซ 7. สตริง 8. แบบแผนการตั้งชื่อ 9. ไลบรารีมาตรฐาน 10. ความไม่เปลี่ยนรูป 11. การทดสอบ 12. ถัดไป .. 13. ดาวน์โหลดซอร์สโค้ด
1. บทนำ
ในบทช่วยสอนในส่วนนี้ เราจะพูดคุยกันต่อเกี่ยวกับหลักการทั่วไปของรูปแบบการเขียนโปรแกรมที่ดีและการออกแบบที่ตอบสนองใน Java เราได้เห็นหลักการเหล่านี้บางส่วนในบทที่แล้วของคู่มือแล้ว แต่จะมีการให้คำแนะนำที่เป็นประโยชน์มากมายโดยมีจุดประสงค์เพื่อพัฒนาทักษะของนักพัฒนา Java
2. ขอบเขตตัวแปร
ในส่วนที่ 3 ("วิธีการออกแบบคลาสและอินเทอร์เฟซ") เราได้พูดคุยกันว่าการมองเห็นและการเข้าถึงสามารถนำไปใช้กับสมาชิกของคลาสและอินเทอร์เฟซได้อย่างไร โดยมีข้อ จำกัด ของขอบเขต อย่างไรก็ตาม เรายังไม่ได้กล่าวถึงตัวแปรท้องถิ่นที่ใช้ในการนำเมธอดไปใช้ ในภาษา Java เมื่อประกาศตัวแปรท้องถิ่นทุกตัวจะมีขอบเขต ตัวแปรนี้สามารถมองเห็นได้จากตำแหน่งที่มีการประกาศจนถึงจุดที่การดำเนินการของเมธอด (หรือบล็อกของโค้ด) เสร็จสมบูรณ์ โดยทั่วไป กฎเดียวที่ต้องปฏิบัติตามคือการประกาศตัวแปรโลคัลให้ใกล้กับตำแหน่งที่จะใช้งานมากที่สุด ผมขอดูตัวอย่างทั่วไป:
for( final Locale locale: Locale.getAvailableLocales() ) { // блок codeа } try( final InputStream in = new FileInputStream( "file.txt" ) ) { // блока codeа } ในส่วนของโค้ดทั้งสอง ขอบเขตของตัวแปรจะถูกจำกัดอยู่ที่บล็อกการดำเนินการซึ่งมีการประกาศตัวแปรเหล่านี้ เมื่อบล็อกเสร็จสมบูรณ์ ขอบเขตจะสิ้นสุดลงและตัวแปรจะมองไม่เห็น ดูเหมือนจะชัดเจนยิ่งขึ้น แต่ด้วยการเปิดตัว Java 8 และการเปิดตัว lambdas สำนวนที่รู้จักกันดีของภาษาจำนวนมากที่ใช้ตัวแปรท้องถิ่นจึงล้าสมัย ผมขอยกตัวอย่างจากตัวอย่างก่อนหน้านี้โดยใช้ lambdas แทนการวนซ้ำ:
Arrays.stream( Locale.getAvailableLocales() ).forEach( ( locale ) -> { // блок codeа } ); จะเห็นได้ว่าตัวแปรท้องถิ่นได้กลายเป็นอาร์กิวเมนต์ของฟังก์ชัน ซึ่งในทางกลับกันจะถูกส่งผ่านเป็นอาร์กิวเมนต์ไปยังเมธอด
forEach
3. ฟิลด์คลาสและตัวแปรท้องถิ่น
แต่ละวิธีใน Java เป็นของคลาสเฉพาะ (หรือในกรณีของ Java8 อินเทอร์เฟซที่ประกาศวิธีการเป็นวิธีเริ่มต้น) ระหว่างตัวแปรท้องถิ่นที่เป็นเขตข้อมูลของคลาสหรือวิธีการที่ใช้ในการดำเนินการ มีความเป็นไปได้ที่ชื่อจะขัดแย้งกัน คอมไพเลอร์ Java รู้วิธีเลือกตัวแปรที่ถูกต้องจากตัวแปรที่มีอยู่ แม้ว่านักพัฒนามากกว่าหนึ่งรายตั้งใจจะใช้ตัวแปรนั้นก็ตาม Java IDE สมัยใหม่ทำงานได้ดีมากในการบอกนักพัฒนาเมื่อข้อขัดแย้งดังกล่าวกำลังจะเกิดขึ้น ผ่านการเตือนคอมไพเลอร์และการเน้นตัวแปร แต่ก็ยังดีกว่าที่จะคิดถึงเรื่องเหล่านี้ในขณะที่เขียนโค้ด ฉันขอแนะนำให้ดูตัวอย่าง:
public class LocalVariableAndClassMember { private long value; public long calculateValue( final long initial ) { long value = initial; value *= 10; value += value; return value; } } ตัวอย่างดูค่อนข้างง่าย แต่มันเป็นกับดัก เมธอด
CalculatorValue จะแนะนำ
ค่าตัวแปรภายในเครื่องและเมื่อดำเนินการกับค่าดังกล่าว จะซ่อนฟิลด์คลาสที่มีชื่อเดียวกัน บรรทัด
value += value; ควรเป็นผลรวมของค่าของฟิลด์คลาสและตัวแปรโลคัล แต่กลับมีอย่างอื่นกำลังดำเนินการอยู่ การใช้งานที่เหมาะสมจะมีลักษณะดังนี้ (โดยใช้คีย์เวิร์ดนี้):
public class LocalVariableAndClassMember { private long value; public long calculateValue( final long initial ) { long value = initial; value *= 10; value += this.value; return value; } } แม้ว่าตัวอย่างนี้จะดูไร้เดียงสาในบางแง่ แต่ก็แสดงให้เห็นจุดสำคัญที่ในบางกรณีอาจต้องใช้เวลาหลายชั่วโมงในการแก้ไขและแก้ไข
4. อาร์กิวเมนต์ของวิธีการและตัวแปรท้องถิ่น
ข้อผิดพลาดอีกประการหนึ่งที่นักพัฒนา Java ที่ไม่มีประสบการณ์มักประสบคือการใช้อาร์กิวเมนต์ของเมธอดเป็นตัวแปรในเครื่อง Java อนุญาตให้คุณกำหนดค่าให้กับอาร์กิวเมนต์ที่ไม่คงที่ (อย่างไรก็ตาม สิ่งนี้ไม่มีผลกระทบต่อค่าดั้งเดิม):
public String sanitize( String str ) { if( !str.isEmpty() ) { str = str.trim(); } str = str.toLowerCase(); return str; } ข้อมูลโค้ดด้านบนไม่สวยงาม แต่ทำงานได้ดีในการเปิดเผยปัญหา: อาร์กิวเมนต์
strถูกกำหนดไว้แล้ว ค่าอื่น (และโดยทั่วไปจะใช้เป็นตัวแปรท้องถิ่น) ในทุกกรณี (โดยไม่มีข้อยกเว้น) คุณสามารถและควรทำโดยไม่มีตัวอย่างนี้ (เช่น โดยการประกาศอาร์กิวเมนต์เป็นค่าคงที่) ตัวอย่างเช่น:
public String sanitize( final String str ) { String sanitized = str; if( !str.isEmpty() ) { sanitized = str.trim(); } sanitized = sanitized.toLowerCase(); return sanitized; } โดยการปฏิบัติตามกฎง่ายๆ นี้ จะง่ายกว่าในการติดตามโค้ดที่กำหนดและค้นหาสาเหตุของปัญหา แม้ว่าจะแนะนำตัวแปรในเครื่องก็ตาม
5. การบรรจุและการแกะออก
Boxing และ unboxing เป็นชื่อของเทคนิคที่ใช้ใน Java เพื่อแปลงประเภทดั้งเดิม (
int, long, double ฯลฯ ) ให้เป็น wrapper ประเภทที่สอดคล้องกัน (
Integer, Long, Doubleฯลฯ ) ในส่วนที่ 4 ของบทช่วยสอนวิธีและเวลาที่จะใช้ Generics คุณเห็นสิ่งนี้แล้วในทางปฏิบัติเมื่อฉันพูดถึงการห่อประเภทดั้งเดิมเป็นพารามิเตอร์ประเภทของยาชื่อสามัญ แม้ว่าคอมไพลเลอร์ Java จะพยายามอย่างดีที่สุดเพื่อซ่อนการแปลงดังกล่าวด้วยการดำเนินการ autoboxing แต่บางครั้งก็อาจน้อยกว่าที่คาดไว้และให้ผลลัพธ์ที่ไม่คาดคิด ลองดูตัวอย่าง:
public static void calculate( final long value ) { // блок codeа } final Long value = null; calculate( value ); ข้อมูลโค้ดด้านบนคอมไพล์ได้ดี อย่างไรก็ตาม มันจะโยน NullPointerException
บนบรรทัดที่
// блок จะแปลงระหว่าง
Longและ
long คำแนะนำสำหรับกรณีเช่นนี้คือ ขอแนะนำให้ใช้ประเภทดั้งเดิม (แต่เรารู้อยู่แล้วว่าสิ่งนี้ไม่สามารถทำได้เสมอไป)
6. อินเทอร์เฟซ
ในส่วนที่ 3 ของบทช่วยสอน "วิธีการออกแบบคลาสและอินเทอร์เฟซ" เราได้กล่าวถึงอินเทอร์เฟซและการเขียนโปรแกรมตามสัญญา โดยเน้นว่าอินเทอร์เฟซควรเป็นที่ต้องการมากกว่าคลาสที่เป็นรูปธรรมทุกครั้งที่เป็นไปได้ วัตถุประสงค์ของส่วนนี้คือเพื่อสนับสนุนให้คุณพิจารณาอินเทอร์เฟซก่อนโดยสาธิตสิ่งนี้ด้วยตัวอย่างในชีวิตจริง อินเทอร์เฟซไม่เชื่อมโยงกับการใช้งานเฉพาะ (ยกเว้นวิธีการเริ่มต้น) เป็นเพียงสัญญาเท่านั้น และเป็นตัวอย่างที่ให้อิสระและความยืดหยุ่นอย่างมากในการดำเนินการตามสัญญา ความยืดหยุ่นนี้มีความสำคัญมากขึ้นเมื่อการใช้งานเกี่ยวข้องกับระบบหรือบริการภายนอก ลองดูตัวอย่างอินเทอร์เฟซแบบธรรมดาและการใช้งานที่เป็นไปได้:
public interface TimezoneService { TimeZone getTimeZone( final double lat, final double lon ) throws IOException; } public class TimezoneServiceImpl implements TimezoneService { @Override public TimeZone getTimeZone(final double lat, final double lon) throws IOException { final URL url = new URL( String.format( "http://api.geonames.org/timezone?lat=%.2f&lng=%.2f&username=demo", lat, lon ) ); final HttpURLConnection connection = ( HttpURLConnection )url.openConnection(); connection.setRequestMethod( "GET" ); connection.setConnectTimeout( 1000 ); connection.setReadTimeout( 1000 ); connection.connect(); int status = connection.getResponseCode(); if (status == 200) { // Do something here } return TimeZone.getDefault(); } } ข้อมูลโค้ดด้านบนแสดงรูปแบบอินเทอร์เฟซทั่วไปและการใช้งาน การใช้งานนี้ใช้บริการ HTTP ภายนอก (
http://api.geonames.org/ ) เพื่อดึงเขตเวลาของสถานที่เฉพาะ แต่เนื่องจาก สัญญาขึ้นอยู่กับอินเทอร์เฟซ มันง่ายมากที่จะแนะนำการใช้งานอินเทอร์เฟซอื่น เช่น ฐานข้อมูล หรือแม้แต่ไฟล์แฟลตปกติ อินเทอร์เฟซมีประโยชน์มากในการออกแบบโค้ดที่ทดสอบได้ ตัวอย่างเช่น การเรียกบริการภายนอกในทุกการทดสอบอาจใช้ไม่ได้ผลเสมอไป ดังนั้นจึงเหมาะสมที่จะนำไปใช้ทางเลือกอื่นและการใช้งานที่ง่ายที่สุด (เช่น stub) แทน):
public class TimezoneServiceTestImpl implements TimezoneService { @Override public TimeZone getTimeZone(final double lat, final double lon) throws IOException { return TimeZone.getDefault(); } } การใช้งานนี้สามารถใช้ได้ทุกที่ที่ ต้องการอินเทอร์เฟซ
TimezoneServiceโดยแยก สคริปต์ทดสอบจากการพึ่งพาส่วนประกอบภายนอก ตัวอย่างที่ยอดเยี่ยมมากมายของการใช้อินเทอร์เฟซดังกล่าวอย่างมีประสิทธิภาพถูกห่อหุ้มไว้ในไลบรารีมาตรฐาน Java คอลเลกชัน รายการ ชุด - อินเทอร์เฟซเหล่านี้มีการใช้งานหลายอย่างที่สามารถสลับออกได้อย่างราบรื่นและสามารถสับเปลี่ยนได้เมื่อสัญญาใช้ประโยชน์ ตัวอย่างเช่น:
public static< T > void print( final Collection< T > collection ) { for( final T element: collection ) { System.out.println( element ); } } print( new HashSet< Object >( /* ... */ ) ); print( new ArrayList< Integer >( /* ... */ ) ); print( new TreeSet< String >( /* ... */ ) );
7. เครื่องสาย
สตริงเป็นหนึ่งในประเภทที่ใช้มากที่สุดทั้งใน Java และภาษาโปรแกรมอื่นๆ ภาษา Java ช่วยให้การจัดการสตริงรูทีนง่ายขึ้นโดยรองรับการต่อข้อมูลและการดำเนินการเปรียบเทียบทันที นอกจากนี้ ไลบรารีมาตรฐานยังมีคลาสจำนวนมากที่ทำให้การดำเนินการสตริงมีประสิทธิภาพ นี่คือสิ่งที่เราจะพูดถึงในส่วนนี้ ใน Java สตริงเป็นวัตถุที่ไม่เปลี่ยนรูปซึ่งแสดงในการเข้ารหัส UTF-16 ทุกครั้งที่คุณเชื่อมสตริงเข้าด้วยกัน (หรือดำเนินการใดๆ ที่แก้ไขสตริงดั้งเดิม) อินสแตนซ์ใหม่ของคลาส
String จะถูกสร้างขึ้น ด้วยเหตุนี้ การดำเนินการต่อข้อมูลอาจไม่มีประสิทธิภาพมากนัก ทำให้อินสแตนซ์ระดับกลางจำนวนมากของ คลาส
String ถูกสร้างขึ้น (โดยทั่วไปสร้างขยะ) แต่ไลบรารีมาตรฐาน Java มีคลาสที่มีประโยชน์มากสองคลาสซึ่งมีจุดประสงค์เพื่อให้การจัดการสตริงสะดวก เหล่านี้คือ
StringBuilderและ
StringBuffer (ข้อแตกต่างเพียงอย่างเดียวคือ
StringBufferปลอดภัยสำหรับเธรด ในขณะที่
StringBuilderตรงกันข้าม) ลองดูตัวอย่างสองสามตัวอย่างของคลาสใดคลาสหนึ่งที่กำลังใช้งานอยู่:
final StringBuilder sb = new StringBuilder(); for( int i = 1; i <= 10; ++i ) { sb.append( " " ); sb.append( i ); } sb.deleteCharAt( 0 ); sb.insert( 0, "[" ); sb.replace( sb.length() - 3, sb.length(), "]" ); แม้ว่าการใช้
StringBuilder/StringBufferเป็นวิธีที่แนะนำในการจัดการกับสตริง แต่ก็อาจดูเกินความจำเป็นในสถานการณ์ที่ง่ายที่สุดในการต่อสตริงสองหรือสามสตริงเข้าด้วยกัน เพื่อให้ตัวดำเนินการบวกปกติ ( ( "+") ตัวอย่างเช่น:
String userId = "user:" + new Random().nextInt( 100 ); ทางเลือกที่ดีที่สุดในการลดความซับซ้อนของการต่อข้อมูลคือการใช้การจัดรูปแบบสตริงเช่นเดียวกับ Java Standard Library เพื่อช่วยจัดเตรียมเมธอด
String.format helper แบบ คงที่ ซึ่งสนับสนุนชุดตัวระบุรูปแบบที่หลากหลาย รวมถึงตัวเลข สัญลักษณ์ วันที่/เวลา ฯลฯ (โปรดดูเอกสารอ้างอิงสำหรับรายละเอียดทั้งหมด)
String.format( "%04d", 1 ); -> 0001 String.format( "%.2f", 12.324234d ); -> 12.32 String.format( "%tR", new Date() ); -> 21:11 String.format( "%tF", new Date() ); -> 2014-11-11 String.format( "%d%%", 12 ); -> 12% เมธอด
String.formatให้แนวทางที่สะอาดและไม่ซับซ้อนในการสร้างสตริงจากข้อมูลประเภทต่างๆ เป็นที่น่าสังเกตว่า Java IDE สมัยใหม่สามารถแยกวิเคราะห์ข้อกำหนดรูปแบบจากอาร์กิวเมนต์ที่ส่งไปยัง เมธอด
String.formatและเตือนนักพัฒนาหากตรวจพบความไม่ตรงกัน
8. แบบแผนการตั้งชื่อ
Java เป็นภาษาที่ไม่ได้บังคับให้นักพัฒนาปฏิบัติตามหลักการตั้งชื่อใดๆ อย่างเคร่งครัด แต่ชุมชนได้พัฒนาชุดกฎง่ายๆ ที่ทำให้โค้ด Java ดูสอดคล้องกันทั้งในไลบรารีมาตรฐานและในโปรเจ็กต์ Java อื่นๆ:
- ชื่อแพ็คเกจเป็นตัวพิมพ์เล็ก: org.junit, com.fasterxml.jackson, javax.json
- ชื่อของคลาส การแจงนับ อินเทอร์เฟซ คำอธิบายประกอบจะถูกเขียนด้วยตัวพิมพ์ใหญ่: StringBuilder, Runnable, @Override
- ชื่อของฟิลด์หรือเมธอด (ยกเว้นstatic Final ) ระบุไว้ในรูปแบบอูฐ: isEmpty, format, addAll
- ฟิลด์สุดท้ายแบบคงที่หรือชื่อคงที่การแจงนับเป็นตัวพิมพ์ใหญ่ คั่นด้วยเครื่องหมายขีดล่าง ("_"): LOG, MIN_RADIX, INSTANCE
- ตัวแปรท้องถิ่นหรืออาร์กิวเมนต์ของเมธอดถูกพิมพ์ในรูปแบบอูฐ: str, newLength, maximumCapacity
- ชื่อประเภทพารามิเตอร์สำหรับยาชื่อสามัญจะแสดงด้วยตัวอักษรตัวเดียวเป็นตัวพิมพ์ใหญ่: T, U, E
การปฏิบัติตามแบบแผนง่ายๆ เหล่านี้ โค้ดที่คุณเขียนจะดูกระชับและมีสไตล์จนแยกไม่ออกจากไลบรารี่หรือเฟรมเวิร์กอื่น และจะรู้สึกเหมือนได้รับการพัฒนาโดยบุคคลคนเดียวกัน (หนึ่งในครั้งที่หายากที่แบบแผนใช้งานได้จริง)
9. ห้องสมุดมาตรฐาน
ไม่ว่าคุณกำลังทำโปรเจ็กต์ Java ประเภทไหน ไลบรารีมาตรฐานของ Java ก็เป็นเพื่อนที่ดีที่สุดของคุณ ใช่ มันยากที่จะไม่เห็นด้วยว่าพวกเขามีขอบที่หยาบและการตัดสินใจในการออกแบบที่แปลก อย่างไรก็ตาม 99% เป็นโค้ดคุณภาพสูงที่เขียนโดยผู้เชี่ยวชาญ มันคุ้มค่าที่จะสำรวจ Java แต่ละรุ่นนำคุณสมบัติใหม่มากมายมาสู่ไลบรารีที่มีอยู่ (โดยมีปัญหาที่อาจเกิดขึ้นกับคุณสมบัติเก่า) และยังเพิ่มไลบรารีใหม่อีกมากมาย Java 5 นำ ไลบรารี
การทำงานพร้อม กันใหม่ มาเป็นส่วนหนึ่งของ แพ็คเกจ
java.util.concurrent Java 6 เปิดตัว (รู้จักกันน้อย) รองรับการเขียนสคริปต์ ( แพ็คเกจ
javax.script ) และ Java คอมไพเลอร์
API (เป็นส่วนหนึ่งของแพ็คเกจ
javax.tools ) Java 7 นำการปรับปรุงมากมายมาสู่
java.util.concurrentโดยแนะนำไลบรารี I/O ใหม่ในแพ็คเกจ
java.nio.fileและรองรับภาษาไดนามิกใน
java.lang.inrigg และในที่สุด Java 8 ก็เพิ่ม วัน
ที่/เวลาที่รอคอยมานานใน แพ็คเกจ
java.time Java เป็นแพลตฟอร์มที่กำลังพัฒนาและเป็นสิ่งสำคัญมากที่จะต้องก้าวหน้าไปพร้อมกับการเปลี่ยนแปลงข้างต้น เมื่อใดก็ตามที่คุณพิจารณารวมไลบรารีหรือเฟรมเวิร์กของบริษัทอื่นไว้ในโปรเจ็กต์ของคุณ ตรวจสอบให้แน่ใจว่าฟังก์ชันการทำงานที่จำเป็นนั้นไม่มีอยู่ในไลบรารี Java มาตรฐาน (แน่นอนว่า มีการใช้งานอัลกอริธึมเฉพาะทางและประสิทธิภาพสูงมากมายที่ล้ำหน้า อัลกอริธึมในไลบรารีมาตรฐาน แต่โดยส่วนใหญ่แล้วไม่จำเป็นจริงๆ)
10. ความไม่เปลี่ยนรูป
ความไม่เปลี่ยนแปลงตลอดทั้งคู่มือและในส่วนนี้ยังคงเป็นเครื่องเตือนใจ: โปรดใช้อย่างจริงจัง หากคลาสที่คุณออกแบบหรือวิธีการที่คุณนำไปใช้สามารถรับประกันความไม่เปลี่ยนรูปได้ ก็สามารถใช้ได้ในกรณีส่วนใหญ่ทุกที่โดยไม่ต้องกลัวว่าจะถูกแก้ไขในเวลาเดียวกัน สิ่งนี้จะทำให้ชีวิตของคุณในฐานะนักพัฒนาซอฟต์แวร์ (และหวังว่าชีวิตของสมาชิกในทีมของคุณ) ง่ายขึ้น
11. การทดสอบ
แนวปฏิบัติของการพัฒนาที่ขับเคลื่อนด้วยการทดสอบ (TDD) ได้รับความนิยมอย่างมากในชุมชน Java โดยเป็นการยกระดับคุณภาพของโค้ด ด้วยคุณประโยชน์ทั้งหมดที่ TDD มอบให้ เป็นเรื่องน่าเศร้าที่ไลบรารีมาตรฐาน Java ในปัจจุบันไม่มีเฟรมเวิร์กการทดสอบหรือเครื่องมือสนับสนุนใดๆ อย่างไรก็ตาม การทดสอบได้กลายเป็นส่วนสำคัญของการพัฒนา Java สมัยใหม่ และในส่วน นี้เราจะดูเทคนิคพื้นฐานบางประการโดยใช้ เฟรมเวิร์ก
JUnit โดยพื้นฐานแล้วใน JUnit แต่ละการทดสอบคือชุดของคำสั่งเกี่ยวกับสถานะหรือพฤติกรรมที่คาดหวังของอ็อบเจ็กต์ เคล็ดลับในการเขียนแบบทดสอบที่ยอดเยี่ยมคือการทำให้มันง่ายและสั้น โดยทดสอบทีละอย่าง ในแบบฝึกหัด เราจะเขียนชุดการทดสอบเพื่อตรวจสอบว่า
String.formatเป็นฟังก์ชันจากส่วนสตริงที่ส่งคืนผลลัพธ์ที่ต้องการ
package com.javacodegeeks.advanced.generic; import static org.junit.Assert.assertThat; import static org.hamcrest.CoreMatchers.equalTo; import org.junit.Test; public class StringFormatTestCase { @Test public void testNumberFormattingWithLeadingZeros() { final String formatted = String.format( "%04d", 1 ); assertThat( formatted, equalTo( "0001" ) ); } @Test public void testDoubleFormattingWithTwoDecimalPoints() { final String formatted = String.format( "%.2f", 12.324234d ); assertThat( formatted, equalTo( "12.32" ) ); } } การทดสอบทั้งสองดูสามารถอ่านได้มากและการดำเนินการนั้นเป็นอินสแตนซ์ ปัจจุบัน โปรเจ็กต์ Java โดยเฉลี่ยประกอบด้วยกรณีทดสอบหลายร้อยกรณี ซึ่งช่วยให้นักพัฒนาได้รับผลตอบกลับอย่างรวดเร็วในระหว่างกระบวนการพัฒนาเกี่ยวกับการถดถอยหรือฟีเจอร์ต่างๆ
12. ถัดไป
คู่มือส่วนนี้จะสรุปชุดการอภิปรายที่เกี่ยวข้องกับการฝึกปฏิบัติการเขียนโปรแกรมใน Java และคู่มือสำหรับภาษาการเขียนโปรแกรมนี้ คราวหน้าเราจะกลับไปสู่ฟีเจอร์ของภาษา สำรวจโลกของ Java เกี่ยวกับข้อยกเว้น ประเภทของมัน วิธีและเวลาที่ควรใช้
13. ดาวน์โหลดซอร์สโค้ด
นี่เป็นบทเรียนเกี่ยวกับหลักการพัฒนาทั่วไปจากหลักสูตร Java ขั้นสูง สามารถดาวน์โหลดซอร์สโค้ดสำหรับบทเรียนได้
ที่นี่
GO TO FULL VERSION