ჯავის ჩამოსხმა სტრიქონიდან ინტამდე. ტიპის კონვერტაცია

ზოგჯერ წარმოიქმნება სიტუაციები, როდესაც საჭიროა ერთი ტიპის ცვლადისთვის მნიშვნელობის მინიჭება სხვა ტიპის ცვლადზე. მაგალითად:

მაგალითი 1: ერთი ტიპის ცვლადის მნიშვნელობის მინიჭება მეორეზე

int i = 11; ბაიტი b = 22; i = b;

ჯავაში გარდაქმნების 2 ტიპი არსებობს - ავტომატური კონვერტაცია (იგულისხმება)და ტიპის ჩამოსხმა (გამოკვეთილი კონვერტაცია).

1. ავტომატური კონვერტაცია

მოდით, ჯერ გადავხედოთ ავტომატურ კონვერტაციას. თუ ორივე ტიპი თავსებადია, მათი კონვერტაცია ავტომატურად განხორციელდება Java-ში. მაგალითად, მნიშვნელობა, როგორიცაა ბაიტი ყოველთვის შეიძლება მიენიჭოს ისეთ ცვლადს, როგორიცაა ინტ , როგორც ნაჩვენებია მაგალით 1-ში.

ტიპის ავტომატური კონვერტაციისთვის ორი პირობა უნდა დაკმაყოფილდეს:

• ორივე ტიპი უნდა იყოს თავსებადი
• სამიზნე ტიპის სიგრძე უნდა იყოს უფრო დიდი ვიდრე წყაროს ტიპის სიგრძე

ამ შემთხვევაში ხდება კონვერტაცია გაფართოებით.

შემდეგი დიაგრამა გვიჩვენებს Java-ში გაფართოებულ კონვერტაციას:

მყარი ხაზები მიუთითებს მონაცემთა დაკარგვის გარეშე შესრულებულ ტრანსფორმაციაზე. წყვეტილი ხაზები მიუთითებს, რომ კონვერტაციის დროს შეიძლება მოხდეს სიზუსტის დაკარგვა.

მაგალითად, მონაცემთა ტიპი ინტ ყოველთვის საკმარისად დიდი ტიპის ყველა მოქმედი მნიშვნელობის შესანახად ბაიტი ასე რომ, ამ შემთხვევაში არ არის საჭირო აშკარა ტიპის კონვერტაციის ოპერატორები. კონვერტაციის გაფართოების პერსპექტივიდან, რიცხვითი მონაცემების ტიპები, მათ შორის მთელი რიცხვი და მცურავი წერტილი, თავსებადია ერთმანეთთან. ამავდროულად, არ ხდება ავტომატური გადაქცევა რიცხვითი ტიპებიდან ტიპზე char ან ლოგიკური . ტიპები char და ლოგიკური ასევე შეუთავსებელია ერთმანეთთან.

ღირს ცოტათი ახსნა, თუ რატომ, მაგალითად, ტიპი ბაიტი ავტომატურად (არა ცალსახად) არ გარდაიქმნება ტიპად char , თუმცა ტიპი ბაიტი არის 8 ბიტიანი და char - 16, იგივე ეხება ტიპის კონვერტაციას მოკლე ვ char . ეს იმიტომ ხდება ბაიტი და მოკლე ხელმოწერილი მონაცემთა ტიპები და char ხელმოუწერელი. ამიტომ, ამ შემთხვევაში, თქვენ უნდა გამოიყენოთ ექსპლიციტური ტიპის cast, რადგან შემდგენელმა მკაფიოდ უნდა მიუთითოს, რომ თქვენ იცით, რა გსურთ და როგორ დამუშავდება ხელმოწერილი ტიპების ბიტი. ბაიტი და მოკლე ტიპად გადაყვანისას char .

აკრიფეთ ღირებულების ქცევა char უმეტეს შემთხვევაში ემთხვევა მთელი რიცხვის ტიპის მნიშვნელობის ქცევას, შესაბამისად, ტიპის მნიშვნელობას char შეიძლება გამოყენებულ იქნას იქ, სადაც საჭიროა მნიშვნელობები ინტ ან გრძელი . თუმცა, შეგახსენებთ, რომ ტიპი char არ აქვს ნიშანი, ამიტომ იქცევა განსხვავებულად ტიპისაგან მოკლე მიუხედავად იმისა, რომ ორივე ტიპის დიაპაზონი 16 ბიტია.

2. ტიპის ჩამოსხმა

მიუხედავად ავტომატური ტიპის კონვერტაციის მოხერხებულობისა, მას არ შეუძლია დააკმაყოფილოს ყველა აქტუალური მოთხოვნილება. მაგალითად, რა მოხდება, თუ მნიშვნელობა მსგავსია ინტ უნდა მიენიჭოს ტიპის ცვლადს ბაიტი ? ეს კონვერტაცია არ განხორციელდება ავტომატურად, რადგან სიგრძის ტიპი ბაიტი ტიპზე ნაკლები ინტ . ზოგჯერ ამ ტიპის ტრანსფორმაციას უწოდებენ შევიწროება ტრანსფორმაცია, რადგან მნიშვნელობა ცალსახად ვიწროვდება სამიზნე მონაცემთა ტიპთან შესატყვისად.

მონაცემთა ორ შეუთავსებელ ტიპს შორის კონვერტაციისთვის, თქვენ უნდა გამოიყენოთ cast ტიპის. მსახიობი მხოლოდ აშკარა ტიპის კონვერტაციაა. ტიპის ჩამოსხმის ზოგადი ფორმა შემდეგია:

(სამიზნე_ტიპი) მნიშვნელობა

სად არის პარამეტრი სამიზნე_ტიპიმიუთითებს ტიპზე, რომელზედაც უნდა გადაიზარდოს მითითებული მნიშვნელობა.

მაგალითი 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. ავტომატური ტიპის ხელშეწყობა გამონათქვამებში

მინიჭების ოპერაციების გარდა, გარკვეული ტიპის კონვერტაციები ასევე შეიძლება განხორციელდეს გამონათქვამებში.

ჯავაში გამოიყენება შემდეგი წესები:

1. თუ ერთი ოპერანდი არის ტიპის ორმაგი ორმაგი.
2. ათწილადი, მეორეც გადაყვანილია ტიპად ათწილადი.
3. წინააღმდეგ შემთხვევაში, თუ ერთი ოპერანდი არის ტიპის გრძელი, მეორეც გადაყვანილია ტიპად გრძელი.
4. წინააღმდეგ შემთხვევაში ორივე ოპერანდი გარდაიქმნება ტიპად ინტ.
5. შერეული დავალების გამონათქვამებში (+=,-=,*=,/=), არ არის საჭირო კასტის შესრულება.

