جاوا میں قدیم قسمیں: وہ اتنی قدیم نہیں ہیں۔

تعارف

ایپلیکیشن ڈویلپمنٹ کو کچھ ڈیٹا کے ساتھ کام کرنے کے طور پر سمجھا جا سکتا ہے، یا اس کے بجائے اسے ذخیرہ کرنا اور اس پر کارروائی کرنا۔ آج میں پہلے اہم پہلو پر بات کرنا چاہوں گا۔ جاوا میں ڈیٹا کیسے محفوظ کیا جاتا ہے؟ یہاں ہمارے پاس دو ممکنہ فارمیٹس ہیں: حوالہ اور ابتدائی ڈیٹا کی اقسام۔ آئیے قدیم اقسام کی اقسام اور ان کے ساتھ کام کرنے کے امکانات کے بارے میں بات کرتے ہیں (کوئی کچھ بھی کہے، یہ پروگرامنگ زبان کے بارے میں ہمارے علم کی بنیاد ہے)۔ جاوا قدیم ڈیٹا کی قسمیں وہ بنیاد ہیں جس پر ہر چیز ٹکی ہوئی ہے۔ نہیں، میں بالکل مبالغہ آرائی نہیں کر رہا ہوں۔ اوریکل کے پاس پرائمیٹوز کے لیے ایک علیحدہ ٹیوٹوریل ہے: پرائمیٹو ڈیٹا ٹائپس تھوڑی ہسٹری۔ شروع میں صفر تھا۔ لیکن صفر بورنگ ہے۔ اور پھر تھوڑا سا نمودار ہوا ۔ اسے ایسا کیوں کہا گیا؟ اس کا نام مخفف " bi nary digi t " (بائنری نمبر) سے رکھا گیا ہے۔ یعنی اس کے صرف دو معنی ہیں۔ اور چونکہ یہ صفر تھا، یہ منطقی ہے کہ اب یہ یا تو 0 یا 1 ہے۔ اور زندگی مزید پرلطف ہو گئی ہے۔ ٹکڑوں کو جھنڈ میں جمع ہونا شروع ہو گیا۔ اور ان ریوڑ کو بائٹ (بائٹ) کہا جانے لگا ۔ جدید دنیا میں، بائٹ = 2 سے تیسری طاقت، یعنی 8. لیکن یہ پتہ چلتا ہے کہ یہ ہمیشہ ایسا نہیں تھا. بائٹ نام کہاں سے آیا اس کے بارے میں بہت سے اندازے، افسانے اور افواہیں ہیں۔ کچھ لوگوں کا خیال ہے کہ یہ سب کچھ اس وقت کی انکوڈنگز کے بارے میں ہے، جب کہ دوسروں کا خیال ہے کہ اس طرح معلومات کو پڑھنا زیادہ فائدہ مند تھا۔ بائٹ میموری کا سب سے چھوٹا ایڈریس ایبل ٹکڑا ہے۔ یہ وہ بائٹس ہیں جن کے میموری میں منفرد پتے ہوتے ہیں۔ ایک افسانہ ہے کہ ByTe Binary Term کا مخفف ہے - ایک مشینی لفظ۔ مشین کا لفظ - سیدھے الفاظ میں، یہ ڈیٹا کی وہ مقدار ہے جسے پروسیسر ایک آپریشن میں پروسیس کر سکتا ہے۔ اس سے پہلے، مشین لفظ کا سائز سب سے چھوٹی ایڈریس ایبل میموری کے برابر تھا۔ جاوا میں، متغیر صرف بائٹ ویلیوز کو اسٹور کر سکتے ہیں۔ جیسا کہ میں نے اوپر کہا، جاوا میں دو قسم کے متغیر ہیں:

• java قدیم قسمیں ڈیٹا بائٹس کی قدر کو براہ راست ذخیرہ کرتی ہیں (ہم ذیل میں مزید تفصیل سے ان قدیم اقسام کی اقسام کو دیکھیں گے)؛
• ایک حوالہ کی قسم، آبجیکٹ کے ایڈریس کے بائٹس کو ہیپ میں اسٹور کرتی ہے، یعنی ان متغیرات کے ذریعے ہمیں براہ راست آبجیکٹ تک رسائی حاصل ہوتی ہے (آبجیکٹ کے لیے ریموٹ کنٹرول کی طرح)

جاوا بائٹ

