جاوا ۾ پرائمري قسمون: اهي اهي ابتدائي نه آهن

تعارف

ايپليڪيشن ڊولپمينٽ سمجهي سگهجي ٿو ڪجھ ڊيٽا سان ڪم ڪرڻ، يا بلڪه، ان کي اسٽوريج ۽ پروسيسنگ. اڄ مان پهرين اهم پهلوءَ تي ڌيان ڏيڻ چاهيان ٿو. جاوا ۾ ڊيٽا ڪيئن محفوظ ٿيل آهي؟ هتي اسان وٽ ٻه ممڪن فارميٽ آهن: حوالو ۽ ابتدائي ڊيٽا جا قسم. اچو ته ابتدائي قسمن جي قسمن ۽ انهن سان ڪم ڪرڻ جي امڪانن جي باري ۾ ڳالهايون (جيڪو ڪجهه به چئي سگهي ٿو، اهو پروگرامنگ ٻولي جي اسان جي ڄاڻ جو بنياد آهي). جاوا پرائمري ڊيٽا جا قسم بنياد آھن جن تي سڀ ڪجھ باقي آھي. نه، مان هرگز مبالغه نه ڪري رهيو آهيان. Oracle وٽ ھڪڙو جدا سبق آھي پرائمٽيوز لاءِ وقف ڪيو ويو آھي: Primitive Data Types A little history. شروعات ۾ اتي صفر هو. پر صفر بورنگ آهي. ۽ پوء ڪجهه ظاهر ٿيو . هن کي اهو ڇو سڏيو ويو؟ ان جو نالو مخفف ” bi nary digi t “ (binary number) تان رکيو ويو. يعني ان جا فقط ٻه مطلب آهن. ۽ جڏهن کان اهو صفر هو، اهو منطقي آهي ته هاڻي اهو يا ته 0 يا 1 آهي. ۽ زندگي وڌيڪ مزو بڻجي وئي آهي. ٻڪريون رڍن ۾ گڏ ٿيڻ لڳيون. ۽ انهن رڍن کي بائيٽ (بائيٽ) سڏڻ لڳو . جديد دنيا ۾، بائيٽ = 2 کان ٽئين طاقت، يعني. 8. پر اهو ظاهر ٿيو ته اهو هميشه نه هو. اتي ڪيترائي اندازا، ڏند ڪٿا ۽ افواهون آھن جتي نالو بائيٽ ڪٿان آيو آھي. ڪجهه ماڻهن جو خيال آهي ته اهو سڀ ڪجهه ان وقت جي انڪوڊنگز جي باري ۾ آهي، جڏهن ته ٻيا سمجهن ٿا ته ان طريقي سان معلومات پڙهڻ وڌيڪ فائديمند هو. بائيٽ ياداشت جو سڀ کان ننڍڙو پتي وارو ٽڪرو آهي. اهو بائٽس آهي جيڪي ميموري ۾ منفرد ايڊريس آهن. اتي هڪ ڏند ڪٿا آهي ته ByTe بائنري اصطلاح لاء هڪ مخفف آهي - هڪ مشين لفظ. مشين جو لفظ - سادو رکو، هي ڊيٽا جو مقدار آهي جيڪو پروسيسر هڪ آپريشن ۾ پروسيس ڪري سگهي ٿو. اڳي، مشيني لفظ جي سائيز ننڍي پتي واري ياداشت جي برابر هئي. جاوا ۾، متغير صرف بائيٽ ويلز کي ذخيرو ڪري سگھن ٿا. جيئن مون مٿي چيو آهي، جاوا ۾ ٻه قسم جا متغير آهن:

• java primitive type سڌو سنئون ڊيٽا بائيٽس جي قيمت کي محفوظ ڪري ٿو (اسان هيٺ ڏنل تفصيل سان انهن پرائمري جي قسمن تي نظر ڪنداسين)؛
• هڪ حوالو جو قسم، هيپ ۾ اعتراض جي ايڊريس جي بائيٽ کي ذخيرو ڪري ٿو، اهو آهي، انهن متغيرن جي ذريعي اسان سڌو سنئون اعتراض تائين رسائي حاصل ڪندا آهيون (آبجیکٹ لاءِ ريموٽ ڪنٽرول جي ترتيب)

جاوا بائيٽ

