تبدیل تایپ در جاوا تبدیل خودکار نوع در عبارات

این مقاله:

• نوشته شده توسط تیم امیدواریم که برای شما مفید واقع شود. خواندن مبارک!
• این یکی از مقالات ما است

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

2 نوع تبدیل در جاوا وجود دارد - یک تصویر برای کمک به شما:

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

• انواع ابتدایی (بایت، کوتاه، int، طولانی، کاراکتر، شناور، دوبل، بولی)
• اشیاء

در این مقاله ما:

• تبدیل نوع را برای انواع متغیرهای اولیه در نظر بگیرید
• تبدیل اشیاء (رشته، اسکنر، و غیره) در این مقاله در نظر گرفته نمی شود، زیرا یک "جادو" جداگانه با اشیا رخ می دهد - این موضوع برای یک مقاله جداگانه است.

تبدیل خودکار

خوب، خوب، بیایید سعی کنیم بفهمیم "تبدیل خودکار" چیست.

به یاد داشته باشید، زمانی که به انواع متغیرها (در مقاله) نگاه کردیم، این را گفتیم یک متغیر نوعی "کانتینر" است ، که می تواند مقدار را برای استفاده بعدی در برنامه ذخیره کند. ما همچنین در مورد این واقعیت صحبت کردیم که هر نوع متغیر دارای محدوده مقادیر معتبر و مقدار حافظه اشغال شده خود است. اینجا تابلویی است که همه چیز در آن نقاشی شده است:

بنابراین این همان چیزی است که ما در واقع به سمت آن سوق می دهیم. به این واقعیت که اصلاً فقط این نبود که محدوده مقادیر مجاز و مقدار حافظه اشغال شده به شما داده شد.

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

1. بایت و کوتاه.بایت دارای محدوده کمتری از مقادیر معتبر نسبت به short است. یعنی بایت مانند یک جعبه کوچکتر است و short یک جعبه بزرگتر است. و این یعنی به طور خلاصه می توانیم بایت را تودرتو کنیم.

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

3. int و long. int دارای محدوده کمتری از مقادیر معتبر نسبت به long است. یعنی int مانند یک جعبه کوچکتر است و long یک جعبه بزرگتر است. و این یعنی ما می توانیم در مدت طولانی لانه بیندازیم.

این یک نمونه از تبدیل خودکار است. این را می توان به صورت شماتیک در قالب تصویری مانند زیر نشان داد:

بیایید ببینیم این در عمل چگونه کار می کند.

مثال شماره 1

کد شماره 1 - اگر این کد را روی رایانه خود اجرا کنید،

کلاس تست (اصلی خالی استاتیک عمومی (آرگس رشته) (بایت a = 15؛ بایت b = a؛ System.out.println (b)؛))

