ریخته گری double به int java. تبدیل را در جاوا تایپ کنید

گاهی اوقات موقعیت‌هایی پیش می‌آیند که شما مقداری از نوع خاصی دارید و باید آن را به متغیری از نوع دیگری نسبت دهید. برای برخی از انواع، این می تواند بدون ریخته گری نوع انجام شود، در چنین مواردی از تبدیل نوع خودکار صحبت می شود. در جاوا، تبدیل خودکار تنها زمانی امکان پذیر است که نمایش عددی متغیر مقصد به اندازه کافی دقیق باشد که مقدار اصلی را حفظ کند. چنین تبدیلی رخ می دهد، برای مثال، زمانی که یک ثابت تحت اللفظی یا مقدار یک متغیر از نوع byte یا short وارد متغیری از نوع int می شود. نامیده می شود افزونه (گسترده شدن) یا افزایش دادن (ترویج), زیرا نوع عمق بیت کوچکتر به یک نوع سازگار بزرگتر گسترش می یابد (بالا می رود). اندازه نوع int همیشه به اندازه کافی بزرگ است تا اعداد را از محدوده مجاز برای نوع بایت ذخیره کند، بنابراین در موقعیت های مشابههیچ اپراتور بازیگری واضحی مورد نیاز نیست. عکس آن در بیشتر موارد درست نیست، بنابراین باید از عملگر cast برای ریختن مقدار int به متغیر بایت استفاده شود. این روش گاهی اوقات نامیده می شود باریک شدن (باریک شدن), زیرا شما صریحاً به مترجم می گویید که مقدار باید به متغیری از نوع مورد نظر شما تبدیل شود. برای فرستادن یک مقدار به یک نوع خاص، قبل از آن نوع محصور در پرانتز قرار دهید. قطعه کد زیر ارسال یک نوع منبع (یک متغیر int) را به یک نوع مقصد (یک متغیر بایت) نشان می‌دهد. اگر در طی چنین عملیاتی مقدار عدد صحیح خارج از محدوده مجاز برای نوع بایت بود، با تقسیم مدول به محدوده مجاز برای بایت کاهش می یابد (نتیجه تقسیم مدول بر یک عدد باقیمانده تقسیم بر این عدد است) ،

int a = 100;
بایتb = (بایت) a;

2.2.1. تبدیل خودکار نوع در عبارات

هنگام ارزیابی مقدار یک عبارت، دقت مورد نیاز برای ذخیره نتایج میانی اغلب باید بیشتر از دقت مورد نیاز برای نمایش نتیجه نهایی باشد.

بایت الف = 40;
بایت b = 50;
بایت با = 100;
int d = a* b / c;

نتیجه عبارت میانی (a * b) ممکن است فراتر از محدوده مقادیر مجاز برای نوع بایت باشد. به همین دلیل است که جاوا به طور خودکار هر قسمت از عبارت را برای تایپ int تبلیغ می کند، بنابراین فضای کافی برای نتیجه میانی (a*b) وجود دارد.

تبدیل خودکار نوع گاهی اوقات می تواند باعث ایجاد پیام های خطای غیرمنتظره کامپایلر شود. برای مثال، کدی که در زیر نشان داده شده است، اگرچه کاملاً صحیح به نظر می رسد، اما در مرحله ترجمه پیام خطا ایجاد می کند. در آن، ما سعی می کنیم مقدار 50 * 2 را که باید کاملاً با نوع بایت مطابقت داشته باشد را در یک متغیر بایت بنویسیم. اما به دلیل تبدیل خودکاراگر نوع نتیجه int باشد، یک پیام خطایی از مترجم دریافت می کنیم - در نهایت، هنگام تبدیل یک int به بایت، ممکن است دقت از دست برود.

بایت b = 50;
b = b*2:
^ نوع ناسازگار برای =. برای تبدیل int به بایت نیاز به ریخته گری واضح است.
(نوع ناسازگار برای =. تبدیل صریح مورد نیاز استبهبایت)

متن تصحیح شده:
بایتb = 50;
b = (بایت) (b*2)؛

که باعث می شود b با مقدار صحیح 100 پر شود.

اگر عبارت از متغیرهایی از نوع byte، short و int استفاده می کند، برای جلوگیری از سرریز شدن، نوع کل عبارت به طور خودکار به int ارتقا می یابد. اگر نوع حداقل یک متغیر در عبارت طولانی باشد، نوع کل عبارت نیز به طولانی ارتقا می یابد. به یاد داشته باشید که تمام اعداد صحیحی که به L (یا 1) ختم نمی شوند از نوع int هستند.