تنهن ڪري، تاريخ اسان کي بائيٽ ڏني آهي - ياداشت جي گهٽ ۾ گهٽ مقدار جيڪا اسان استعمال ڪري سگهون ٿا. ۽ اهو 8 بٽس تي مشتمل آهي. جاوا ۾ سڀ کان ننڍو انٽيجر ڊيٽا جو قسم بائيٽ آهي. هي هڪ دستخط ٿيل 8-bit قسم آهي. هن جو ڇا مطلب آهي؟ اچو ته شمار ڪريون. 2^8 آهي 256. پر جيڪڏهن اسان هڪ منفي نمبر چاهيون ٿا؟ ۽ جاوا ڊولپرز فيصلو ڪيو ته بائنري ڪوڊ "10000000" -128 جي نمائندگي ڪندو، اهو آهي، سڀ کان اهم سا (کاٻي پاسي وارو سا) ظاهر ڪندو ته ڇا نمبر منفي آهي. بائنري "0111 1111" 127 جي برابر آهي. اهو آهي، 128 ڪنهن به طرح نامزد نه ٿو ڪري سگهجي، ڇاڪاڻ ته اهو ٿيندو -128. مڪمل حساب هن جواب ۾ ڏنو ويو آهي: جاوا ۾ بائيٽ جي حد -128 کان 127 ڇو آهي؟ سمجھڻ لاءِ ته انگ ڪيئن حاصل ڪيا ويا آھن، توھان کي تصوير ڏسڻ گھرجي: ان مطابق، ماپ ڪرڻ لاءِ 2^(8-1) = 128. هن جو مطلب آهي گھٽ ۾ گھٽ حد (۽ ان ۾ هڪ مائنس آهي) -128 هوندو. ۽ وڌ ۾ وڌ آهي 128 - 1 (ذڪر صفر). اھو آھي، وڌ ۾ وڌ 127 ھوندو. حقيقت ۾، اسان بائيٽ ٽائيپ سان ڪم نه ڪندا آھيون گھڻو ڪري "اعلي سطح" تي. بنيادي طور تي هي "خام" ڊيٽا جي پروسيسنگ آهي. مثال طور، جڏهن هڪ نيٽ ورڪ تي ڊيٽا ٽرانسميشن سان ڪم ڪري رهيو آهي، جڏهن ڊيٽا 0s ۽ 1s جو هڪ سيٽ آهي جيڪو ڪجهه مواصلاتي چينل ذريعي منتقل ڪيو ويو آهي. يا جڏهن فائلن مان ڊيٽا پڙهڻ. اهي پڻ استعمال ڪري سگھجن ٿيون جڏهن تار ۽ انڪوڊنگ سان ڪم ڪري رهيا آهن. مثال ڪوڊ:

public static void main(String []args){
        byte value = 2;
        byte shortByteValue = 0b10; // 2
        System.out.println(shortByteValue);
        // Начиная с JDK7 мы можем разделять литералы подчёркиваниями
        byte minByteValue = (byte) 0B1000_0000; // -128
        byte maxByteValue = (byte) 0b0111_1111; // 127
        byte minusByteValue = (byte) 0b1111_1111; // -128 + 127
        System.out.println(minusByteValue);
        System.out.println(minByteValue + " to " + maxByteValue);
}

رستي جي ذريعي، اهو نه سوچيو ته بائيٽ قسم استعمال ڪندي ياداشت جي استعمال کي گھٽائي ڇڏيندو. بائيٽ خاص طور تي ميموري جي استعمال کي گھٽائڻ لاءِ استعمال ڪيو ويندو آهي جڏهن ڊيٽا کي صفن ۾ محفوظ ڪيو ويندو آهي (مثال طور، نيٽ ورڪ تي حاصل ڪيل ڊيٽا کي ڪجهه بفر ۾ محفوظ ڪرڻ، جنهن کي بائيٽ ايري طور لاڳو ڪيو ويندو). پر جڏهن ڊيٽا تي عمل ڪندي، بائيٽ استعمال ڪندي توهان جي اميدن کي پورو نه ڪندي. اهو جاوا ورچوئل مشين (JVM) جي نفاذ جي ڪري آهي. جيئن ته اڪثر سسٽم 32 يا 64 بٽ آهن، حساب جي دوران بائيٽ ۽ شارٽ کي 32-بٽ انٽ ۾ تبديل ڪيو ويندو، جنهن بابت اسان بعد ۾ ڳالهائينداسين. اهو حساب ڪتاب کي آسان بڻائي ٿو. وڌيڪ تفصيل لاءِ، ڏسو ڇا بائيٽ جو اضافو int ۾ بدلجي ٿو جاوا ٻوليءَ جي ضابطن جي ڪري يا jvm جي ڪري؟ . جواب ۾ JLS (Java Language Specification) جا لنڪ پڻ شامل آهن. اضافي طور تي، غلط جاء تي بائيٽ استعمال ڪندي عجيب لمحن جي ڪري سگھي ٿو:

