Inleiding tot typeconversie in Java
Zodra zowel variabelen als constanten van verschillende typen worden samengevoegd in een uitdrukking, kunnen deze worden gewijzigd in een soortgelijk type. Deze techniek voor het omzetten van een enkel vooraf gedefinieerd type in een ander staat in Java bekend als typeconversie.
Type conversie
Er zijn 2 verschillende soorten conversies die we in programmeertalen gebruiken.
1. Impliciete typeconversie
Als de typeconversie direct door de compiler wordt uitgevoerd zonder de betrokkenheid van de programmeur, staat de typeconversie bekend als impliciete typeconversie. De compiler moedigt fundamenteel elke operand aan naar het gegevenstype van de grootste operand. Er treedt geen gegevensverlies op tijdens de gegevensconversie. Geen kans op uitzonderingen door de conversie en staat daarom bekend als typeveilig. Conversie van kleinere hoeveelheden te veel groter aantal kan impliciete conversie zijn. Transformatie van integer type data naar float.
float i=0;
int j=10;
i=j;
// Dit kan een impliciete transformatie zijn, omdat float groter kan zijn dan een geheel getal, dus geen gebrek aan gegevens en ook geen uitzondering.
2. Expliciete typeconversie
De typeconversie die via het programmeerapparaat kan worden afgedwongen, wordt expliciete typeconversie genoemd. in wezen maakt de programmeur een uitdrukking om van een bepaald type te worden. Expliciete typetransformatie kan typecasting worden genoemd. Gegevensverlies kan al dan niet optreden tijdens gegevensconversie. Daarom bestaat er een kans op detailverlies. het kan een fout veroorzaken als het misschien probeerde uit te voeren zonder typecasting. Transformatie van een groter aantal naar kleinere aantallen kan een expliciete conversie zijn.
float k=123.456
int i= (int) k
// dit kan expliciete conversie zijn, evenals (int) is typecast, operator. Op dit moment kunnen we misschien aan een uitzondering ontsnappen, maar u kunt het zichtbare verlies van gegevens vinden. dat wil zeggen i = 123
// .456 kan tijdens het conversieproces worden verwijderd
Typ Conversion in Java
Net als andere programmeertalen zijn er 2 soorten conversies in Java:
Impliciete Type Conversie
- Dit zijn over het algemeen wat we verbreding-conversie noemen, en deze kunnen automatisch worden gedaan omdat we naar een breder gegevenstype gaan. Dus als we een 32-bits geheel getal hebben en we willen naar een 64-bits geheel getal gaan, is dat breder. De waarde kan dus veilig worden verplaatst, zodat deze impliciet kunnen worden gedaan. En de compiler moet een beslissing nemen over hoe deze conversies moeten worden uitgevoerd, en de regels zijn vrij eenvoudig.
- Als we een uitdrukking hebben met meerdere (gemengde) gehele getallen erin, als we korte en een lange hebben, wat dan ook de grootste getalgrootte is waar dingen het naar zullen converteren. Dus als we een operatie uitvoeren met een korte en een lange, wordt de korte impliciet meegewogen.
- Als we een bewerking uitvoeren met gemengde drijvende-kommagroottes, dus we hebben een float en een dubbele, zullen ze altijd naar de dubbele gaan omdat dubbele de grootste drijvende-kommagrootte is.
- En als we dan een bewerking hebben die gebruikmaakt van typen met verschillende getallen en drijvende-komma-typen, zal de compiler casten naar het grootste drijvende-komma in de vergelijking. Dus als we een operatie uitvoeren met een lange en drijvende, zal de lange worden gegoten om te drijven.
- Als we een bewerking uitvoeren met een lange en een dubbele, wordt de lange naar een dubbele cast.
Expliciete type conversie
- We voeren expliciet onze code uit wanneer we deze cast-bewerking gebruiken. Als we dat doen, nemen we verantwoordelijkheid voor wat er ook gebeurt als gevolg van dat soort conversie. Daarom kunnen we zowel verbredingsconversie als smalheid uitvoeren. Dus verbreding van een 32-bit naar 64-bit zeggen, versmallen, van een 64-bit naar een 32-bit gaan. We moeten gewoon weten dat we weten wat er zou kunnen gebeuren.
- Als we een expliciete cast uitvoeren van een drijvend punt naar een geheel getal, dus drijvende punten kunnen een fractioneel gedeelte hebben, integer niet, dus elk fractioneel gedeelte wordt verwijderd wanneer we die float naar een geheel getal casten.
- U wilt voorzichtig zijn bij het uitvoeren van een vernauwingsconversie. Als we een 64-bits geheel getal hebben, kan dit waarden bevatten die te groot zijn om in een 32-bits geheel getal te passen.
- Dus als we die 64 bit naar een 32-bit casten, zal het programma het ook doen, maar als de waarde te groot is om in een 32-bit te passen, krijg je daar wat rare resultaten van. Dus je wilt er zeker van zijn dat wanneer je het cast, een vernauwende cast doet, dat je weet dat wat je doet veilig is.
- En de laatste is alleen dat je voorzichtig wilt zijn bij het converteren van een geheel getal naar een drijvend punt, want als je een geheel getal met een groot aantal significante cijfers hebt, kun je door de manier waarop het drijvende punt wordt opgeslagen, een deel van die significante cijfers.
Voorbeelden van typeconversie
Voorbeelden van typeconversie hieronder in detail genoemd:
Code:
We hebben hier een eenvoudig programma, een verklaring bovenaan, float, double, byte, short en long, en de variabelen hebben elk een naam om te helpen bepalen hoe hun typen zijn float is floatVal,
Code:
lang is longVal
Code:
En het programma drukt alleen een succesbericht af als het wordt uitgevoerd.
Laten we dus eens kijken hoe een deel van de typeconversie hier een rol speelt. Dus laten we eerst en vooral gaan en een variabele maken. We hebben kort en we zullen het gewoon het resultaat noemen.
Laten we het in feite resultaat1 noemen. En laten we gewoon een eenvoudige opdracht doen. En dus zullen we er eerst de byteVal aan toewijzen. Zoals we verwachten, als we doorgaan en dit uitvoeren, dus ren met succes.
Code:
Output:
We weten dat dit een geldige toewijzing is, omdat een byte kan worden toegewezen aan een short omdat dat een verbredende conversie is.
Als we deze byteVal echter nemen en er in plaats daarvan een longVal van maken, dus nu is het eigenlijk een lange, als we dit uitvoeren, krijgen we hier een foutmelding met een incompatibel type, mogelijk conversieverlies van lang naar kort.
Code:
Dus wat we hier kunnen doen, is dat we een expliciete cast kunnen doen. We zullen hier gewoon kort voor staan. Dus nu is het geldig zodat we het kunnen uitvoeren.
Code:
En natuurlijk werkt het. Omdat de lange niet in een korte kon ingaan omdat dat een vernauwende conversie was.
Output:
Maar door de expliciete cast ervoor te plaatsen, is het nu geldig. Als we willen, kunnen we een castnotatie zeer expliciet maken en zeggen dat je weet dat we weten dat hoewel een byteconversie legaal is, we expliciet willen laten zien dat we het casten door de korte cast erin te plaatsen, we kunnen doen dat, en dat is volkomen legaal.
Code:
Output:
Laten we nu een ander scenario bekijken. We gaan een andere variabele maken die we resultaat2 zullen noemen , en resultaat2 is ook een korte. En wat we hier willen doen, is dat we gewoon onze byteVal nemen, en we willen de longVal aftrekken. Nu weten we dat dit niet legaal is, omdat het resultaat van de uitdrukking de grootte van het grootste gehele getal erin zal zijn, namelijk de lengte.
Code:
Dus als we dit uitvoeren, krijgen we de foutmelding dat het niet geldig is om een lange naar een korte te converteren.
Maar laten we zeggen dat we door willen gaan en dat resultaat kort houden. We moeten een cast doen. Maar we willen deze keer casten is de waarde van het hele resultaat hier. Dus wat we gaan doen, zet de korte cast hier voor.
Zet hier de korte cast voor. En wikkel het hele ding tussen haakjes. En voer het uit.
Code:
Het zal met succes worden uitgevoerd.
Output:
Declareer nu een andere variabele met de naam result3, maar declareer deze als lang. Dus heb resultaat 3, en wat we hier zullen doen, is dat we ons longVal - floatVal zullen toewijzen. Dus we voeren dat, de fout raakt de conversie kwijt bij het converteren van float naar long, omdat wanneer we een geheel getal en elk type met drijvende komma hebben, het resultaat het type met drijvende komma zal zijn.
Code:
Dus laten we doorgaan en ons resultaat nu omzetten in een float. Dus door dat een dobber te maken, moeten we door kunnen gaan en het kunnen uitvoeren. En met succes uitgevoerd.
Code:
Output:
Maar als we nu het floatVal hier nemen en dit omzetten in een doubleVal en als we dit proberen uit te voeren, krijgen we de fout omdat het zegt dat het resultaat een dubbel wordt, want als je een geheel getal en een drijvend punt doet, het is de grootte van het grootste drijvende punt in de vergelijking.
Code:
Dus laten we doorgaan en dit resultaat verdubbelen zodat we het nu kunnen uitvoeren.
Code:
Output:
Conclusie
1. Variabele worden sterk getypt in Java
2. Primitieve typen
- Gehele getallen, drijvende-komma types, char type, Boolean type
3. Typ conversie
- We moeten vaak van het ene type naar het andere gaan, omdat onze programma's, naarmate ze complexer worden, waarschijnlijk meerdere gegevenstypen zullen omvatten.
- De compiler kan type conversies verwerken die verbreden, van het ene type naar het andere gaan dat grotere waarden kan bevatten,
- Maar je kunt ook casten gebruiken om expliciet dat soort conversies uit te voeren die de compiler niet automatisch kan uitvoeren.
Aanbevolen artikelen
Dit is een handleiding voor typeconversie in Java. Hier bespreken we de introductie, typ conversie in Java zoals impliciet en expliciet, samen met de voorbeelden die verschillende situaties gebruiken. U kunt ook de volgende artikelen bekijken voor meer informatie-
- Constructor in Java
- Sorteren op Java
- Constructor in Java
- JCheckBox in Java
- Gooien versus Gooien | Top 5 verschillen die u moet weten
- Hoe Checkbox in Bootstrap te implementeren
- Conversie in Java met voorbeelden