اگر عبارت شامل عملوند باشد نوع شناور، سپس نوع کل عبارت به طور خودکار به شناور ارتقا می یابد. اگر حداقل یکی از عملوندها از نوع double باشد، نوع کل عبارت به دو برابر ارتقا می یابد. به‌طور پیش‌فرض، جاوا با تمام لفظ‌های ممیز شناور از نوع double رفتار می‌کند. برنامه زیر نشان می دهد که چگونه نوع هر مقدار در یک عبارت برای مطابقت با عملوند دوم هر عملگر باینری ارتقا می یابد.

ارتقاء کلاس(
اصلی خالی استاتیک عمومی (رشته آرگ)(
بایت=42;
کاراکتر با= "a';
شورت = 1024;
int i = 50000;
float f = 5.67f;
دو برابر شد=.1234;
نتیجه مضاعف = (f*b) + (i/c) - (d*s);
سیستم، خارج println ((f* b)+ "+ "+ (i / c)+ "-" + (d*s));
سیستم، خارج println("result = "+result); )
}

عبارت فرعی f*b یک شناور ضرب در یک بایت است، بنابراین به طور خودکار به شناور ارتقا می یابد. نوع عبارت فرعی i/c بعدی (int تقسیم بر char) به int ارتقا می یابد. به طور مشابه، عبارت فرعی d*s (دو برابر ضربدر کوتاه) به دو برابر ارتقا می یابد. در مرحله بعدی محاسبات، با سه نتیجه میانی از انواع float، int و double روبرو هستیم. ابتدا، وقتی دو مورد اول اضافه می شوند، نوع int به شناور ارتقا می یابد و نتیجه یک نتیجه شناور است. وقتی یک مقدار دو برابر از آن کم می کنیم، نوع نتیجه به دو برابر ارتقا می یابد. نتیجه نهایی کل عبارت یک مقدار دو برابر است.

اکنون که همه انواع ساده از جمله اعداد صحیح، واقعی، نمادها و بولی ها را دیدیم، بیایید سعی کنیم همه اطلاعات را با هم جمع کنیم. مثال زیر برای هر یک از متغیرها ایجاد می کند انواع سادهو مقادیر این متغیرها نمایش داده می شود.