public static void main(String []args){
        for (byte i = 1; i <= 200; i++) {
            System.out.println(i);
        }
}

هتي هڪ لوپ ٿيندو. ڇاڪاڻ ته انسداد جي قيمت وڌ ۾ وڌ (127) تائين پهچي ٿي، هڪ اوور فلو ٿيندو ۽ قيمت -128 ٿي ويندي. ۽ اسان ڪڏهن به چڪر مان ٻاهر نه نڪرنداسين.

مختصر

بائيٽ جي قيمتن جي حد تمام ننڍڙو آهي. تنهن ڪري، ايندڙ ڊيٽا جي قسم لاء اسان بٽ جي تعداد کي ٻيڻو ڪرڻ جو فيصلو ڪيو. اھو آھي، ھاڻي اھو 8 بٽ نه آھي، پر 16. اھو آھي، 2 بٽ. قدر به ساڳيء طرح حساب ڪري سگهجي ٿو. 2^(16-1) = 2^15 = 32768. هن جو مطلب آهي حد -32768 کان 32767 تائين. اهو تمام گهٽ استعمال ڪيو ويندو آهي ڪنهن خاص ڪيسن لاءِ. جيئن ته جاوا ٻولي دستاويز اسان کي ٻڌائي ٿو: " توهان هڪ مختصر استعمال ڪري سگهو ٿا ميموري کي وڏي صفن ۾ محفوظ ڪرڻ لاء ."

int

تنهنڪري اسان کي حاصل ڪيو ويو اڪثر استعمال ٿيل قسم. اهو وٺي ٿو 32 بٽ، يا 4 بائيٽ. عام طور تي، اسان ٻه ڀيرا جاري رکون ٿا. قدرن جي حد -2 ^ 31 کان 2 ^ 31 - 1 تائين آهي.

وڌ ۾ وڌ int قدر

int 2147483648 جي وڌ ۾ وڌ قيمت 1 آهي، جيڪو تمام ننڍو ناهي. جيئن مٿي بيان ڪيو ويو آهي، حساب کي بهتر ڪرڻ لاء، ڇاڪاڻ ته اهو جديد ڪمپيوٽرن لاءِ وڌيڪ آسان آهي، انهن جي بٽ ظرفيت کي مدنظر رکندي، ڳڻپ ڪرڻ؛ ڊيٽا کي واضح طور تي int ۾ تبديل ڪري سگهجي ٿو. هتي هڪ سادي مثال آهي:

byte a = 1;
byte b = 2;
byte result = a + b;

اهڙو بي ضرر ڪوڊ، پر اسان کي غلطي ملي ٿي: "غلطي: غير مطابقت واري قسم: ممڪن نقصان واري تبديلي انٽ کان بائيٽ تائين." توھان کي ان کي درست ڪرڻو پوندو byte result = (byte)(a + b)؛ ۽ هڪ وڌيڪ بي ضرر مثال. ڇا ٿيندو جيڪڏهن اسان هيٺ ڏنل ڪوڊ هلون؟

int value = 4;
System.out.println(8/value);
System.out.println(9/value);
System.out.println(10/value);
System.out.println(11/value);

۽ اسان نتيجو حاصل ڪنداسين

2
2
2
2

*خوف جا آواز* حقيقت اها آهي ته جڏهن int قدرن سان ڪم ڪندي، باقي رهي ٿو ڇڏي، صرف سڄو حصو ڇڏي (اهڙين حالتن ۾ اهو بهتر آهي ته ڊبل استعمال ڪرڻ).

ڊگهو