آزمون کلاسی ( بایت a = 15; بایت b = a;

کد شماره 2 - اگر این کد را روی رایانه خود اجرا کنید، عدد 15 در کنسول نمایش داده می شود

کلاس تست (اصلی خالی استاتیک عمومی (آرگس رشته) (بایت a = 15؛ int b = a؛ System.out.println (b)؛))

آزمون کلاسی ( اصلی خالی استاتیک عمومی (Args رشته) ( بایت a = 15; int b = a; سیستم. بیرون println (b)؛

و-و-و؟ شما فکر می کنید هنگامی که همان شماره در کنسول چاپ شد، و کد # 1 با کد # 2 فقط در نوع متغیر b متفاوت است پس فرقی بین آنها نیست؟ NSاینطور نیست

کد شماره 2 شامل خودکارتبدیل نوع ، اما در کد شماره 1 - خیر:

اگرچه در اصل عدد یکسان است، اما اکنون در b است Oیک ظرف بزرگتر که فضای دیسک بیشتری را اشغال می کند. در همان زمان، JVM تبدیل های خودکار را برای شما انجام می دهد. او این را می داند بین المللیبیشتر از بایت .

قالب

اگر می خواهید چیزی را از ظرف بزرگتر به ظرف کوچکتر منتقل کنید، موضوع دیگری است.

ممکن است بدانید که ظرف بزرگتر حاوی چیزی است که در ظرف کوچک جا می شود - اما JVM از این موضوع اطلاعی ندارد و سعی می کند از اشتباه کردن شما جلوگیری کند.

بنابراین، باید «صراحتاً بگویید» که اوضاع تحت کنترل است:

کلاس تست (خلأ استاتیک اصلی اصلی (آرگس های رشته ای) (int a = 0؛ طولانی b = 15؛ a = (int) b؛))

آزمون کلاسی ( اصلی خالی استاتیک عمومی (Args رشته) ( int a = 0; طولانی b = 15; a = (int) b;

در اینجا ما اضافه کردیم (int)جلو ب... اگر متغیر آبود، برای مثال، مانند بایت، در پرانتز خواهد بود (بایت)... فرمول کلی به این صورت است:

او می گوید "از (بیشتر) معنی بساز بیک متغیر از نوع (هدف) مورد نیاز من است بین المللی ".

اگر مشکلی پیش آمد.

تا کنون، با فرض اینکه می دانیم دقیقاً چه کاری انجام می دهیم، موقعیت ها را بررسی کرده ایم. اما اگر بخواهید چیزی را در ظرفی قرار دهید که در آن جا نمی شود چه؟

معلوم می شود که فقط آنچه "مناسب" است در ظرف باقی می ماند. به عنوان مثال، اعداد ممیز شناور دارای قسمت کسری "قطع" خواهند بود:

// مثال 1 کلاس تست (معمولی استاتیک void main (String args) (double a = 11.2345; int b = (int) a; System.out.println (b)؛ // کنسول عدد 11 را دریافت می کند))

// مثال 1 آزمون کلاسی ( اصلی خالی استاتیک عمومی (Args رشته) ( دو برابر = 11.2345; int b = (int) a; سیستم. بیرون println (b)؛ // کنسول عدد 11 را نمایش می دهد

باید به خاطر داشت که بخش کسری گرد نیست، آ دور انداخته شد.

اگر بخواهیم عددی را خارج از محدوده قرار دهیم چه اتفاقی می افتد؟ به عنوان مثال، اگر عدد 128 را در بایت قرار دهید (محدوده بایت از 128- تا 127)؟ فکر می کنی 1 بگیریم؟ خیر ما -128 را دریافت می کنیم:

کلاس تست (اصلی خالی استاتیک عمومی (Args رشته) (دو برابر a = 128؛ بایت b = (بایت) a؛ System.out.println (b)؛ // در کنسول ما 128- را خواهیم دید))

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

وظایف:

1. به طور متوالی در کامپایلر تبدیل همه انواع اولیه به یکدیگر از جمله انواع char را بنویسید و جدولی از نوع زیر ایجاد کنید:

	بایت	کوتاه	کاراکتر	بین المللی	طولانی	شناور	دو برابر	بولی
بایت
کوتاه
کاراکتر
بین المللی
طولانی
شناور
دو برابر
بولی

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

* تایپ کست به خود نامیده می شود همسان- نیازی به ثبت آن نیست

1. دوباره به اندازه هر نوع اولیه نگاه کنید. سعی کنید یک بلوک دیاگرام بسازید که نشان دهد کدام نوع ها در کجا قرار می گیرند. فلش هایی را که می گویند تبدیل گسترده و تبدیل باریک می شوند بکشید.

سوالات

در طول مصاحبه برای موقعیت توسعه‌دهنده جاوا، ممکن است از شما خواسته شود:

در مورد تبدیل انواع داده های اولیه چه می دانید، آیا از دست دادن داده وجود دارد، آیا امکان تبدیل نوع بولین وجود دارد؟

سعی کنید به سوال پاسخ دهید.

بیایید خلاصه کنیم:

• اگر محتویات یک ظرف کوچکتر را در یک ظرف بزرگتر "قرار دهید"، تبدیل به صورت خودکار انجام می شود و نباید خطایی رخ دهد.

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

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

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

امیدواریم مقاله ما برای شما مفید بوده باشد. همچنین امکان ثبت نام در دوره های جاوا ما در کیف وجود دارد. ما از ابتدا آموزش می دهیم. شما می توانید اطلاعات دقیق را در وب سایت ما پیدا کنید.

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

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

byte-> short-> int-> long-> float-> double

اگر عملوندهای a و b با یک عملگر باینری ترکیب شوند (در زیر به آن خواهیم پرداخت)، قبل از اجرای آن، هر دو عملوند به صورت زیر به داده هایی از یک نوع تبدیل می شوند:

• اگر یکی از عملگرها از نوع double باشد، دومی نیز به double تبدیل می شود.
• اگر یکی از عملگرها float باشد، دیگری نیز به float تبدیل می شود.
• اگر یکی از عملگرها طولانی باشد، دومی نیز به طولانی تبدیل می شود.
• اگر یکی از عملگرها از نوع int باشد، دومی نیز به int تبدیل می شود.

تبدیل نوع مجاز

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

برای محدود شدن کاست ها باید صریح شود. به عنوان مثال: بایت b = (بایت) 128; int به نوع بایت اختصاص داده شده است.

پیشنهاد می کنم چند نمونه تهیه کنید.

ممکن است کمی متوجه این کد نشوید، زیرا من هنوز توضیح نداده‌ام که کامپایلر چیست، ثابت‌ها و غیره. در ادامه در آموزش، همه چیز را به شما می گویم، اگرچه باید زودتر این کار را انجام می دادم. و اکنون می خواهم توضیح دهم که نام متغیرها چه قوانینی باید داشته باشد.

• نام متغیرها نمی توانند با یک رقم شروع شوند، نمی توانند در نام ها به عنوان نماد عملگرهای حسابی و منطقی و همچنین کاراکتر "#" استفاده شوند.
• کاراکترهای '$' یا '_'، از جمله موقعیت اول و نام، قابل قبول هستند.
• یک متغیر نوع اولیه که به عنوان عضوی از یک کلاس (متغیر جهانی) اعلام شده است به طور پیش فرض روی صفر تنظیم شده است.
• اگر یک متغیر به عنوان یک متغیر محلی در یک متد اعلام شود، باید قبل از استفاده مقداردهی اولیه شود. از آنجایی که متغیرهای محلی به طور پیش فرض مقداردهی اولیه نمی شوند. این بدان معنی است که شما نمی توانید یک متغیر محلی را اعلام کنید و آن را بدون مقدار اولیه رها کنید. یعنی به این صورت: int i ;. اگر این کار را در یک متد انجام دهید، کامپایلر از شما می خواهد که مقدار پیش فرض را تنظیم کنید، در حالی که چنین متغیری را به عنوان عضوی از یک کلاس (جهانی) ایجاد می کند، کامپایلر آن را روی 0 تنظیم می کند.
• دامنه و طول عمر یک متغیر توسط بلوک () که در آن تعریف شده است محدود می شود. اگر متغیری را در داخل متد ایجاد کرده اید (همانطور که در مثال ها انجام دادیم)، پس نمی توانید از آن در خارج از متد استفاده کنید، زیرا متد با پرانتز () مشخص شده است. متغیر سراسری در همه بلوک ها قابل مشاهده است.
• همچنین استفاده از کلمات رزرو شده جاوا ممنوع است. کل لیست کلمات کلیدی را می توانید در تصویر زیر مشاهده کنید.

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

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

کلمات هوشمندانه زیادی وجود دارد، اما این تصویر همه چیز را بسیار ساده توضیح می دهد:

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

کلاس عمومی OperatorsInJava (

int a = 5;

int b = 6;

int sum = a + b;

int تفاوت = a - b;

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 بیت و یک متغیر از نوع byte 8 بیت می گیرد. مقدار متغیری از نوع int کوتاه شده است. و ما چیزی را داریم که داریم (b = -120).

مثال های بالا برای متغیرهای انواع short و char نیز کاربرد دارند.

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 باشد، کل عبارت به تایپ long ارتقا می یابد.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

کلاس SimpleTypes (
اصلی خالی استاتیک عمومی (Args رشته) (
بایت b = 0x55;
s کوتاه = 0x55ff;
int i = 1000000;
طولانی l = 0xffffffffL;
کاراکتر با= 'A';
شناور f = 0.25f;
دو برابر d = 0.00001234;
boolean bool = درست;
System.out.println ("byte b = = b);
System.out.println ("s کوتاه =" + s)؛
System.out.println ("int i =" + i);
System.out.println ("long 1 = + l);
System.out.println ("char with= ” + S);
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
بولی بولی = درست است

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

آخرین به روز رسانی: 1397/10/29

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

Int a = 4; بایت b = a; //! خطا

در این کد با خطا مواجه خواهیم شد. اگرچه هر دو بایت و int نشان دهنده اعداد صحیح هستند. علاوه بر این، مقدار متغیر a که به متغیری از نوع بایت اختصاص داده می شود، به خوبی در محدوده مقادیر برای نوع بایت (از 128- تا 127) قرار دارد. با این حال، با یک خطای زمان کامپایل مواجه می شویم. زیرا در این حالت سعی داریم داده هایی را که 4 بایت هستند به متغیری که تنها 1 بایت است اختصاص دهیم.

با این حال، ممکن است برنامه شما نیاز به انجام این تبدیل داشته باشد. در این مورد، من باید از عملیات تبدیل نوع (عملیات ()) استفاده کنم:

Int a = 4; بایت b = (بایت) a; // نوع تبدیل: از int به بایت System.out.println (b); // 4

عملیات تبدیل نوع نشان‌دهنده نشانی در داخل پرانتز از نوعی است که مقدار باید به آن تبدیل شود. به عنوان مثال، در مورد عملیات (بایت) a، نوع داده int به نوع بایت تبدیل می شود. در نتیجه یک مقدار بایت دریافت می کنیم.

تبدیل صریح و ضمنی

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

تبدیل های خودکار

فلش های شکل نشان می دهد که کدام نوع تبدیل را می توان به طور خودکار انجام داد. فلش‌های نقطه‌دار تبدیل‌های خودکار را با کاهش دقت نشان می‌دهند.

تولید اتوماتیک بدون هیچ مشکلی گسترش تحولات(گسترش) - آنها نمایش یک شی را در حافظه گسترش می دهند. مثلا:

بایت b = 7; int d = b; // تبدیل از بایت به int

در این حالت، یک بایت که 1 بایت در حافظه اشغال می کند، به یک int گسترش می یابد که 4 بایت را اشغال می کند.

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

byte -> short -> int -> long

int -> double

کوتاه -> شناور -> دو برابر

char -> int

تبدیل خودکار با از دست دادن دقت

برخی از تبدیل ها را می توان به طور خودکار بین انواع داده با عمق بیت یکسان یا حتی از نوع داده با عمق بیت بالاتر به نوع با عمق بیت کمتر انجام داد. اینها زنجیره‌های تبدیل زیر هستند: int -> float، long -> float و long -> double بدون خطا انجام می‌شوند، اما ممکن است در حین تبدیل با از دست دادن اطلاعات مواجه شویم.

مثلا:

Int a = 2147483647; شناور b = a; // از int به float System.out.println (b); // 2.14748365E9

تبدیل های صریح

همه تبدیل‌های نوع اولیه به صراحت تعریف تبدیل نوع را اعمال می‌کنند. معمولاً، اینها تبدیل‌های باریک از نوع با عمق بیت بالاتر به نوع با عمق بیت کمتر است:

طولانی a = 4; int b = (int) a;

از دست دادن اطلاعات در حین تبدیل

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

Int a = 5; بایت b = (بایت) a; System.out.println (b); // 5

عدد 5 به خوبی در محدوده مقادیر نوع بایت قرار می گیرد، بنابراین پس از تبدیل، متغیر b برابر با 5 خواهد بود. اما در حالت زیر چه اتفاقی می افتد:

Int a = 258; بایت b = (بایت) a; System.out.println (b); // 2

نتیجه 2 است. در این حالت، 258 خارج از محدوده بایت است (128- تا 127)، بنابراین مقدار کوتاه می شود. چرا نتیجه دقیقاً عدد 2 است؟

عدد a که 258 است به صورت دودویی 00000000 00000000 00000001 000000010 خواهد بود. مقادیر بایت تنها 8 بیت در حافظه اشغال می کند. بنابراین نمایش دودویی int به 8 رقم سمت راست یعنی 00000010 کوتاه می شود که در اعشار عدد 2 را می دهد.

برش اعداد گویا به اعداد صحیح

هنگام تبدیل مقادیر ممیز شناور به مقادیر صحیح، قسمت کسری کوتاه می شود:

Double a = 56.9898; int b = (int) a;

در اینجا b 56 خواهد بود، حتی اگر 57 به 56.9898 نزدیک تر باشد. برای جلوگیری از چنین حوادثی، باید از تابع گرد کردن که در کتابخانه ریاضی جاوا است استفاده کنید:

Double a = 56.9898; int b = (int) Math.round (a);

تحولات در عملیات

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

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

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

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

در غیر این صورت، تمام عملوندهای عملیات به نوع int تبدیل می شوند

نمونه هایی از تبدیل:

Int a = 3; دو برابر b = 4.6; دو برابر c = a + b;

از آنجایی که عملیات شامل یک مقدار دوگانه است، مقدار دیگر به نوع دوگانه ریخته می شود و مجموع دو مقدار a + b نشان دهنده نوع دوگانه است.

مثالی دیگر:

بایت a = 3; کوتاه b = 4; بایت c = (بایت) (a + b);

این دو متغیر از نوع byte و short هستند (نه double، float یا long)، بنابراین در صورت اضافه شدن به int تبدیل می شوند و مجموع a + b آنها نشان دهنده int است. بنابراین، اگر این مجموع را به متغیری از نوع بایت اختصاص دهیم، دوباره باید یک نوع تبدیل به بایت انجام دهیم.

اگر عملیات شامل داده هایی از نوع char باشد، آنها به int تبدیل می شوند:

Int d = "a" + 5; System.out.println (d); // 102