აი მაგალითი:

მაგალითი 6. ავტომატური ტიპის ხელშეწყობა გამონათქვამებში

b1 ცვლადის გამრავლებისას ( ბაიტი) 2-ით ( ინტ) შედეგი იქნება ასეთი ინტ. ამიტომ, როდესაც ვცდილობთ მივაკუთვნოთ შედეგი ცვლადს b2 ( ბაიტი) მოხდება კომპილაციის შეცდომა. მაგრამ კომბინირებული მინიჭების ოპერატორის გამოყენებისას (*=), ეს პრობლემა არ წარმოიქმნება.

ბაიტი b1 = 1; ბაიტი b2 = 2 * b1; //კომპილაციის შეცდომა int i1 = 2 * b1; b2 *= 2;

მაგალითი 7. ავტომატური ტიპის ხელშეწყობა გამონათქვამებში

შემდეგ მაგალითში, ასევე მოხდება შედგენის შეცდომა - მიუხედავად იმისა, რომ ნომრები მოსწონს ბაიტი, ოპერაციის შედეგი იქნება ტიპი int,და არა მოკლე.

საჯარო კლასი 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); ) )

ეს საკმაოდ ვრცელი თემაა, მაგრამ შევეცდებით მაქსიმალურად სრულად და ამავდროულად კომპაქტურად განვიხილოთ. ჩვენ ნაწილობრივ უკვე შევეხეთ ამ თემას, როდესაც გადავხედეთ პრიმიტიულ ჯავას ტიპებს.

ჯავაში შესაძლებელია კონვერტაცია მთელ რიცხვსა და მცურავი წერტილის მნიშვნელობებს შორის. თქვენ ასევე შეგიძლიათ გადაიყვანოთ მთელი და მცურავი წერტილის მნიშვნელობები char მნიშვნელობებად და პირიქით, რადგან თითოეული სიმბოლო შეესაბამება უნიკოდის ციფრს. სინამდვილეში, ლოგიკური ტიპი ერთადერთი პრიმიტიული ტიპია ჯავაში, რომელიც არ შეიძლება გარდაიქმნას სხვა პრიმიტიულ ტიპად. გარდა ამისა, ნებისმიერი სხვა პრიმიტიული ტიპი არ შეიძლება გარდაიქმნას ლოგიკურად.

ჯავაში არსებობს ორი ტიპის ტიპის კონვერტაცია: იმპლიციტურიდა გამოკვეთილი.

იმპლიციტური ტიპის კონვერტაციაშესრულებულია შემდეგი პირობების დაკმაყოფილების შემთხვევაში:

1. ორივე ტიპი თავსებადია
2. სამიზნე ტიპის სიგრძე მეტია ან ტოლია წყაროს ტიპის სიგრძეზე

ყველა სხვა შემთხვევაში ის უნდა იქნას გამოყენებული აშკარა ტიპის კონვერტაცია.

ასევე არსებობს ორი სახის ტრანსფორმაცია:

1. გაფართოებული კონვერტაცია
2. შევიწროება კონვერტაცია

ტრანსფორმაციის გაფართოება ( გაფართოებული კონვერტაცია) ხდება, როდესაც ერთი ტიპის მნიშვნელობა გარდაიქმნება უფრო ფართო ტიპად, მოქმედი მნიშვნელობების უფრო დიდი დიაპაზონით. ჯავა ავტომატურად ახორციელებს გაფართოებულ კონვერტაციებს, მაგალითად, თუ თქვენ მიანიჭებთ int literal-ს ორმაგ ცვლადს ან char ცვლადის მნიშვნელობას int ცვლადს. იმპლიციტურ კონვერტაციას ყოველთვის აქვს გაფართოების ტიპი.

მაგრამ ამას შეიძლება ჰქონდეს საკუთარი პატარა საფულეები. მაგალითად, თუ int მნიშვნელობა გარდაიქმნება float მნიშვნელობად. და int მნიშვნელობას ბინარულ წარმოდგენაში აქვს 23-ზე მეტი მნიშვნელოვანი ბიტი, მაშინ სიზუსტის დაკარგვა შესაძლებელია, რადგან float ტიპს აქვს 23 ბიტი გამოყოფილი მთელი რიცხვისთვის. ყველა დაბალი ბიტი int მნიშვნელობები, რომლებიც არ ჯდება float mantissa-ს 23 ბიტში, გაუქმდება, ასე რომ, მიუხედავად იმისა, რომ რიცხვის თანმიმდევრობა შენარჩუნდება, სიზუსტე დაიკარგება. იგივე ეხება გრძელი ტიპის ორმაგად გადაქცევას.

ჯავის ტიპების გაფართოებული კონვერტაცია ასევე შეიძლება გამოისახოს შემდეგნაირად:

მყარი ხაზები მიუთითებს მონაცემთა დაკარგვის გარეშე შესრულებულ ტრანსფორმაციაზე. წყვეტილი ხაზები მიუთითებს, რომ კონვერტაციის დროს შეიძლება მოხდეს სიზუსტის დაკარგვა.

ღირს ცოტა ახსნა, თუ რატომ, მაგალითად, ბაიტის ტიპი ავტომატურად არ გარდაიქმნება (არა ცალსახად) char ტიპად, თუმცა ბაიტის ტიპს აქვს სიგანე 8 ბიტი, ხოლო char არის 16, იგივე ეხება კონვერტაციას. მოკლე ტიპის char. ეს იმიტომ ხდება, რომ ბაიტი და მოკლე არის ხელმოწერილი მონაცემთა ტიპები, ხოლო char არის ხელმოუწერელი. ამიტომ, ამ შემთხვევაში, თქვენ უნდა გამოიყენოთ ექსპლიციტური ტიპის cast, რადგან შემდგენელმა მკაფიოდ უნდა მიუთითოს, რომ თქვენ იცით, რა გსურთ და როგორ დამუშავდება ბაიტის და მოკლე ტიპების ნიშნების ბიტი char ტიპზე გადაყვანისას.