اسان ٻيڻو جاري رکون ٿا. اسان 32 کي 2 سان ضرب ڪيو ۽ 64 بٽ حاصل ڪيو. روايت موجب، هي 4 * 2 آهي، يعني 8 بائيٽ. قدرن جي حد -2^63 کان 2^63 تائين آهي – 1. ڪافي کان وڌيڪ. هي قسم توهان کي وڏي، وڏي انگن اکرن کي ڳڻڻ جي اجازت ڏئي ٿو. اڪثر وقت سان ڪم ڪرڻ وقت استعمال ڪيو ويندو آهي. يا ڊگھي فاصلي تي، مثال طور. اهو ظاهر ڪرڻ لاءِ ته هڪ نمبر ڊگهو آهي، لغوي نمبر جي پٺيان L - ڊگهو رکو. مثال:

long longValue = 4;
longValue = 1l; // Не ошибка, но плохо читается
longValue = 2L; // Идеально

مان پاڻ کي اڳتي وڌڻ چاهيان ٿو. اڳيون، اسان ان حقيقت تي غور ڪنداسين ته پرائمري لاء لاڳاپيل لفافي موجود آهن، جيڪي شيون جي طور تي ابتدائي سان ڪم ڪرڻ ممڪن بڻائين ٿا. پر اتي هڪ دلچسپ خصوصيت آهي. هتي هڪ مثال آهي: ساڳي Tutorialspoint آن لائن ڪمپلر استعمال ڪندي، توهان هيٺ ڏنل ڪوڊ چيڪ ڪري سگهو ٿا:

public class HelloWorld {

     public static void main(String []args) {
        printLong(4);
     }

    public static void printLong(long longValue) {
        System.out.println(longValue);
    }
}

هي ڪوڊ بغير ڪنهن غلطي جي ڪم ڪري ٿو، سڀ ڪجهه ٺيڪ آهي. پر جيئن ئي پرنٽ لانگ ميٿڊ ۾ ٽائيپ کي لانگ کان لانگ ۾ تبديل ڪيو ويندو آهي (يعني ٽائيپ پرائميوٽ نه پر اعتراض ٿيندو آهي)، اهو جاوا لاءِ اڻڄاڻ ٿي ويندو آهي ته اسان ڪهڙي پيراميٽر پاس ڪري رهيا آهيون. اهو فرض ڪرڻ شروع ٿئي ٿو ته هڪ int منتقل ٿي رهيو آهي ۽ اتي هڪ غلطي هوندي. تنهن ڪري، هڪ طريقي جي صورت ۾، اهو ضروري آهي ته واضح طور تي 4L اشارو ڪيو وڃي. گهڻو ڪري ڊگھو هڪ ID طور استعمال ڪيو ويندو آهي جڏهن ڊيٽابيس سان ڪم ڪندي.

جاوا فلوٽ ۽ جاوا ڊبل

انهن قسمن کي فلوٽنگ پوائنٽ قسم سڏيو ويندو آهي. اهو آهي، اهي عددي قسم نه آهن. فلوٽ جو قسم 32 بِٽ (جهڙوڪ int) آھي، ۽ ڊبل کي ڊبل پرسيجن ٽائيپ چئبو آھي، تنھنڪري اھو 64 بِٽ آھي (2 سان ضرب ڪريو، جيئن اسان چاهيون ٿا). مثال:

public static void main(String []args){
        // float floatValue = 2.3; lossy conversion from double to float
        float floatValue = 2.3F;
        floatValue = 2.3f;
        double doubleValue = 2.3;
        System.out.println(floatValue);
        double cinema = 7D;
}

۽ هتي قدرن ۾ فرق جو هڪ مثال آهي (قسم جي درستگي جي ڪري):

public static void main(String []args){
        float piValue = (float)Math.PI;
        double piValueExt = Math.PI;
        System.out.println("Float value: " + piValue );
        System.out.println("Double value: " + piValueExt );
 }

