Primitieve Java-typen

Laten we vandaag snel typen in Java begrijpen. Alle typen in Java zijn verdeeld in twee groepen: primitieve en referentietypen.

Hier zullen we te maken krijgen met primitieve typen.

Misschien wel het meest primitieve type is het logische gegevenstype. Hij is dezelfde Booleaans- het eenvoudigste gegevenstype. Een variabele van dit type kan slechts twee waarden opslaan: waar of onwaar. Met variabelen van dit type kunnen de volgende bewerkingen worden uitgevoerd: “!” — ontkenning (niet), “&&” — logisch AND (en), “||” — logische OR (of), “^” — exclusieve OR (xor). Waarheidstabellen voor deze operaties zijn te vinden.

De volgende zijn integer-gegevenstypen. Deze typen in Java omvatten het volgende: byte, kort, int En lang. Elk van deze typen accepteert een ander bereik aan waarden, het enige wat ze gemeen hebben is dat alle waarden altijd gehele getallen zijn. Dus voor het bytetype is het interval van?128 tot 127, voor het korte type van?32768 tot 32767, voor het int-type van?2147483648 tot 2147483647 en voor het lange type is het interval van?9.2·10 18 tot 9.2· 10 18. Met hen kunnen we eenvoudigweg aftrekken, optellen, delen, vermenigvuldigen...

En natuurlijk zijn er drijvende-kommagegevenstypen, fractionele typen. Dit vlot en dubbel precisietype dubbele. float neemt waarden aan in het bereik van ongeveer €3,4·1038 tot 3,4·1038, en verdubbelt in het bereik van €1,8·10308 tot 1,8·10308. Bovendien zijn er speciale betekenissen voor deze typen +? — plus oneindig, -? - minus oneindig en NaN is geen getal (bijvoorbeeld bij delen door 0).

Dus als we een variabele van een bepaald type willen declareren, moeten we eerst het type en vervolgens de naam aangeven:

Int ik; zweven f;

U kunt ook meteen de beginwaarde opgeven:

Int ik = 0; vlotter f = 3,5;

Java maakt gebruik van impliciete typeconversie. Wat is het? U wilt bijvoorbeeld twee variabelen toevoegen, één van het type int en de andere van het type float. Vervolgens wordt uw variabele van het type int omgezet naar het type float en pas daarna vindt de optelling plaats. Dienovereenkomstig zal het resultaat van het float-type zijn. In dit geval wordt het kleinere type altijd omgezet naar het grotere en het gehele getal naar het fractionele type. Nou, dit zal bijvoorbeeld werken:

Int a = 3; vlotter b = 4,5, c; c = a + b;

maar dit is niet:

Int a = 3, c; vlotter b = 4,5; c = a + b;

Hier is de variabele waarin het resultaat wordt geschreven van het type int, en het resultaat zelf zal van het type float zijn. Uiteraard kunt u het ene type handmatig naar het andere converteren. Dit wordt als volgt gedaan:

Int a = 3, c; vlotter b = 4,5; c = (int)(a + b);

hier, met behulp van de notatie (int), converteren we de som van a en b naar het type int. Het is echter duidelijk dat de gehele variabele c de waarde 7,5 niet kan opslaan. Bij het casten van fractionele typen naar gehele getallen wordt het fractionele deel eenvoudig weggegooid. Dit kan enkele fouten veroorzaken, dus vergeet dit niet.

Een variabele wordt ons verstrekt door een opslagnaam, zodat ons programma kan worden gemanipuleerd. Elke variabele in Java heeft een specifiek type dat de grootte en plaatsing in het geheugen bepaalt; het bereik van waarden dat in het geheugen kan worden opgeslagen; en een reeks bewerkingen die op de variabele kunnen worden toegepast.

Alle variabelen moeten worden gedeclareerd voordat ze kunnen worden gebruikt. Hieronder ziet u het basisadvertentieformulier:

Gegevenstype variabele [=waarde], [variabele [=waarde], ...] ;

Om meer dan één variabele van een bepaald type te declareren, kunt u een door komma's gescheiden lijst gebruiken.

Hieronder staan ​​voorbeelden van variabeledeclaratie en initialisatie in Java:

Int a, b, c; // Verklaring van drie gehele getallen a, b en c. int a = 10, b = 10; // Voorbeeld van initialisatie. byte b = 22; // Initialiseer variabele b van het type byte. dubbele pi = 3,14159; // Verklaring en toewijzing van pi. teken a = "een"; // Variabele a van het type char krijgt de waarde "a".