کلاس SimpleTypes(
اصلی خالی استاتیک عمومی (رشته آرگ) (
بایت b = 0x55;
s کوتاه = 0x55ff;
int i = 1000000;
طولانی l = 0xffffffffL;
کاراکتر با= 'a';
float f= .25f;
دو برابر d = 0.00001234;
boolean bool = درست;
System.out.println("byte b = " + b);
System.out.println("s short = " +s);
System.out.println("int i =" + i);
System.out.println("long 1 = " + l);
System.out.println("char with=” + با);
System.out.println("float f =" + f);
System.out.println("double d = " + d);
System.out.println("boolean bool =" + bool); )
}

هنگامی که این برنامه را اجرا می کنید، باید خروجی زیر را دریافت کنید:

بایت b = 85
شورت = 22015
int i = 1000000
طول 1 = 4294967295
کاراکتر با= a
شناور f = 0.25
دو برابر d=1.234e-005
بولی بولی = درست است

توجه داشته باشید که اعداد صحیح به صورت اعشاری چاپ می شوند، اگرچه ما برخی از آنها را به صورت هگزادسیمال مشخص کردیم.

جاوا یک زبان برنامه نویسی قوی تایپ شده است، به این معنی که هر عبارت و هر متغیر دارای یک تایپ قوی است نوع خاصیدر حال حاضر در زمان تدوین
انواع گچ
جاوا هفت نوع بازیگر را ارائه می دهد:

• هویت؛


• گسترش یک نوع اولیه (بسط بدوی)؛


• نوع بدوی باریک (narrowing primitive);


• پسوند نوع شی (مرجع گسترده)؛


• باریک شدن نوع شی (مرجع محدود کننده)؛


• تبدیل به رشته (رشته)؛


• تبدیل ممنوع (ممنوع);

بیایید آنها را جداگانه در نظر بگیریم.
دگرگونی هویت
ساده ترین آن تغییر هویت است. در جاوا، تبدیل یک عبارت از هر نوع دقیقاً به همان نوع همیشه قانونی است و موفقیت آمیز است.
این مهم است تا بتوانیم از لحاظ نظری استدلال کنیم که هر نوع در جاوا می تواند در یک تبدیل شرکت کند، حتی اگر یکسان باشد.
تبدیل نوع اولیه (بسط و باریک شدن)
برای انواع ساده، انبساط به این معنی است که انتقال از نوع کم ظرفیت به نوع جادارتر انجام می شود. به عنوان مثال، از نوع بایت (طول 1 بایت) به تایپ int (طول 4 بایت). این گونه دگرگونی ها به این معنا امن هستند نوع جدیدهمیشه تضمین می شود که حاوی تمام داده هایی است که در نوع قدیمی ذخیره شده است، و بنابراین هیچ گونه از دست دادن داده رخ نمی دهد. به همین دلیل است که کامپایلر خود آن را به طور نامحسوس برای توسعه دهنده پیاده سازی می کند:

بایت=3;
int a=b;

19 تبدیل زیر در حال گسترش هستند:

• از بایت به کوتاه، int، طولانی، شناور، دو برابر


• از کوتاه به int، بلند، شناور، دوتایی


• از char به int، long، float، double


• از int تا long، float، double


• از طولانی به شناور، دو برابر


• شناور برای دو برابر شدن

توجه داشته باشید که نمی توانید از انواع کمتر از یا به char تبدیل کنید طول مساوی(بایت، کوتاه) یا برعکس به کوتاه از char بدون از دست دادن اطلاعات. این به دلیل این واقعیت است که char، بر خلاف سایر انواع عدد صحیح، امضا شده است.
با این حال، باید به خاطر داشت که حتی با گسترش، داده ها همچنان می توانند تحریف شوند. اینها ریخته‌گری‌هایی از مقادیر int به float و ریخته‌هایی از مقادیر طولانی به float یا double هستند. اگر چه این انواع کسری می توانند چیزهای زیادی را در خود جای دهند اعداد بزرگنسبت به اعداد صحیح مربوطه، اما ارقام مهم کمتری دارند.
مثلا:

طولانی a = 111111111111L;
شناور f=a;
a=(طولانی)f; // () فقط یک عملیات تبدیل نوع است
System.out.println(a); //نتیجه 111111110656

توجه داشته باشید - باریک شدن - به این معنی است که انتقال از نوع جادارتر به نوع کم ظرفیت تر انجام می شود. با چنین تبدیلی، خطر از دست دادن داده ها وجود دارد. به عنوان مثال، اگر یک int بزرگتر از 127 باشد، وقتی به بایت فرستاده می شود، مقادیر بیت بزرگتر از هشتم از بین می رود. در جاوا، چنین تبدیلی باید به صراحت انجام شود، یعنی. برنامه نویس در کد باید به صراحت نشان دهد که قصد دارد چنین تبدیلی را انجام دهد و آماده از دست دادن داده است.
23 تبدیل زیر در حال باریک شدن هستند:

• از بایت به کاراکتر


• از کوتاه تا بایت، کاراکتر


• از کاراکتر به بایت، کوتاه


• از int به بایت، کوتاه، کاراکتر


• از طولانی به بایت، کوتاه، char، int


• از شناور به بایت، کوتاه، char، int، طولانی


• از دو به بایت، کوتاه، char، int، طولانی، شناور

هنگام باریک کردن یک نوع عدد صحیح به یک عدد صحیح باریک تر، تمام بیت های مرتبه بالا که در نوع جدید مناسب نیستند به سادگی کنار گذاشته می شوند. برای به دست آوردن نتیجه صحیح تر، هیچ گرد کردن یا اقدامات دیگری انجام نمی شود:

System.out.println((byte)383);
System.out.println((byte)384);
System.out.println((بایت)-384);

نتیجه این خواهد بود:

127
-128
-128
مشاهده می شود که بیت علامت در حین باریک شدن تأثیری نداشته است ، زیرا به سادگی کنار گذاشته شد - نتیجه ریخته گری اعداد متقابل (384 ، -384) یکسان بود. در نتیجه، نه تنها قدر مطلق دقیق را می توان از دست داد، بلکه علامت کمیت را نیز می توان از دست داد.
این برای char نیز صادق است:

کاراکتر c=4000;
System.out.println((کوتاه)c);

نتیجه:

-25536
تبدیل نوع مرجع (بسط و باریک کردن)
تبدیل نوع شی به بهترین شکل با استفاده از درخت ارثی نشان داده می شود. یک مثال کوچک از وراثت را در نظر بگیرید:

classParent(
intx;
}

کلاس ChildY گسترش پدر و مادر(
int y;
}

کلاس ChildZ گسترش پدر و مادر(
intz;
}

هر کلاس یک فیلد با یک نام منحصر به فرد را اعلام می کند. ما این فیلد را به عنوان نمونه ای از مجموعه ای از ویژگی های منحصر به فرد ذاتی در برخی از انواع شی در نظر خواهیم گرفت.
اشیاء کلاس Parent فقط یک فیلد x دارند، به این معنی که فقط مراجع از نوع Parent می توانند به چنین اشیایی ارجاع دهند. اشیاء کلاس ChildY دارای یک فیلد y و یک فیلد x است که از کلاس Parent به ارث رسیده است. بنابراین، ارجاعاتی از نوع ChildY یا Parent می توانند به چنین اشیایی اشاره کنند. مثال:

p والد = newChildY();

توجه داشته باشید که این مرجع p فقط می تواند به فیلد x شی ایجاد شده دسترسی داشته باشد. فیلد y در دسترس نیست زیرا کامپایلر، هنگام بررسی صحت عبارت p.y، نمی تواند پیش بینی کند که p مرجع به یک شی از نوع ChildY در زمان اجرا اشاره می کند. فقط نوع خود متغیر را آنالیز می کند و به عنوان Parent اعلام می شود، اما این کلاس فیلد y ندارد که باعث خطای کامپایل می شود.
به طور مشابه، اشیاء کلاس ChildZ دارای یک فیلد z و یک فیلد x هستند که از کلاس Parent به ارث برده شده است. این بدان معناست که مراجعی مانند ChildZ و Parent می توانند به چنین اشیایی اشاره کنند.
بنابراین، ارجاعات از نوع Parent می توانند به یک شی از هر یک از سه نوع در نظر گرفته شده اشاره کنند، در حالی که مراجع از نوع ChildY و ChildZ فقط می توانند به اشیاء دقیقاً همان نوع اشاره کنند. اکنون می توانیم به تبدیل انواع مرجع بر اساس چنین درخت ارثی برویم.
Extension به معنای رفتن از یک نوع خاص تر به یک نوع کمتر خاص است، i.e. انتقال از فرزندان به والدین مانند مورد با انواع ابتدایی، این انتقال در صورت لزوم توسط خود JVM انجام می شود و برای توسعه دهنده "نامرئی" است ، یعنی به هیچ تغییر خاصی نیاز ندارد.

والد p1=newChildY();
والد p2=newChildZ();

در هر دو خط، به متغیرهای نوع Parent مقداری از نوع دیگری اختصاص می‌یابد که به این معنی است که یک تبدیل رخ می‌دهد. از آنجا که یک افزونه است، به طور خودکار انجام می شود و همیشه موفق می شود.
باید توجه داشت که با چنین تبدیلی هیچ اتفاقی برای خود شیء نمی افتد. علیرغم اینکه، برای مثال، فیلد y کلاس ChildY دیگر در دسترس نیست، این به معنای ناپدید شدن آن نیست. چنین تغییر قابل توجهی در جسم امکان پذیر نیست. این از کلاس ChildY مشتق شده است و تمام ویژگی های خود را حفظ می کند. فقط نوع پیوندی که از طریق آن به شی دسترسی پیدا می کند تغییر کرده است.
انتقال معکوس، یعنی حرکت به سمت پایین درخت ارث به سمت وراث، یک باریک شدن است. به عنوان مثال، در این مورد، انتقال از یک مرجع از نوع Parent، که می تواند به اشیاء سه کلاس اشاره کند، به مرجعی از نوع ChildY، که فقط می تواند به یکی از سه کلاس اشاره کند، بدیهی است که یک باریک شدن است. چنین انتقالی ممکن است امکان پذیر نباشد. اگر مرجعی از نوع Parent به یک شی از نوع Parent یا ChildZ اشاره داشته باشد، انتقال به ChildY غیرممکن است، زیرا در هر دو مورد شیء دارای فیلد y نیست که در کلاس ChildY اعلان شده است. بنابراین، هنگام محدود کردن، توسعه‌دهنده باید به صراحت نشان دهد که تلاش برای انجام چنین تحولی ضروری است. JVM صحت انتقال را در زمان اجرا بررسی می کند. در صورت امکان، تبدیل انجام می شود. در غیر این صورت، خطایی رخ می دهد (معمولاً یک ClassCastException).

والد p=newChildY();
ChildYcy = (ChildY)p; //درست
والد p2=newChildZ();
ChildYcy2 = (ChildY)p2; //اشتباه

برای بررسی اینکه آیا انتقال مورد نظر امکان پذیر است، می توانید از عملگر instanceof استفاده کنید:

والد p=newChildY();
if (p instanceofChildY)(
ChildYcy = (ChildY)p;
}

والد p2=newChildZ();
if (p2 instance of ChildY) (
ChildYcy = (ChildY)p2;
}

والد p3=جدید والد();
if (p3 instanceofChildY)(
ChildYcy = (ChildY)p3;
}

AT این مثالهیچ خطایی رخ نخواهد داد اولین تحول ممکن است و انجام خواهد شد. در حالت دوم و سوم، شرایط دستور if کار نمی کند و بنابراین، انتقال نادرستی وجود نخواهد داشت.
تبدیل به رشته
هر نوع را می توان به یک رشته ریخت، یعنی. به عنوان مثال رشته رشته. چنین تبدیلی به دلیل این واقعیت استثنایی است که کاملاً همه انواع را پوشش می دهد.
انواع مختلف به صورت زیر به رشته تبدیل می شوند:

• انواع عددی در نوشته شده است فرم متنبدون از دست دادن دقت نمایش ابتدا، بر اساس مقدار اولیه، یک نمونه از کلاس "wrapper" مربوطه تولید می شود، سپس متد toString() روی آن فراخوانی می شود. اما از آنجایی که این اقدامات از بیرون نامرئی هستند، JVM آنها را بهینه می کند و تبدیل می کند ارزش های اولیهمستقیما پیامک کنید


• مقادیر بولی بسته به مقدار به رشته "true" یا "false" ریخته می شوند.


• برای مقادیر شیء، متد toString() فراخوانی می شود. اگر متد null را برگرداند، نتیجه رشته "null" خواهد بود.


• برای یک مقدار null، رشته "null" تولید می شود.

تبدیل های ممنوع
همه انتقال‌ها بین انواع دلخواه مجاز نیستند. به عنوان مثال، تبدیل های ممنوعه عبارتند از: انتقال از هر نوع مرجع به ابتدایی و بالعکس (به جز تبدیل به رشته)، بولین را فقط می توان به این نوع یا به رشته تبدیل کرد. علاوه بر این، نمی توان طبقات واقع در شاخه های همسایه درخت ارث را به یکدیگر آورد. در مثال، که برای نشان دادن انواع مرجع در نظر گرفته شد، انتقال از ChildY به ChildZ ممنوع است.
این فهرست تغییرات ممنوعه تمام نشده است. این کاملاً گسترده است و در عین حال همه گزینه ها کاملاً واضح هستند ، بنابراین جزئیات در نظر گرفته نمی شوند. کسانی که تمایل دارند می توانند دریافت کنند اطلاعات کاملاز مشخصات
البته تلاش برای انجام تبدیل ممنوعه باعث خطا می شود.

استفاده از گچ
موقعیت های تبدیل نوع را می توان به صورت زیر گروه بندی کرد:

• تخصیص مقادیر به متغیرها (تخصیص). همه انتقال‌ها تحت چنین تبدیلی مجاز نیستند - محدودیت‌ها به گونه‌ای انتخاب می‌شوند که استثنا رخ ندهد.


• فراخوانی روش. این تبدیل برای آرگومان های متد یا سازنده فراخوانی شده اعمال می شود. چنین بازیگرانی هرگز خطا ایجاد نمی کند. هنگام بازگرداندن مقدار روش، ریخته گری نیز انجام می شود.


• بازیگران صریح در این حالت به صراحت مشخص می شود که می خواهید مقدار اصلی را به کدام نوع ارسال کنید.


• عملگر الحاق به رشته ای از آرگومان های خود تبدیل می کند.


• بسط عددی عملیات عددیممکن است نیاز به تغییر در نوع آرگومان(های) داشته باشد. این تحول یک نام خاص دارد - از زمان انتخاب گسترش یافته است نوع هدفممکن است نه تنها به مقدار اولیه، بلکه به آرگومان دوم عملیات نیز بستگی داشته باشد.

وظیفه شماره 8
استفاده از بازیگران را برای سلسله مراتب کلاس خود به پروژه اضافه کنید.

گاهی اوقات موقعیت‌هایی پیش می‌آیند که لازم است مقداری به متغیری از یک نوع به متغیری از نوع دیگر اختصاص دهیم. مثلا:

مثال 1: اختصاص یک مقدار به یک متغیر از یک نوع به دیگری

int i = 11; بایت b = 22; i = b;

2 نوع تبدیل در جاوا وجود دارد - تبدیل خودکار (ضمنی)و ریخته گری نوع (تبدیل صریح).

1. تبدیل خودکار

اولین تبدیل خودکار را در نظر بگیرید. اگر هر دو نوع سازگار باشند، تبدیل آنها به طور خودکار توسط جاوا انجام می شود. به عنوان مثال، یک مقدار مانند بایت همیشه می توان به یک متغیر از نوع اختصاص داد بین المللی ، همانطور که در مثال 1 نشان داده شده است.

برای تبدیل نوع خودکار، دو شرط باید رعایت شود:

• هر دو نوع باید سازگار باشند
• طول نوع هدف باید بیشتر از طول باشد نوع اولیه

در این صورت اتفاق می افتد تبدیل گسترش.

نمودار زیر گسترش تبدیل در جاوا را نشان می دهد:

خطوط یکپارچه نشان دهنده تبدیل های انجام شده بدون از دست دادن داده است. خطوط چین نشان می دهد که ممکن است در حین تبدیل دقت از دست برود.

به عنوان مثال، نوع داده بین المللی همیشه به اندازه کافی بزرگ برای نگه داشتن همه چیز مقادیر مجازنوع بایت ، بنابراین هیچ عملگر مشخصی وارد نمی شود این موردلازم نیست. از نظر تبدیل گسترده، انواع داده های عددی، از جمله عدد صحیح و ممیز شناور، با یکدیگر سازگار هستند. در عین حال، هیچ تبدیل خودکار انواع عددی به تایپ وجود ندارد کاراکتر یا بولی . انواع کاراکتر و بولی همچنین با یکدیگر ناسازگار هستند.

شایان ذکر است که چرا مثلاً نوع آن کمی توضیح داده شود بایت به طور خودکار (به طور ضمنی) به یک نوع تبدیل نمی شود کاراکتر ، اگرچه نوع بایت 8 بیت عرض دارد و کاراکتر - 16، در مورد تبدیل نوع نیز صدق می کند کوتاه که در کاراکتر . این اتفاق می افتد زیرا بایت و کوتاه انواع داده های امضا شده و کاراکتر بدون امضا بنابراین، در این مورد، باید از ریخته گری نوع صریح استفاده کنید، زیرا کامپایلر باید به صراحت نشان دهد که شما می دانید چه می خواهید و چگونه بیت علامت انواع پردازش می شود. بایت و کوتاه هنگام تبدیل به نوع کاراکتر .

رفتار ارزش را تایپ کنید کاراکتر در بیشتر موارد منطبق بر رفتار یک مقدار نوع عدد صحیح است، از این رو مقدار نوع کاراکتر می توان از هر جایی که مقادیر مورد نیاز است استفاده کرد بین المللی یا طولانی . با این حال، ما به یاد می آوریم که نوع کاراکتر بدون علامت است، بنابراین رفتار آن متفاوت از نوع است کوتاه ، حتی اگر محدوده هر دو نوع 16 بیت باشد.

2. ریخته گری

با وجود تمام راحتی تبدیل نوع خودکار، قادر به برآورده کردن تمام نیازهای فوری نیست. به عنوان مثال، اگر مقدار نوع بین المللی باید به یک متغیر از نوع اختصاص داده شود بایت ? این تبدیل به دلیل طول نوع به صورت خودکار انجام نمی شود بایت کمتر از نوع بین المللی . گاهی به این نوع دگرگونی می گویند تغییر شکل باریک، از آنجایی که مقدار به وضوح محدود شده است تا در نوع داده هدف قرار گیرد.

برای تبدیل دو نوع داده ناسازگار، باید از Cast استفاده کنید. بازیگران فقط یک تبدیل نوع صریح است. فرم کلینوع ریخته گری به شکل زیر است:

مقدار (نوع_هدف).

پارامتر کجا target_typeنشان دهنده نوعی است که مقدار مشخص شده باید به آن تبدیل شود.

مثال 2: ریخته گری

به عنوان مثال، در قطعه کد زیر، تایپ کنید بین المللی بازیگران به تایپ بایت:

Int i = 11; بایت b = 22; b = (بایت)i;

مثال 3: تبدیل مقادیر ممیز شناور به اعداد صحیح

بیایید به مثالی از تبدیل مقادیر ممیز شناور به اعداد صحیح نگاه کنیم. در این مثال کسرمقادیر ممیز شناور به سادگی کنار گذاشته می شوند (عملیات برش):

دو برابر d = 3.89; int a = (int) d; //نتیجه 3 خواهد بود

مثال 4: تبدیل نوع عدد صحیح بزرگتر به عدد صحیح کوچکتر

هنگام ریختن یک نوع عدد صحیح بزرگتر به یک نوع عدد صحیح کم ظرفیت تر، بیت های بالا به سادگی کنار گذاشته می شوند:

int i = 323; بایت b = (بایت) i; //نتیجه 67 خواهد بود

مثال 5: تبدیل یک شناور بزرگتر به یک عدد صحیح کوچکتر

هنگام ریختن یک مقدار ممیز شناور بزرگتر به یک عدد صحیح، مهم ترین بیت ها کوتاه شده و کنار گذاشته می شوند:

دابل d = 389889877779.89; کوتاه s = (کوتاه) d; //نتیجه -1 خواهد بود

3. ارتقای خودکار انواع در عبارات

علاوه بر عملیات انتساب، تبدیل نوع خاصی را می توان در عبارات نیز انجام داد.

AT زبان جاواقوانین زیر اعمال می شود:

1. اگر یک عملوند از نوع باشد دو برابر دو برابر.
2. شناور، دیگری نیز به نوع تبدیل می شود شناور.
3. در غیر این صورت، اگر یک عملوند از نوع باشد طولانی، دیگری نیز به نوع تبدیل می شود طولانی.
4. در غیر این صورت، هر دو عملوند به نوع تبدیل می شوند بین المللی.
5. عبارات تخصیص ترکیبی (+=،-=،*=،/=) نیازی به ارسال ندارند.

در اینجا یک مثال است:

مثال 6: ارتقای نوع خودکار در عبارات

هنگام ضرب متغیر b1 ( بایت) در 2 ( بین المللی) نتیجه مانند خواهد بود بین المللی. بنابراین، هنگام تلاش برای اختصاص نتیجه به متغیر b2 ( بایت) یک خطای کامپایل ایجاد می کند. اما هنگام استفاده از عملگر انتساب ترکیبی (*=)، این مشکل پیش نمی آید.

بایت b1 = 1; بایت b2 = 2 * b1; //خطای کامپایل int i1 = 2 * b1; b2 *= 2;

مثال 7: ارتقای نوع خودکار در عبارات

AT مثال زیریک خطای کامپایل نیز رخ خواهد داد - با وجود این واقعیت که اعداد مانند بایت، نتیجه عملیات نوع خواهد بود بین المللی،اما نه کوتاه.

کلاس عمومی IntegerDemo1 (اصلی خالی استاتیک عمومی (رشته آرگ) (بایت b1 = 50، b2 = -99؛ کوتاه k = b1 + b2؛ //خطای کامپایل System.out.println("k=" + k); ))

مثال 8: ارتقای نوع خودکار در عبارات

این مثال مشابه نمونه قبلی است، اما از عملیات انتساب ترکیبی استفاده می‌شود که در آن ریخته‌گری به طور خودکار انجام می‌شود.

کلاس عمومی IntegerDemo2 (اصلی خالی استاتیک عمومی (رشته آرگ) (بایت b1 = 50، b2 = -99؛ b1 += b2; System.out.println("b1=" + b1؛ ))

1. آنچه صریح است و ریخته گری خودکارانواع در عبارات؟

نوع ریخته گری می تواند صریح یا خودکار باشد.

با ریخته گری نوع صریح، خود عملیات ریخته گری به صراحت مشخص می شود.

برای ریخته گری نوع اتوماتیک دو شرط لازم است:

• هر دو نوع باید سازگار باشند.
• طول نوع منبع (نوع منبع) باید کمتر از طول نوع هدف (نوع مقصد) باشد.

2. ریخته گری نوع صریح در عبارات چگونه به نظر می رسد؟ مثال ها

ریخته‌گری با نوع صریح امکان تخصیص انواع ناسازگار را می‌دهد. شکل کلی ریخته گری نوع صریح عبارت است از:

مقدار (نوع_هدف).

target_typeنوعی است که شما می‌خواهید مورد مشخص شده را به آن بفرستید معنی.

مثال هاتبدیل نوع صریح

// ریخته گری نوع صریح در عبارات بایت b; int a; دو d; شناور f; d = -39.9203; a = (int)d; // a = -39 f = (شناور)d; // f = -39.9203 b = (بایت)d; // b = -39 d = 302930932; b = (بایت)d; // b = -12 - برش مقدار a = -27; b = (بایت) a; // b = -27

3. نمونه هایی از ریخته گری نوع اتوماتیک

مثال 1. ریخته گری اتوماتیک انواع انتگرال.

// ریخته گری اتوماتیک انواع انتگرال int a; بایت b; ش کوتاه; b = -23; a = b; // a = -23 - ریخته گری نوع اتوماتیک sh = -150; a = sh; // a = -150 طول l = 200; // خطا: "عدم تطابق نوع: نمی تواند از طولانی به int تبدیل شود" // a = l; l = b; // l = -23 l = sh; // l = -150 char c = "Z" ; a = c; // a = 90 - کد کاراکتر "Z" بولی b1 = غلط ; //a = b1; - خطا، انواع ناسازگار هستند

مثال 2. ریخته گری اتوماتیک انواع ممیز شناور.

// ریخته گری خودکار به نقطه شناور شناور f; دو d; f = 3.409033f; d = f; // d = 3.409033

مثال 3. ریخته گری خودکار انواع مخلوط. چنین حالتی در صورتی امکان پذیر است که به یک متغیر از نوع ممیز شناور مقدار یک متغیر از نوع عدد صحیح اختصاص داده شود.

// تبدیل خودکار انواع مختلط شناور f; دو d; a = 28; d = a; // d = 28.0 f = a; // f = 28.0 // خطا: نوع عدم تطابق: نمی تواند از float به int تبدیل شود // a = f;

4. ارتقای نوع خودکار در عبارات چگونه انجام می شود؟

ارتقاء خودکارانواع در عبارات رخ می دهد. در این حالت، مقداری که در عبارات ظاهر می‌شود، به‌طور خودکار به انواع با دامنه‌های مقادیر زیاد ارتقا می‌یابد.

هنگام تبلیغ خودکار انواع در عبارات:

• اگر یکی از عملوندهای عدد صحیح از نوع int باشد، تمام مقادیر بایت، short و char به نوع int ارتقا می یابند.
• اگر یکی از عملوندهای عدد صحیح از نوع long باشد، کل عبارت به تایپ long ارتقا می یابد.
• اگر یکی از عملوندها از نوع float باشد، نوع کل عبارت نیز از نوع float خواهد بود (اگر هیچ عملوندی از نوع double وجود نداشته باشد).
• اگر یکی از عملوندها از نوع double باشد، نوع کل عبارت نیز double خواهد بود.

5. نمونه ای از ارتقاء از نوع بایت به int که در آن عبارت شامل عملوندها-متغیرهای نوع int (طولانی) نیست.

// byte -> int بایت b; b = 1000 / 20; // b = 50، کار می کند زیرا نتیجه در یک بایت قرار می گیرد

مثال بالا به درستی کار می کند زیرا:

• نتیجه در نوع بایت (سازگار) قرار می گیرد.
• هیچ عملوندی از نوع int وجود ندارد.

در مثال بالا، مقدار 1000 از محدوده مقادیر بایت بیشتر است. ابتدا عدد 1000 به نوع int ریخته می شود. اما نتیجه

1000 / 20 = 50

به تایپ بایت فرستاده می شود و می تواند به درستی در یک متغیر قرار گیرد ب .

اگر اینطور بنویسید:

بایت b; b = 100000 / 20; خطا // زیرا نتیجه با نوع بایت مطابقت ندارد

سپس یک خطای کامپایل با پیام زیر رخ می دهد:

در این مورد، نتیجه با نوع بایت مطابقت ندارد:

100000 / 20 = 5000

سپس این عدد (5000) به طور خودکار به نوع int تبدیل می شود و کامپایلر پیغام خطا صادر می کند.

اگر یک تایپ کست صریح انجام دهید:

بایت b; b = (بایت) (100000 / 20)؛ // b = -120

سپس در این حالت نتیجه 5000 از نوع int به نوع بایت تبدیل می شود. همانطور که می دانید یک متغیر int 32 بیت و یک متغیر نوع بایت 8 بیت طول می کشد. مقدار متغیری از نوع int کوتاه شده است. و ما چیزی را داریم که داریم (b = -120).

مثال های بالا برای متغیرها را تایپ کنیدکوتاه و کاراکتر

6. مثال. ارتقاء از نوع بایت به نوع int، که در آن عبارت شامل یک عملوند متغیر از نوع int است

// ترویج انواع در عبارات // byte -> int بایت b; int d; d=20; // خطا، نتیجه از نوع int است، زیرا متغیر d از نوع int است // b = 1000 / d;

در مثال بالا، عبارت از متغیر استفاده می کند داز نوع int . بنابراین، کامپایلر یک پیغام خطا می دهد:

عدم تطابق نوع: نمی تواند از int به بایت تبدیل شود

این بدان معنی است که نتیجه از نوع int (نه بایت) است حتی اگر مقدار در محدوده مقادیر بایت قرار بگیرد. از آنجایی که عبارت از یک عملوند متغیر استفاده می کند د int را تایپ کنید

اگر یک تبدیل نوع صریح را پیاده سازی کنید، نتیجه درست خواهد بود:

// ترویج انواع در عبارات // byte -> int بایت b; int d; d=20; b = (بایت) (1000 / d); // b = 50 - به درستی کار می کند

7. مثال. ارتقاء از نوع int به تایپ طولانی

نمونه ای از نوع ارتقاء از int به طولانی. اگر یکی از عملوندها از نوع long باشد، کل عبارت به تایپ long ارتقا می یابد.

int d; longl; d = 10000 * 200; // آثار، d = 2000000 // اشتباه! عدم تطابق نوع: نمی تواند از long به int تبدیل شود // d = 1L * 2L; - عملوندهای 1L و 2L از نوع طولانی هستند l = 100; // خطا، یکی از عملوندها از نوع long است // d = l * 2;

همانطور که از مثال می بینید، اگر یکی از عملوندها از نوع long باشد، کل عبارت از نوع long می شود.