اهي ابتدائي قسمون رياضي ۾ استعمال ٿيندا آهن، مثال طور. هتي ثبوت آهي، نمبر PI حساب ڪرڻ لاء هڪ مسلسل . خير، عام طور تي، توهان ڏسي سگهو ٿا API جي رياضي ڪلاس جي. هتي اهو آهي ته ٻيو ڇا هجڻ گهرجي اهم ۽ دلچسپ: جيتوڻيڪ دستاويز چوي ٿو: " هن ڊيٽا جو قسم ڪڏهن به درست قدرن لاءِ استعمال نه ڪيو وڃي، جهڙوڪ ڪرنسي. ان لاءِ، توھان کي استعمال ڪرڻ جي ضرورت پوندي java.math.BigDecimal ڪلاس بجاءِ.Numbers and Strings covers BigDecimal ۽ جاوا پليٽ فارم پاران مهيا ڪيل ٻيا مفيد ڪلاس. " اهو آهي، فلوٽ ۽ ڊبل ۾ پئسا حساب ڪرڻ جي ضرورت ناهي. NASA تي ڪم جو مثال استعمال ڪندي درستگي بابت هڪ مثال: Java BigDecimal, Dealing with high precision calculations خير، پاڻ کي محسوس ڪرڻ لاءِ:

public static void main(String []args){
        float amount = 1.0000005F;
        float avalue = 0.0000004F;
        float result = amount - avalue;
        System.out.println(result);
}

هن مثال تي عمل ڪريو، ۽ پوءِ 0 شامل ڪريو انگن 5 ۽ 4 کان اڳ. ۽ توهان تمام خوفناڪ ڏسندا) فلوٽ ۽ ڊبل بابت روسي ۾ هڪ دلچسپ رپورٽ آهي موضوع تي: https://youtu.be/1RCn5ruN1fk ڪم ڪرڻ جا مثال BigDecimal سان هتي ڏسي سگھجي ٿو: بگ ڊيسيمل سان سينٽ ٺاهيو، رستي ۾، فلوٽ ۽ ڊبل صرف هڪ انگ کان وڌيڪ واپس ڪري سگھن ٿا. مثال طور، هيٺ ڏنل مثال Infinity واپس ڪندو:

public static void main(String []args){
        double positive_infinity = 12.0 / 0;
        System.out.println(positive_infinity);
}

۽ هي هڪ واپس ڪندو NAN:

public static void main(String []args){
        double positive_infinity = 12.0 / 0;
        double negative_infinity = -15.0 / 0;
        System.out.println(positive_infinity + negative_infinity);
}

اهو لامحدوديت بابت واضح آهي. NaN ڇا آهي؟ هي نمبر نه آهي ، مطلب ته نتيجو ڳڻپ نه ٿو ڪري سگهجي ۽ هڪ نمبر نه آهي. هتي هڪ مثال آهي: اسان -4 جي چورس روٽ کي ڳڻڻ چاهيون ٿا. 4 جو چورس روٽ 2 آهي. يعني 2 کي چورس ٿيڻو پوندو ۽ پوءِ اسان کي 4 ملندو. -4 حاصل ڪرڻ لاءِ ڪهڙي چورس ٿيڻ گهرجي؟ اهو ڪم نه ڪندو، ڇاڪاڻ ته ... جيڪڏھن ھڪڙو مثبت نمبر آھي، پوء اھو رھندو. ۽ جيڪڏھن اھو منفي ھو، پوء مائنس کان مائنس ھڪڙو پلس ڏيندو. اهو آهي، اهو شمار نه آهي.

public static void main(String []args){
        double sqrt = Math.sqrt(-4);
        System.out.println(sqrt + 1);
        if (Double.isNaN(sqrt)) {
           System.out.println("So sad");
        }
        System.out.println(Double.NaN == sqrt);
}

هتي سچل پوائنٽ نمبرن جي موضوع تي هڪ ٻيو وڏو جائزو آهي: توهان جو نقطو ڪٿي آهي؟

جاوا بوليان

ايندڙ قسم آهي Boolean (منطقي قسم). اهو صرف انهن قدرن کي قبول ڪري سگهي ٿو صحيح يا غلط، جيڪي لفظ آهن. منطقي عملن ۾ استعمال ٿيندو آهي جيئن ته جڏهن لوپ، ۽ برانچنگ ۾ if، switch استعمال ڪندي. توهان هتي ڪهڙيون دلچسپ شيون ڳولي سگهو ٿا؟ خير، مثال طور، نظرياتي طور تي، اسان کي صرف 1 بٽ معلومات جي ضرورت آهي، 0 يا 1، اهو آهي، صحيح يا غلط. پر حقيقت ۾، بوليان وڌيڪ ياداشت کڻندو ۽ اهو منحصر هوندو مخصوص JVM عمل درآمد تي. عام طور تي ان جي قيمت int جي برابر آهي. ٻيو اختيار استعمال ڪرڻ آهي BitSet. هتي جاوا بنياديات جي ڪتاب مان هڪ مختصر وضاحت آهي: BitSet

