یہ مضمون تعلیمی کورس "Advanced Java" کا حصہ ہے۔ یہ کورس آپ کو Java خصوصیات کو مؤثر طریقے سے استعمال کرنے کا طریقہ سیکھنے میں مدد کرنے کے لیے ڈیزائن کیا گیا ہے۔ مواد میں "اعلی درجے کے" موضوعات کا احاطہ کیا گیا ہے جیسے کہ آبجیکٹ کی تخلیق، مقابلہ، سیریلائزیشن، عکاسی، وغیرہ۔ کورس آپ کو سکھائے گا کہ جاوا کی تکنیکوں میں کس طرح مہارت حاصل کی جائے۔ تفصیلات
یہاں ۔
مواد
1. تعارف 2. متغیر دائرہ کار 3. کلاس فیلڈز اور مقامی متغیرات 4. طریقہ کار کے دلائل اور مقامی متغیرات 5. باکسنگ اور ان باکسنگ 6. انٹرفیس 7. سٹرنگز 8. نام دینے کے کنونشنز 9. معیاری لائبریریاں 10. ناقابل تبدیلی 11. اگلا ٹیسٹنگ .. 13. سورس کوڈ ڈاؤن لوڈ کریں۔
1. تعارف
ٹیوٹوریل کے اس حصے میں ہم جاوا میں اچھے پروگرامنگ اسٹائل اور ریسپانسیو ڈیزائن کے عمومی اصولوں پر اپنی بحث جاری رکھیں گے۔ ان اصولوں میں سے کچھ کو ہم گائیڈ کے پچھلے ابواب میں دیکھ چکے ہیں، لیکن جاوا ڈویلپر کی مہارت کو بہتر بنانے کے مقصد سے بہت سے عملی نکات دیے جائیں گے۔
2. متغیر دائرہ کار
تیسرا حصہ ("کلاسز اور انٹرفیسز کو کیسے ڈیزائن کریں") میں ہم نے اس بات پر تبادلہ خیال کیا کہ دائرہ کار کی رکاوٹوں کے پیش نظر، کلاسز اور انٹرفیس کے اراکین پر مرئیت اور رسائی کا اطلاق کیسے کیا جا سکتا ہے۔ تاہم، ہم نے ابھی تک مقامی متغیرات پر بات نہیں کی ہے جو طریقہ کار کے نفاذ میں استعمال ہوتے ہیں۔ جاوا زبان میں، ہر مقامی متغیر کا، ایک بار اعلان کیا جاتا ہے، اس کی گنجائش ہوتی ہے۔ یہ متغیر اس جگہ سے نظر آتا ہے جہاں اسے اس مقام پر قرار دیا جاتا ہے جہاں طریقہ کار (یا کوڈ کا بلاک) مکمل ہوتا ہے۔ عام طور پر، پیروی کرنے کا واحد اصول یہ ہے کہ ایک مقامی متغیر کو اس جگہ کے قریب جتنا ممکن ہو اس کا اعلان کیا جائے جہاں اسے استعمال کیا جائے گا۔ مجھے ایک عام مثال پر نظر ڈالنے دو:
for( final Locale locale: Locale.getAvailableLocales() ) { // блок codeа } try( final InputStream in = new FileInputStream( "file.txt" ) ) { // блока codeа } دونوں کوڈ کے ٹکڑوں میں، متغیرات کا دائرہ عمل درآمد کے بلاکس تک محدود ہے جہاں ان متغیرات کا اعلان کیا گیا ہے۔ جب بلاک مکمل ہو جاتا ہے، دائرہ ختم ہو جاتا ہے اور متغیر پوشیدہ ہو جاتا ہے۔ یہ واضح معلوم ہوتا ہے، لیکن جاوا 8 کے اجراء اور لیمبڈا کے تعارف کے ساتھ، مقامی متغیرات کا استعمال کرتے ہوئے زبان کے بہت سے معروف محاورے متروک ہوتے جا رہے ہیں۔ میں لوپ کے بجائے lambdas کا استعمال کرتے ہوئے پچھلی مثال سے ایک مثال دیتا ہوں:
Arrays.stream( Locale.getAvailableLocales() ).forEach( ( locale ) -> { // блок codeа } ); آپ دیکھ سکتے ہیں کہ مقامی متغیر فنکشن کے لیے ایک دلیل بن گیا ہے، جس کے نتیجے میں
forEach طریقہ کو دلیل کے طور پر پاس کیا جاتا ہے ۔
3. کلاس فیلڈز اور مقامی متغیرات
جاوا میں ہر طریقہ ایک مخصوص طبقے سے تعلق رکھتا ہے (یا، Java8 کے معاملے میں، ایک انٹرفیس جہاں طریقہ کو ڈیفالٹ طریقہ قرار دیا جاتا ہے)۔ مقامی متغیرات کے درمیان جو کسی طبقے کے شعبے ہیں یا نفاذ میں استعمال ہونے والے طریقوں کے درمیان، نام کے تصادم کا اتنا ہی امکان ہے۔ جاوا کمپائلر جانتا ہے کہ دستیاب میں سے صحیح متغیر کا انتخاب کیسے کیا جائے، حالانکہ ایک سے زیادہ ڈویلپر اس متغیر کو استعمال کرنے کا ارادہ رکھتے ہیں۔ جدید جاوا آئی ڈی ای ڈیولپر کو بتانے کا ایک بہت اچھا کام کرتے ہیں جب اس طرح کے تنازعات ہونے والے ہیں، کمپائلر وارننگز اور متغیر ہائی لائٹنگ کے ذریعے۔ لیکن کوڈ لکھتے وقت ایسی چیزوں کے بارے میں سوچنا اب بھی بہتر ہے۔ میں ایک مثال دیکھنے کا مشورہ دیتا ہوں:
public class LocalVariableAndClassMember { private long value; public long calculateValue( final long initial ) { long value = initial; value *= 10; value += value; return value; } } مثال کافی آسان نظر آتی ہے، لیکن یہ ایک جال ہے۔
calculateValue طریقہ ایک مقامی متغیر
ویلیو کو متعارف کرواتا ہے اور اس پر کام کرتے ہوئے، اسی نام کے ساتھ کلاس فیلڈ کو چھپاتا ہے۔ لائن
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. طریقہ کے دلائل اور مقامی متغیرات
ایک اور خرابی جس میں ناتجربہ کار جاوا ڈویلپرز اکثر پڑتے ہیں وہ ہے طریقہ کار کے دلائل کو مقامی متغیر کے طور پر استعمال کرنا۔ جاوا آپ کو غیر مستقل دلائل کو اقدار کو دوبارہ تفویض کرنے کی اجازت دیتا ہے (تاہم، اس کا اصل قدر پر کوئی اثر نہیں ہوتا ہے):
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. پیکنگ اور پیک کھولنا
باکسنگ اور ان باکسنگ ایک تکنیک کا نام ہے جو جاوا میں قدیم اقسام (
int, long, double, etc. ) کو متعلقہ قسم کے ریپرز (
Integer, Long, Double , وغیرہ) میں تبدیل کرنے کے لیے استعمال کیا جاتا ہے۔ جنرکس ٹیوٹوریل کا استعمال کیسے اور کب کرنا ہے کے حصہ 4 میں، آپ نے پہلے ہی اس کو عملی طور پر دیکھا جب میں نے جنرکس کے ٹائپ پیرامیٹرز کے طور پر قدیم اقسام کو لپیٹنے کے بارے میں بات کی۔ اگرچہ جاوا کمپائلر آٹو باکسنگ کے ذریعے اس طرح کے تبادلوں کو چھپانے کی پوری کوشش کرتا ہے، بعض اوقات یہ توقع سے کم ہوتا ہے اور غیر متوقع نتائج پیدا کرتا ہے۔ آئیے ایک مثال دیکھیں:
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/ ) کا استعمال کرتا ہے۔ تاہم، کیونکہ معاہدہ انٹرفیس پر منحصر ہے، مثال کے طور پر، ایک ڈیٹا بیس یا یہاں تک کہ ایک باقاعدہ فلیٹ فائل کا استعمال کرتے ہوئے، انٹرفیس کا دوسرا نفاذ متعارف کروانا بہت آسان ہے۔ ان کے ساتھ، انٹرفیس قابل امتحان کوڈ ڈیزائن کرنے میں بہت مددگار ہیں۔ مثال کے طور پر، ہر ٹیسٹ پر بیرونی خدمات کو کال کرنا ہمیشہ عملی نہیں ہوتا، اس لیے اس کے بجائے ایک متبادل، آسان ترین نفاذ (جیسے اسٹب) کو لاگو کرنا سمجھ میں آتا ہے:
public class TimezoneServiceTestImpl implements TimezoneService { @Override public TimeZone getTimeZone(final double lat, final double lon) throws IOException { return TimeZone.getDefault(); } } اس عمل کو کسی بھی جگہ استعمال کیا جا سکتا ہے جہاں
TimezoneService انٹرفیس کی ضرورت ہو، بیرونی اجزاء پر انحصار سے ٹیسٹ سکرپٹ اس طرح کے انٹرفیس کے موثر استعمال کی بہت سی عمدہ مثالیں جاوا معیاری لائبریری میں سمیٹی گئی ہیں۔ مجموعے، فہرستیں، سیٹس - ان انٹرفیس میں متعدد نفاذات ہیں جو بغیر کسی رکاوٹ کے بدلے جا سکتے ہیں اور جب معاہدوں سے فائدہ اٹھایا جائے تو ان کا تبادلہ کیا جا سکتا ہے۔ مثال کے طور پر:
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. تار
جاوا اور دیگر پروگرامنگ زبانوں دونوں میں سٹرنگز سب سے زیادہ استعمال ہونے والی اقسام میں سے ایک ہیں۔ جاوا لینگویج باکس کے بالکل باہر کنکٹنیشن اور موازنہ کی کارروائیوں کی حمایت کر کے بہت سے معمول کے سٹرنگ ہیرا پھیری کو آسان بناتی ہے۔ اس کے علاوہ، معیاری لائبریری میں بہت سی کلاسیں ہیں جو سٹرنگ آپریشنز کو موثر بناتی ہیں۔ یہ بالکل وہی ہے جو ہم اس سیکشن میں بحث کرنے جا رہے ہیں. جاوا میں، تاریں ناقابل تغیر آبجیکٹ ہیں جن کی نمائندگی UTF-16 انکوڈنگ میں ہوتی ہے۔ جب بھی آپ سٹرنگز کو جوڑتے ہیں (یا کوئی ایسا آپریشن انجام دیتے ہیں جو اصل سٹرنگ کو تبدیل کرتا ہو)،
String کلاس کی ایک نئی مثال بن جاتی ہے ۔ اس کی وجہ سے، کنکٹنیشن آپریشن بہت ناکارہ ہو سکتا ہے، جس کی وجہ سے
سٹرنگ کلاس کی کئی درمیانی مثالیں بنتی ہیں (عموماً کوڑا کرکٹ بنانا)۔ لیکن جاوا معیاری لائبریری میں دو بہت مفید کلاسز ہیں جن کا مقصد سٹرنگ ہیرا پھیری کو آسان بنانا ہے۔ یہ
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.format
String userId = "user:" + new Random().nextInt( 100 ); مددگار طریقہ فراہم کرنے میں مدد کے لیے سٹرنگ فارمیٹنگ کے ساتھ ساتھ جاوا اسٹینڈرڈ لائبریری کا استعمال کرنا اکثر کنکٹنیشن کو آسان بنانے کا بہترین متبادل ہے ۔ یہ فارمیٹ کی وضاحت کرنے والوں کے ایک بھرپور سیٹ کو سپورٹ کرتا ہے، بشمول نمبرز، علامتیں، تاریخ/وقت
، وغیرہ ۔
یہ بات قابل غور ہے کہ جدید جاوا IDEs String.format طریقہ کو پاس کیے گئے دلائل سے فارمیٹ کی تفصیلات کو پارس کر سکتے ہیں اور اگر کوئی مماثلت پائی جاتی ہے تو ڈویلپرز کو متنبہ کر سکتے ہیں۔
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%
8. نام دینے کے معاہدے
جاوا ایک ایسی زبان ہے جو ڈویلپرز کو کسی بھی نام کے کنونشن کی سختی سے پیروی کرنے پر مجبور نہیں کرتی ہے، لیکن کمیونٹی نے سادہ اصولوں کا ایک سیٹ تیار کیا ہے جو جاوا کوڈ کو معیاری لائبریری اور کسی بھی دوسرے جاوا پروجیکٹس دونوں میں یکساں نظر آتا ہے:
- پیکیج کے نام چھوٹے حروف میں ہیں: org.junit, com.fasterxml.jackson, javax.json
- کلاسوں کے نام، شماریات، انٹرفیس، تشریحات بڑے حرف کے ساتھ لکھی جاتی ہیں: StringBuilder، Runnable، @Override
- کھیتوں یا طریقوں کے نام (ماسوائے static final کے ) اونٹ کے اشارے میں بیان کیے گئے ہیں: isEmpty, format, addAll
- جامد حتمی فیلڈ یا گنتی کے مستقل نام بڑے حروف میں ہیں، انڈر سکور ("_") سے الگ کیے گئے ہیں: LOG، MIN_RADIX، INSTANCE۔
- مقامی متغیرات یا طریقہ کار کے دلائل اونٹ کے اشارے میں ٹائپ کیے جاتے ہیں: str، newLength، minimum Capacity
- generics کے لیے پیرامیٹر قسم کے نام اوپری کیس میں ایک ہی حرف سے ظاہر ہوتے ہیں: T, U, E
ان سادہ کنونشنوں پر عمل کرنے سے، آپ جو کوڈ لکھتے ہیں وہ کسی اور لائبریری یا فریم ورک کے انداز میں جامع اور الگ الگ نظر آئے گا، اور محسوس کرے گا کہ اسے ایک ہی شخص نے تیار کیا تھا (ان نادر اوقات میں سے ایک جب کنونشنز حقیقت میں کام کرتے ہیں)۔
9. معیاری لائبریریاں
اس سے کوئی فرق نہیں پڑتا ہے کہ آپ کس قسم کے جاوا پروجیکٹ پر کام کر رہے ہیں، جاوا معیاری لائبریریاں آپ کی بہترین دوست ہیں۔ ہاں، اس بات سے اختلاف کرنا مشکل ہے کہ ان کے کچھ کھردرے کنارے اور عجیب و غریب ڈیزائن کے فیصلے ہیں، تاہم، 99% وقت یہ ماہرین کے ذریعے لکھا ہوا اعلیٰ معیار کا کوڈ ہوتا ہے۔ یہ دریافت کرنے کے قابل ہے۔ ہر جاوا ریلیز موجودہ لائبریریوں میں بہت سی نئی خصوصیات لاتا ہے (پرانی خصوصیات کے ساتھ کچھ ممکنہ مسائل کے ساتھ)، اور بہت سی نئی لائبریریوں کو بھی شامل کرتا ہے۔ Java 5
java.util.concurrent پیکیج کے حصے کے طور پر ایک نئی
کنکرنسی لائبریری لایا ہے ۔
Java 6 نے اسکرپٹنگ ( javax.script پیکیج) اور جاوا کمپائلر
API (
javax.tools پیکیج کے حصے کے طور پر ) کے لیے (کم معروف) تعاون فراہم کیا ہے ۔ Java 7 نے
java.util.concurrent میں بہت سی بہتری لائی،
java.nio.file پیکیج میں ایک نئی I/O لائبریری متعارف کرائی اور
java.lang.invoke میں متحرک زبانوں کے لیے سپورٹ ۔
اور آخر کار، Java 8 نے java.time پیکیج میں طویل انتظار کی
تاریخ/وقت شامل کیا ۔ جاوا ایک پلیٹ فارم کے طور پر تیار ہو رہا ہے اور اس کے لیے مندرجہ بالا تبدیلیوں کے ساتھ ساتھ ترقی کرنا بہت ضروری ہے۔ جب بھی آپ اپنے پروجیکٹ میں تھرڈ پارٹی لائبریری یا فریم ورک کو شامل کرنے پر غور کریں تو یقینی بنائیں کہ معیاری جاوا لائبریریوں میں مطلوبہ فعالیت پہلے سے موجود نہیں ہے (یقیناً، الگورتھم کے بہت سے خصوصی اور اعلیٰ کارکردگی کے نفاذ ہیں جو معیاری لائبریریوں میں الگورتھم، لیکن زیادہ تر معاملات میں ان کی واقعی ضرورت نہیں ہے)۔
10. تغیر پذیری
گائیڈ میں اور اس حصے میں عدم تغیر ایک یاد دہانی کے طور پر باقی ہے: براہ کرم اسے سنجیدگی سے لیں۔ اگر آپ کی ڈیزائن کردہ کلاس یا کوئی طریقہ جو آپ لاگو کرتے ہیں وہ ناقابل تبدیلی کی ضمانت فراہم کر سکتا ہے، تو اسے زیادہ تر صورتوں میں ایک ہی وقت میں ترمیم کیے جانے کے خوف کے بغیر ہر جگہ استعمال کیا جا سکتا ہے۔ یہ ایک ڈویلپر کے طور پر آپ کی زندگی کو آسان بنا دے گا (اور امید ہے کہ آپ کی ٹیم کے اراکین کی زندگیاں)۔
11. جانچ
ٹیسٹ پر مبنی ترقی (TDD) کی مشق جاوا کمیونٹی میں انتہائی مقبول ہے، جو کوڈ کے معیار کے لیے بار بڑھاتی ہے۔ ان تمام فوائد کے ساتھ جو TDD فراہم کرتا ہے، یہ دیکھ کر افسوس ہوتا ہے کہ آج جاوا معیاری لائبریری میں کوئی ٹیسٹ فریم ورک یا سپورٹ ٹولز شامل نہیں ہیں۔
تاہم، جانچ جدید جاوا کی ترقی کا ایک ضروری حصہ بن گئی ہے اور اس حصے میں ہم 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" ) ); } } دونوں ٹیسٹ بہت پڑھنے کے قابل نظر آتے ہیں اور ان پر عمل درآمد مثال ہے۔ آج، اوسط جاوا پروجیکٹ سینکڑوں ٹیسٹ کیسز پر مشتمل ہے، جو ڈیولپر کو ریگریشنز یا فیچرز پر ڈیولپمنٹ کے دوران فوری فیڈ بیک دیتا ہے۔
12. اگلا
گائیڈ کا یہ حصہ جاوا میں پروگرامنگ کی مشق اور اس پروگرامنگ زبان کے دستورالعمل سے متعلق بات چیت کا ایک سلسلہ مکمل کرتا ہے۔ اگلی بار ہم زبان کی خصوصیات پر واپس جائیں گے، مستثنیات، ان کی اقسام، انہیں کیسے اور کب استعمال کرنا ہے، کے حوالے سے جاوا کی دنیا کی تلاش کریں گے۔
13. سورس کوڈ ڈاؤن لوڈ کریں۔
یہ ایڈوانس جاوا کورس سے عمومی ترقی کے اصولوں کا سبق تھا۔ سبق کے لیے سورس کوڈ
یہاں سے ڈاؤن لوڈ کیا جا سکتا ہے ۔
GO TO FULL VERSION