Introduktion till typkonvertering i Java
När såväl variabler som konstanter av olika typer kommer att sätts samman i ett uttryck kan de ändras till en liknande typ. Denna teknik för att omvandla en enda fördefinierad typ till en annan kallas typkonvertering i Java.
Skriv konvertering
Det finns två olika typer av konvertering som vi använder i programmeringsspråk.
1. Implicit typkonvertering
Om typkonvertering genomförs direkt genom kompilator utan att programmerarens deltagande är typkonvertering känd som implicit typkonvertering. Kompilatören uppmuntrar i grund och botten varje operand mot datatypen för den största operand.Inga förlust av data uppstår under hela datakonverteringen. Omvandling av mindre storlek för mycket större antal kan vara implicit omvandling. Transformation av heltalstypdata att flyta.
float i=0;
int j=10;
i=j;
// Detta kan vara implicit transformation eftersom flottör kan vara större än ett heltal, därför ingen brist på data Och inte heller något undantag.
2. Omfattande typkonvertering
Den typkonvertering som kan verkställas genom programmeraren kallas explicit typkonvertering. i grunden gör programmeraren ett uttryck för att bli av en viss typ. Explicit typomvandling kan kallas typcasting. Förlust av data kan eller inte kan inträffa under datakonvertering. Därför finns det en sannolikhet för förlust av detaljer. det kan kasta ett fel om det kanske försökte utföra utan typkasting. Omvandling av ett större antal till mindre storlek kan vara uttrycklig konvertering.
float k=123.456
int i= (int) k
// detta kan vara Explicit-konvertering samt, (int) är typecast, operator. Vid denna tidpunkt kanske vi lyckas undkomma ett undantag men du kan hitta den synliga dataförlusten. dvs i = 123
// .456 kan släppas i konverteringsprocessen
Skriv konvertering i Java
Liksom andra programmeringsspråk finns det två typer av omvandlingar i java:
Implicit typkonvertering
- Detta är i allmänhet vad vi kallar Bredare konvertering, och dessa kan göras automatiskt eftersom vi flyttar till en bredare datatyp. Så om vi har ett 32-bitars heltal och vi vill flytta till ett 64-bitars heltal är det bredare. Så värdet kan flyttas säkert så att de kan göras implicit. Och kompilatorn måste fatta ett beslut om hur man gör dessa omvandlingar, och reglerna är ganska enkla.
- Om vi har ett uttryck med flera (blandade) heltalstorlekar i det, om vi har korta och långa, oavsett den största heltalstorleken är vad saker kommer att konvertera till. Så om vi gör en operation med en kort och en lång, kommer den korta implicit att kastas med.
- Om vi utför en operation med blandade flytpunktsstorlekar, så att vi har en flottör och en dubbel, kommer de alltid att gå till dubbla eftersom dubbla är den största flytpunktsstorleken.
- Och sedan om vi har en operation som använder blandade heltalstyper och flytpunkttyper kommer kompilatorn att kasta till den största flytande punkten i ekvationen. Så om vi gör en operation med en lång och flytande kommer den långa att kastas till flytande.
- Om vi gör en operation med en lång och en dubbel, kommer den långa sedan att kastas till en dubbel.
Explicit Type Conversion
- Vi utför uttryckligen vår kod när vi använder denna rolloperation. När vi gör det tar vi ansvar för vad som händer till följd av den typen av omvandling. På grund av det kan vi utföra både utvidgad konvertering och smal. Så utvidgningen går från en 32-bitars till 64-bitars, minskar, går från en 64-bitars ned till en 32-bitars. Vi borde bara vara medvetna om att vi vet vad som kan hända.
- Om vi gör en uttrycklig roll från en flytande punkt till ett heltal, så flytande punkter kan ha en bråkdel, kan heltal inte, så någon bråkdel kommer att tappas när vi kastar den flyter ner till ett heltal.
- Du vill vara försiktig när du utför en minskande konvertering. Om vi har ett 64-bitars heltal har det förmågan att hålla värden som är för stora för att passa in i ett 32-bitars heltal.
- Så om vi kastar den 64-bitars till en 32-bitars kommer programmet faktiskt att göra det, men om värdet är för stort för att passa in i en 32-bitars får du några udda resultat av det. Så du vill se till att när du gjuter det gör en smalare roll att du vet att det du gör är säkert.
- Och den sista är bara att du vill vara försiktig när du konverterar från ett heltal till en flytande punkt, för om du har ett heltal med ett stort antal betydande siffror, på grund av hur flyttpunkten lagras, kan du förlora en del av de betydande siffrorna.
Exempel på typkonvertering
Exempel på typkonvertering som nämns nedan i detalj:
Koda:
Vi har ett enkelt program här, några förklaringar i toppen, flyta, dubbel, byte, kort och lång, och variablerna namnges var och en för att identifiera hur deras typer är som float är floatVal,
Koda:
lång är långVal
Koda:
Och programmet skriver bara ut ett framgångsmeddelande om det körs.
Så låt oss bara se hur någon av typen konvertering spelar in här. Så låt oss först av allt, låt oss bara gå vidare och skapa en variabel. Vi har kort och vi kommer bara att kalla det resultatet.
Låt oss faktiskt gå vidare och kalla det resultat1. Och låt oss bara göra en enkel uppgift. Och så först tilldelar vi bara byteVal till den. Nu som vi förväntar oss, om vi fortsätter och kör detta, så kör framgångsrikt.
Koda:
Produktion:
Vi vet att det är en giltig tilldelning eftersom en byte kan tilldelas till en kort eftersom det är en utvidgad konvertering.
Om vi tar detta byteVal men och gör det till en longVal istället, så nu är det faktiskt en lång, om vi kör detta får vi ett felmeddelande här som säger inkompatibel typ, möjlig förlust av omvandling från lång till kort.
Koda:
Så det vi kan göra här då är att vi kan göra en uttrycklig roll. Vi kommer bara att sätta kort framför detta. Så nu är det giltigt så att vi kan köra det.
Koda:
Och naturligtvis fungerar det. Eftersom det långa inte kunde gå på kort eftersom det var en snävare konvertering.
Produktion:
Men genom att sätta den uttryckliga rollen framför den är den nu giltig. Om vi vill, kan vi sätta en roll-notation vara väldigt uttrycklig och säga att du vet, vi vet att även om en byte-konvertering är laglig, vill vi uttryckligen visa att vi kastar den genom att sätta kortkommandot där, vi kan göra det, och det är helt lagligt.
Koda:
Produktion:
Så nu ska vi titta på ett annat scenario. Vi kommer att skapa en annan variabel som vi kommer att kalla resultat2 , och resultat2 är också en kort. Och vad vi vill göra här är att vi bara tar vår byteVal, och vi vill subtrahera longVal. Nu vet vi att det inte är lagligt eftersom resultatet av uttrycket kommer att bli storleken på det största heltalet i det, vilket är längden.
Koda:
Så om vi kör detta får vi ett fel med att säga att det inte är giltigt att konvertera en lång till en kort.
Men låt oss säga att vi vill gå vidare och hålla resultatet så kort. Vi måste göra en roll. Men vi vill att den här gången är värdet på hela resultatet här. Så vad vi ska göra, lägger den korta rollen framför den här.
Sätt den korta rollisten framför den här. Och linda in det hela inom parentes. Och kör det.
Koda:
Det kommer att köras framgångsrikt.
Produktion:
Förklara nu en annan variabel som heter result3, men förklar den här som en lång. Så fick resultat 3, och vad vi ska göra här är att vi ska tilldela vår longVal - floatVal. Så vi kör det, felet går förlorad konvertering konvertering från flottör till lång eftersom varje gång vi har en heltalstyp och vilken typ av flytande punkt som helst kommer resultatet att bli flytpunkttypen.
Koda:
Så låt oss gå vidare och konvertera vårt resultat nu till en flottör. Så genom att göra det till ett flottör bör vi kunna fortsätta och driva det. Och kör framgångsrikt.
Koda:
Produktion:
Men nu om vi tar floatVal här och omvandlar detta till att vara ett doubleVal och om vi försöker köra detta får vi felet eftersom det säger att resultatet kommer att bli en dubbel eftersom när du gör ett heltal och en flytande punkt, det är storleken på den största flytande punkten i ekvationen.
Koda:
Så låt oss gå vidare och göra detta resultat till ett dubbelt så nu kan vi köra det.
Koda:
Produktion:
Slutsats
1. Variabla är starkt skrivna i Java
2. Primitiva typer
- Heltalstyper, flytpunkttyper, koltyp, boolesktyp
3. Skriv omvandling
- Vi måste ofta flytta mellan olika typer, eftersom våra program, eftersom de blir mer komplexa, sannolikt kommer att involvera flera datatyper.
- Kompilatorn kan hantera typkonverteringar som utvidgas och flyttar från en typ till en annan som kan innehålla större värden,
- Men du kan också använda casting för att uttryckligen utföra de typer av omvandlingar som kompilatorn inte kan utföra automatiskt.
Rekommenderade artiklar
Det här är en guide till typkonvertering i Java. Här diskuterar vi introduktionen, skriv konvertering i java som implicit och explicit tillsammans med exemplen med olika situationer. Du kan också titta på följande artiklar för att lära dig mer-
- Konstruktör i Java
- Sorterar i Java
- Konstruktör i Java
- JCheckBox i Java
- Kast vs kastar | Topp 5 skillnader du borde veta
- Hur man implementerar kryssrutan i Bootstrap
- Konvertering i Java med exempel