جاوا چار

هاڻي اسان آخري ابتدائي قسم تي پهچي چڪا آهيون. تنهن ڪري، چار ۾ ڊيٽا 16 بٽ وٺي ٿو ۽ ڪردار کي بيان ڪري ٿو. جاوا چار لاءِ يونيڪوڊ انڪوڊنگ استعمال ڪري ٿو. علامت ٻن جدولن جي مطابق مقرر ڪري سگھجي ٿو (توهان ان کي هتي ڏسي سگهو ٿا ):

• يونيڪوڊ ڪردار جدول
• ASCII ڪردار ٽيبل

اسٽوڊيو ۾ مثال:

public static void main(String[] args) {
    char symbol = '\u0066'; // Unicode
    symbol = 102; // ASCII
    System.out.println(symbol);
}

رستي ۾، چار، بنيادي طور تي هڪ انگ هجڻ ڪري، رياضياتي عملن کي سپورٽ ڪري ٿو جهڙوڪ رقم. ۽ ڪڏهن ڪڏهن هي مضحکہ خیز نتيجا ڏئي سگهي ٿو:

public class HelloWorld{

    public static void main(String []args){
        String costForPrint = "5$";
        System.out.println("Цена только для вас " +
        + costForPrint.charAt(0) + getCurrencyName(costForPrint.charAt(1)));
    }

    public static String getCurrencyName(char symbol) {
        if (symbol == '$') {
            return " долларов";
        } else {
            throw new UnsupportedOperationException("Not implemented yet");
        }
    }

}

مان تمام گهڻي سفارش ڪريان ٿو آن لائن IDE کي چيڪ ڪريو tutorialspoint مان . جڏهن مون هن پزل کي هڪ ڪانفرنس ۾ ڏٺو، اهو منهنجو روح بلند ڪيو. مون کي اميد آهي ته توهان کي پڻ مثال پسند ايندو) تازه ڪاري: هي جوڪر 2017 تي هو، رپورٽ: " جاوا پزلرز NG S03 - توهان سڀ ڪٿان کان اچي رهيا آهيو؟! "

لفظي

هڪ لفظي هڪ واضح طور تي بيان ڪيل قدر آهي. لفظي استعمال ڪندي، توھان مختلف نمبر سسٽم ۾ قدر بيان ڪري سگھو ٿا:

• ڊيسيمل سسٽم: 10
• Hexadecimal: 0x1F4، 0x سان شروع ٿئي ٿو
• اوڪٽل سسٽم: 010، صفر کان شروع ٿئي ٿو.
• بائنري سسٽم (جاوا7 کان وٺي): 0b101، 0b تي شروع ٿئي ٿو

مان آڪٽل سسٽم تي ٿورو وڌيڪ رهان ها، ڇاڪاڻ ته اهو عجيب آهي:

int costInDollars = 08;

ڪوڊ جي هي لائن مرتب نه ٿيندي:

error: integer number too large: 08

لڳي ٿو بيوقوف. هاڻي اچو ته بائنري ۽ آڪٽل سسٽم جي باري ۾ ياد رکون. بائنري سسٽم ۾ ڪو به ٻه نه آهن، ڇاڪاڻ ته اتي ٻه قدر آهن (شروع ٿيندڙ 0). ۽ آڪٽل سسٽم ۾ 8 قدر آهن، صفر کان شروع ٿيندي. اهو آهي، قيمت 8 پاڻ موجود ناهي. تنهن ڪري، اها هڪ غلطي آهي جيڪا پهرين نظر ۾ بيوقوف لڳي ٿي. ۽ ياد رکڻ لاءِ، ھتي آھي ”فالو اپ“ قاعدو قدرن جي ترجمي لاءِ:

ڪپڙا ڪلاس

