Въведение в преобразуването на типове в Java
След като променливите, както и, константи от различни типове ще бъдат събрани в един израз, те могат да бъдат променени в подобен тип. Тази техника за преобразуване на един предварително определен тип в друг е известна като преобразуване на типа в Java.
Тип Преобразуване
Има два различни типа преобразуване, които използваме в езиците за програмиране.
1. Неявно преобразуване на типа
Ако преобразуването на типа се извършва незабавно чрез компилатор, без участието на програмиста, преобразуването на типа е известно като неявно преобразуване на типа. Компилаторът по принцип насърчава всеки операнд към типа данни на най-големия операнд. По време на преобразуването на данни няма загуба на данни. Няма шанс да хвърли изключение чрез преобразуването и по този начин е известен като тип-безопасен. Преобразуването на по-малък размер с твърде много по-голям брой може да бъде неявно преобразуване. Трансформация на целочислени данни в плаваща.
float i=0;
int j=10;
i=j;
// Това може да бъде косвено преобразуване, тъй като float може да бъде по-голямо от цяло число, следователно липса на данни И също така не е изключение.
2. Изрично преобразуване на типа
Преобразуването на типа, което може да бъде наложено чрез програмиста, е известно като изрично преобразуване на типа. по същество, програмистът прави израза да стане от определен тип. Изричното преобразуване на типа може да бъде известно като typecasting. По време на конвертирането на данни може да има или не може да възникне загуба на данни. Следователно съществува вероятност от загуба на детайли. може да хвърли грешка, ако може би се опита да изпълни без въвеждане на текст. Преобразуването на по-голям брой в по-малки по големина числа може да бъде изрично преобразуване.
float k=123.456
int i= (int) k
// това може да бъде явно преобразуване, както и, (int) е typecast, оператор. В този момент може да успеем да избягаме от изключение, но можете да откриете видимата загуба на данни. т.е. i = 123
// .456 може да отпадне в процеса на преобразуване
Тип Преобразуване в Java
Подобно на другите езици за програмиране, в Java има 2 вида конверсия:
Неявно преобразуване на типа
- Обикновено това наричаме разширяване на конверсията и те могат да бъдат направени автоматично, защото преминаваме към по-широк тип данни. Така че ако имаме 32-битово цяло число и искаме да преминем към 64-бито цяло число, това е по-широко. Така стойността може да бъде безопасно преместена, така че те да могат да се правят неявно. И компилаторът трябва да вземе решение как да извърши тези преобразувания, а правилата са доста ясни.
- Ако имаме израз с множество (смесени) цели числа в него, ако имаме кратък и дълъг, какъвто и да е най-големият цяло число, в какво ще го преобразуваме. Така че, ако правим операция с къса и дълга, късата ще бъде включена неявно.
- Ако извършим операция със смесени размери с плаваща запетая, така че имаме поплавък и двойник, те винаги ще отидат на двойния, защото двойният е най-големият размер с плаваща запетая.
- И тогава, ако имаме операция, която използва смесени цели числа и типове с плаваща запетая, компилаторът ще прехвърли към най-голямата плаваща точка в уравнението. Така че, ако правим операция с дълга и на плаваща дължина, тя ще бъде хвърлена на плаване.
- Ако направим операция с дълга и двойна, тогава дългата ще бъде прехвърлена на двойна.
Изрично преобразуване на типа
- Ние изрично изпълняваме в нашия код, когато използваме тази операция за отливане. Когато правим това, ние поемаме отговорност за всичко, което се случи в резултат на този тип преобразуване. Поради това можем да извършим както разширяващо се преобразуване, така и тясно. Така разширяването преминава от 32-битово да каже 64-битово, стеснява се, преминава от 64-битово към 32-битово. Трябва просто да искаме да сме наясно, че знаем какво потенциално може да се случи.
- Ако правим изрично заглавие от плаваща запетая към цяло число, така че плаващите точки могат да имат дробна част, цяло число не може, така че всяка дробна част ще бъде отпаднала, когато прехвърлим тази плаваща част към цяло число.
- Искате да бъдете внимателни, когато извършвате стесняване на преобразуването. Ако имаме 64-битово цяло число, то има способността да държи стойности, които са твърде големи, за да се поберат в 32-битово цяло число.
- Така че, ако прехвърлим 64-битовия 32-битов, програмата всъщност ще го направи, но ако стойността е твърде голяма, за да се впише в 32-битова, ще получите някои странни резултати от това. Така че искате да сте сигурни, че когато го правите, правите стесняващ актьор, че знаете, че това, което правите, е безопасно.
- И последното е просто, че искате да бъдете внимателни, когато преобразувате от цяло число в плаваща запетая, защото ако имате цяло число с голям брой значими цифри, поради начина, по който плаващата точка се съхранява, бихте могли да загубите част от тези значими цифри.
Примери за преобразуване на типа
Примери за преобразуване на типа, споменати по-подробно по-долу:
Код:
Тук имаме проста програма, някаква декларация в горната част, float, double, byte, short и long, а променливите се назовават, за да помогнат да се идентифицират какви са техните типове като float е floatVal,
Код:
long е longVal
Код:
И програмата просто отпечатва съобщение за успех, ако се изпълнява.
Така че нека просто видим как част от преобразуването на типа влиза в игра тук. Така че нека първо, нека просто продължим напред и да създадем променлива. Ние имаме кратък и просто ще го наречем резултата.
Всъщност, нека да продължим напред и да го наречем резултат1. И нека направим просто задача. И така първо първо ще присвоим byteVal към него. Сега, както очакваме, ако продължаваме напред и изпълняваме това, така че стартирайте успешно.
Код:
изход:
Знаем, че това е валидно задание, тъй като един байт може да бъде присвоен в кратко, защото това е разширяваща се конверсия.
Ако вземем този byteVal и вместо това го направим longVal, така че сега всъщност е дълъг, ако изпълним това, тук получаваме съобщение за грешка, казващо несъвместим тип, възможна загуба на конверсия от дълга в къса.
Код:
Така че това, което можем да направим тук тук е, че можем да направим изрично участие. Просто ще поставим кратко пред това. Така че сега е валиден, за да можем да го изпълним.
Код:
И разбира се, работи. Защото дългото не можеше да премине в кратко, защото това беше стесняване на преобразуването.
изход:
Но като поставите изричния актьорски състав пред него, сега е валиден. Ако искаме, можем да поставим нотацията на гласове да бъде много явна и да кажем, че знаете, че знаем, въпреки че преобразуването на байтове е законно, искаме изрично да покажем, че го предаваме, като поставяме краткия глас там, можем да направим това и това е напълно законно.
Код:
изход:
Затова сега нека разгледаме друг сценарий. Ще създадем друга променлива, която ще наречем result2 , а result2 също е кратка. И това, което искаме да направим тук, е просто да вземем нашия byteVal и искаме да извадим longVal. Сега знаем, че това не е законно, защото резултатът от израза ще бъде размерът на най-голямото цяло число в него, което е дължината.
Код:
Така че, ако изпълним това, получаваме грешка, казваща, че не е валидно да преобразувате дълго в кратко.
Но нека кажем, че искаме да продължим напред и да поддържаме този резултат като кратък. Трябва да направим актьорски състав. Но ние искаме да хвърлим този път е стойността на целия резултат тук. Така че това, което ще го направим, постави краткия актьорски състав пред него тук.
Поставете късата актьорска част тук. И увийте цялата работа в скоби. И го пусни.
Код:
Ще работи успешно.
изход:
Сега декларирайте друга променлива, наречена result3, но декларирайте тази като дълга. Така че получихме резултат 3 и какво ще направим тук, ще присвоим нашия longVal - floatVal. Така че ние изпълняваме това, грешката се губи преобразуване преобразуване от float в long, защото всеки път, когато имаме цяло число и всеки тип с плаваща запетая, резултатът ще бъде тип с плаваща запетая.
Код:
Така че нека продължим напред и преобразуваме нашия резултат сега в поплавък. Така че, като направим този поплавък, ние би трябвало да можем да продължим напред и да го изпълним. И тичайте успешно.
Код:
изход:
Но сега, ако вземем floatVal тук и преобразуваме това в doubleVal и ако се опитаме да стартираме това, получаваме грешката, защото тя казва, че резултатът ще бъде двойник, защото когато направите цяло число и плаваща запетая, това е размерът на най-голямата плаваща точка в уравнението.
Код:
Така че нека продължим напред и да направим този резултат двоен, за да можем сега да го изпълним.
Код:
изход:
заключение
1. Променливите са силно въведени в Java
2. Примитивни типове
- Типове цели числа, типове с плаваща запетая, тип char, булев тип
3. Тип преобразуване
- Често се налага да се движим между различен тип, тъй като тъй като нашите програми, тъй като придобиват по-голяма сложност, вероятно ще включват множество типове данни.
- Компилаторът може да обработва конверсии от тип, които се разширяват, преминавайки от един тип в друг, който може да поддържа по-големи стойности,
- Но също така можете да използвате кастинга, за да извършите изрично тези типове преобразувания, които компилаторът не може да извърши автоматично.
Препоръчителни статии
Това е ръководство за преобразуване на тип в Java. Тук обсъждаме въвеждането, преобразуването на типа в java като имплицитно и изрично заедно с примерите, използващи различни ситуации. Можете също да разгледате следните статии, за да научите повече-
- Конструктор в Java
- Сортиране в Java
- Конструктор в Java
- JCheckBox на Java
- Хвърли срещу Хвърли | Топ 5 разлики, които трябва да знаете
- Как да внедрите отметка в Bootstrap
- Преобразуване в Java с примери