char მნიშვნელობის ქცევა უმეტეს შემთხვევაში იგივეა, რაც მთელი რიცხვის ტიპის მნიშვნელობის ქცევა, შესაბამისად, char მნიშვნელობა შეიძლება გამოყენებულ იქნას იქ, სადაც საჭიროა int ან long მნიშვნელობა. თუმცა, შეგახსენებთ, რომ char ტიპი ხელმოუწერელია, ამიტომ ის განსხვავებულად იქცევა მოკლე ტიპისგან, მიუხედავად იმისა, რომ ორივე ტიპს აქვს 16 ბიტიანი დიაპაზონი.

მოკლე ს = ( მოკლე ) 0xffff; // ეს ბიტები წარმოადგენს რიცხვს -1
char გ = "\უფფფ"; // იგივე ბიტები წარმოადგენს უნიკოდის სიმბოლოს
ინტ i1 = ს; // მოკლედ int-ად გადაყვანა იძლევა –1
ინტ i2 = გ; // char-ის int-ად გადაქცევა იძლევა 65535-ს

შევიწროება ტრანსფორმაცია ( შევიწროების კონვერტაცია) ხდება მაშინ, როდესაც მნიშვნელობა გარდაიქმნება იმ ტიპის მნიშვნელობად, რომლის დიაპაზონი არ არის უფრო ფართო ვიდრე ორიგინალი. კონვერტაციების შევიწროება ყოველთვის უსაფრთხო არ არის: მაგალითად, 13-ის მთელი მნიშვნელობის ბაიტად გადაქცევა აზრი აქვს, მაგრამ 13000-ის ბაიტად გადაქცევა არაგონივრულია, რადგან ბაიტს შეუძლია შეინახოს მხოლოდ −128-დან 127-მდე რიცხვები. რადგან მონაცემები შეიძლება დაიკარგოს შევიწროებისას. , ჯავის შემდგენელი აპროტესტებს ნებისმიერ ასეთ კონვერტაციას, მაშინაც კი, თუ კონვერტირებადი მნიშვნელობა ხვდება მითითებული ტიპის ვიწრო დიაპაზონში:

ინტ მე = 13 ;
ბაიტი ბ = მე ; // შემდგენელი არ დაუშვებს ამ გამოთქმას

წესიდან ერთადერთი გამონაკლისი არის ბაიტისთვის ან მოკლე ცვლადისთვის მთელი ლიტერალის (int მნიშვნელობის) მინიჭებისას, თუ ლიტერალი ემთხვევა ცვლადის დიაპაზონს.

ვიწრო კონვერტაცია ყოველთვის არის აშკარა ტიპის კონვერტაცია.

პრიმიტიული ტიპების აშკარა კონვერტაცია

აშკარა ტიპის კონვერტაციის ოპერატორი, უფრო ზუსტად, ტიპის ჩამოსხმა, არის ფრჩხილების გამოყენება, რომელშიც მითითებულია ტიპი, რომელშიც ხდება კონვერტაცია - (ტიპი). მაგალითად:

ინტ მე = 13 ;
ბაიტი ბ = ( ბაიტი ) მე ; // იძულებითი კონვერტაცია int-დან ბაიტზე
მე = ( ინტ ) 13.456 ; // ორმაგი ლიტერალის იძულებითი გადაქცევა int 13-ზე

პრიმიტიული ტიპის ჩამოსხმა ყველაზე ხშირად გამოიყენება მცურავი წერტილის მნიშვნელობების მთელ რიცხვებად გადაქცევა. ამავე დროს მცურავი წერტილის ფრაქციული ნაწილი უბრალოდ გაუქმებულია(ანუ, მცურავი წერტილის მნიშვნელობა მრგვალდება ნულისკენ და არა უახლოესი მთელი რიცხვისკენ). არსებითად აღებულია რეალური ტიპის მხოლოდ მთელი რიცხვიდა ის უკვე გადაცემულია სამიზნე მთელი რიცხვის ტიპზე.

უფრო ტევადი მოყვანისას მთელი ტიპინაკლებად ტევადობისთვის, ყველაზე მნიშვნელოვანი ბიტები უბრალოდ უგულებელყოფილია. არსებითად, ეს უდრის მოდულის გაყოფის ოპერაციას, რომელიც მცირდება სამიზნე ტიპის დიაპაზონით (მაგალითად, ბაიტის ტიპისთვის ეს არის 256).

წილადი რიცხვი, რომელიც ძალიან დიდია მთელ რიცხვად გარდაქმნისას, ხდება MAX_VALUE ან MIN_VALUE.

ძალიან დიდი ორმაგიროდესაც მიიყვანეს ათწილადიიქცევა Float.POSITIVE_INFINITY ან Float.NEGATIVE_INFINITY.

ქვემოთ მოყვანილი ცხრილი არის ბადე, სადაც თითოეული პრიმიტიული ტიპისთვის მითითებულია ტიპები, რომლებშიც შესაძლებელია მათი გარდაქმნა და კონვერტაციის მეთოდი. წერილი ნცხრილში ნიშნავს, რომ კონვერტაცია შეუძლებელია. წერილი ინიშნავს გაფართოებულ ტრანსფორმაციას, რომელიც სრულდება ავტომატურად. წერილი თანნიშნავს ვიწრო ტრანსფორმაციას, რომელიც მოითხოვს აშკარა მსახიობობას. ბოლოს და ბოლოს, Y*ნიშნავს ავტომატურ გაფართოებულ ტრანსფორმაციას, რომლის დროსაც მნიშვნელობამ შეიძლება დაკარგოს ზოგიერთი ყველაზე ნაკლებად მნიშვნელოვანი ციფრი. ეს შეიძლება მოხდეს int-ის ან long-ის float-ად ან ორმაგად გადაქცევისას. მცურავი წერტილის ტიპებს აქვთ უფრო დიდი დიაპაზონი, ვიდრე მთელი რიცხვები, ამიტომ int ან long შეიძლება წარმოდგენილი იყოს float ან double. თუმცა, მცურავი წერტილის ტიპები არის რიცხვების მიახლოება და შეიძლება ყოველთვის არ შეიცავდეს მანტისაში იმდენ მნიშვნელოვან ციფრს, რამდენიც მთელ რიცხვებს.

ავტომატური ტიპის გაფართოება გამონათქვამებში

ასევე, კიდევ ერთხელ უნდა აღინიშნოს გამონათქვამებში ტიპების ავტომატური დაწინაურება (გაფართოება). ჩვენ ამას უკვე შევხვდით, როდესაც განვიხილეთ მთელი რიცხვის მონაცემთა ტიპები და მათზე მოქმედებები, მაგრამ მაინც ღირს აქ გავიხსენოთ, რომ ეს კიდევ უფრო კარგად იყოს გაგებული და, უფრო მეტიც, ეს პირდაპირ კავშირშია ამ თემასთან. ნიშნის ქვემოთ მოცემულ მაგალითში @ + , – , * , / და ა.შ.