لہذا، تاریخ نے ہمیں ایک بائٹ دیا - میموری کی کم از کم مقدار جسے ہم استعمال کر سکتے ہیں۔ اور یہ 8 بٹس پر مشتمل ہے۔ جاوا میں انٹیجر ڈیٹا کی سب سے چھوٹی قسم بائٹ ہے۔ یہ ایک دستخط شدہ 8 بٹ قسم ہے۔ اس کا کیا مطلب ہے؟ آئیے شمار کرتے ہیں۔ 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 (جاوا زبان کی تفصیلات) کے لنکس بھی شامل ہیں۔ مزید برآں، غلط جگہ پر بائٹ کا استعمال عجیب لمحات کا باعث بن سکتا ہے:

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;

اس طرح کے بے ضرر کوڈ، لیکن ہمیں غلطی ملتی ہے: "خرابی: غیر مطابقت پذیر اقسام: ممکنہ نقصان دہ تبدیلی int سے بائٹ میں۔" آپ کو اسے بائٹ نتیجہ = (بائٹ) (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; // Идеально

میں خود سے آگے نکلنا چاہوں گا۔ اگلا، ہم اس حقیقت پر غور کریں گے کہ پرائمیٹوز کے لیے متعلقہ ریپرز موجود ہیں، جو پرائمیٹو کے ساتھ بطور آبجیکٹ کام کرنا ممکن بناتے ہیں۔ لیکن ایک دلچسپ خصوصیت ہے. یہاں ایک مثال ہے: اسی ٹیوٹوریل پوائنٹ آن لائن کمپائلر کا استعمال کرتے ہوئے، آپ درج ذیل کوڈ کو چیک کر سکتے ہیں:

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 بٹس (انٹ کی طرح) ہے، اور ڈبل کو ڈبل پریسجن قسم کہا جاتا ہے، لہذا یہ 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 اور Strings کا احاطہ کرتا ہے BigDecimal اور جاوا پلیٹ فارم کی طرف سے فراہم کردہ دیگر مفید کلاسز۔ " یعنی فلوٹ اور ڈبل میں رقم کا حساب کرنے کی ضرورت نہیں ہے۔ NASA میں کام کی مثال کو استعمال کرتے ہوئے درستگی کے بارے میں ایک مثال: Java BigDecimal، اعلی درستگی کے حساب سے نمٹنا ٹھیک ہے، اسے اپنے لیے محسوس کرنا:

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

اس مثال پر عمل کریں، اور پھر نمبر 5 اور 4 سے پہلے 0 کا اضافہ کریں۔ اور آپ کو تمام خوفناک منظر نظر آئے گا) موضوع پر فلوٹ اور ڈبل کے بارے میں روسی زبان میں ایک دلچسپ رپورٹ ہے: https://youtu.be/1RCn5ruN1fk کام کرنے کی مثالیں BigDecimal کے ساتھ یہاں دیکھا جا سکتا ہے: BigDecimal کے ساتھ سینٹ بنائیں ویسے، float اور double صرف ایک نمبر سے زیادہ واپس کر سکتے ہیں۔ مثال کے طور پر، نیچے دی گئی مثال انفینٹی کو لوٹائے گی۔

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);
}

فلوٹنگ پوائنٹ نمبرز کے موضوع پر ایک اور عمدہ جائزہ یہ ہے: آپ کا نقطہ کہاں ہے؟

جاوا بولین

اگلی قسم بولین (منطقی قسم) ہے۔ یہ صرف صحیح یا غلط اقدار کو قبول کر سکتا ہے، جو کلیدی الفاظ ہیں۔ منطقی کارروائیوں میں استعمال کیا جاتا ہے جیسے while loops، اور if, switch کا استعمال کرتے ہوئے برانچنگ میں۔ آپ یہاں کون سی دلچسپ چیزیں جان سکتے ہیں؟ ٹھیک ہے، مثال کے طور پر، نظریاتی طور پر، ہمیں صرف 1 بٹ معلومات کی ضرورت ہے، 0 یا 1، یعنی صحیح یا غلط۔ لیکن حقیقت میں، بولین زیادہ میموری لے گا اور یہ مخصوص JVM نفاذ پر منحصر ہوگا۔ عام طور پر اس کی قیمت int کے برابر ہوتی ہے۔ دوسرا آپشن بٹ سیٹ استعمال کرنا ہے۔ جاوا فنڈامینٹلز کی کتاب سے ایک مختصر تفصیل یہ ہے: BitSet