In deze zelfstudie bekijken we de verschillende soorten variabelen die beschikbaar zijn in de Java-taal. Bestaat drie soorten variabelen:

  • lokale variabelen;
  • instantievariabelen;
  • statische variabelen of klassevariabelen.

Lokale variabelen in Java

  • Lokale variabelen worden gedeclareerd in methoden, constructors of blokken.
  • Lokale variabelen worden gemaakt wanneer een methode, constructor of blok wordt uitgevoerd en worden vernietigd nadat de methode, constructor of blok is voltooid.
  • Toegangsmodifiers kunnen niet worden gebruikt voor lokale variabelen.
  • Ze zijn alleen zichtbaar binnen de gedeclareerde methode, constructor of blok.
  • Lokale variabelen worden intern op stapelniveau geïmplementeerd.
  • Er is geen standaardwaarde voor lokale variabelen in Java, dus ze moeten worden aangegeven en er moet een initiële waarde aan worden toegewezen vóór het eerste gebruik.

Voorbeeld

“age” is een lokale variabele, gedefinieerd binnen de “pupAge()”-methode en de reikwijdte ervan wordt alleen beperkt door deze methode.

Public class Test( public void pupAge())( int age = 0; leeftijd = leeftijd + 7; System.out.println("Puppy leeftijd: " + leeftijd); ) public static void main(String args)( Test test = nieuwe Test(); test.pupAge();

Het volgende resultaat wordt verkregen:

Puppyleeftijd: 7

Voorbeeld zonder initialisatie

Een voorbeeld van het gebruik van 'leeftijd' zonder initialisatie. Het programma geeft een foutmelding tijdens het compileren.

Public class Test( public void pupAge())( int leeftijd; leeftijd = leeftijd + 7; System.out.println("Puppy leeftijd: " + leeftijd); ) public static void main(String args)( Test test = nieuwe Test (); test.pupAge();

Dit resulteert tijdens het compileren in het volgende foutbericht:

Test.java:4:variabel getal is mogelijk niet geïnitialiseerd age = leeftijd + 7;

^1 fout

  • Instantievariabelen
  • Instantievariabelen worden gedeclareerd binnen de klasse, maar buiten de methode, constructor of welk blok dan ook.
  • Wanneer er stapelruimte wordt toegewezen aan een object, wordt er een slot gemaakt voor elke instantievariabelewaarde.
  • In Java worden instantievariabelen gemaakt wanneer een object wordt gemaakt met het trefwoord "nieuw" en vernietigd wanneer het object wordt vernietigd.
  • Variabelen bevatten waarden die moeten verwijzen naar meer dan één methode, constructor of blok, of kerndelen van de status van een object die in de hele klasse aanwezig moeten zijn.
  • Instantievariabelen kunnen op klasseniveau worden gedeclareerd, voor of na gebruik.
  • Er kunnen bijvoorbeeld toegangsmodificatoren worden geleverd voor variabelen.
  • Instantievariabelen in Java zijn zichtbaar voor alle methoden, constructors en blokken in een klasse. In de regel wordt aanbevolen om ze privé te maken (toegangsniveau). U kunt ze echter zichtbaar maken voor subklassen van deze variabelen met behulp van toegangsmodifiers.
  • Instantievariabelen hebben standaardwaarden. De standaardwaarde is 0 voor getallen, false voor logische getallen en null voor objectverwijzingen. Waarden kunnen worden toegewezen bij declaratie of in de constructor. Instantievariabelen in Java zijn rechtstreeks toegankelijk door de variabelenaam binnen de klasse aan te roepen. Bij statische methoden en verschillende klassen (wanneer toegang tot instantievariabelen wordt gegeven) moeten ze echter worden aangeroepen met de volledig gekwalificeerde naam -.

Voorbeeld

java.io.* importeren; public class Employee( // De instantievariabele is openbaar voor elke onderliggende klasse. public String name; // De salarisvariabele is alleen zichtbaar in Employee. private double wage; // De variabelenaam wordt toegewezen in de constructor. public Employee (String empName)( name = empName; ) // Aan de salarisvariabele wordt een waarde toegewezen public void setSalary(double empSal)( wage = empSal; ) // Deze methode geeft de werknemersgegevens public void printEmp() ( System.out.println) weer. ("naam: " + naam) ; System.out.println("salaris:" + salaris); public static void main(String args)( Werknemer empOne = nieuwe werknemer("Oleg"); empOne.setSalary(1000); empOne.printEmp();

Het programma zal de volgende uitvoer produceren:

Naam: Oleg salaris: 1000,0

Klassevariabelen of statische variabelen in Java

  • Klassevariabelen, ook wel statische variabelen genoemd in Java, die worden gedeclareerd met een statisch trefwoord in de klasse, maar buiten de methode, constructor of blok.
  • Er zal slechts één kopie zijn van elke statische variabele in een klasse, ongeacht hoeveel objecten er van worden gemaakt.
  • Statische variabelen of klassenvariabelen worden in Java zelden gebruikt, behalve wanneer ze als constanten worden gedeclareerd. Constanten zijn variabelen die openbaar/privaat, definitief en statisch worden verklaard. Constanten veranderen nooit van hun oorspronkelijke waarde.
  • In Java worden statische variabelen aangemaakt wanneer een programma start en vernietigd wanneer het programma stopt.
  • Zichtbaarheid is als een instantievariabele. De meeste statische variabelen worden echter openbaar verklaard omdat ze toegankelijk moeten zijn voor gebruikers van de klasse.
  • De standaardwaarden zijn hetzelfde als bijvoorbeeld variabelen. Voor getallen is de standaardwaarde 0, voor gegevens van het type Boolean - false; en voor objectreferenties - null. Waarden kunnen worden toegewezen bij declaratie of in de constructor. Bovendien kunnen ze worden toegewezen in speciale statische initialisatieblokken.
  • Statische variabelen zijn toegankelijk door aan te roepen met de klassenaam Klassenaam.Variabelenaam.
  • Bij het declareren van klassevariabelen als public, static, final, worden de namen in hoofdletters weergegeven. Als statische variabelen niet statisch zijn, is de syntaxis hetzelfde als bijvoorbeeld en lokale variabelen.

Voorbeeld

java.io.* importeren; public class Employee( // salarisvariabele privé statisch privé statisch dubbel salaris; // DEPARTMENT (afdeling) is een constante openbare statische finale String DEPARTMENT = "Ontwikkeling"; public static void main(String args)( salaris = 1000; System.out .println(AFDELING+"gemiddeld salaris: "+salaris) )

Dit levert de volgende uitvoer op:

Ontwikkeling gemiddeld salaris: 1000

Opmerking: Om toegankelijk te zijn vanuit een buitenste klasse, moeten de constanten toegankelijk zijn als Employee.DEPARTMENT.

Toegangsmodificatoren zijn meer dan eens genoemd in eerdere materialen. In de volgende les zullen we ze in detail bekijken.

Een primitieve variabeledeclaratie-instructie kan worden gevolgd door een initialisatie-instructie "= die een initiële waarde aan de gemaakte variabele toekent.

1. Typen gehele variabelen

Geheel typen verschillen in de grootte van het geheugen dat eraan is toegewezen. Kenmerken van integer-typen worden gegeven in de tabel. 1.1. Tafel 1.1. Kenmerken van Java-integertypen
Zoals u in de onderstaande tabel kunt zien, worden integer-variabelen, met uitzondering van het type char , in Java beschouwd als variabelen met teken. Gehele constanten kunnen op drie manieren in een programma worden opgegeven: als decimale, hexadecimale of octale waarden. Standaard worden alle getallen geïnterpreteerd als decimale en zijn van het type int . Je kunt expliciet aangeven dat je een lang type bent door de letter "l" of de letter "L" toe te voegen aan het einde van het nummer. Hexadecimaal de waarde wordt gespecificeerd met behulp van de tekens "0x" of "0X", gevolgd door de waarde van het getal (de cijfers 0-9 en de letters A-F of a-f), bijvoorbeeld: 0x7FFF . Een getal in octale notatie moet beginnen met een nul gevolgd door een of meer octale cijfers, bijvoorbeeld 077777. Octale en hexadecimale getallen kunnen zowel positief als negatief zijn en variëren in hetzelfde bereik als getallen in decimale weergave (hexadecimale bytegetallen hebben bijvoorbeeld een maximale waarde van 0x7F en een minimumwaarde van 0x80, en octale getallen hebben 177 en -200. respectievelijk) Voorbeelden van het declareren van gehele variabelen: intx = 0; lang i, j, k; in Java worden gedefinieerd met behulp van het trefwoord char en worden geïmplementeerd met behulp van de Unicode-standaard. U kunt een symboolconstante in een programma of als gewoon symbool opgeven. De symbolische waarde moet worden omsloten door een paar enkele apostrofs, bijvoorbeeld: char symbol= "f" ; Een andere manier om tekens te schrijven is als een paar tekens "\u" gevolgd door een viercijferig hexadecimaal getal (variërend van 0000 tot FFFF) dat de Unicode-code van het teken vertegenwoordigt, bijvoorbeeld: char symbol = "\u0042" ;
Sommige tekens die niet op het toetsenbord voorkomen, kunnen worden gespecificeerd met behulp van zogenaamde escape-reeksen, die het teken "\" bevatten, gevolgd door een alfabetisch teken dat de escape-reeks identificeert, zoals weergegeven in Tabel 1. 1.2.

Tafel 1.2. Escape-reeksen die worden gebruikt in de Java-taal

Wat moet je nog meer lezen: 2. Echte soorten variabelen De Java-taal ondersteunt getallen en variabelen met drijvende punt
normale en dubbele cijfers – float- en dubbele typen. Voor getallen met drijvende komma moet u de gehele en breukdelen opgeven, gescheiden door een punt, bijvoorbeeld 4,6 of 7,0. Voor grote getallen kunt u de exponentiële notatie gebruiken (waarbij u het symbool "e" of het symbool "E" gebruikt om de mantisse van de exponent te scheiden). Het getal -3,58×107 wordt bijvoorbeeld geschreven als –3,58E7 en het getal 73.675×10-15 wordt geschreven als 73.675e-15. De kenmerken van echte Java-typen worden weergegeven in Tabel. 2.1. Tafel 2.1. Kenmerken van echte Java-typen Variabelen met drijvende komma kunnen niet alleen numerieke waarden opslaan, maar ook elk van de speciaal gedefinieerde vlaggen (toestanden): negatieve oneindigheid, negatieve nul, positieve oneindigheid, positieve nul en geen getal (NaN). Er wordt aangenomen dat alle drijvende-kommaconstanten van het type dubbel zijn. Om een ​​float-getal op te geven, moet u het teken "f" of het symbool "F" aan het einde van het getal toevoegen.

Voorbeelden van declaraties van drijvende kommavariabelen:

vlotter x1 = 3,5f, x2 = 3,7E6f, x3 = - 1,8E-7f;< 1 будет «ложь». В отличие от C, где результату «ложь» сопоставлено целое значение типа int , равное 0, а результату «истина» – ненулевое значение типа int , и, соответственно, результатам сравнения присваивается целое значение (обычно 0 или 1), в Java для булевских переменных введен свой, отдельный тип данных. Переменные dubbele z = 1,0; 3. Booleaanse variabeletype Booleaanse variabelen (logische variabelen) kunnen twee waarden aannemen: “true” of “false” en worden in programmeertalen gebruikt in relationele (vergelijkings) en logische bewerkingen. Het resultaat van de vergelijking zal dus 5 > 3 “waar” zijn, en het resultaat van de vergelijking 8 Booleaans type in Java worden gespecificeerd met behulp van het booleaanse sleutelwoord en kunnen slechts één van de twee waarden hebben: WAAR

Numerieke typen zijn typen die zijn ontworpen om getallen op te slaan. Als je wiskunde doet, heb je te maken met numerieke waarden. Er zijn twee soorten numerieke typen. Degenen die zijn ontworpen om getallen op te slaan zonder een fractioneel deel, worden gebeld geheel typen, en die waarin het fractionele deel van een getal kan worden opgeslagen - echt, of typen met drijvende punt.

Er bestaat geen concept van niet-ondertekende getallen in Java. Alle numerieke typen in deze taal zijn ondertekend. Als de waarde van een bytevariabele bijvoorbeeld 0x80 is in hexadecimaal, dan is het getal -1.

2.1.1.1. Typen gehele getallen

Het gebrek aan getallen zonder teken in Java halveert het aantal typen gehele getallen. De taal heeft 4 integer-typen, die 1, 2, 4 en 8 bytes aan geheugen in beslag nemen. Elk type - byte, short, int en long - heeft zijn eigen natuurlijke toepassingen.

Typebyte

Het bytetype is een 8-bits type met teken. Het bereik is -128 tot 127. Het is het meest geschikt voor het opslaan van een willekeurige bytestroom die is gedownload van het netwerk of uit een bestand.

byte b;
byte c = 11;

Tenzij er sprake is van bitmanipulatie, moet het bytetype in het algemeen worden vermeden. Voor normale gehele getallen die als tellers en in rekenkundige uitdrukkingen worden gebruikt, is het int-type veel beter geschikt.

Typekort

Short is een 16-bits type met handtekening. Het bereik loopt van -32768 tot 32767. Het is waarschijnlijk het meest zelden gebruikte type in Java, omdat het wordt gedefinieerd als een type waarin de meest significante byte op de eerste plaats komt.

korte s;
korte t= 129;
Typeint

Het int-type vertegenwoordigt gehele getallen met 32 ​​bits teken. Het bereik van geldige waarden voor dit type is -2147483648 tot 2147483647. Het meest voorkomende gebruik van dit gegevenstype is het opslaan van gewone gehele getallen met waarden tot twee miljard. Dit type is ideaal voor gebruik met arrays en tellers. In de komende jaren zal dit type perfect aansluiten bij de machinewoorden van niet alleen 32-bits processors, maar ook 64-bits processors met ondersteuning voor snelle pipelining om 32-bits code uit te voeren in de compatibiliteitsmodus. Telkens wanneer variabelen van het type byte, short, int en gehele getallen in dezelfde expressie voorkomen, wordt het type van de gehele expressie omgezet naar int voordat de evaluatie is voltooid.

intj = 1000;
Typelang

Het lange type is ontworpen om 64-bits getallen met teken weer te geven. Het bereik van acceptabele waarden is groot genoeg, zelfs voor taken zoals het tellen van het aantal atomen in het universum,

langM;
langn = 123;

Het is niet nodig om zich te identificeren beetje diepte integer-type met de hoeveelheid geheugen die het in beslag neemt. De actieve Java-code kan elke hoeveelheid geheugen gebruiken die hij geschikt acht voor uw variabelen, zolang hun gedrag overeenkomt met het gedrag van de typen die u definieert.

Tabel 2.1. Tabel met bitdieptes en acceptabele bereiken voor verschillende soorten gehele getallen

Beetje diepte

Bereik

-9, 223, 372,036, 854, 775, 808 ... 9, 223, 372, 036, 854, 775, 807

-2, 147, 483, 648 .... 2, 147, 483, 647

-32,768 .... 32, 767

-128 ... 127

2.1.1.2. Drijvende-kommagetallen

Getallen met drijvende komma, in andere talen vaak reële getallen genoemd, worden gebruikt bij berekeningen waarbij het gebruik van een breuk vereist is. Java implementeert een standaardset (IEEE-754) met typen voor getallen met drijvende komma - float en double - en operators om ermee te werken.

Tabel 2.2. Kenmerken van drijvende-kommagetaltypen

Beetje diepte

Bereik

1.7e-308....1.7e+ 308

3.4e-038....3.4e+038

Typevlot

In variabelen met de gebruikelijke, of enkele precisie, gedeclareerd met het float-trefwoord, worden 32 bits gebruikt om de echte waarde op te slaan,

zweven f;
vlotter f2 = 3,14;
Typedubbele

In het geval dat dubbele precisie, gespecificeerd met het dubbele sleutelwoord, worden 64 bits gebruikt om waarden op te slaan. Alle transcendentaal wiskundige functies zoals sin, cos, sqrt retourneren een dubbel resultaat,

dubbeleD;
dubbele pi = 3,14159265358979323846;

Wat is een variabele?

Een variabele kan worden gezien als een container die waarde voor u heeft tijdens de levensduur van een Java-programma. Aan elke variabele wordt een toegewezen gegevenstype die het type en de hoeveelheid waarde ontwerpt die het kan bevatten.

Om een ​​variabele in een programma te gebruiken, moet je 2 stappen uitvoeren

  1. Variabele declaratie
  2. Variabele initialisatie

In deze tutorial leer je-

Variabele declaratie:

Om een ​​variabele te declareren, moet u het gegevenstype opgeven en de variabele een unieke naam geven.

Voorbeelden van andere geldige verklaringen zijn

Int a,b,c; zwevende pi; dubbele d; teken een;

Variabele initialisatie:

Om een ​​variabele te initialiseren, moet u er een geldige waarde aan toekennen.

Voorbeeld van andere geldige initialisaties zijn

Pi =3,14f; doen = 20,22d; a=’v’;

U kunt variabeledeclaratie en initialisatie combineren.

Int a=2,b=4,c=6; vlotter pi=3,14f; dubbele do=20,22d; char a=’v’;

Soorten variabelen

In Java zijn er drie soorten variabelen:

  1. Lokale variabelen
  2. Instantievariabelen
  3. Statische variabelen

1) Lokale variabelen

Lokale variabelen zijn variabelen die in de hoofdtekst van een methode worden gedeclareerd.

2) Instantievariabelen

Instantievariabelen worden gedefinieerd zonder het STATIC-sleutelwoord. Ze worden buiten een methodedeclaratie gedefinieerd. Ze zijn objectspecifiek en staan ​​bekend als instantievariabelen.

3) Statische variabelen

Statische variabelen worden slechts één keer geïnitialiseerd, aan het begin van de programma-uitvoering. Deze variabelen moeten eerst worden geïnitialiseerd, vóór de initialisatie van eventuele instantievariabelen.

Voorbeeld: soorten variabelen in Java

class Guru99 ( int data = 99; //instance variabele statisch int a = 1; // statische variabele void method() ( int b = 90; // lokale variabele ) )

Gegevenstypen in Java

Gegevenstypen classificeren de verschillende waarden die in de variabele moeten worden opgeslagen. In Java zijn er twee soorten gegevenstypen:

  1. Primitieve gegevenstypen
  2. Niet-primitieve gegevenstypen

Primitieve gegevenstypen

Primitieve gegevenstypen zijn vooraf gedefinieerd en beschikbaar binnen de Java-taal. Primitieve waarden delen de staat niet met andere primitieve waarden.

Er zijn 8 primitieve typen: byte, short, int, long, char, float, double en boolean Gehele gegevenstypen

Byte (1 byte) kort (2 bytes) int (4 bytes) lang (8 bytes)

Zwevend gegevenstype

Zweven (4 bytes) dubbel (8 bytes)

Tekstueel gegevenstype

Char (2 bytes)

Booleaans (1 byte) (waar/onwaar)

Gegevenstype Standaardwaarde Standaardgrootte
byte 0 1 byte
kort 0 2 bytes
int 0 4 bytes
lang 0L 8 bytes
vlot 0,0f 4 bytes
dubbele 0,0 d 8 bytes
Booleaans vals 1 beetje
verkoold "\u0000" 2 bytes

Punten om te onthouden:

  • Alle numerieke gegevenstypen zijn ondertekend (+/-).
  • De grootte van datatypen blijft op alle platforms hetzelfde (gestandaardiseerd)
  • char-gegevenstype in Java is 2 bytes omdat het gebruikt UNICODE tekenset. Op grond daarvan ondersteunt Java de internationalisering. UNICODE is een tekenset die alle bekende scripts en talen ter wereld omvat

Java-variabele typeconversie en typecasting

Een variabele van het ene type kan de waarde van een ander type ontvangen. Hier zijn er 2 gevallen -

Geval 1) Variabele met kleinere capaciteit wordt toegewezen aan een andere variabele met grotere capaciteit.

Dit proces is automatisch en niet-expliciet staat bekend als Conversie

Geval 2) Variabele met grotere capaciteit wordt toegewezen aan een andere variabele met kleinere capaciteit

In dergelijke gevallen moet u de type cast-operator. Dit proces staat bekend als Type Casting.

Als u geen type cast-operator opgeeft; de compiler geeft een foutmelding. Omdat deze regel wordt afgedwongen door de compiler, wordt de programmeur ervan bewust gemaakt dat de conversie die hij gaat uitvoeren enig gegevensverlies kan veroorzaken en voorkomt accidentele verliezen.

Voorbeeld: om typecasting te begrijpen

Stap 1) Kopieer de volgende code naar een editor.

Klassedemo ( public static void main(String args) ( byte x; int a = 270; double b = 128.128; System.out.println("int geconverteerd naar byte"); x = (byte) a; System.out. println("a en x " + a + " " + x); System.out.println("dubbel geconverteerd naar int"); System.out.println("b en a " + b + " " + a); System.out.println("\ndubbel geconverteerd naar byte"); x = (byte)b; System.out.println("b en x " + b + " + x);

Stap 2) Bewaar, compileer en voer de code uit.

Int geconverteerd naar byte a en x 270 14 dubbel geconverteerd naar int b en a 128.128 128 dubbel geconverteerd naar byte b en x 128.128 -128



GERELATEERDE ARTIKELEN