جاوا ۾ پرائمري جا پنهنجا ريپر ڪلاس آهن ته جيئن توهان انهن سان گڏ ڪم ڪري سگهو ٿا شيون. اهو آهي، هر ابتدائي قسم لاء هڪ لاڳاپيل حوالو قسم آهي. لفافي طبقن کي تبديل نه ڪيو وڃي ٿو: هن جو مطلب آهي ته هڪ ڀيرو هڪ اعتراض پيدا ٿئي ٿي، ان جي حالت - قدر جي فيلڊ جي قيمت - تبديل نه ٿي ڪري سگھجي. ريپر طبقن کي حتمي قرار ڏنو ويو آهي: شيون، تنهنڪري ڳالهائڻ، صرف پڙهڻ لاء. مان اهو به ذڪر ڪرڻ چاهيان ٿو ته انهن طبقن مان وارث ٿيڻ ممڪن ناهي. جاوا خود بخود ابتدائي قسمن ۽ انهن جي لفافن جي وچ ۾ تبديلي آڻيندو آهي:

Integer x = 9;          // autoboxing
int n = new Integer(3); // unboxing

ابتدائي قسمن کي حوالن جي قسمن (int->Integer) ۾ تبديل ڪرڻ جي عمل کي آٽو باڪسنگ چئبو آھي ، ۽ ريورس کي انباڪسنگ چئبو آھي . انهن طبقن کي ڪنهن شئي جي اندر هڪ ابتدائي ذخيرو ڪرڻ ممڪن بڻائي ٿو، ۽ اعتراض پاڻ کي هڪ اعتراض (چڱو، ڪنهن ٻئي شئي وانگر) وانگر عمل ڪندو. ان سان گڏ، اسان کي مختلف، مفيد جامد طريقن جو هڪ وڏو تعداد ملي ٿو، جهڙوڪ انگن جو مقابلو ڪرڻ، هڪ اکر کي رجسٽر ڪرڻ ۾ تبديل ڪرڻ، اهو طئي ڪرڻ ته ڇا هڪ اکر آهي يا هڪ نمبر، گهٽ ۾ گهٽ نمبر ڳولڻ، وغيره. ڪارڪردگي جو مهيا ڪيل سيٽ صرف لفافي تي منحصر آهي. int لاءِ هڪ ريپر جي توهان جي پنهنجي عمل درآمد جو هڪ مثال:

public class CustomerInt {

   private final int value;

   public CustomerInt(int value) {
       this.value = value;
   }

   public int getValue() {
       return value;
   }
}

مکيه پيڪيج، java.lang، اڳ ۾ ئي Boolean, Byte, Short, Character, Integer, Float, Long, Double ڪلاسن تي عمل درآمد ڪري چڪو آهي ۽ اسان کي پنهنجي طرفان ڪا به شيءِ ٺاهڻ جي ضرورت نه آهي، پر صرف تيار ڪيل شيون ٻيهر استعمال ڪرڻ گهرجن. وارا. مثال طور، اهڙا ڪلاس اسان کي هڪ فهرست ٺاهڻ، چئو، ٺاهڻ جي صلاحيت ڏين ٿا , ڇاڪاڻ ته هڪ فهرست ۾ صرف شيون شامل ٿيڻ گهرجن، جيڪي ابتدائي نه آهن. ھڪڙي ابتدائي قسم جي ھڪڙي قدر کي تبديل ڪرڻ لاء، جامد قدر جا طريقا آھن، مثال طور، Integer.valueOf(4) Integer قسم جي ھڪڙي اعتراض کي واپس ڪندو. ريورس ڪنورشن لاءِ طريقا آهن intValue(), longValue(), وغيره. ڪمپائلر ڪالز داخل ڪري ٿو ValueOf ۽ *Value پاڻ تي، هي آٽو باڪسنگ ۽ آٽو ان باڪسنگ جو جوهر آهي. مٿي ڏنل پيش ڪيل آٽو پيڪنگ ۽ آٽوپيڪنگ جو مثال ڇا ڏسڻ ۾ اچي ٿو:

Integer x = Integer.valueOf(9);
int n = new Integer(3).intValue();

توهان هن مضمون ۾ خودڪار پيڪنگ ۽ خودڪار پيڪنگ بابت وڌيڪ پڙهي سگهو ٿا .

ڪاسٽ