ანუ ყველა მთელი რიცხვი ლიტერალი გამონათქვამებში, ასევე ტიპებში ბაიტი, მოკლედა charგაფართოვდეს ინტ . თუ, როგორც ზემოთ იყო აღწერილი, სხვა, უფრო დიდი მონაცემების ტიპები არ არის გამოხატულში ( გრძელი, ათწილადიან ორმაგი). ამიტომ ზემოაღნიშნული მაგალითი გამოიწვევს კომპილაციის შეცდომას, რადგან ცვლადი გაქვს ტიპი ბაიტი, ხოლო გამოთქმას b+1, ავტომატური დაწინაურების შედეგად, აქვს ტიპი ინტ.

იმპლიციტური ტიპის კასტინგი შერეული დავალების გამონათქვამებში

მიუხედავად იმისა, რომ ეს განყოფილება ეხება იმპლიციტური ტიპის კონვერტაციას (კასტინგს), ჩვენ აქ მივეცით მისი ახსნა, რადგან ამ შემთხვევაში ავტომატური ტიპის გაფართოება გამონათქვამებში და შემდეგ იმპლიციტური ტიპის ჩამოსხმაც მუშაობს. ეს არის კორპუსი დე ბალეტი. ვფიქრობ, ქვემოთ მოყვანილი მაგალითი ყველაფერს ახსნის. ისევე, როგორც წინა ახსნაში, ნიშანი @ ნიშნავს ნებისმიერ მოქმედ ოპერატორს, მაგალითად + , – , * , / და ა.შ.

ამის ახსნა ღირს მარტივი მაგალითით:

ბაიტი b2 = 50 ;
b2 = b2 * 2 ; // არ შედგეს
b2 *= 2 ; //აწყობს, თუმცა უდრის b2 = b2 * 2-ს

მაგალითში მოცემული მეორე სტრიქონი არ არის შედგენილი გამონათქვამებში ტიპის ავტომატური გაფართოების გამო, რადგან გამონათქვამი b2*2 არის int ტიპის, ვინაიდან ხდება ავტომატური ტიპის გაფართოება (გამოსახულებაში მთელი რიცხვითი ლიტერალები ყოველთვის არის int). მესამე სტრიქონი ადვილად შედგენილია, ვინაიდან მასში იმუშავებს იმპლიციტური ტიპის ჩამოსხმა კომბინირებული დავალების გამოსახულებაში.

Boxing/unboxing - პრიმიტიული ტიპების გადაქცევა შეფუთულ ობიექტებად

კრივი და კრივი ასევე საკმაოდ დიდი თემაა, მაგრამ საკმაოდ მარტივია.

არსებითად კრივი და unboxing არის გადაქცევა პრიმიტიული ტიპებიდან შეფუთვის ობიექტებად და უკან.

პრიმიტიული ტიპების შესაფუთი ობიექტებისთვის ვრცელდება ყველაფერი, რაც ზემოთ იყო ნათქვამი.

შეფუთვის კლასები ნახსენები იყო ცხრილებში თითოეული პრიმიტიული ტიპის გაანალიზებისას. მაგრამ მაშინ ეს მხოლოდ ხსენება იყო ცხრილში.

ასე რომ, ყველა პრიმიტიულ ტიპს აქვს მისი უფროსი ძმა და ის სულაც არ არის პრიმიტიული, მაგრამ არის ნამდვილი კლასი, ველებითა და მეთოდებით. და თითოეული ასეთი წყვილისთვის შესაძლებელია ავტომატური კონვერტაცია.

ჩვეულებრივ, თუ პროგრამაში ბევრი მათემატიკური გამოთვლაა, უმჯობესია გამოიყენოთ პრიმიტიული ტიპები, რადგან ის უფრო სწრაფი და ეკონომიურია რესურსების თვალსაზრისით, მაგრამ ზოგჯერ საჭიროა პრიმიტიული ტიპის ობიექტად გადაქცევა.

მარტივ მაგალითს მოგიყვან:

ინტ i3 ;
ბაიტი b2 = 3 ;
ბაიტი myB ;
myB= b2;
myB++;
b2= myB;
i3= myB;

თუ ჯერ კიდევ გაუგებარია, რატომ არის ეს საჭირო, მაშინ ეს არ არის საშინელი, უბრალოდ მიამაგრეთ კვანძი, როგორც სამახსოვრო.

ეს სტატია:

• გუნდის მიერ დაწერილი. ვიმედოვნებთ, რომ ეს თქვენთვის სასარგებლო იქნება. ბედნიერი კითხვა!
• ეს არის ჩვენი ერთ-ერთი სტატია

ტიპების კონვერტაცია არის თემა, რომელიც შეიძლება საშინლად მოეჩვენოს მათთვის, ვინც ახალ Java პროგრამირებას იწყებს. თუმცა, გარწმუნებთ, რომ ყველაფერი რეალურად მარტივია. მთავარია გაგება რა კანონები არეგულირებს ცვლადებს შორის ურთიერთქმედებას და დაიმახსოვრეთ ეს პროგრამების წერისას. ასე რომ, მოდით გაერკვნენ.

ჯავაში ტრანსფორმაციის 2 ტიპი არსებობს - სურათი დაგეხმარებათ:

შეგახსენებთ, რომ მთელი "ჯავას სამყარო" შედგება:

• პრიმიტიული ტიპები (ბაიტი, მოკლე, int, long, char, float, double, boolean)
• ობიექტები

ამ სტატიაში ჩვენ:

• განვიხილოთ ტიპის კონვერტაცია პრიმიტიული ცვლადის ტიპებისთვის
• ობიექტების კონვერტაცია (სტრიქონი, სკანერი და ა.შ.) არ განიხილება ამ სტატიაში, რადგან ცალკეული „მაგია“ ხდება ობიექტებზე - ეს ცალკე სტატიის თემაა.

ავტომატური კონვერტაცია

მოდით, ვცადოთ გაერკვნენ, რა არის "ავტომატური კონვერტაცია".