جاوا چار

اب ہم آخری قدیم قسم تک پہنچ چکے ہیں۔ لہذا، چار میں موجود ڈیٹا 16 بٹس لیتا ہے اور کریکٹر کو بیان کرتا ہے۔ جاوا چار کے لیے یونیکوڈ انکوڈنگ کا استعمال کرتا ہے۔ علامت کو دو جدولوں کے مطابق سیٹ کیا جا سکتا ہے (آپ اسے یہاں دیکھ سکتے ہیں ):

• یونیکوڈ کریکٹر ٹیبل
• ASCII کریکٹر ٹیبل

سٹوڈیو میں مثال:

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

ویسے، char، بنیادی طور پر ایک عدد ہونے کی وجہ سے، ریاضی کی کارروائیوں کو سپورٹ کرتا ہے جیسے کہ sum۔ اور بعض اوقات یہ مضحکہ خیز نتائج کا باعث بن سکتا ہے:

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 کو چیک کرنے کی انتہائی سفارش کرتا ہوں ۔ جب میں نے ایک کانفرنس میں اس پہیلی کو دیکھا تو اس نے میری روح کو بلند کردیا۔ مجھے امید ہے کہ آپ کو بھی یہ مثال پسند آئے گی) اپ ڈیٹ: یہ جوکر 2017 میں تھا، رپورٹ: " Java Puzzlers NG S03 - آپ سب کہاں سے آرہے ہیں؟! "

لٹریلز

لغوی ایک واضح طور پر متعین قدر ہے۔ لٹریلز کا استعمال کرتے ہوئے، آپ مختلف نمبر سسٹمز میں اقدار کی وضاحت کر سکتے ہیں:

• اعشاریہ نظام: 10
• ہیکساڈیسیمل: 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، میں پہلے سے ہی بولین، بائٹ، شارٹ، کریکٹر، انٹیجر، فلوٹ، لانگ، ڈبل کلاسز کا نفاذ موجود ہے اور ہمیں اپنی مرضی سے کچھ بنانے کی ضرورت نہیں ہے، لیکن صرف ریڈی میڈ کو دوبارہ استعمال کرنا ہے۔ والے مثال کے طور پر، ایسی کلاسیں ہمیں ایک فہرست بنانے، کہنے، بنانے کی صلاحیت دیتی ہیں۔ ، کیونکہ ایک فہرست میں صرف اشیاء پر مشتمل ہونا چاہئے، جو قدیم نہیں ہیں۔ ایک قدیم قسم کی قدر کو تبدیل کرنے کے لیے، static valueOf کے طریقے ہیں، مثال کے طور پر، Integer.valueOf(4) Integer قسم کی کسی چیز کو لوٹائے گا۔ ریورس کنورژن کے لیے intValue(), longValue(), وغیرہ طریقے ہیں۔ اوپر پیش کی گئی آٹو پیکنگ اور آٹو ان پیکنگ کی مثال دراصل کیسی دکھتی ہے:

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 — хранят значения типа "истина/ложь".
• حروف - اس گروپ میں چار قسم شامل ہے۔

جیسا کہ اوپر کا متن دکھایا گیا ہے، جاوا میں قدیم چیزیں اتنی قدیم نہیں ہیں اور آپ کو بہت سے مسائل کو مؤثر طریقے سے حل کرنے کی اجازت دیتی ہیں۔ لیکن اس میں کچھ خصوصیات بھی متعارف کرائی گئی ہیں جنہیں ہمیں ذہن میں رکھنا چاہیے اگر ہم اپنے پروگرام میں غیر متوقع رویے کا سامنا نہیں کرنا چاہتے ہیں۔ جیسا کہ وہ کہتے ہیں، آپ کو ہر چیز کی قیمت ادا کرنی ہوگی۔ اگر ہم "کھڑی" (وسیع) رینج کے ساتھ ایک قدیم چاہتے ہیں - کچھ لمبی جیسی - ہم میموری کے ایک بڑے ٹکڑے کو مختص کرنے اور مخالف سمت میں قربان کردیتے ہیں۔ میموری کو بچانے اور بائٹس استعمال کرنے سے، ہم -128 سے 127 تک محدود رینج حاصل کرتے ہیں۔