При работе с примитивами существует такое понятие How приведение типов, одно из не очень приятных свойств C++, тем не менее приведение типов сохранено и в языке Java. Иногда мы сталкиваемся с такими ситуациями, когда нам нужно совершать взаимодействия с данными разных типов. И очень хорошо, что в некоторых ситуациях это возможно. В случае с ссылочными переменными, там свои особенности, связанные с полиморфизмом и наследованием, но сегодня мы рассматриваем простые типы и соответственно приведение простых типов. Существует преобразование с расширением и преобразование сужающее. Всё на самом деле просто. Если тип данных становится больше (допустим, был int, а стал long), то тип становится шире (из 32 бит становится 64). И в этом случае мы не рискуем потерять данные, т.к. если влезло в int, то в long влезет тем более, поэтому данное приведение мы не замечаем, так How оно осуществляется автоматически. А вот в обратную сторону преобразование требует явного указания от нас, данное приведение типа называется — сужение. Так сказать, чтобы мы сами сказали: «Да, я даю себе отчёт в этом. В случае чего — виноват сам».

public static void main(String []args){
   int intValue = 128;
   byte value = (byte)intValue;
   System.out.println(value);
}

Whatбы потом в таком случае не говорor что «Ваша Джава плохая», когда получат внезапно -128 instead of 128 ) Мы ведь помним, что в byteе 127 верхнее meaning и всё что находилось выше него соответственно можно потерять. Когда мы явно превратor наш int в byte, то произошло переполнение и meaning стало -128.

Область видимости

Это то место в codeе, где данная переменная будет выполнять свои функции и хранить в себе Howое-то meaning. Когда же эта область закончится, переменная перестанет существовать и будет стерта из памяти и. How уже можно догадаться, посмотреть or получить ее meaning будет невозможно! Так что же это такое — область видимости? Область определяется "блоком" — вообще всякой областью, замкнутой в фигурные скобки, выход за которые сулит удаление данных объявленных в ней. Или How минимум — сокрытие их от других блоков, открытых вне текущего. В Java область видимости определяется двумя основными способами:

• Классом.
• Методом.

Как я и сказал, переменная не видна codeу, если она определена за пределами блока, в котором она была инициализирована. Смотрим пример:

int x;
x = 6;
if (x >= 4) {
   int y = 3;
}
x = y;// переменная y здесь не видна!

И How итог мы получим ошибку:

Error:(10, 21) java: cannot find symbol
  symbol:   variable y
  location: class com.javaRush.test.type.Main

Области видимости могут быть вложенными (если мы объявor переменную в первом, внешнем блоке, то во внутреннем она будет видна).

Заключение

Сегодня мы познакомorсь с восемью примитивными типами в Java. Эти типы можно разделить на четыре группы:

• Целые числа: byte, short, int, long — представляют собой целые числа со знаком.
• Числа с плавающей точкой — эта группа включает себе float и double — типы, которые хранят числа с точностью до определённого знака после запятой.
• Булевы значения — boolean — хранят значения типа "истина/ложь".
• اکر - ھن گروپ ۾ چار قسم شامل آھن.

جيئن مٿي ڏنل متن ڏيکاريو ويو آهي، جاوا ۾ primitives ايترو ابتدائي نه آهن ۽ توهان کي ڪيترن ئي مسئلن کي مؤثر طريقي سان حل ڪرڻ جي اجازت ڏين ٿا. پر هي پڻ ڪجهه خاصيتون متعارف ڪرايون ٿا جيڪي اسان کي ذهن ۾ رکڻ گهرجن جيڪڏهن اسان نٿا چاهيون ته اسان جي پروگرام ۾ غير متوقع رويي کي منهن ڏيڻو پوي. جيئن اهي چون ٿا، توهان کي هر شيء لاء ادا ڪرڻو پوندو. جيڪڏهن اسان هڪ ”اسٽيپ“ (وڏين) رينج سان هڪ پرائمري چاهيون ٿا - ڪجهه ڊگهو جهڙو - اسان ياداشت جي وڏي ٽڪري جي تخصيص کي قربان ڪريون ٿا ۽ مخالف طرف. ميموري کي بچائڻ ۽ بائيٽ استعمال ڪندي، اسان کي -128 کان 127 تائين محدود رينج ملي ٿو.