დაიმახსოვრეთ, როდესაც ჩვენ გადავხედეთ ცვლადის ტიპებს (სტატიაში), ჩვენ ეს ვთქვით ცვლადი არის ერთგვარი „კონტეინერი“ , რომელსაც შეუძლია შეინახოს მნიშვნელობა პროგრამაში შემდგომი გამოყენებისთვის. ჩვენ ასევე ვისაუბრეთ იმაზე, რომ ცვლადის თითოეულ ტიპს აქვს სწორი მნიშვნელობების საკუთარი დიაპაზონი და მეხსიერების რაოდენობა, რომელიც მას იკავებს. აქ არის ნიშანი, სადაც ეს ყველაფერი ეწერა:

ასე რომ, ეს არის ის, რასაც ჩვენ რეალურად ვიღებთ. გარდა ამისა, ეს არ არის მხოლოდ ის, რომ თქვენ მოგცეს მისაღები მნიშვნელობების დიაპაზონი და დაკავებული მეხსიერების რაოდენობა :)

შევადაროთ, მაგალითად:

1. ბაიტი და მოკლე.ბაიტს აქვს მოქმედი მნიშვნელობების უფრო მცირე დიაპაზონი, ვიდრე მოკლე. ანუ, ბაიტი უფრო პატარა ყუთს ჰგავს, ხოლო short არის უფრო დიდი ყუთი. და ეს ნიშნავს შეგვიძლია მოკლედ დავწეროთ ბაიტი.

2. ბაიტი და ინტ. ბაიტს აქვს მოქმედი მნიშვნელობების უფრო მცირე დიაპაზონი, ვიდრე int. ანუ ბაიტი უფრო პატარა ყუთს ჰგავს, int კი უფრო დიდ ყუთს. და ეს ნიშნავს ჩვენ შეგვიძლია ჩავდოთ ბაიტი int-ში.

3. int და long. int-ს აქვს მოქმედი მნიშვნელობების უფრო მცირე დიაპაზონი, ვიდრე long. ანუ, int უფრო პატარა ყუთს ჰგავს, გრძელი კი უფრო დიდ ყუთს ჰგავს. და ეს ნიშნავს ჩვენ შეგვიძლია დავდოთ int შევიდა ხანგრძლივი.

ეს არის ავტომატური კონვერტაციის მაგალითი. ეს შეიძლება სქემატურად იყოს გამოსახული ასეთი სურათის სახით:

ვნახოთ, როგორ მუშაობს ეს პრაქტიკაში.

მაგალითი No1

კოდი No1 - თუ ამ კოდს გაუშვით თქვენს კომპიუტერში,

კლასის ტესტი ( საჯარო სტატიკური სიცარიელე მთავარი (სტრიქონის არგები) (ბაიტი a = 15; ბაიტი b = a; System.out.println(b); ) )

კლასის ტესტი ( ბაიტი a = 15; ბაიტი b = a ;

კოდი No2 - თუ ამ კოდს გაუშვით თქვენს კომპიუტერში, ნომერი 15 გამოჩნდება კონსოლში

კლასის ტესტი ( საჯარო სტატიკური სიცარიელე მთავარი (სტრიქონი არგები) (ბაიტი a = 15; int b = a; System.out.println(b); ) )

კლასის ტესტი ( საჯარო სტატიკური სიცარიელე მთავარი (სტრიქონი არგები) ( ბაიტი a = 15; int b = a ; სისტემა. გარეთ . println(b);

ეიორი? გგონია რომ ჯერ ერთი და იგივე რიცხვი გამოვიდა კონსოლზე, ხოლო კოდი No1 განსხვავდება კოდი No2-ისგან მხოლოდ b ცვლადის ტიპით , მაშინ მათ შორის განსხვავება არ არის?ეეს არ არის სიმართლე.

კოდი No2 შეიცავს ავტომატურიტიპის კონვერტაცია , მაგრამ No1 კოდში - არა:

მიუხედავად იმისა, რომ რიცხვი, პრინციპში, იგივეა, ის ახლა ბ-შია ოუფრო დიდი კონტეინერი, რომელიც იკავებს მეტ ადგილს დისკზე. ამ შემთხვევაში, JVM ასრულებს ავტომატურ კონვერტაციებს თქვენთვის. მან ეს იცის ინტმეტი ვიდრე ბაიტი .

ტიპის ჩამოსხმა

სხვა საქმეა, თუ თქვენ ცდილობთ რაღაცის გადატანას უფრო დიდი კონტეინერიდან პატარაზე.

თქვენ შეიძლება იცოდეთ, რომ უფრო დიდი კონტეინერი შეიცავს რაღაცას, რაც შეიძლება მოთავსდეს პატარაში - მაგრამ JVM-მა არ იცის ამის შესახებ და ცდილობს დაგიცვათ შეცდომებისგან.

ამიტომ, თქვენ უნდა "მკაფიოდ თქვათ", რომ სიტუაცია კონტროლდება:

კლასის ტესტი ( საჯარო სტატიკური სიცარიელე მთავარი (სტრიქონი არგები) ( int a=0; long b=15; a = (int) b; ) )

კლასის ტესტი ( საჯარო სტატიკური სიცარიელე მთავარი (სტრიქონი არგები) ( int a = 0; გრძელი b = 15; a = (int) b;

აქ დავამატეთ (ინტ)ადრე ბ. თუ ცვლადი აიყო, მაგალითად, მსგავსი ბაიტი, ფრჩხილებში იქნებოდა (ბაიტი). ზოგადი ფორმულა ასე გამოიყურება:

ის ამბობს: „გააკეთე (მეტი) მნიშვნელობა ბმე მჭირდება ტიპის ცვლადი (სამიზნე) ინტ ".

თუ რამე შეცდა.

მანამდე ჩვენ მივუდგებოდით სიტუაციებს იმ ვარაუდით, რომ ზუსტად ვიცოდით რას ვაკეთებდით. მაგრამ რა მოხდება, თუ ცდილობთ კონტეინერში ჩადოთ ისეთი რამ, რაც იქ არ ჯდება?

გამოდის, რომ კონტეინერში დარჩება მხოლოდ ის, რაც "ჯდება". მაგალითად, მცურავი პუნქტიანი რიცხვებისთვის წილადი ნაწილი "მოიჭრება":

//მაგალითი 1 კლასის ტესტი ( საჯარო static void main(String args) ( double a=11.2345; int b=(int)a; System.out.println(b); // კონსოლი აჩვენებს რიცხვს 11) )

//მაგალითი 1 კლასის ტესტი ( საჯარო სტატიკური სიცარიელე მთავარი (სტრიქონი არგები) ( ორმაგი a = 11.2345; int b = (int ) a ; სისტემა. გარეთ . println(b); // კონსოლში გამოჩნდება ნომერი 11

უნდა გვახსოვდეს, რომ წილადი ნაწილი არ არის მომრგვალებული, ა გადაყრილი.

რა მოხდება, თუ შევეცდებით დავაყენოთ რიცხვი, რომელიც ნებადართული დიაპაზონის მიღმაა? მაგალითად, თუ დააყენებთ რიცხვს 128 ბაიტში (ბაიტის დიაპაზონი -128-დან 127-მდე)? როგორ ფიქრობთ, 1-ს მივიღებთ? არა. ჩვენ ვიღებთ -128:

კლასის ტესტი ( public static void main (String args) ( double a=128; byte b=(byte)a; System.out.println(b); //ვნახავთ -128-ს კონსოლში) )

ასეთი ტრანსფორმაციის მქონე ცვლადის მნიშვნელობა შეიძლება გამოითვალოს, მაგრამ პროგრამისტის მიზანია თავიდან აიცილოს სიტუაცია, როდესაც მნიშვნელობა სცილდება დასაშვებ საზღვრებს, რადგან ამან შეიძლება გამოიწვიოს პროგრამის არასწორი მოქმედება.

ქვესტი:

1. თანმიმდევრულად ჩაწერეთ შემდგენელში ყველა პრიმიტიული ტიპის კონვერტაცია, მათ შორის სიმბოლოები და ტიპები, გააკეთეთ ასეთი ცხრილი:

	ბაიტი	მოკლე	char	ინტ	გრძელი	ათწილადი	ორმაგი	ლოგიკური
ბაიტი
მოკლე
char
ინტ
გრძელი
ათწილადი
ორმაგი
ლოგიკური

გზაჯვარედინზე ჩაწერეთ: a - თუ კონვერტაცია ხდება ავტომატურად, ჩართეთ - თუ საჭიროა გამოკვეთილი კონვერტაციის გამოყენება, x - თუ კონვერტაცია შეუძლებელია.

* ტიპის თავისთვის ჩამოსხმა ჰქვია იდენტური– არ არის საჭირო მისი რეგისტრაცია

1. კიდევ ერთხელ დააკვირდით, რა ზომისაა თითოეული პრიმიტიული ტიპი. შეეცადეთ შეადგინოთ დიაგრამა, სადაც ნაჩვენებია რომელი ტიპები სად მიდიან. დახაზეთ ისრები წარწერით "გაფართოებული ტრანსფორმაცია" და "შემზღუდავი ტრანსფორმაცია".

კითხვები

Java-ის უმცროსი დეველოპერის პოზიციაზე გასაუბრების დროს შეიძლება გკითხოთ:

რა იცით პრიმიტიული მონაცემთა ტიპების კონვერტაციის შესახებ, არის თუ არა მონაცემთა დაკარგვა, შესაძლებელია თუ არა ლოგიკური ტიპის კონვერტაცია?

შეეცადეთ უპასუხოთ კითხვას.

შევაჯამოთ:

• თუ პატარა კონტეინერის შიგთავსს „ჩადებთ“ უფრო დიდ კონტეინერში, კონვერტაცია ხდება ავტომატურად და არ უნდა მოხდეს შეცდომები.

• თუ საჭიროა „მნიშვნელობის უფრო დიდი კონტეინერიდან პატარაში“ ჩასმა, ფრთხილად უნდა იყოთ და გამოიყენოთ აშკარა ტიპის ჩამოსხმა.

• როდესაც ჩამოსხმის float ან ორმაგი მთელი რიცხვი ტიპის, ფრაქციული ნაწილი არ არის მომრგვალებული, მაგრამ უბრალოდ განადგურდეს.
• ლოგიკური ტიპი არ არის ჩამოსხმული რომელიმე ტიპზე.
• სიმბოლოს ტიპი გადაცემულია ციფრულ ტიპებზე, როგორც სიმბოლოების კოდი UNICODE სისტემაში.
• თუ რიცხვი მის კონტეინერზე დიდია, შედეგი არაპროგნოზირებადი იქნება.

ეს სტატია აღწერს მასალის მხოლოდ ნაწილს ტიპის ჩამოსხმის თემაზე. ასევე არის ობიექტის ტიპის casts, casts to string (ბოლოს და ბოლოს, სტრიქონში ყველაფრის დაწერა შეიძლება, არა?) და ავტომატური ტიპის პრომოუშენი გამონათქვამებში.

ვიმედოვნებთ, რომ ჩვენი სტატია თქვენთვის სასარგებლო იყო. ასევე არის შესაძლებლობა დარეგისტრირდეთ ჯავის კურსებზე კიევში. ჩვენ ვასწავლით ნულიდან. დეტალური ინფორმაცია შეგიძლიათ იხილოთ ჩვენს ვებგვერდზე.

ხშირად საჭიროა სტრიქონების გარდაქმნა სხვა ტიპის მნიშვნელობებად, როგორიცაა int ან boolean და პირიქით. მიღებული კონვენციის თანახმად, პასუხისმგებლობა სტრიქონის გარდაქმნაზე ვსხვა ტიპის მნიშვნელობა ენიჭება ამ ტიპის შესაბამის მეთოდს. მაგალითად, სტრიქონის კონვერტაცია int ტიპის მნიშვნელობად ხორციელდება სტატიკური მეთოდით Integer wrapper კლასიდან. ქვემოთ მოყვანილი ცხრილი ჩამოთვლის ყველა ტიპს, რომელსაც შეუძლია მნიშვნელობების სტრინგებად გადაქცევა და პირიქით, და ჩამოთვლილია შესაბამისი მეთოდები.

TYPE კონვერტაციის მეთოდი - სტრიქონიდან კონვერტაციის მეთოდი

tion to ხაზი

ლოგიკური სტრიქონი.valueOf(Boolean) new.Boolean(String). booleanvalue ()

ბაიტი String.valueOf(ბაიტი) Byte.parseByte(სტრიქონი, int)

short String.valueOf(short) Short.parseShort(string, int)

int String.valueOf(int) Integer.parseInteger(string, int)

long String.valueOf(long) Long.parseLong(string, int)

float String.valueOf(float) Float.parseFloat(სტრიქონი)

double String.valueOf(double) Double.parseDouble(string)

სტრიქონის ლოგიკურ მნიშვნელობად გადასაყვანად, თქვენ უნდა შექმნათ ლოგიკური ობიექტი და შემდეგ მოითხოვოთ მისი მნიშვნელობა. შეფუთვის ყველა სხვა კლასი შეიცავს შესაბამის მეთოდებს გაანალიზება.მეთოდები გაანალიზებამთელი ტიპები არსებობს ორი გადატვირთული ფორმით: პირველი, სტრიქონის გარდა, მოითხოვს int ტიპის დამატებითი არგუმენტის მითითებას, რომელიც წარმოადგენს რიცხვთა სისტემის საფუძველს - 2-დან 32-მდე; მეორე იღებს მხოლოდ სტრიქონის პარამეტრს და ნაგულისხმევად ითვალისწინებს ათობითი რიცხვების სისტემის გამოყენებას. ყველა შემთხვევაში, გარდა ლოგიკურისა, კეთდება შემდეგი დაშვება: თუ სტრიქონი წარმოადგენს მნიშვნელობას, რომელიც არ შეიძლება სწორად გადაკეთდეს შესაბამისი ტიპის რიცხვად, იდება NumberFormatException. ლოგიკური კლასი მიჰყვება კონვენციას, რომ ნებისმიერი სტრიქონის პარამეტრი, რომელიც არ არის ტოლი "true"-ის (case-inensitive) იწვევს ლოგიკური ობიექტის შექმნას მნიშვნელობით false.

მეთოდები, რომლებიც საშუალებას გაძლევთ გადაიყვანოთ სიმბოლოები, რომლებიც წარმოდგენილია ენის მიერ მხარდაჭერილ ერთ-ერთ ფორმაში (როგორიცაა \b, \uxxxxდა ა.შ.), char ტიპის მნიშვნელობები და პირიქით არ არსებობს. ერთი სიმბოლოს შემცველი String ობიექტის მისაღებად, უბრალოდ გამოძახეთ String.valueOf მეთოდი და პარამეტრად გადასვით შესაბამისი char მნიშვნელობა.

ასევე არ არსებობს ენით მხარდაჭერილი ერთ-ერთ ფორმატში მითითებული რიცხვების სიმებიანი წარმოდგენის შექმნის გზები - წინა ნულით (O), რომელიც მიუთითებს რვა რიცხვზე და პრეფიქსი Ox (ან OX), რომელიც ემსახურება ნიშანს. თექვსმეტობითი რიცხვების სისტემა. ამის საპირისპიროდ, მთელი რიცხვის შეფუთვის კლასები მხარს უჭერენ დეკოდირების მეთოდის ვერსიებს, რომლებსაც შეუძლიათ სტრიქონების გადაქცევა შესაბამისი ტიპის ციფრულ მნიშვნელობებად და გააცნობიერონ, რომ წამყვანი O არის რვა რიცხვი და ერთ-ერთი პრეფიქსი Ox OR Ox არის თექვსმეტობითი რიცხვი.

აპლიკაციის ნებისმიერ კლასს შეუძლია უზრუნველყოს საკუთარი ობიექტების სტრინგებად და უკან გადაქცევის მხარდაჭერა, თუ მისი დეკლარაცია შესაბამისად გადალახავს toString მეთოდს და უზრუნველყოფს სპეციალურ კონსტრუქტორს, რომელიც ქმნის კლასის ობიექტს პარამეტრად გადაცემული სტრიქონის საფუძველზე. თქვენ ასევე გაქვთ String.valueOf(Object obj) მეთოდი, რომელიც აბრუნებს ან "null" სტრიქონის ობიექტს (თუ obj არის null) ან obj.toString მეთოდის შედეგს. String კლასი შეიცავს valueOf მეთოდის საკმარის გადატვირთვებს, რომ თქვენ შეგიძლიათ გადაიყვანოთ ნებისმიერი ტიპის ნებისმიერი მნიშვნელობა String ობიექტად უბრალოდ valueOf-ის გამოძახებით და სასურველი არგუმენტის გადაცემით.

1. რა არის ექსპლიციტური და ავტომატური ტიპის ჩამოსხმა გამონათქვამებში?

ტიპის ჩამოსხმა შეიძლება იყოს აშკარა ან ავტომატური.

აშკარა ტიპის ჩამოსხმისას, თავად ჩამოსხმის ოპერაცია პირდაპირ არის მითითებული.

ავტომატური ტიპის ჩამოსხმის შესრულებისას უნდა დაკმაყოფილდეს ორი პირობა:

• ორივე ტიპი უნდა იყოს თავსებადი;
• წყაროს ტიპის სიგრძე (წყაროს ტიპი) უნდა იყოს სამიზნე ტიპის სიგრძეზე ნაკლები (ჩაძირვის ტიპი).

2. როგორ გამოიყურება ექსპლიციტური ტიპის კასტინგი გამონათქვამებში? მაგალითები

აშკარა ტიპის ჩამოსხმა იძლევა შეუთავსებელი ტიპების მინიჭების საშუალებას. აშკარა ტიპის ჩამოსხმის ზოგადი ფორმაა:

(სამიზნე_ტიპი) მნიშვნელობა

სამიზნე_ტიპი– ეს ის ტიპია, რომელზეც გსურთ მითითებულის გადაცემა მნიშვნელობა.

მაგალითებიაშკარა ტიპის ჩამოსხმა.

// ექსპლიციტური ტიპის ჩამოსხმა გამონათქვამებში ბაიტი b; int a; ორმაგი დ; float f; d = -39,9203; a = (int )d; // a = -39 f = (float )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 - ავტომატური ტიპის ჩამოსხმა შ = -150; a = შ; // a = -150 გრძელი ლ = 200; // შეცდომა: "ტიპის შეუსაბამობა: გრძელიდან int-ზე გადაყვანა შეუძლებელია" // a = l; l = b; // ლ = -23 ლ = შ; // ლ = -150 char c = "Z" ; a = c; // a = 90 - სიმბოლოს კოდი "Z" ლოგიკური b1 = მცდარი; //a = b1; - შეცდომა, ტიპები შეუთავსებელია

მაგალითი 2. მცურავი წერტილის ტიპების ავტომატური ჩამოსხმა.

// მცურავი წერტილის ტიპების ავტომატური ჩამოსხმა float f; ორმაგი დ; f = 3.409033f; d = f; // d = 3.409033

მაგალითი 3. შერეული ტიპების ავტომატური ჩამოსხმა. ეს შესაძლებელია, თუ მცურავი წერტილის ცვლადს მიენიჭება მთელი რიცხვის ტიპის ცვლადის მნიშვნელობა.

// შერეული ტიპის ავტომატური ჩამოსხმა float f; ორმაგი დ; a = 28; d = a; // d = 28.0 f = a; // f = 28.0 // შეცდომა: Type mismatch: ვერ გადაიყვანება float-დან int-ზე // a = f;

4. როგორ ხდება ავტომატური ტიპის ხელშეწყობა გამონათქვამებში?

ავტომატური ტიპის ხელშეწყობა ხდება გამონათქვამებში. ამ შემთხვევაში, გამონათქვამებში გამოსახული მნიშვნელობები ავტომატურად გადადის ტიპებად დიდი მნიშვნელობის დიაპაზონებით.

ტიპების ავტომატურად რეკლამირებისას გამონათქვამებში:

• თუ ერთ-ერთი მთელი ოპერანდი არის int ტიპის, მაშინ ყველა ტიპის ბაიტი, მოკლე და char მნიშვნელობები დაწინაურებულია int ტიპის;
• თუ ერთ-ერთი მთელი რიცხვი ოპერანდებიდან არის long ტიპის, მაშინ მთელი გამოხატულება დაწინაურებულია აკრეფით long;
• თუ ერთ-ერთი ოპერანდი არის float ტიპის, მაშინ მთელი გამოხატვის ტიპი ასევე იქნება float ტიპის (თუ არ არის double ტიპის ოპერანდები);
• თუ ერთ-ერთი ოპერანდი არის double ტიპის, მაშინ მთლიანი გამოხატვის ტიპი ასევე იქნება ორმაგი.

5. დაწინაურების მაგალითი ტიპის ბაიტიდან int-მდე, რომელშიც გამონათქვამი არ შეიცავს int (გრძელი) ტიპის ცვლად ოპერანდებს.

// ბაიტი -> ინტ ბაიტი b; b = 1000 / 20; // b = 50, მუშაობს იმიტომ, რომ შედეგი მოთავსებულია ბაიტის ტიპში

ზემოთ მოყვანილი მაგალითი სწორად მუშაობს, რადგან:

• შედეგი მოთავსებულია (თავსებადი) ბაიტის ტიპში;
• int ტიპის ოპერანდები არ არის.

ზემოთ მოყვანილ მაგალითში, მნიშვნელობა 1000 აჭარბებს ბაიტის მნიშვნელობების დიაპაზონს.

1000 / 20 = 50

პირველ რიგში, რიცხვი 1000 არის ჩამოსხმული, რომ აკრიფოთ int. ბ .

მაგრამ შედეგი

ბაიტი b; გადაცემულია ბაიტზე და შეიძლება სწორად მოერგოს ცვლადში თუ ასე დაწერ:

b = 100000 / 20;

// შეცდომა, რადგან შედეგი არ ჯდება ბაიტის ტიპში

100000 / 20 = 5000

შემდეგ გამოჩნდება შედგენის შეცდომა შეტყობინებასთან ერთად:

ამ შემთხვევაში, შედეგი არ შედის ბაიტის ტიპში:

ბაიტი b; შემდეგ ეს რიცხვი (5000) ავტომატურად ხდება int ტიპის და შემდგენელი წარმოქმნის შეცდომის შეტყობინებას.

თუ თქვენ აკეთებთ ექსპლიციტური ტიპის კასტინგს:

b = (ბაიტი) (100000 / 20); // ბ = -120

მაშინ ამ შემთხვევაში int ტიპის 5000 შედეგი იქცევა ტიპის ბაიტად.

მოგეხსენებათ, int ტიპის ცვლადი იკავებს 32 ბიტს, ხოლო ბაიტის ტიპის ცვლადი 8 ბიტს. int ცვლადის მნიშვნელობა შემცირებულია. და ჩვენ გვაქვს ის, რაც გვაქვს (b = -120). // ბაიტი -> ინტ ბაიტი b; ზემოთ მოყვანილი მაგალითები ასევე ვრცელდება მოკლე და char ტიპის ცვლადებზე. 6. მაგალითი. დაწინაურება ბაიტიდან int-ში, სადაც გამოხატულება შეიცავს int ცვლადის ოპერანდს // ტიპების ხელშეწყობა გამონათქვამებში int d;

d = 20; // შეცდომა, შედეგი არის int ტიპის, ვინაიდან ცვლადი d არის int ტიპის// b = 1000 / დ;

ტიპის შეუსაბამობა: ვერ გადაიყვანება int-დან ბაიტზე

ეს ნიშნავს, რომ შედეგი არის int (არა ბაიტი) მაშინაც კი, თუ მნიშვნელობა ჯდება ბაიტის მნიშვნელობების დიაპაზონში. // შეცდომა, შედეგი არის int ტიპის, ვინაიდან ცვლადი d არის int ტიპისრადგან გამოხატულება იყენებს ოპერანდის ცვლადს

აკრიფეთ int.

მოგეხსენებათ, int ტიპის ცვლადი იკავებს 32 ბიტს, ხოლო ბაიტის ტიპის ცვლადი 8 ბიტს. int ცვლადის მნიშვნელობა შემცირებულია. და ჩვენ გვაქვს ის, რაც გვაქვს (b = -120). // ბაიტი -> ინტ ბაიტი b; თუ თქვენ შეასრულებთ ექსპლიციტური ტიპის ჩამოსხმას, შედეგი სწორი იქნება: 6. მაგალითი. დაწინაურება ბაიტიდან int-ში, სადაც გამოხატულება შეიცავს int ცვლადის ოპერანდს int d; b = (ბაიტი) (1000/დ);

// b = 50 - მუშაობს სწორად

7. მაგალითი. დაწინაურება ინტიმიდან გრძელამდე

ზემოთ მოყვანილი მაგალითები ასევე ვრცელდება მოკლე და char ტიპის ცვლადებზე. ტიპის დაწინაურების მაგალითი int-დან long. თუ ერთ-ერთი ოპერანდი არის ხანგრძლივი ტიპის, მაშინ მთელი გამოხატულება დაწინაურებულია აკრეფით long. longl; d = 10000 * 200; // სამუშაოები, d = 2000000 // შეცდომა! ტიპის შეუსაბამობა: არ შეიძლება გადაიზარდოს გრძელიდან int-ზე // დ = 1ლ * 2ლ; - ოპერანდები 1L და 2L არის გრძელი ტიპის ლ = 100;

// შეცდომა, ერთ-ერთი ოპერანდი არის გრძელი ტიპის