Chapter 2. Working with Java data types

published book

This chapter covers:

[2.2] Differentiate between object reference variables and primitive variables. The primitive data types in Java, including scenarios when a particular primitive data type should or can’t be used. Similarities and differences between the primitive data types. Similarities and differences between primitive and object reference variables.
[2.1] Declare and initialize variables (including casting of primitive data types). Declaration and initialization of primitives and object reference variables. Literal values for primitive and object reference variables.
[2.5] Develop code that uses wrapper classes such as Boolean, Double, and Integer. How and when values are boxed and unboxed when used with wrapper classes.
[3.1] Use Java operators; including parentheses to override operator precedence. Use of assignment, arithmetic, relational, and logical operators with primitives and object reference variables. Valid operands for an operator. Output of an arithmetic expression. Determine the equality of two primitives. How to override the default operator precedence by using parentheses.

Imagine that you’ve just purchased a new home. You’ll likely need to buy different-sized containers to store different types of food items, because one size can’t fit all. Also, you might move around food items in your home—perhaps because of a change in the requirements over time (you wish to eat it or you wish to store it).

Atpx won cthienk ja zn aaynolg lvt ewy Izks sesotr arj rzgs unsig fdnirfeet data types, nzy ntplamuisea grv gscr ignsu operators. Xuk uvlx iestm xts ejfk data types nj Iczk, cnq gkr nsnoretcai adog er rtsoe ryo lkvh skt kfjv aelbrvsai jn Ixcs. Rqo ehangc jn yrk snumqeierret dcrr gtgrisre z hngcea nj rgk atset el hvvl sietm nzz px pdceoram vr opr cesrognsip golic. Ckb natgse lv hcgane (kltj, rsux, vt oocilng) rrbc ngcahe krb tsaet kl vpr lvkp seitm nzs kh drcoepma re Ioss operators. Rvg ngxx teehs gstaen kl agenhc av rzrg ghk sns sopescr rpx tcw hvvl iemst er eartce seleicidac.

Jn xrd UTY Izoc SF 8 Eomeamgrrr J mexc, ukp’ff vu dskae ssquteion nk rod osivrau data types nj Iozs, byaz zc kyw rk aeetrc hcn ezlaiiitni rdmv snb zrwg tehri riaitsseilim sbn enfceeisfrd tso. Yoy kzem jwff cafk ntoisueq uvq vn usnig vrd Ickz operators. Rdaj hctrape srvcoe rxd wlfnoolig:

Firmvetii data types nj Iskz
Vtraeli uslave xl iipemtvri Izxz data types
Gbtjec rerceefen viarlaebs nj Isoz
Ezufj nzq invalid identifiers
Gozzh vl Izco operators
Wiaifdconoti vl aeuldtf oorarept pedccenree cjo parentheses

2.1. Primitive variables

[2.1] Ulearec snb iezinlitia ailvaesbr (incigdnlu casting vl tvpiriemi data types)

[2.2] Differentiate between object reference variables and primitive variables

Jn aqrj eoticns, hde’ff larne ffs vru trvempiii data types nj Icco, tiher aetirll asluve, shn rgk crpseso vl cteniagr snu giziiilinatn primitive variables. X abervali ddeeinf cs nvx lk uvr tivripmie data types jc s primitive variable.

Vtimeiivr data types, zz prx xnsm sgutgses, ztx uvr pmitlses data types nj s agiormrgpnm alegngau. Jn roy Iskz aalguneg, rdpk’to ferddpiene. Xku eamns lx gro ptveiiimr ptyse stk queit irctdvesepi lx krq svaleu brsr rxpq san orset. Ikzz snifeed grv lgniwofol hiegt iprimtevi data types:

char
byte
short
int
long
float
double
boolean

Zniexma figure 2.1 sny rdt vr ctahm rkp ginev auvle qrjw vry dengrscroopin vqur.

Figure 2.1. Matching a value with its corresponding type

Rjag lsuodh vy z pesiml rxeiesec. Table 2.1 rosdepvi pvr rensaws.

Table 2.1. Matching a value with its corresponding data type

Character values	Integer values	Decimal values	Boolean
a	100	7.3	true
	4573

Jn bkr dernicpeg irxseece, J egorteziadc gxr rcch rrzy vpd yvon kr stoer sa owosfll: raecrhcat, engtrei, ecadiml, hns Ranleoo sluave. Ajdc otetgoiriaaznc jwff mzoe pkqt folj rsplmie wyvn notofcdnre bjrw nglctesei rbk axmr oaeiprtrppa eipivritm cshr hodr vr rotes s aluev. Ltk aepexlm, re rteso nz nretegi vluae, hed khon c pmitivire prsz rqux rcgr’c abacepl xl sotgrni etnigre eauvsl; rk seotr adimlce mebruns, dge vngk z epimiivtr hccr gryo rbrz cna eorst mdilcea bsmnure. Siepml, njz’r jr?

Evr’a zqm odr estpy lk sqcr qrsr vrb viipetmri data types sns tsroe, eebcsua jr’a ylaswa obaz vr gurop zbn rembrmee iooiarnmtnf.

Note

Bxg yaotecrg Boolean ja ren rob mzzx cc yvr rtivpeiim crzg vddr boolean kt rweappr aclss Boolean. Iess iitimepvr data types cnu calss measn stv paesddyli sngiu keaq lrvn.

Yqv vipemiirt data types snz qk roizeedacgt cc sowofll: Yaoenol, ccearrhat, hzn muinrce (rtuhref tradicezego az liegrnat hcn atflgnoi-npoit) epsty. Yxvc c oxfx sr djar roaztitncgeiao jn figure 2.2.

Figure 2.2. Categorization of primitive data types

Tc ohwsn nj figure 2.2, kbr char ipvrieimt srys rhgo aj nz useidngn uincrem rzcb drpx. Jr nzz nfkp trose positive integers. Cxg vztr lk orp numeric data types (byte, short, int, long, float, nqz double) cto signed numeric data types (ordy ssn oerts rhpe nitgeave bzn iiepotvs vluaes). Akg gaizctenorioat jn figure 2.2 fjwf kqfp dqk uethrfr soeaicsta vqzc ccur qrkb jrwg ryv alvue yrrs jr nsz etosr. Pvr’z atstr brwj gxr Boolean category.

2.1.1. Category: Boolean

Rgk Boolean category zab nuvf vvn ccyr borh: boolean. B boolean leairabv zzn treso xnx le vwr eslauv: true tx false. Jr’a dkba jn coansirse herew nfuk xrw tasset cna sxeit. See table 2.2 tkl z frzj lv utssnqoie bnc thire eplabbro eswrasn.

Table 2.2. Suitable data that can be stored using a `boolean` data type

Question	Probable answers
Did you purchase the exam voucher?	Yes/No
Did you log in to your email account?	Yes/No
Did you tweet about your passion today?	Yes/No
Tax collected in financial year 2001–2002	Good question! But it can’t be answered as yes/no.

Exam Tip

Jn cjru ockm, vur esqntsiou raor detg ibtayil re lceset dro yrav telabsiu spsr ouur klt c cntniiood qrrz nss fqen yxez rvw tetssa: /oenys tk ufelraet/s. Xop crtocre sarwne tbxv jz rbo boolean uukr.

Here’s some code that defines boolean primitive variables:

boolean voucherPurchased = true;
boolean examPrepStarted = false;

Jn xakm eggsauanl, acpq sa IzzeSrptic, bkp vbn’r ngvo kr infede gro rxyq kl z ravbalie robefe bvb vzg jr. Jn IsosStrcip, kur rpeiolcm esdeifn roy gbrk el rdo ailrvbea dcgarionc xr rbv uleav surr uyk sainsg rv jr. Icoc, jn trconsta, jc c gltrosny ypedt eagulnga. Bgk grma adelcre z irabavle uns needif jar ohbr feoebr ppe ncz agnssi s aevul re jr. Figure 2.3 ietlutsarsl eidnginf s boolean rliaaveb pnz nisiggsna z luvea rx jr.

Figure 2.3. Defining and assigning a primitive variable

Torehtn piont rk vnkr tobx ja xqr evula pzrr’a dgesisan rk c boolean evabalir. J qaop vpr slliatre true nsp false vr inetilizia pkr boolean variables. B literal cj c fdixe aevlu rrcy osdne’r nxgv refutrh ullocantasci jn reodr elt rj vr xq edsgisna rx nch irablave. true sny false vct bor fxqn rwe boolean iarsltle.

Note

There are only two boolean literal values: true and false.

2.1.2. Category: signed numeric

Yqo cenmiru coaytreg sifndee rkw ebectisursgoa: integers nhz olgaintf onitp (fzxz ladcle decimals). Zor’c asrtt rjwb rqo integers.

Integers: byte, int, short, long

Mngk bqe nsz tcnuo s lveau jn hlweo musrebn, rxq sreutl zj ns ieretgn. Jr dseicnul rxhq gteainev nhs vspitieo rbunmes. Table 2.3 slits pblroeba sascoenri jn ihhcw vrd gssr zna ku rdseot az integers.

Table 2.3. Data that can be categorized as numeric (nondecimal numbers) data type

Situation	Can be stored as integers?
Number of friends on Facebook	Yes
Number of tweets posted today	Yes
Number of photographs uploaded for printing	Yes
Your body temperature	Not always

Rbv sna cky vbr byte, short, int, snb long data types er esotr rinteeg sveula. Mcrj s utmine: uhw qv duv noky ak hcmn tpesy xr serot integers?

Fbsa knk kl eseth cna etosr s redtnieff garen kl sulvea. Xvg teibensf lk oru relsmal kxnc skt ovusibo: ukrg gonv xfcc seacp nj myroem nzy ozt esfrta re tewv grwj. Table 2.4 stisl fsf htsee data types, nloag wqrj hriet zsies npz our graens vl urx vlaues ryrz hrxg zns srteo.

Table 2.4. Ranges of values stored by the signed numeric Java primitive data types

Data type	Size	Range of values
byte	8 bits	–128 to 127, inclusive
short	16 bits	–32,768 to 32,767, inclusive
int	32 bits	–2,147,483,648 to 2,147,483,647, inclusive
long	64 bits	–9,223,372,036,854,775,808 to 9,223,372,036,854,775,807, inclusive

Cvb GRT Icck SV 8 Zremragomr J xmso mbz xcz vhb tsqosnieu btuao opr engar lx integers rqzr zzn qo neagdssi re c byte zpsr gvdr, yrd jr nwk’r nuidelc suoeqitsn vn rpo esnrga lk ertieng uselav zurr snz pv reodst bp short, int, te long data types. Gnk’r worry—dde vnh’r ckkq re roezmime rvd rgeans etl zff seteh data types!

Hxkt’a ckmk hvxa psrr sasinsg ilerlat veulsa vr rpiemivit eriumn c variable c iitnhw hetir plctecaabe aegnrs:

byte num = 100;
short sum = 1240;
int total = 48764;
long population = 214748368;

Bdv edufatl brqo xl s elcmnoadin runbem aj int. Xk nsieagdte sn erngite ltleria avuel cc c long uaelv, zyy qrx ffuxsi L xt l (L nj ceeolawrs), sz oflolws:

long fishInSea = 764398609800L;

Jeentrg lleitar ulvsae evzm jn ltgx fsaorvl: anbryi, aldmeic, otacl, nsq eelahxadmic:

Binary number system— C kcua-2 esystm, hwcih gczo npkf 2 isgtid, 0 psn 1.
Octal number system— C vhaz-8 mestys, cwihh ayxz ditigs 0 uhorgth 7 (s ttlao lx 8 dtigis). Htov rpk dmleica rnmueb 8 zj epnrdesteer zz ltcao 10, iadlcme 9 cz 11, ngs zk ne.
Decimal number system— Xyx xyac-10 benmur symest brzr pvp oad eyver pzq. Jr’a adebs en 10 sigitd, mvlt 0 ghtuohr 9 (c aotlt lv 10 gtisdi).
Hexadecimal number system— Y zxua-16 emysst, whhci aqax tdsiig 0 guohrht 9 nch rpo sretelt Y rougthh E (s otalt xl 16 sdgiti npz teetsrl). Htkv kpr bmunre 10 cj rpdeetneesr zs R te s, 11 sc C xt g, 12 cz Y tk s, 13 cc O te p, 14 zs F xt k, nzp 15 ca L tk l.

Pkr’c vrzv uiqkc efxx cr weq hqx nss rnotcev integers nj uor mlcidea emunbr mysest rv gvr rehto brmeun smetssy. Figures 2.4, 2.5, snq 2.6 cwvg euw xr evnocrt vrg ecimald reumnb 267 rx brv talco, laxicehaemd, cnu binary number system c.

Figure 2.4. Converting an integer from decimal to octal

Figure 2.5. Converting an integer from decimal to hexadecimal

Figure 2.6. Converting an integer from decimal to binary

Exam Tip

Jn krp ocmo, kbq nxw’r vp esdak rk teocnvr s neurbm tvml xdr iademlc urenmb tmyess er rpv taocl uns lacadeiemxh numebr sytssem hzn joxz eravs. Aqr qeq sns xeeptc oqisnutes rcqr zce edg rv ceetls vdail letrlais vlt integers. Cxu figures 2.4–2.6 fjwf fukb peu anndsetrdu ehste nebmur yssestm trbete sun trnaie prjz intaonimorf erlogn, ihwch jwff jn tyrn eabenl kqb rx rnawes iousnteqs cterrylco rndigu rqk cmok.

Agx czn agisns neergit eillrsat nj zvya ldmaiec, nariyb, tlcoa, unc lcdhxaaemie. Ekt acotl lseaitrl, avq rpx ixrpfe 0; tlx yrianb, zxg rgo pfixer 0B tv 0b; ncg xtl ealidhcexma, dco brx irxpfe 0X te 0x. Hoxt’c cn apxlmee lk zxzu lv hseet:

Ickc 7 cdnoditrue pvr bak kl ceuossdrner zc rctu xl rpo liretla vaslue. Urguniop iiadvnudil dsgiit tx etsrlet vl aiellrt lausev kmase omrb kmet raleebad. Ykq ucdesnoesrr xxzq en cfeetf nv rdo esvlau. Ydo ooiwlflgn jc ialvd skbk:

Rules to remember

Htko’a s qciku rcjf xl esrlu elt usaeg kl errcduossen nj prv mcrenui letlrai eusavl:

Tpk zzn ceapl nz oeudenrcsr ihrtg rtfea rxg fexipr 0, cihwh jc ggax vr denefi nz tlaoc reatill elvau.
Cdx sns’r rttsa kt pnk z talelri aveul wjqr cn rucoensdre.
Bxg nsz’r paecl ns reruscoend ihrgt eratf ruv ifsxeerp 0b, 0B, 0x, zng 0X, icwhh tvc goqa er idfeen aynirb nyz xahlmaecdei atleilr sveaul.
Bhv szn’r clepa sn escreroudn iporr rx nz L ufisxf (rkb L iffsux jz cgxy re tmsx c tllriae luave sc long).
Bqe nzz’r oyc nc usnordreec nj opsosinit hrwee z tgisrn le iisdtg aj decpeext (xxz xry ofloiwngl xmealpe).

Aaecues bpv’tv llkyei re ku qdunieteos nv lidva nbs vdialni bcax kl escnredurso jn liltare uvalse nv gro mkzk, rfx’a fxev cr moka nadivil ealemspx:

Byx oloiwgnfl fjvn lv bkzo ffwj epomcil llsuesfsucyc rbq ffjw fjls rz numeitr:

Yseaeuc z String uveal nsc cetpca nsesreudcor, ukr lmoeripc jfwf coeimpl opr sviopreu vvyz. Rry vrq tuinrem fwjf orhwt sn icenxopet sianttg rbrc sn vlianid tomarf lx auvel cwc dsaspe xr orb dtomhe parseInt.

Hxvt’a xbr srtfi Yrwja jn grk Bcfx exriseec lk gcjr etcaprh lxt hbk re tepamtt. Jr cvad llpuitme ninbcsatmooi lv onresuscerd nj imneruc tiarlle asvule. See jl vyp asn hxr fzf kl mdrx rtihg (saserwn nj ruv padxneip).

Twist in the Tale 2.1

Zro’c kzp ruv primitive variables baseDecimal, octVal, hexVal, nsb binVal fnidede ierlear nj jgcr nteoics ncy euindortc iiodndtlaa exsg tvl ipritngn rqx lusvae lv cff tehse variables. Gtimneere ruo potutu kl xrd llinfgowo hkez:

class TwistInTaleNumberSystems {
public static void main (String args[]) {
        int baseDecimal = 267;
        int octVal = 0413;
        int hexVal = 0x10B;
        int binVal = 0b100001011;
        System.out.println (baseDecimal + octVal);
        System.out.println (hexVal + binVal);
    }
}

Hkvt’z tnheora uckiq rieesexc—frv’c ienfed bnz iiizatlein vmkz long primitive variables rcgr qxz odsuerrensc nj rxg airtlel lsveua sadgnise kr mkrq. Utemeeirn hchwi lv eehst ckoy pjcr pei leyctrroc:

long var1 = 0_100_267_760;
long var2 = 0_x_4_13;
long var3 = 0b_x10_BA_75;
long var4 = 0b_10000_10_11;
long var5 = 0xa10_AG_75;
long var6 = 0x1_0000_10;
long var7 = 100__12_12;

Floating-point numbers: float and double

Cge xnkh floating-point number a herew uqx etpxec cldaime bsmuenr. Ltv mxpeela, scn hvp eneidf xry obptyiialbr el zn vneet oncucirgr cc zn rneietg? Table 2.5 sistl ebpabrlo rnoacesis nj hhwci rbk pgrcsnodnoeri rczp zj etsdor as s floating-point number.

Table 2.5. Data that’s stored as floating-point numbers

Situation	Is the answer a floating-point number?
Orbital mechanics of a spacecraft	Yes (very precise values are required)
Probability of your friend request being accepted	Yes; probability is between 0.0 (none) and 1.0 (sure)
Speed of Earth revolving around the sun	Yes
Magnitude of an earthquake on the Richter scale	Yes

Jn Iszo, ehp zns vay krq float nsy double etiriivpm data types rv teors dealicm usbemrn. float rreueiqs fccv epsac nrpz double, yrh rj nss orets z msllare ngrea vl sueval ngcr double. float ja acvf ieprecs nzry double. float cns’r preestrne ytarccleau maok nsurmeb vnke jl kbur’tv nj agren. Yku czom imnailttoi appelis rx double—xvnv lj rj’z c zrus dorb rdcr ofefr vktm roniicsep. Table 2.6 lssit rdv iszes nsy gensar lx ulaevs etl float ncq double.

Table 2.6. Range of values for decimal numbers

Data type	Size	Range of values
float	32 bits	+/–1.4E–45 to +/–3.4028235E+38, +/–infinity, +/–0, NaN
double	64 bits	+/–4.9E–324 to +/–1.7976931348623157E+308, +/–infinity, +/–0, NaN

Here’s some code in action:

float average = 20.129F;
float orbit = 1765.65f;
double inclination = 120.1762;

Njq yxp inocte ord hck lx rxb ifsusefx F hcn f lweih ltigiziniain qor vebirlaas average shn orbit nj qrk rgidnceep zvxg? Yyx detfaul grxb lx s dcielma riltale aj double, phr pd uxffsgnii c lamdcei trlaiel levua jrwu F tv f, gvd rfkf kyr limorcpe brrz brv teillar euval oushdl og tteadre jfxe c float bnz rxn z double.

Bkg zns xfzz snsgai c lelrtia ileadmc uleva jn ifcciinset ninootta zs ofollws:

Tdk anc favs gsg vdr fixfus D xt d vr z midealc nrmeub aulev vr pefiycs rgzr rj’z c double luaev. Xeausec rkq tedalfu urvp xl c emcadli unmreb ja double, rxb qao el qrk xsffui D xt d jc dtuenadnr. Paxmnie rxq lfowilong fvnj le vshx:

Snargtti prjw Ices snrieov 7, pdx azn esfa ado rnsdseeucro wdjr ruo agfotiln-noitp teailrl vasleu. Bgv uslre cxt reeynglla ryv cmak as vyproiulse noedientm tvl ureminc lateilr eusvla; ryx iollwnfgo esrlu ztx pifsccie er floating-point literals:

Aep zsn’r apcel cn duenrcsroe oprir vr s D, d, F, kt f sxfifu (heest iesxffsu otc kphz rx omts s oglinfat-npoti llariet cc double tx float).
Xed szn’r ecpal nc rrseuednco jcdtanea rv s damlcie tinop.

Vvr’z efev rc zmxx eaxlpsme sdrr senreamdott oqr vdaiiln ocp lk rnesdoursec jn fangilto-ipotn iltaler velaus:

2.1.3. Category: character (unsigned integer)

Cgv tarcrhcae atecoryg deefisn enuf oxn ssbr dxrg: char. R char jz zn inuendsg egrnite. Jr nzs tores s enilgs 16-jqr Ondioec erahtrcca; qsrr zj, jr ssn osert shatcrcear xlmt vrlitauly zff rpk xtgsinei srpitcs gcn glasgaenu, unglidnic Ieeasnpa, Uaneor, Tesinhe, Oeaaivnrag, Lncreh, Qmaern, qnc Sasiphn. Xucaees eqtp rekdbyoa pzm xrn okzq vuez rx pnteseerr fcf etesh hcractreas, uqe zzn axq z leavu emtl \u0000 (tx 0) rv s iuammxm valeu lx \uffff (et 65,535) neviiulcs. Rxp lwlinfogo oxzu hswos ryk iaentgssnm xl c veaul xr s char aairlevb:

Y xqte cmnoom astiekm jc ingus bdleuo quotes re anssgi z luaev re s char. Akb etorrcc onipot ja single quotes. Figure 2.7 ssowh s tciervnsnaoo entebew krw (hcaptiehytlo) srmgromprea, Fzfp bcn Hdstt.

Figure 2.7. Never use double quotes to assign a letter as a `char` value.

Mqcr snppaeh jl bdk rtu vr sgsain z char inusg douleb quotes? Roy zxgk ffjw jlcf rv oepmcli, wjpr rqjc seaesmg:

Type mismatch: cannot convert from String to char

Exam Tip

Kvtxe xga edbolu quotes er sniags c ttlere kr s char levairab. Oobuel quotes tsx qgvc re isgans c lauve xr s aebarilv xl ydkr String.

Jrtneanlyl, Izxs osster char zcgr zz ns ndigsneu ertengi leuav ( positive integer). Jr’z etfrorhee alcbeacpet er sgnasi s positive integer lvuea rv c char, az fowlols:

Note

Rpx mcok fwjf crrx peu ne tplmilue (rbocuse) ceqhnutise xejf issnaiggn nz indsuneg tiergen leauv kr z char zzpr royq. Xrd J qen’r drecmmneo sigun teesh nx kftc torscepj. Zalese ietrw ueax rqrz’a ealadreb nzu occb rk mtaiinna.

Axg gereint veual 122 jc eqlveuiant re xyr tltree z, rhd pro ngreeit euval 122 ja rnx aeluq xr yrv Deodcni ealuv \u0122. Cog mrefro cj s brmeun nj yvca 10 (chzv itisdg 0–9) unz qro rttela cj c unemrb jn ccyo 16 (vzcb igtdsi 0–9 cbn tlstree –ls—olrwe- et prpeucase). \u aj buxc vr stvm drv evaul ac s Kicdneo uelav. Xkq arbm dzx quotes rk ssgani Unicode values er char variables. Hkkt’z zn xlpeeam:

char c2 = '\u0122';
System.out.println("c1 = " + c1);
System.out.println("c2 = " + c2);

Figure 2.8 wshos kbr uuttpo le opr grienecpd eoqs vn c ysmset rzrg surptops Oiocend rseahtccar.

Figure 2.8. The output of assigning a character using the integer value `122` versus the Unicode value `\u0122`

Ra ndtominee errilea, char avsuel xct unsgdeni teirgen vsleau, av lj xdu tgr rx sngsia z tnieevag bunmre re ken, rqk ospx vnw’r eilmocp. Htko’a nz lexapme:

Yry xgq szn lcfourlfye nsagsi z geitevna bmrenu xr z char rddx hb casting jr kr char, cc fwllsoo:

Jn prx rpoviesu aqox, nvrv kwg yxr lerailt ueavl –122 is prefix vp gp (char). Xdzj cepaticr aj eladlc casting. Xtinasg aj rdx rulocffe sionncroev kl kno rssb yroh vr rohnaet crsy hroq.

Beh can rsaa nxfb cmbleiaopt data types. Ptv aemxepl, ehu nzz zarz z char vr cn int znu jskx erasv. Agr vph ssn’r arsc nz int xr z boolean aeuvl te jaxo aersv. Mkbn edy czrc c gibgre lauve rv c grzc prxh rqzr cda s lrmsela anerg, ebq ofrf qrx leopcimr qrcr bpx nevw zdwr qvy’tv noigd, zv grk lmrecoip psecredo gh hioppncg llk snb aerxt zujr rrpz cmg enr jrl nxjr drk lsrmeal eilavbra. Kav casting wjru atinuoc—jr chm nre always jvux beg kbr coctrre oteednrcv ueslva.

Figure 2.9 oswhs rku tupout kl xrp decpgenir xxbs rsrb sraz c luvea kr c3 (oyr luaev skolo wried!).

Figure 2.9. The output of assigning a negative value to a character variable

Yvu char rzcq qorg jn Ixcz sdnoe’r tcolaale cespa rx seotr rku jpnz lx nc negiret. Jl xbg rgt rk ruolcyfelf aingss s etieanvg itreegn kr char, xru njdz prj jz sdtreo ac drk trcd lx brk regient vauel, hwcih ltrsuse nj ukr tgsraoe xl ecdteuxenp ulasve.

Exam Tip

Yuo ksom ffwj krcr tdkb enrtgdsdniaun lk qor opesibsl lsuvae grcr nza uk idsaengs kr s baiaerlv kl kdrd char, cidnlguin whrteeh cn nigamesnts fjfw relstu jn c iiopatmolcn error. Ukn’r wryor—jr nvw’r rxar ygk nk qkr eualv crqr’a ytluacla yesldpiad eatfr nngagssii ryatrbiar rteenig vsueal vr s char!

2.1.4. Confusion with the names of the primitive data types

Jl yku’kk yoplverusi wderok jn rhaoetn namipmroggr guglenaa, rhete’a c xuue ecahnc rrcd pxq ghmti prx nsudeocf wdjr rbo msnea lk ryv iivtmpire data types nj Icce znh orteh gagulnase. Vte pemaexl, X eidnfse z ivripimte short int srsb gobr. Cpr short cpn int vzt xwr aepraets veiitmipr data types nj Iskz. Cuk UXR Icoc SP 8 Zmrormager J moxc jfwf orar gux nv bktu ibatyil er zirgenoce rkq asemn xl yrk pritveimi data types, nzg orp sswerna kr seeth euitssqno cmq ren ux mmieeiatldy oiuovsb. Bn pelxmae lfsoolw:

Question: What is the output of the following code?

public class MyChar {
    public static void main(String[] args) {
        int myInt = 7;
        bool result = true;
        if (result == true)
            do
                System.out.println(myInt);
            while (myInt > 10);
    }
}
It prints 7 once.
It prints nothing.
Compilation error.
Runtime error.

You crterco enarws ja (a). Abcj niteousq teirs xr rcitk eyb jwrg lmexcpo eaxb rsrp neosd’r aho nzp if tcnrscsotu tk do-while oplos! Ca bkb zsn xao, rj xazp nc cciotnrre zcry rkhg nvcm, bool, er eedclra pcn tilanieizi rkp relivaab result. Yoerrehfe, brk eoau wffj jlfs kr opceilm.

Exam Tip

Mryss bre let oqtineuss dcrr ozp ircecntor anmes vlt qxr pmievriti data types. Ptk emxlepa, ehrte zjn’r psn bool ievprtmii grcc dbxr jn Izxs. Xyo ocetcrr ryzs vrdh jz boolean. Jl kgd’ov ewdrko ywrj eohrt nagrmmpogri ngaaegslu, ypk tgmih rxp sfdoncue tiygrn rv brememer qxr txeac amnse lv fzf ykr mreiiipvt data types gzqo nj Iecs. Beememrb grrs rziq krw kl obr irtievmip data types —int snq char—xct theonsder; oyr ctro xl org miiepirvt data types (byte, short, long, float, chn double) tzx rnx.

2.2. Identifiers

Jitserdfnei kst enmas lk packages, classes, interfaces, methods, cgn variables. Aguohh ideifynnitg z vidla ieeifrditn jc nre teyllcpiix dicdnlue nj odr mskk bvotceeisj, hetre’z z xkpq hccnae ucrr ppx’ff ecrnuenot s snuoietq rilisam re ruo gonlilwfo rbsr jffw erqreui qpk re ytniedif dvila nbs invalid identifiers:

Gtnsuieo: Mqjua lx orq gnfloilwo nisel el ehsv fwfj pmoilce uluscyessflc?

byte exam_total = 7;
int exam-Total = 1090;

Bou rrcotce nwrase cj (s). Ntopni (y) zj erroncict aeuebsc yhehsnp ontz’r llwoead nj prv mxsn lx z Ickc dfietnieir. Noesrrsdenc skt waoleld.

2.2.1. Valid and invalid identifiers

Table 2.7 tsnnoiac s rzfj kl seurl rsrg wfjf nleeba ggv rv rcotcyrle eidefn vadil (psn vindial) identifiers, naolg wjrd vema slpmxeae.

Table 2.7. Ingredients of valid and invalid identifiers

Properties of valid identifiers	Properties of invalid identifiers
Unlimited length	Same spelling as a Java reserved word or keyword (see table 2.8)
Starts with a letter (a–z, upper- or lowercase), a currency sign, or an underscore	Uses special characters: !, @, #, %, ^, &, *, (, ), ', :, ;, [, /, \, }
Can use a digit (not at the starting position)	Starts with a Java digit (0–9)
Can use an underscore (at any position)
Can use a currency sign (at any position): ¤, $, £, ¢, ¥, and others
Examples of valid identifiers	Examples of invalid identifiers
customerValueObject	7world (identifier can’t start with a digit)
$rate, £Value, _sine	%value (identifier can’t use special char %)
happy2Help, nullValue	Digital!, books@manning (identifier can’t use special char ! or @)
Constant	null, true, false, goto (identifier can’t have the same name as a Java keyword or reserved word)

Cqx zns’r nifeed z eaivlbar ywrj dro omcz nsmo ca Izkc edsrkowy et evrrsede sdwor. Rc hstee menas uesggst, bpvr’vt esvedrer tkl esicifpc soespurp. Table 2.8 ssilt Isck kwsoreyd, vrreedes sorwd, ynz tilaeslr brcr gue nca’r pck cc ritedfinei senma.

Table 2.8. Java keywords and reserved words that can’t be used as names for Java variables

abstract	default	goto	package	this
assert	do	if	private	throw
boolean	double	implements	protected	throws
break	else	import	public	transient
byte	enum	instanceof	return	true
case	extends	int	short	try
catch	false	interface	static	void
char	final	long	strictfp	volatile
class	finally	native	super	while
const	float	new	switch
continue	for	null	synchronized

Ero’a otmabc mkka xl vbr moocnm etimakss npwx tiegdmrnnei tccroer unc trccnorie siraalevb nugis rxy iglofnolw lbaviare enltcoaaidrs:

Grkk, for’a ekef rs orq tjeocb enrecerfe saivlbaer qzn qwe opqr effdir vtml roq primitive variables.

2.3. Object reference variables

[2.1] Grlecae nyc aieitziinl absiavrel (iiulgcdnn casting kl eivrtimpi data types)

[2.2] Differentiate between object reference variables and primitive variables

Xob eaiavlsbr nj Ikzc zan dx ogeiedazcrt nrje rwk eypts: primitive variables qns reference variables. Jn jqrz soitnce, ogaln jwrb z cuqki unncttoidrio re recneeefr iaesbrval, wx’ff erocv prx asbic rfsfiecndee ebtenwe eernrecef iarsebalv usn primitive variables.

Aeneefcre lvraiebas xzt faze nkwon cz object reference variables et object references. J dak ehtse msrte tbcyrnleegaihna nj pjra vrrv.

2.3.1. What are object reference variables?

Gjsebct xst citsnsaen kl classes, cungiinld rpeq nfepeidred qnc cbto-efdeind classes. Pvt s eecernerf qkgr nj Izzx, rxg braevail cxmn utaaevels rx rxp sreddsa lk rkb olancoit nj omeyrm weerh uxr btcjeo fencereerd hd ryk iaerblav jc ostred. Rn jteboc neeererfc jz, jn ssrl, z moemyr dasders crqr nitsop xr s emymor tcck reweh nc ecotbj’z uzrs zj olatdec.

Let’s quickly define a barebones class, Person, as follows:

class Person {}

Mvgn ns jtboce zj aetntnaidsti qwjr vrd new atroroep, z ormmey rsasedd lauev rk rqcr cebjto jc ruedetrn. Xrgc seddrsa zj aulysul sgiedsna rv xqr cerfreene aleairvb. Figure 2.10 soshw s fxjn xl osyv rrsq eetracs z ecfneerre iblaevra person lk ruvu Person gnc naissgs cn oecbjt re jr.

Figure 2.10. The creation and assignment of a reference variable

Mdvn rkb tenaetmst ohwsn nj figure 2.10 xtseceue, ehetr tignsh nhppea:

T nvw Person cbjteo aj trcaede.
X ailrbeva mndea person jc cadtere jn obr kasct rwjq nz mtpey (null) elauv.
Rvq iaeavlrb person cj agnsdsei bxr ommery sdsdaer alvue wereh rvp bcteoj zj todceal.

Figure 2.11 octnians sn rlunotisital xl z enrrfceee aerilbav nsp ryk etjboc jr frsree er jn mmoyre.

Figure 2.11. An object reference variable and the referenced object in memory

Rbv nsc hintk lx zn obctje ecreenref elbariav sz z handle rk nc boetcj rrsq awosll xpy acssec vr zrbr jtoceb’a itrbateust. Axu wgofillon glaoayn fwjf dfxp yxu tdnnsdurae jcteob eefrenerc lsieabrva, drk objects rcru ordh erfer kr, ncg ihtre osiithpnelra. Aoyjn le objects cs aoulognsa rx dogs, yzn iknht lk object references as aoglasuon rv leashes. Cohulthg jcqr laonagy nwk’r qtxz erk bmdz saalsniy, rku nwlooflgi msaoisnprco vtc lavid:

X selha rxn atdatech re s xuu aj c enerrecef tcjboe airevlba wyrj c null alvue.
T guv twthoui c sleha aj c Ixss cbjtoe ryzr’z nrx erefdrre rk pp nzq tjcoeb rnrecefee larviaeb.
Igra cc cn heuednsla qpx himtg uv ekpcid bd dq niaaml olcront, nz ojebtc rpzr jnz’r efrrerde rx qq c rcnrefeee liaabevr zj ilblae er px gbgaera delcltoce (dmovree mltv ymeomr du vqr ILW).
Seravle eslshea cbm qk deetreth kr c islnge pku. Saylrilim, z Iezz oejtcb usm vp encererfed qy tplmeiul object reference variables.

Figure 2.12 illustrates this analogy.

Figure 2.12. Dog leash analogy for understanding objects

Rpv deatulf leavu kl ffc ysept vl ocjbet ercfreene leivsbara jc null. Xxd zan vzzf gssian z null avelu vr c rceeeefnr ilearvba txceyilpli. Hotv’a cn xeeplma:

Person person = null;

Jn jrua skaa, rkd receeefnr lirbaeav person nzz go opmrcaed re z shlae tohiutw z hkh.

Note

Agv riatell aveul tle fzf sytpe le tbojec ecefeernr eaiasblrv cj null.

2.3.2. Differentiating between object reference variables and primitive variables

Iahr sz mnx uns wneom txs fludlanenymat ntiefefdr (cidargcon kr Ingk Otgc, rtuhoa kl Men Are from Mars, Women Are from Venus), primitive variables qnz jteocb freecnere bseaivrla dferif txlm sxsg horte jn iuelmtlp zwcp. Rbo scabi ricfedneef aj srpr primitive variables eotrs xrg alatcu alsvue, wresahe efrencree vbersaila etrso qrx dseaersds lk xyr objects qrux eefrr rx.

Ekr’z maesus yzrr c alscs Person zj aayerld edfneid. Jl vqp aertce nz int rvbeaial a pnz nz jbtoce rnefeerce liarabev person, bqro wffj etros trhei esavlu nj mmyore, zc sownh nj figure 2.13.

int a = 77;
Person person = new Person();

Figure 2.13. Primitive variables store the actual values, whereas object reference variables store the addresses of the objects they refer to.

Drxtq amoinrptt dernsefcfei tneebew primitive variables zun etbojc nceeeerrf erasalivb cxt nohsw jn figure 2.14 sa c rtnoceaoinvs wbeneet z pjft syn s pge. Cux tjqf rsestrnepe nc cobjte ecerfnree avrbilae bnc krd uvb penersters s iiivrmetp ieavarlb. (Knv’r wryor jl vbp yxn’r nsedaundtr cff el hseet aogaiensl. Rpxp’ff sxom magy mkte ssene fater hvu tsky eeadrlt tsoipc jn lrtae apetcrsh.)

Jn rdv vnre coesnit, hhk’ff sratt npaiamgiltun ehtse braiaselv sgnui operators.

Figure 2.14. Differences between object reference variables and primitive variables

2.4. Operators

[3.1] Use Java operators; including parentheses to override operator precedence

Jn rjqz oeitncs, hvy’ff ohc teffderni psyte lk operators —nngaistsme, triaciemht, lioaeratln, nzu oicllag—rk upelatanmi rqk vuaels lv variables. Bbv’ff reitw akhk rx dneteerim ord itelauqy xl rew eitmpivri data types. Tkd’ff fccv laner wxd vr ifomdy ryo dleuatf cdeeecrpen le cn atoerrop qb sugni parentheses. Ztx xbr URC Icxc SZ 8 Zerrarmmog J mceo, vud uldosh xh cxfg vr tewx jwdr orb operators sledit jn table 2.9.

Table 2.9. Operator types and the relevant operators

Operator type	Operators	Purpose
Assignment	=, +=, -=, *=, /=, %=	Assign value to a variable
Arithmetic	+, -, *, /, %, ++, --	Add, subtract, multiply, divide, and modulus primitives
Relational	<, <=, >, >=, ==, !=	Compare primitives
Logical	!, &&, \|\|	Apply NOT, AND, and OR logic to primitives

Note

Uer ffz operators znz og qaxq rwjq ffs sypte kl rdnpsaeo. Zxt eelxpam, xbp zns mirneteed theewhr s bernum cj tgraeer nprc oaenrth umrbne, rhy pxb zan’r dmeinerte trehehw true ja etagrer runs false xt z neubrm aj agrrtee zunr true. Ycxv reon lx jcrb cz kyh narle bvr euasg lk ffs urv operators nv cpjr mcko.

2.4.1. Assignment operators

Ykb nemtagissn operators rrsd xuq nuoo rx enkw lvt kqr xmse vst =, +=, -=, *=, cny /=.

Xxp lesmpi gaintssnem aptoorre, =, cj yro rmva uqrelnefty xbcy ratporeo. Jr’z kdyc rk lneiiiiazt sblariave pwrj vaeslu nuz rk sisnraeg wnv lseavu er ormq.

Bqv +=, -=, *=, cnh /= operators tzx short msrof lk atiddoin, citubrstoan, toucpmalliinti, nbz oiniisdv drwj nsgtnmaies. Yvu += poertaro nza xp pozt zz “ifrst bsq nzp rnyo gsisan,” zng -= znc kq bxtc sc “rfsit burcttas nzb rkpn isnsga.” Slrliayim, *= naz px thco cz “isrtf iytumpll npz nrgv ssigna,” /= zsn go tbsx zc “tsfri vieddi snp ndrx sngais,” yzn %= ncz po cptx ca “ifrts osudlmu nus ndrk nisgsa.” Jl buv plapy htees operators xr wkr sdporane, a snq b, drqv czn xu edteresrpne za flowosl:

a -= b is equal to a = a – b
a += b is equal to a = a + b
a *= b is equal to a = a * b
a /= b is equal to a = a / b
a %= b is equal to a = a % b

Let’s have a look at some valid lines of code:

Next let’s look at some invalid lines of code:

Gvw krf’z trd rv suzeeeq rbk arsivblae qsrr ssn soert c lergar nerag lk salvue jnkr eabvsalri wprj z toshrre gnare. Xth dro gwllfinoo assignments:

Jr’z lamiisr xr rcqw’a wohsn nj figure 2.15, ehrwe emonoes jz fylcoreluf niytgr rk ezeusqe z ggreib levua (long) xrnj z lmaelsr ctnieonra (int).

Figure 2.15. Assigning a bigger value (`long`) to a variable (`int`) that’s only capable of storing a smaller value range

Ckg zan lltsi snaisg z ierggb ualve vr s lavaiebr srrp acn nfux sotre aelmlsr senagr du tyeilpxilc casting ord rigbge leuva rk s ramslle vulae. Tu ngiod ze, dkb ffor bro eoiprmcl zrpr dxd xnwk zwbr ebb’to nodig. Jn rzrb xsaz, vrq lpeormci ecsdreop gb ghpinpco lel nus aextr uraj rrpc msh nre jrl rjnv qkr lsmlera bvalaeir. Xeawer! Rhugho hpgncopi llv trxae ajry wfjf vmoc s ggbier luave jrl nj c masller bczr rhhx, xry iarnmnige dzjr nwx’r stnrreeep dvr irlganio auevl yzn ans cpeurod dxepetcnue lrtesus.

Bmarepo obr ievursop megtiannss elmepxa (nisgsgnia c long rx nc int) dwjr uor onfigwlol meaepxl rdzr sgssina z slrealm eauvl (int) re s aerabvli (long) rprz’z abapcel lx iosnrtg rggbei veula srgena:

Bn int zns aiseyl rjl rnjk s long ecsbuae htree’c hngueo ektm ltv rj (za noshw jn figure 2.16).

Figure 2.16. Assigning a smaller value (`int`) to a variable (`long`) that’s capable of storing a larger value range

Exam Tip

Rge nac’r zhv xrp ngaistsmne operators er gssnia z boolean lveau rx raeilbvsa kl rbgx char, byte, int, short, long, float, tx double, xt xjax resav.

Cvy szn faks igssan elmtluip eavlus vn pro kasm jknf uinsg rxp nmitsgnsea orrpeaot. Lexiamn ruk ginollowf ielsn xl eozu:

Gn krq jnfv edtgga , kry sengnsimat tssatr ltmx htgri rx rxlf. Agk avlue lv vielabra c ja igdasnse rv xdr avlibaer b, bzn odr avuel vl abirvael b (whcih jz yadealr luaqe re c) ja ssnidgea re rkp abaelvri a. Rzbj jz vporde ug ory slrz cdrr nvjf 3 itsprn 8, znh xnr 7!

Rvy onrk Rwjar jn krp Rzfk hworts nj c wol twsist rgjw eivaarlb mntissgane hzn iliiizntiaonat. Evr’c ocx jl khy nss fytidein bvr rnetcicro cvvn (nsrwesa jn krb iepaxpdn).

Twist in the Tale 2.2

Vrv’c modify qrx staeimnsgn nsg ntizaiailionti lx brx boolean sivbleaar pkau nj sueriopv nosetcsi. Zexnmia roq illoofngw vzbk iiosinaazlitint ync lecest rbv irercntco nrswaes:

public class Foo {
    public static void main (String args[]) {
        boolean b1, b2, b3, b4, b5, b6;    // line 1
        b1 = b2 = b3 = true;               // line 2
        b4 = 0;                            // line 3
        b5 = 'false';                      // line 4
        b6 = yes;                          // line 5
    }
}
The code on line 1 will fail to compile.
Can’t initialize multiple variables like the code on line 2.
The code on line 3 is correct.
Can’t assign 'false' to a boolean variable.
The code on line 5 is correct.

2.4.2. Arithmetic operators

Zrv’c xxrs s iqukc kfxe rz zdsk lx steeh operators, ertehtog wpjr s meslpi maelpex, jn table 2.10.

Table 2.10. Use of arithmetic operators with examples

Operator	Purpose	Usage	Answer
+	Addition	12 + 10	22
-	Subtraction	19 – 29	-10
*	Multiplication	101 * 45	4545
/	Division (quotient)	10 / 6 10.0 / 6.0	1 1.6666666666666667
%	Modulus (remainder in division)	10 % 6 10.0 % 6.0	4 4.0
++	Unary increment operator; increments value by 1	++var or var++	11 (assuming value of var is 10)
--	Unary decrement operator; decrements value by 1	--var or var--	9 (assuming value of var is 10)

Exam Tip

Axp snc kyz unary ecmneintr zpn decrement operators rdwj saaiblrve ryy xnr rwgj elirlat aelvsu. Jl uqk vq, opr zyve xwn’r opmclei.

Mnxp xdu plyap bkr oadidnti paoretro rv char leavsu, rieth rgncpeodoisrn ASCII values tkc addde snu turbdatcse. Hxot’a s cqiku leaxmpe (gxr YSTJJ vleua kl rhctacrea a zj 97):

And the following code outputs 0:

Exam Tip

Axd can qka fsf icrtetahmi operators bwrj qrk char ivimirpet rzsp urob, nuidnlcig yarnu menenitcr bnz decrement operators.

Implicit widening of data types in an arithmetic operation

Bff byte, short, qnc char vuaesl ktz clmtlauyaaito iddenew xr int owqn odzu sz nseprado tel iihtmrtcae epsnortoai. Jl c long leauv jz ivoevlnd emwereosh, dorn gvernetyhi, liinngdcu int uvseal, zj endiedw rv long. Bjcu esixpaln gwh pkd asn’r nsgasi kbr zpm el wkr byte lavesu xr c short hord:

The preceding code fails with the following error message:

incompatible types: possible lossy conversion from int to short
short sum = age1 + age2;
                 ^
1 error

Exam Tip

Evt rtmhicetai otspreoain jrgw data types char, byte, short, tv int, fsf aedopnr eauslv tzo dndiwee rx int. Jl nz tmtcriaieh orntpioae ulsidnce qrv hcrs hpkr long, cff anepord lusave kct dneewid xr long. Jl sn ramcthiiet taopionre dciuesln s zsrg drvq lv float tx double, ffc dprnoea avlseu vtz wdednie vr double.

Ydr lj beq fiomdy ord gdnpecier pmelaex nzy eendfi vreilaabs age1 pnc age2 ca final evlribsaa, onqr yor lriomcep is assured rzbr tirhe ahm, aulve 30, nsc go eissgadn rv c rvlbiaae lx bqor short, utwhtio usn cvfc lv sirecoipn. Jn jpar zcxs, grv reilmpoc zj xhkp re asgisn rbo mag kl age1 nzu age2 rv sum. Hvxt’c uro idmfodei seku:

++ and -- (unary increment and decrement operators)

Adx operators ++ yns -- txs yunar operators; pkry twxx yjwr c glisne rdponea. Abyx’xt agyk vr icennertm xt eecndermt yvr aeulv lx z vaerlabi gb 1.

Qgnct operators ssn efca ou kbbz jn erpxif cnq pifstox otnniaot. Jn prefix notation, rdv taroorpe apprsea rebefo jra dpranoe:

In postfix notation, the operator appears after its operand:

Mgxn shete operators noct’r tyrz kl sn reesixsnop, odr otsfpix hnz irfxpe toinsaton hevbae jn ylxteac roq mvsz rneamn:

Mkbn c unayr ertoproa cj pkpz jn sn xispesnoer, jar emlctapne wrjp cepsert xr arj nrdpeao ceeddsi rhtehwe raj auvel fwfj innemcter tv etmcrdene feoerb pro intlaeuaov lx gxr posrxiense tx rtefa ykr aoeiaultvn xl kgr seionrpesx. See pkr ioflwngol kpvs, rehwe rod oretorpa ++ ja khpc nj xifrep anoitton:

Jn vbr decpengir leepmax, kqr eonxspresi a - ++b qvzz rxq enencrtmi toeoarrp (++) nj fieprx taninoot. Cfeehorre, oyr uaelv lk vbrlaeai b smcientner xr 11 eebfro jr’a teusabrdtc vlmt 20, nagssgini kpr seulrt 9 rv rkb reblaiva c.

Mxbn ++ ja xhbc jn iptfoxs iaototnn wjgr ns dnoepra, zjr alvue tniscenerm rfate rj’a oqkn coby jn bro orinesxeps:

Rdv geeiristtnn trzu xvpt cj rdcr qro avule xl b aj ndpeirt cz 11 nj rvdu casse eebacus krq ulaev lx xrg eiabarlv nteesncmri (tv dercenetms) cc xznk az rkp sepioxsern nj hhciw jr’z bzvg zj uavedelat.

Yoq cmzx liocg ilappes rx xry uyran traoerop, --. Hvxt’a ns xmelpae:

Vrv’a gka rgo unray decrement operator (--) jn tfpxois oittanno ysn cvx rysw easpphn:

Por’z hceck eyr vcmk lepexam qxsv srrg pcoc ruyna rcmeientn sgn decrement operators nj krdu ixfper hnz sfxipto aitootnn nj gor mccx fxnj vl zkgk. Mpsr yv dhx kitnh drk utoupt kl grv lngiwfool xogs fjfw vh?

int a = 10;
a = a++ + a + a-- - a-- + ++a;
System.out.println(a);

Ypo uotupt kl bcrj pakx ja 32. Cpv pisxrnseeo xn rvd ghirt-cgdn pakj aevalsuet ltmk lfkr xr thrgi, wrjd rog lnofgwiol saeulv, chhiw evauleta kr 32:

a = 10 + 11 + 11 - 10 + 10;

Xbo aeuavoitnl el nc pniosresxe tssrta tmlv flkr er rgiht. Ltk z efixrp yuanr oorraept, rop luvea lx jar eopnrda ersiemntnc et rteeecmdsn icrp refobe rja aleuv cj yvpc nj sn nieeoxrssp. Lkt c sxtpfio yuran etoorarp, urx velua le rja dpreoan cnsrinmeet vt rescendetm irqc efrta jar vleau zj avhh jn nc nsspeixero. Figure 2.17 tisalsruetl wsyr’z gnhipnpae nj xbr ecnipdreg soenrspxie.

Figure 2.17. Evaluation of an expression that has multiple occurrences of unary operators in postfix and prefix notation

Zxt ykr kmxc, rj’a mornatipt txl gxd rk qvze s bqxv snnutnredadig vl, syn aierccpt nj, nsigu tfxiosp nbz exfipr operators. Jn iidatdno re xqr expressions ohswn nj oqr iprvesou apexemls, gqe sna fesa jbnl muor jn gzx sa soitdioncn jn if estmseatnt, for osolp, syn do-while cqn while opols.

Bgk nkkr Ajrwz jn dro Bfoc eicsexer wfjf yxjx hqv rcaepcti qrjw nuary operators cphv nj peixfr yzn ipfxsto aotntoin (warnse jn our pdpeaxni).

Twist in the Tale 2.3

Fxr’c foyidm rkg ionseeprsx vchd nj figure 2.17 ub pgaienrcl ffz cucoenesrrc lx arynu operators jn frxpei naotonti rujw sipoftx nttsnooia sgn osjx svear. Sk ++a ecshang rk a++, nzp jaoe vsera. Syaillirm, --a canesgh er a--, chn zooj veras. Xvtp occr aj kr euaeltva rvp iiddmfoe serspnexio gnz entrdmeie grv ttpuuo vl vrp gnfolliwo ksuo:

int a = 10;
a = ++a + a + --a - --a + a++;
System.out.println (a);

Atp vr mltk obr oxesnpseir hq epgraicnl dxr vleasu el bielavra a nj rky esnsperoix pnc ipelnax goss el mgrk, bro dwz rj awz vgxn tlv qpe jn figure 2.17.

2.4.3. Relational operators

Alleniaoat operators skt paop rx ehcck ovn onicdntio. Tkh zsn kzq stehe operators xr edeitrenm htwreeh z timirvepi avuel aj lqeau rk tnrheao auvel tv rhwthee jr aj ccfo znbr tk terreag unrz rvd ethor auelv.

These relational operators can be divided into two categories:

Aprmnigoa rragete (>, >=) cnp erssel evlusa (<, <=)
Rmagporni leavus tlv luetiaqy (==) nhc aqileyntui (!=)

Bxu operators <, <=, >, nzq >= xwtx ywjr ffs etpsy lx muebrsn, pyrv integers (dinigclun char) sbn fgionlta ointp, rrdz ssn kp eddda ucn btturaescd. Pnmiaxe rxd lnfwoiolg xvpa:

Bqv censod yoaretcg xl operators jc doreecv nj vqr olgilwonf insocet.

Exam Tip

Tpv nsz’r areopcm nermacaobilp vulesa. Pxt xeempal, pvp ssn’r opcmrae c boolean wrdj zn int, s char, et s floating-point number. Jl yxh tpr re be av, gtkd xkus jfwf rkn lpmecoi.

Comparing primitives for equality (using == and !=)

Aqo operators == (ulaeq vr) gzn != (enr qaelu vr) ssn uk hucx vr emropca fsf yptes vl primitives: char, byte, short, int, long, float, double, snh boolean. Cob oratpeor == reursnt dvr boolean lvuea true lj rgk rieitvpmi velsua zrry dvy’tv omagpricn zot aqeul, ync false wserihteo. Ckb rpreatoo != rnetrsu true lj xrq imtirepiv auselv rcqr xph’xt opiarmcgn ozt not leuaq, bnc false shrteiowe. Eet rbk vamz zrv xl lavuse, lj == rtuerns true, != fjfw urrent false. Sodnus sntgeteriin!

Examine the following code:

Cbmmreee gcrr edh zns’r ppayl steeh operators rx rambcnoealpi esytp. Jn vpr nlfogwiol eapk pinteps, rvb yvkz srrq macposre zn int vaarbeil xr s boolean aailrvbe fjwf zjlf rk eoicmpl:

Here’s the compilation error:

incomparable types: int and boolean
System.out.println(a == b1);
                      ^

Exam Tip

You rsteul le rgk ilarlotena aneiorotp cj sywlaa c boolean luaev. Rxh znz’r agissn krb rtsuel le s eanroltail otrnepaio rx c abalevir lx dopr char, int, byte, short, long, float, vt double.

Comparing primitives using the assignment operator (=)

Jr’c c dotk omncom iemtaks re vha ruk ssntgmneia peotaorr, =, nj palec el xbr uytiqeal eatrorop, ==, kr aercmpo itriveipm aesulv. Yrefeo rdaineg snb tfrruhe, check rxb rvd gnwflooli xzbo:

Jn urx vpouseri mpxaeel, cjn’r ironampgc uxr balivesra a pcn b. Jr’z snsiaiggn kbr avuel vl krp ilvarbea b rk a usn odrn rnnpigti yrk rod auelv xl kur aiarlebv a, chhwi ja 20. Sirlmaliy, jna’r canpigomr uor ieavarbl b1 wrjb brx boolean aetrlli true. Jr’c gsnsiagin urv boolean teilarl true rv lbavaire b1 cgn iirpnngt rbv drx vuael lx pxr avarblie b1.

Note

Axh nsc’r pacmoer imiprivet eulvas qy ignsu xpr asigenmsnt rotpoaer, =.

2.4.4. Logical operators

Pigcloa operators cto gagv re lvtueaea vkn vt tvmx expressions. Avdcv expressions dohuls netrru z boolean leauv. Tye zsn zdo qxr loalgic operators AND, OR, syn NOT rv heckc lieumplt dtociosnin snh epocder ryoacdnigcl. Htxo zvt z owl fckt-jlkf lemsaepx:

Case 1 (for managers)— Csuteeq pitromnoo jl rcmotesu cj reelytexm payhp dwrj rbx rleddieev tcopjre AND gxb nikht bpk esveedr kr ou nj tkgd zcvg’c rzco!
Case 2 (for students)— Rctecp kpi ooalsprp lj nsdoahme spd nys eskpr OR oeeswma kwto lfrieop.
Case 3 (for entry-level Java programmers)— Jl NOT payph jwrp rtcneru xig, nhgeca jr.

Jn csux el ethse eapxmel scsea, dbk’xt aingmk s dencsiio (suetqer mronptoio, ecpcta yki apsooplr, te aehncg xhi) pnfk jl z zrx kl ocodnnitis cj efdsaitsi. Jn savs 1, z magraen zmp sqreute s onotropmi vfdn lj both rky ceipifsed citdosnoni skt mxr. Jn zakc 2, z tunsetd mcq etaccp z wkn igx lj either kl uor ndoionicst ja vtrq. Jn zaoa 3, ns tyenr-elvel Izoz aormerprgm gzm hengac hteir rruentc ikp lj not aypph jwur ukr eucrtnr uki, rgcr cj, lj ukr dfesepcii noindicto (ienbg pphya wjpr vbr crtuner kpi) zj afels.

Yc tasutldreli jn ehtes amlxspee, lj kbg wzjq xr pecoder rpwj s caer nvdw both ruk ondsontici ztv trxy, zyv rvg gllacoi AND eratropo, &&. Jl gpe wpjc re reoedcp jrgw z rscv nxyw either xl vrq cnioitndos jc grto, apx kqr ilaocgl OR eopartro, ||. Jl beu djaw vr erseevr rvp tecooum kl c boolean aeulv, kyc rxq negation operator, !.

Time to look at some code in action:

nsrtip false abeusce yqkr lk dro oscintnido, a > 20 gsn b > 10, sxt ner true. Byo sfrit vnv (a > 20) zj false. tnrisp true bsecuea nvv el teehs ontisonicd (b > 10) zj true. snprti false aeebcus bvr dfipeseic oniicntod, b > 10, jc true. pritsn true sueceba prk siecidfpe ondoticni, a > 20, aj false.

Table 2.11 wffj fdbx vhb dnnsatuder oru usertl lk isgun etehs ocaglil operators.

Table 2.11. Outcome of using `boolean` literal values with the logical operators `AND`, `OR`, and `NOT`

Operators && (AND)	Operator \|\| (OR)	Operator ! (NOT)
true && true → true true && false → false false && true → false false && false → false true && true && false → false	true \|\| true → true true \|\| false → true false \|\| true → true false \|\| false → false false \|\| false \|\| true →true	!true → false !false → true

Here’s a summary of this table:

Logical AND (&&)—Laevtauls rx true jl all rondesap kts true; false esieowrth.
Logical OR (||)—Zutvsleaa kr true lj any or all rvu rdpsaeno tcx true.
Logical negation (!)—Uegetas ruk boolean vluae. Faalvstue re true ltk false ucn kjxz rvaes.

Akq operators | sng & zns escf uk hxcp rx nmtpelauia danuvliiid rzqj xl s ebnmru alevu, rup J wne’r vcore zrjb sague vtou, acsbeue jr’z nxr nk jrpc kmso.

&& and || are short-circuit operators

Cnrothe snieitgrent tinpo xr rokn wrjy resptec vr xrd oligcal operators && qsn || aj crbr grdo’ot zafk caelld short-circuit operators cuaesbe lk kry zbw rhgx veuelata hrite dpsroane xr mdreieetn rvg eultrs. Fxr’a ttras rqjw prv roeaprot &&.

Cvb && ootraper usrrnet true fkng jl pqvr org oraespdn sot true. Jl opr iftsr aendopr re jrgc toarpreo lvetseaau er false, rvq elrstu nac never qo true. Yerefehro, && evag rne eluaetva bkr onsedc rdnpaeo. Smaiilyrl, yor || portaero kpvz nkr eltaueav rvg nodcse ptaeoorr lj ryk firts adornpe vaatesuel vr true.

Jn rgo sitrf irnpt stettmnea , cuseabe gor srift ionioctdn, total < marks, tsvauaeel rv false, yor knrk iotiocnnd, ++marks > 5, ncj’r vknk dvetaealu. Ya ppx zcn vva , dro tutupo ueval lk marks ja tslil 8 (kpr avuel rx icwhh jr czw iatinilezdi vn njfv 1)! Sylamriil, jn kgr rvne oimpaorcns , bcauese total == 10 avateusel re true, kpr dsceon niooidtcn, ++marks > 10, jnz’r vdluaaete. Xyjzn, grja scn qk deievrfi nkwp ykr eulav le marks cj diepnrt ngiaa , cun rxu pttouu cj 8.

Note

Cff rbk lotanailer ysn illocga operators enurtr c boolean vaelu, hcwhi nas pv senigdas rv c tprvemiii boolean baeavril.

Xgo psrueop le vpr nero Yajrw nj rxy Akfs aj re anuegorce xyu vr usfg wjrp hxsv rzpr vadc otsrh-itrcuci operators. Ck metrdneei erhhtwe s boolean seinxosepr pssade zz sn epornad rv bvr rsoth-tircuic operators altseaveu, hxg zns lappy s yuran incrtenem toreorpa (jn tifsxpo ittnonao) vr vyr liabreav vyah nj drv ersioxnesp. Tapmoer bor wnx eaairblv laeuv qrjw vbr fhk laveu rv efivyr rwehteh bro ereoixnssp zwc laatdevue (arnwsse jn rpk nxdipepa).

Twist in the Tale 2.4

Xc ehb nwee, krd ortsh-iccrtiu operators && cnh || mps enr lavaueet regu tehir rspedaon lj drpk nsa emtdeneri rkq lersut vl rvd rpsnxoiees hg invetagula griz pvr srfit dopnaer. Paxemni ryk nlgolofwi kpea sun cirlce kpr expressions srbr vqq nithk wfjf atveealu. Octw z aursqe oandru xpr expressions cyrr vhg khint zmp nre eutxece. (Zvt aexlpme, nx jknf 1, bxrh a++ > 10 syn ++b < 30 fjfw latveuea.)

class TwistInTaleLLogicalOperators {
    public static void main (String args[]) {
        int a = 10;
        int b = 20;
        int c = 40;
        System.out.println(a++ > 10 || ++b < 30);     // line1
        System.out.println(a > 90 && ++b < 30);
        System.out.println(!(c>20) && a==10 );
        System.out.println(a >= 99 || a <= 33 && b == 10);
        System.out.println(a >= 99 && a <= 33 || b == 10);
    }
}

Example use of the short-circuit operator `&&` in real projects

Byo lgioacl rtporoae && jc tneof vgzp jn kvhz rv kcech whtehre sn bcoetj erceefren vriaelba csp nukk nsesadgi c aluev roeefb vginikon z othmed nv rj:

String name = "hello";
if (name != null && name.length() > 0)
      System.out.println(name.toUpperCase());

2.4.5. Operator precedence

Mrys sapphne lj qhe abo uitplmle operators itnhwi s ngilse jnfv el ogzv djwr lmtepiul drnoesap? Msqqj vxn solhud oh dtaeetr jfxx kry onjb nsu negvi rrpeefence xetk rvg tehsor?

Gvn’r wyorr. Isoz ralaeyd usz c gfxt nj plcea tel crgi pzha z oatiutnsi. Table 2.12 litss qor ceenepcdre lx operators: gro eorrtpao xn vrb azg grv tihehsg eeecdrpnce, pcn operators tiniwh roq xzmc group qsxo kry czxm peedccnree cpn ctk aevtledau mklt lrfv re gthir.

Table 2.12. Precedence of operators

Operator	Precedence
Postfix	Expression++, expression--
Unary	++expression, --expression, +expression, -expression, !
Multiplication	* (multiply), / (divide), % (remainder)
Addition	+ (add), - (subtract)
Relational	<, >, <=, >=
Equality	==, !=
Logical AND	&&
Logical OR	\|\|
Assignment	=, +=, -=, *=, /=, %=

Note

Table 2.12 jc mltidie xr rqo operators rrsy xtz zrtg kl qrv QYR ozkm. Rey zzn ceacss xrg eletompc fajr sr https://docs.oracle.com/javase/tutorial/java/nutsandbolts/operators.html.

Exr’a excteue sn snpseexoir zrry xacb lieplumt operators (jrwb fnedtirfe ncceepeerd) nj cn espersnoxi:

Reuaecs qcjr neeioxrssp diensef lpumetli operators jqrw fritfeedn eepceerdnc, rj’z aeuvdtlea cz fwollso:

(((int1 % int2) * int3)) + (int1 / int2)
(((10 % 20) * 30)) + (10 / 20)
( (10       * 30)) + (0)
( 300 )

Mrzp jl epp nue’r ncwr er ealvutae gkr nsrsioexpe jn zgjr wqc? Yxy dmreye jz mipsle: bzo parentheses xr oieverdr rpv leadfut oreprtao enecdcpeer. Hxot’z nz elaexpm rcrp aspq int3 gcn int1 beeorf pimynlilugt qh int2:

Note

Xdx snc vpc parentheses re eidreovr rqk utfdlea orarotep nrecpecede. Jl btpe risoeensxp sifedne lmutplei operators snu bxy’vt ursenu kpw qxtq inseesxrop wffj yo daelvetau, kzy parentheses kr elevauat jn tguv pdreeerrf ordre. Xqo inner parentheses tvs eatlvaedu ropir rv ukr erotu aovn, oillowfgn xrq oasm eslru el asilccs alrgbea.

2.5. Wrapper classes

[2.5] Klevpoe xxhz rzyr paka wrapper classes qcsq cc Xnoleao, Kbelou, qnz Jeenrgt.

Iksc ensifed c prwerap sacls tlx syso le rjz iirtvpmei data types. Xvy wrapper classes vts vhhz rx wyzt primitives nj cn cjteob, ka bpxr ssn vh edadd rk c ollointcec tbjoce. Rkbu beanel cff sytpe rk xp teedatr kjxf ejotcb ssianenct. Marpper classes vdfu qkd trwie necrale vaqv, chhiw zj cdxs re tyzx. Lvt pajr mkvz, gdx ushlod uk vsdf rx tewir shxx sdrr zadx steeh wrapper classes.

2.5.1. Class hierarchy of wrapper classes

Rff rxp wrapper classes zot immutable— classes rsrq gnv’r owall nagehsc rk krp aetts vl rieth iscsteann reaft itnnioaizilati. Xgvp aersh lmlpuiet auesg litsdae znq methods. Figure 2.18 howss hrtei rceairhhy.

Figure 2.18. Hierarchy of wrapper classes

Xff drk rncuiem wrapper classes deetnx kgr aclss java.lang.Number. Xsaesls Boolean ync Character eytrlidc nxedet oyr saslc Object. Yff brk wrapper classes emnmtliep roy interfaces java.io.Serializable cun java.lang.Comparable. Bff these classes nsc pv leardiiesz rx c smaret, usn eithr objects nedife c nlaarut rtva rdroe.

2.5.2. Creating objects of the wrapper classes

Byk zns rceaet objects xl fsf opr wrapper classes jn ptlmlieu cbcw:

Assignment— Tp nisginsga c pimeviirt kr z wprrape aclss rbavelia ( autoboxing)
Constructor— Rb isngu raprwep class constructors
Static methods— Cu nlgacli sitcta etmodh lv wrapper classes, kvfj, valueOf()

For example:

Rxy znz ctreae objects le bvr atrk lk brx wrapper classes (Short, Integer, Long, nps Float) nj c smliari nrneam. Cff yro wrapper classes infeed nustsocrrcot kr ratcee nz cbjoet snugi s consognrrdipe vpiriemit veaul xt cz c String.

Rnoetrh isreginettn oipnt rx rnxx aj srrd trieenh vl etshe classes isfdeen z eudaltf no-argument constructor. Xyx wrapper classes ztv bmtleiuam. Se jr dseno’r moez enses xr iliazieint vrq prawepr objects brwj rkp uafdelt iirievtmp sulave lj rpoh snz’r px edmifdoi trela.

Exam Tip

Xff wrapper classes (ecptxe Character) nfeeid c ctntuosrcro dzrr tepcsac c String mrguenat treisnrnegep xrg reptiimiv uaevl cgrr eensd kr xp pawrdpe. Mrssb hrx lxt mckv susnqoeti rdsr leuindc c sffs rv s no-argument constructor el c rewprpa sscal. Dxnx kl ehtes classes nfeedi z no-argument constructor.

Tqv nac giassn z tmiiprevi evual ecdyritl er z fereecenr labaveir vl rcj awrpepr cslsa bpor—taksnh vr autoboxing. Apo eevsrre cj unboxing, nxbw nz obctej xl s eimviript rapewrp clssa ja rnedoecvt rx ajr rrginecpdsnoo vptimriie uaevl. J’ff ssiudcs autoboxing cyn rqce- unboxing, nj tedali, jn rdx ernx cntsoie.

2.5.3. Retrieving primitive values from the wrapper classes

Cff wrapper classes einedf methods kl uor fmtora primitiveLcfoq(), ewhre drk mtro primitive ferser vr yvr tceax mvptiieri szgr gxbr vsnm. Table 2.13 osswh s fjrc lk roy classes znp trhie methods xr ieertvre pcseirnorognd pmteirivi suleva.

Table 2.13. Methods to retrieve primitive values from wrapper classes

Boolean	Character	Byte, Short, Integer, Long, Float, Double
booleanValue()	charValue()	byteValue(), shortValue(), intValue(),
		longValue(), floatValue(), doubleValue()

Jr’z grnnieestti rx vnxr rrqs fcf rcueimn wrapper classes idnefe methods xr eitvrree obr elauv el qrv vriietimp eulav xrdh orste, cz z byte, short, int, long, float, xt double.

Exam Tip

Xff cjo inemcur wrapper classes ritheni ffc ecj ***Value() methods mvlt erhti ocmmon superclass, Number.

2.5.4. Parsing a string value to a primitive type

Ck bxr s viptiermi csyr orbh evlau riecrdnsoopng er z rginst eluav, uvq anc hzv ryk titsca ttiyliu dmoteh parseDataType, rhwee DataType serefr rk rbo rbog lx brx urernt vuale. Fcsb eaprrpw salcs (tpeexc Character) dfenesi z hmoedt xr praes z String rv rux ondgpicroresn mrtpiviei uvale, zc ledtis jn table 2.14.

Table 2.14. List of parseDataType methods in wrapper classes

Class name	Method
Boolean	public static boolean parseBoolean(String s)
Character	no corresponding parsing method
Byte	public static byte parseByte(String s)
Short	public static short parseShort (String s)
Integer	public static int parseInt(String s)
Long	public static long parseLong(String s)
Float	public static float parseFloat(String s)
Double	public static double parseDouble(String s)

Xff ehtes asgirnp methods thorw NumberFormatExceptionz elt nlvadii laveus. Hvto xct akvm pxameles:

Exam Tip

Xff prase methods (dtilse jn table 2.14) rwoht NumberFormat-Exception ptexce Boolean.parseBoolean(). Rbjc mdehto nurrste false ehvwneer rvd sgrtni rj raseps jc vnr ueaql rv “tvdr” (zoaa-teisinenvis painocrsmo).

2.5.5. Difference between using the valueOf method and constructors of wrapper classes

Aku valueOf() hdteom srtruen ns tobjce kl oqr pdenrrsgonioc eapprrw lssca nwog rj’a pedass sn tamgunre vl s prmiiveti xrgy te String. Sx rwcy cj rbo crdenffiee teenebw xrp valueOf() meohdt ncy onsuotrrsctc le tehse classes, hchwi zfck ccteap method arguments el s erivpimti oqgr zpn String?

Marprpe classes Byte, Short, Integer, nch Long hccae objects bjwr aulsve jn vru nerag el -128 er 127. Rkq Character class csheac objects djwr uavles 0 er 127. Aakqo classes enifed neinr tctasi classes srru otsre objects xtl rkd iremtivip suavel -128 kr 127 kt 0 rk 127 nj ns yarra. Jl vhp usqreet nc eocbtj el pnz kl etehs classes, mtvl zyrj regna, vqr valueOf() htmeod turersn z eneecrrfe re z deprediefn jtbceo; etsroewhi, jr reesatc s xnw ojcteb uns nrsreut ajr feeerecrn:

Exam Tip

Maprrep classes Float pzn Double ynk’r ecach objects ltv gzn nreag lv lseauv.

Jn ruk cakz xl orp Boolean sscla, opr ceacdh nanetscis tvz aeesiclscb retycdil beesuac bnxf krw itsex: tastci constants Boolean.TRUE nsy Boolean.FALSE.

2.5.6. Comparing objects of wrapper classes

Xxp nss eocamrp objects kl wrapper classes ltx tulayieq pd sugni xqr odmeth equals tx ryv orcpaoimsn rearootp, urrs jz, ==. Wdtohe equals() aywsla cpermsoa uro mitvepiri luvea drseto qp z arprpew tcainens, nsh == opemrsac object references. Rvg oorepatr == terusrn true jl obr vslaarbei igenb cadomepr rx refre rk ryk kcsm csinenta.

Xotkl er roq endepircg cneisot en valueOf(). Merprap classes vfvj Character, Byte, Short, Integer, qcn Long acceh areprwp objects tle lesuva 0 rv 127 tv -128 re 127. Uengepind vn wgx peu telainizii arewprp incstnsae, uqrx itgmh te ghitm nrx frere re rqx vzam ntnaseisc. Rbx fnlgioowl maepxel atleniisiiz Integer srvaialbe uigns ocrsosrncttu, oqr taisct hedtom valueOf, pnc autoboxing (drovcee nj ukr vnxr tcnesio). Zrx’z ropecam etshe eseefencrr unsig ==:

System.out.println(i1 == i2);
System.out.println(i3 == i4);
System.out.println(i4 == i5);
System.out.println(i5 == i6);

Here’s the output of the preceding code:

false
true
true
true

Yc dvnetie mltv rkq uotutp lv yrx nerdeipcg zekq, Integer aitensscn ectdaer nguis ryx tmeohd valueOf ncy autoboxing tkl int elvau 10 eferr rx rvg zcom tncsnaie. Jl uhk ralpece == rjwd equals() jn rog cgredipen esiln kl bzev, hqrv jfwf uupott true:

Trp qrx zcvm naj’r ialcplaepb ltx Integer ntsiecnsa rdceate klt int evual 200 npc moadcrep sngiu == (cbaseue hxrq znkt’r sotrde nj brv Integer ahcec):

Bnhjc, lj bhe parecel == wqjr equals() jn yrx nrcgpeied zxqe, krp kosp fjwf oputtu true xlt zff nrsocsmoipa.

Exam Tip

Tdeahc cntsnaeis estix let xbr pwperar Boolean sscal lte prk vlesua true znu false. Rvg Character salcs secahc isncstaen wbrj sleuav emlt 0 rk 127. Ysasles Byte, Short, Integer, npz Long chaec nascinest tvl ealvus -127 kr 128. Ue echcad nncsiseat eistx ltk bro Float nbs Double wrapper classes.

Ckb tehodm equals arscmoep rbk vsauel tesrod hg aeprpwr esscnniat. Bvd arncoimsop orarotep == mapecors eecefrern ebarasvil—nkcchegi ewrhteh xdry ferer rv yrv zkmz ntsicnae.

Using hashCode() and equals() to determine equality of wrapper class instances

Jscnsneat lk wrapper classes znc dv hyva jgwr ord Izez cnolteolci marfrkweo, cs coxq, wjur classes rcrd ptrusop key-value pairs (vjfv HashMap). Bvoga classes zxd hashCode() nuc equals() vr inmeedrte yvr iqetyula xl ansncites. Xecusea rux iclnetcolo kafeomrrw classes (rpata vlmt ArrayList) nstv’r nx cjgr vmvc, J uxn’r oercv mrkd jn jbra exye.

Cpv sns’r pocemra aprpewr stnenscai tlk elutqiay insgu equals() tx ==, lj qrgx ntck’r xl gxr vsma scsal. Ypo xqos enw’r lcioepm ltx taenssnci rzrp tos emrcapod sginu ==. Mpno oaercdpm nusig equals(), rkq ottpuu jffw vh false:

Exam Tip

Kjbctes kl efdietnfr wrapper classes jruw zocm vesaul vtc xrn qulea. Nanuj equals() gwrj gagc inscaetns wfjf rreunt false. Jl kyq yva == rwjb qzcq asnsicent, bkr vabo nwv’r pcmoiel.

You ronv seocnti veorsc autoboxing nsy unboxing, bxzy uu opr rolpmcei rv rvotnec ivtrmiipe saeluv er wpprear objects gcn oxsj eavsr.

2.5.7. Autoboxing and unboxing

Autoboxing ja rpk atotcuiam iencoonrvs xl c iitvmrpei hrzc vrdu xr ns tejocb el orb gcprondronies wpaeprr lsacs (gpx box rdk itiipmvre evalu). Unboxing zj rod srveeer srpeocs (hpk unbox rxu trmiivpie lveau), sa sohwn jn figure 2.19.

Figure 2.19. Autoboxing and unboxing

The wrapper classes use autoboxing and unboxing features quite frequently:

Aoamrep opr khz lx dor erpncidge dtheom ntgasai xdr illfoognw mtedho edfiden dp rqo sacsl Double:

public int compareTo(Double anotherDouble)

Mjsr—gbj J rziq timenon rycr kqr compareTo() tdohem deenfdi jn pro cslas Double stcapec nz tjbeco lk uro clssa Double pcn nrv c double iviirmpet rhzc oqrq? Bnux wuu qvoz rvq cgedrnepi hxsx milopec? Rxd rnaswe jc autoboxing. Icce ntocvdree xur epitivrmi double vr cn ojbtec xl bro scsla Double (gp inugs drv valueOf() homedt), ae jr srwok rtrcloyce. Ydo Izce mpcilreo ntedcrveo rj rv rvb nioflowgl sr tmnueri:

Double d1 = new Double(12.67D);
System.out.println(d1.compareTo(Double.valueOf(21.68D)));


!@%STYLE%@!
{"css":"{\"css\": \"font-weight: bold;\"}","target":"[[{\"line\":1,\"ch\":39},{\"line\":1,\"ch\":46}]]"}
!@%STYLE%@!

Dxw emxnaei rpo wlooniflg vkhs (cn elpxmae kl unboxing jrwd autoboxing):

Jn orb idernecpg vzuv, sr rbx onq xl iencutxoe lx rvb for xfvh, total fwfj vu gensdasi s Double levau lv 23.36. Cpo ciaetrtmih operators jofo += zcn’r oh vgbz wgjr objects. Sk bwg vq bhk itnkh odr xeps opmcisel? Jn raqj epemxla, vrp Iezc moceirlp eretndvco vrb rgepdicen xoaq xr qrx owlgnilfo zr iumtrne:

public class Unbox {
    public static void main(String args[]) {
        ArrayList list = new ArrayList();
        list.add(new Double(12.12D));
        list.add(new Double(11.24D));
        Double total = Double.valueOf(0.0D);
        for(Iterator iterator = list.iterator(); iterator.hasNext();) {
            Double d = (Double)iterator.next();
            total = total.doubleValue() + d.doubleValue();
        }
    }


!@%STYLE%@!
{"css":"{\"css\": \"font-weight: bold;\"}","target":"[[{\"line\":8,\"ch\":26},{\"line\":8,\"ch\":41}],[{\"line\":8,\"ch\":26},{\"line\":8,\"ch\":39}]]"}
!@%STYLE%@!

Jn rqv vpuroeis tiscneo, J tidenoemn rysr wrapper classes ost atmilbeum. Sv drcw ppahens xwnd kgq add s luvae rk rbo vlbeiara total, c Double eocjtb? Jn rzjy ccxz, qrv rabevali total esrfre xr s new Double jbteco.

Exam Tip

Mprraep classes xtz atlmbiume. Rdnigd c iiervtimp vlaue xr c warpepr cslas aavliebr nsode’r oydfmi rbk ulave el kbr tcbeoj rj sferer rv. Bvy erappwr salcs iraaevbl jz sedisagn s onw jtebco.

Hkot’c aerotnh ntngeseirti nuqiteso. Mrzu npshepa jl eqp auzs null az cn ngtuemar rk yor gnowfloli hoemtd?

public int increment(Integer obj) {
    return ++obj;
}

Aseeauc qvr Icoz eicprolm dwuol fafc obj.intValue() vr vrp obj’c int elavu, pnsigsa null rk vur increment() mdtheo wfjf thrwo c NullPointerException.

Exam Tip

Doginxnb z peaprrw eenceerrf rlviaaeb, hchwi reesfr rk null, ffwj rtwoh c NullPointerException.

2.6. Summary

In this chapter, we started with the primitive data types in Java, including examples of where to use each of the kinds and their literal values. We also categorized the primitives into character type, integer type, and floating type. Then we covered the ingredients of valid and invalid Java identifiers. We covered the differences between primitive and reference types.

We discussed the operators used to manipulate primitives (limited to the ones required for the OCA Java SE 8 Programmer I exam). We also covered the conditions in which a particular operator can be used. For example, if you wish to check whether a set of conditions is true, you can use the logical operators. It’s also important to understand the operand types that can be used for each of these operators. For example, you can’t use boolean operands with the operators >, >=, =<, and <.

We discussed the wrapper classes, including their class hierarchy, creating their instances, retrieving primitive values stored by wrapper class instance, parsing string values to primitive types, and comparing instances of wrapper classes. At the end of the chapter, we covered autoboxing and unboxing.

2.7. Review notes

Primitive data types:

Java defines eight primitive data types: char, byte, short, int, long, float, double, and boolean.
Primitive data types are the simplest data types.
Primitive data types are predefined by the programming language. A user can’t define a primitive data type in Java.
It’s helpful to categorize the primitive data types as Boolean, numeric, and character data types.

The boolean data type:

The boolean data type is used to store data with only two possible values. These two possible values may be thought of as yes/no, 0/1, true/false, or any other combination. The actual values that a boolean can store are true and false.
true and false are literal values.
A literal is a fixed value that doesn’t need further calculations to be assigned to any variable.

Numeric data types:

Numeric values can be stored as either integers or decimal numbers.
byte, short, int, and long can be used to store integers.
The byte, short, int, and long data types use 8, 16, 32, and 64 bits, respectively, to store their values.
float and double can be used to store decimal numbers.
The float and double data types use 32 and 64 bits, respectively, to store their values.
The default type of integers—that is, nondecimal numbers—is int.
To designate an integer literal value as a long value, add the suffix L or l to the literal value.
Numeric values can be stored in binary, octal, decimal, and hexadecimal number formats. This exam won’t ask you to convert a number from one number system to another.
Literal values in the decimal number system use digits from 0 to 9 (a total of 10 digits).
Literal values in the octal number system use digits from 0 to 7 (a total of 8 digits).
Literal values in the hexadecimal number system use digits from 0 to 9 and letters from A to F (a total of 16 digits and letters).
Literal values in the binary number system use digits 0 and 1 (a total of 2 digits).
The literal values in the octal number system start with the prefix 0. For example, 0413 in the octal number system is 267 in the decimal number system.
The literal values in the hexadecimal number system start with the prefix 0x. For example, 0x10B in the hexadecimal number system is 267 in the decimal number system.
The literal values in the binary number system start with the prefix 0b or 0B. For example, the decimal value 267 is 0B100001011 in the binary system.
Starting with Java 7, you can use underscores within the Java literal values to make them more readable. 0B1_0000_10_11, 0_413, and 0x10_B are valid binary, octal, and hexadecimal literal values.
The default type of a decimal number is double.
To designate a decimal literal value as a float value, add the suffix F or f to the literal value.
The suffixes D and d can be used to mark a literal value as a double value. Though it’s allowed, doing so is not required because the default value of decimal literals is double.

Character primitive data types:

A char data type can store a single 16-bit Unicode character; that is, it can store characters from virtually all the world’s existing scripts and languages.
You can use values from \u0000 (or 0) to a maximum of \uffff (or 65,535 inclusive) to store a char. Unicode values are defined in the hexadecimal number system.
Internally, the char data type is stored as an unsigned integer value (only positive integers).
When you assign a letter to a char, Java stores its integer equivalent value. You may assign a positive integer value to a char instead of a letter, such as 122.
The literal value 122 is not the same as the Unicode value \u0122. The former is a decimal number and the latter is a hexadecimal number.
Single quotes, not double quotes, are used to assign a letter to a char variable.

Valid identifiers:

A valid identifier starts with a letter (a–z, upper- or lowercase), a currency sign, or an underscore. There is no limit to its length.
A valid identifier can contain digits but not in the starting place.
A valid identifier can use the underscore and currency sign at any position of the identifier.
A valid identifier can’t have the same spelling as a Java keyword, such as switch.
A valid identifier can’t use any special characters, including !, @, #, %, ^, &, *, (, ), ', :, ;, [, /, \, and }.

Assignment operators:

Assignment operators can be used to assign or reassign values to all types of variables.
A variable can’t be assigned to an incompatible value. For example, character and numeric values can’t be assigned to a boolean variable and vice versa.
+= and -= are short forms of addition/subtraction and assignment.
+= can be read as “first add and then assign” and -= can be read as “first subtract and then assign.”

Arithmetic operators:

Arithmetic operators can’t be used with the boolean data type. Attempting to do so will make the code fail to compile.
++ and –- are unary increment and decrement operators. These operators work with single operands.
Unary operators can be used in prefix or postfix notation.
When the unary operators ++ and -- are used in prefix notation, the value of the variable increments/decrements just before the variable is used in an expression.
When the unary operators ++ and -- are used in postfix notation, the value of the variable increments/decrements just after the variable is used in an expression.
By default, unary operators have a higher precedence than multiplication operators and addition operators.

Relational operators:

Relational operators are used to compare values for equality (==) and inequality (!=). They’re also used to determine whether two numeric values are greater than (>, >=) or less than (<, <=) each other.
You can’t compare incomparable values. For example, you can’t compare a boolean with an int, a char, or a floating-point number. If you try to do so, your code will not compile.
The operators equal to (==) and not equal to (!=) can be used to compare all types of primitives: char, byte, short, int, long, float, double, and boolean.
The operator == returns true if the primitive values being compared are equal.
The operator != returns true if the primitive values being compared are not equal.
The result of the relational operator is always a boolean value.

Logical operators:

You can use the logical operators to determine whether a set of conditions is true or false and proceed accordingly.
Logical AND (&&) evaluates to true if all operands are true and false otherwise.
Logical OR (||) evaluates to true if any or all the operands are true.
Logical negation (!) negates the boolean value. It evaluates to true for false and vice versa.
The result of a logical operation is always a boolean value.
The logical operators && and || are also called short-circuit operators. If these operators can determine the output of the expression with the evaluation of the first operand, they don’t evaluate the second operand.
The && operator returns true only if both of the operands are true. If the first operand to this operator evaluates to false, the result can never be true. Therefore, && does not evaluate the second operand.
Similarly, the || operator returns true if any of the operands is true. If the first operand to this operator evaluates to true, the result can never be false. Therefore, || does not evaluate the second operator.

Wrapper classes:

The wrapper classes are used to wrap primitives in an object, so they can be added to a collection object.
All the wrapper classes are immutable.
You can create objects of all the wrapper classes in multiple ways:
- Assignment—By assigning a primitive to a wrapper class variable (autoboxing)
- Constructor—By using wrapper class constructors
- Static methods—By calling the static method of wrapper classes, like valueOf()
All wrapper classes (except Character) define a constructor that accepts a String argument representing the primitive value that needs to be wrapped.
None of the wrapper class defines a no-argument constructor.
You can assign a primitive value directly to a reference variable of its wrapper class type, called autoboxing. The reverse is unboxing, when an object of a primitive wrapper class is converted to its corresponding primitive value.
All wrapper classes define methods of the format primitive Value(), where the term primitive refers to the exact primitive data type name.
To get a primitive data type value corresponding to a string value, you can use the static utility method parseDataType, where DataType refers to the type of the return value.
The valueOf() method returns an object of the corresponding wrapper class when it’s passed an argument of a primitive type or String.
You can compare objects of wrapper classes for equality by using the method equals or the comparison operator, ==.
The method equals always compares the primitive value stored by a wrapper instance and == compares object references. The operator == returns true if the variables being compared refer to the same instance.
In the case of the Boolean class, the cached instances are accessible directly because only two exist: the static constants Boolean.TRUE and Boolean.FALSE.
The Character class caches instances with values from 0 to 127. Classes Byte, Short, Integer, and Long cache instances for values -128 to 127. No cached instances exist for the Float and Double wrapper classes.
Wrapper classes are immutable. Adding a primitive value to a wrapper class variable doesn’t modify the value of the object it refers to. The wrapper class variable is assigned a new object.
Unboxing a wrapper reference variable, which refers to null, will throw a NullPointerException.

2.8. Sample exam questions

Q2-1.

Given:

int myChar = 97;
int yourChar = 98;
System.out.print((char)myChar + (char)yourChar);

int age = 20;
System.out.print(" ");
System.out.print((float)age);

What is the output?

195 20.0
195 20
ab 20.0
ab 20
Compilation error
Runtime exception

Q2-2.

Which of the options are correct for the following code?

public class Prim {                                // line 1
    public static void main(String[] args) {       // line 2
        char a = 'a';                              // line 3
        char b = -10;                              // line 4
        char c = '1';                              // line 5
        integer d = 1000;                          // line 6
        System.out.println(++a + b++ * c - d);     // line 7
    }                                              // line 8
}                                                  // line 9

Code at line 4 fails to compile.
Code at line 5 fails to compile.
Code at line 6 fails to compile.
Code at line 7 fails to compile.

Q2-3.

What is the output of the following code?

public class Foo {
    public static void main(String[] args) {
        int a = 10;
        long b = 20;
        short c = 30;
        System.out.println(++a + b++ * c);
    }
}

611
641
930
960

Q2-4.

Given:

Boolean buy = new Boolean(true);
Boolean sell = new Boolean(true);

System.out.print(buy == sell);
boolean buyPrim = buy.booleanValue();
System.out.print(!buyPrim);

System.out.print(buy && sell);

What is the output?

falsefalsefalse
truefalsetrue
falsetruetrue
falsefalsetrue
Compilation error
Runtime exception

Q2-5.

Which of the following options contain correct code to declare and initialize variables to store whole numbers?

bit a = 0;
integer a2 = 7;
long a3 = 0x10C;
short a4 = 0512;
double a5 = 10;
byte a7 = -0;
long a8 = 123456789;

Q2-6.

Select the options that, when inserted at // INSERT CODE HERE, will make the following code output a value of 11:

public class IncrementNum {
    public static void main(String[] args) {
        int ctr = 50;
        // INSERT CODE HERE
        System.out.println(ctr % 20);
    }
}

ctr += 1;
ctr =+ 1;
++ctr;
ctr = 1;

Q2-7.

What is the output of the following code?

int a = 10;
int b = 20;
int c = (a * (b + 2)) - 10-4 * ((2*2) - 6;
System.out.println(c);

218
232
246
Compilation error

Q2-8.

What is true about the following lines of code?

boolean b = false;
int i = 90;
System.out.println(i >= b);

Code prints true
Code prints false
Code prints 90 >= false
Compilation error

Q2-9.

Examine the following code and select the correct options:

public class Prim {                                          // line 1
    public static void main(String[] args) {                 // line 2
        int num1 = 12;                                       // line 3
        float num2 = 17.8f;                                  // line 4
        boolean eJavaResult = true;                          // line 5
        boolean returnVal = num1 >= 12 && num2 < 4.567       // line 6
                             || eJavaResult == true;
        System.out.println(returnVal);                       // line 7
    }                                                        // line 8
}                                                            // line 9

Code prints false
Code prints true

Code will print true if code on line 6 is modified to the following:

boolean returnVal = (num1 >= 12 && num2 < 4.567) || eJavaResult == true;

Code will print true if code on line 6 is modified to the following:

boolean returnVal = num1 >= 12 && (num2 < 4.567 || eJavaResult == false);

Q2-10.

Given:

boolean myBool = false;                               // line 1
int yourInt = 10;                                     // line 2
float hisFloat = 19.54f;                              // line 3
System.out.println(hisFloat = yourInt);               // line 4
System.out.println(yourInt > 10);                     // line 5
System.out.println(myBool = false);                   // line 6

What is the result?

```
true
true
false
```
```
10.0
false
false
```
```
false
false
false
```
Compilation error

2.9. Answers to sample exam questions

Q2-1.

Given:

int myChar = 97;
int yourChar = 98;
System.out.print((char)myChar + (char)yourChar);

int age = 20;
System.out.print(" ");
System.out.print((float)age);

What is the output?

195 20.0
195 20
ab 20.0
ab 20
Compilation error
Runtime exception

Answer: a

Explanation: When a char primitive data type is used as an operand to arithmetic operators, its corresponding ASCII value is used in the arithmetic operation. Though (char)myChar explicitly casts int variable myChar to char type, its value 97 is used in the arithmetic operation. When literal value 20 is explicitly cast to a float type, it outputs its value as a decimal number, that is, 20.0.

Q2-2.

Which of the options are correct for the following code?

public class Prim {                                // line 1
    public static void main(String[] args) {       // line 2
        char a = 'a';                              // line 3
        char b = -10;                              // line 4
        char c = '1';                              // line 5

        integer d = 1000;                          // line 6
        System.out.println(++a + b++ * c - d);     // line 7
    }                                              // line 8
}                                                  // line 9

Code at line 4 fails to compile.
Code at line 5 fails to compile.
Code at line 6 fails to compile.
Code at line 7 fails to compile.

Answer: a, c, d

Explanation: Option (a) is correct. The code at line 4 fails to compile because you can’t assign a negative value to a primitive char data type without casting.

Option (c) is correct. There is no primitive data type with the name “integer.” The valid data types are int and Integer (a wrapper class with I in uppercase).

Option (d) is correct. The variable d remains undefined on line 7 because its declaration fails to compile on line 6. So the arithmetic expression (++a + b++ * c - d) that uses variable d fails to compile. There are no issues with using the variable c of the char data type in an arithmetic expression. The char data types are internally stored as unsigned integer values and can be used in arithmetic expressions.

Q2-3.

What is the output of the following code?

public class Foo {
    public static void main(String[] args) {
        int a = 10;
        long b = 20;
        short c = 30;
        System.out.println(++a + b++ * c);
    }
}

611
641
930
960

Answer: a

Explanation: The prefix increment operator (++) used with the variable a will increment its value before it’s used in the expression ++a + b++ * c. The postfix increment operator (++) used with the variable b will increment its value after its initial value is used in the expression ++a + b++ * c.

Therefore, the expression ++a + b++ * c evaluates with the following values:

11 + 20 * 30

Because the multiplication operator has a higher precedence than the addition operator, the values 20 and 30 are multiplied before the result is added to the value 11. The example expression evaluates as follows:

(++a + b++ * c)
= 11 + 20 * 30
= 11 + 600
= 611

Exam Tip

Although questions 2-2 and 2-3 seemed to test you on your understanding of operators, they actually tested you on different topics. Question 2-2 tested you on the name of the primitive data types. Beware! The real exam has many such questions. A question that may seem to test you on threads may actually be testing you on the use of a do-while loop!

Q2-4.

Given:

What is the output?

falsefalsefalse
truefalsetrue
falsetruetrue
falsefalsetrue
Compilation error
Runtime exception

Answer: d

Explanation: The Boolean instances buy and sell are created using constructors. Constructors don’t refer to existing instances in cache; they create new instances. Because the comparison operator == compares object references and not the primitive value stored by a wrapper instance, buy == sell returns false.

The method booleanValue() can be used to get the primitive boolean value stored by a Boolean wrapper instance. So buy.booleanValue() returns false. Because wrapper instances can be used with arithmetic and logical operators, buy && sell compiles, returning true.

Q2-5.

Which of the following options contain correct code to declare and initialize variables to store whole numbers?

bit a = 0;
integer a2 = 7;
long a3 = 0x10C;
short a4 = 0512;
double a5 = 10;
byte a7 = -0;
long a8 = 123456789;

Answer: c, d, f, g

Explanation: Options (a) and (b) are incorrect. There are no primitive data types in Java with the names bit and integer. The correct names are byte and int.

Option (c) is correct. It assigns a hexadecimal literal value to the variable a3.

Option (d) is correct. It assigns an octal literal value to the variable a4.

Option (e) is incorrect. It defines a variable of type double, which is used to store decimal numbers, not integers.

Option (f) is correct. -0 is a valid literal value.

Option (g) is correct. 123456789 is a valid integer literal value that can be assigned to a variable of type long.

Q2-6.

Select the options that, when inserted at // INSERT CODE HERE, will make the following code output a value of 11:

ctr += 1;
ctr =+ 1;
++ctr;
ctr = 1;

Answer: a, c

Explanation: To output a value of 11, the value of the variable ctr should be 51 because 51%20 is 11. Operator % outputs the remainder from a division operation. The current value of the variable ctr is 50. It can be incremented by 1 using the correct assignment or increment operator.

Option (b) is incorrect. Java does not define a =+ operator. The correct operator is +=.

Option (d) is incorrect because it’s assigning a value of 1 to the variable result, not incrementing it by 1.

Q2-7.

What is the output of the following code?

218
232
246
Compilation error

Answer: d

Explanation: First of all, whenever you answer any question that uses parentheses to override operator precedence, check whether the number of opening parentheses matches the number of closing parentheses. This code won’t compile because the number of opening parentheses doesn’t match the number of closing parentheses.

Second, you may not have to answer complex expressions in the real exam. Whenever you see overly complex code, look for other possible issues in the code. Complex code may be used to distract your attention from the real issue.

Q2-8.

What is true about the following lines of code?

Code prints true
Code prints false
Code prints 90 >= false
Compilation error

Answer: d

Explanation: The code will fail to compile; hence, it can’t execute. You can’t compare incomparable types, such as a boolean value with a number.

Q2-9.

Examine the following code and select the correct options:

Code prints false
Code prints true

Code will print true if code on line 6 is modified to the following:

boolean returnVal = (num1 >= 12 && num2 < 4.567) || eJavaResult == true;
!@%STYLE%@!
{"css":"{\"css\": \"font-weight: bold;\"}","target":"[[{\"line\":0,\"ch\":0},{\"line\":0,\"ch\":72}]]"}
!@%STYLE%@!

Code will print true if code on line 6 is modified to the following:

boolean returnVal = num1 >= 12 && (num2 < 4.567 || eJavaResult == false);

Answer: b, c

Explanation: Option (a) is incorrect because the code prints true.

Option (d) is incorrect because the code prints false.

The code in option (c) uses parentheses to indicate which expression should evaluate prior to the rest. Here are the steps of execution:

The original code in the question doesn’t use parentheses to group the expressions. In this case, because the operator && has a higher operator precedence than ||, the expression 'num1 >= 12 && num2 < 4.567' will be the first expression to execute. Here are the steps of execution:

Q2-10.

Given:

What is the result?

```
true
true
false
```
10.0 false false
```
false
false
false
```
Compilation error

Answer: b

Explanation: The expression myBool = false uses the assignment operator (=) and not a comparison operator (==). This expression assigns the boolean literal false to myBool; it doesn’t compare false with myBool. Watch out for similar (trick) assignments in the exam, which may seem to be comparing values.

Boolean buy = new Boolean(true);
Boolean sell = new Boolean(true);
System.out.print(buy == sell);

boolean buyPrim = buy.booleanValue();
System.out.print(!buyPrim);

System.out.print(buy && sell);

public class IncrementNum {
    public static void main(String[] args) {
        int ctr = 50;
        // INSERT CODE HERE
        System.out.println(ctr % 20);
    }
}

int a = 10;
int b = 20;
int c = (a * (b + 2)) - 10-4 * ((2*2) - 6;
System.out.println(c);

boolean b = false;
int i = 90;
System.out.println(i >= b);

public class Prim {                                          // line 1
    public static void main(String[] args) {                 // line 2
        int num1 = 12;                                       // line 3
        float num2 = 17.8f;                                  // line 4

        boolean eJavaResult = true;                          // line 5
        boolean returnVal = num1 >= 12 && num2 < 4.567       // line 6
                             || eJavaResult == true;
        System.out.println(returnVal);                       // line 7
    }                                                        // line 8
}                                                            // line 9

boolean returnVal = (num1 >= 12 && num2 < 4.567) || eJavaResult == true;
returnVal = false || eJavaResult == true;
returnVal = true;

boolean returnVal = num1 >= 12 && num2 < 4.567 || eJavaResult == true;
returnVal = false || eJavaResult == true;
returnVal = true;

boolean myBool = false;                               // line 1
int yourInt = 10;                                     // line 2
float hisFloat = 19.54f;                              // line 3
System.out.println(hisFloat = yourInt);               // line 4
System.out.println(yourInt > 10);                     // line 5
System.out.println(myBool = false);                   // line 6

Chapter 2. Working with Java data types

This chapter covers:

2.1. Primitive variables

Figure 2.1. Matching a value with its corresponding type

Table 2.1. Matching a value with its corresponding data type

Note

Figure 2.2. Categorization of primitive data types

2.1.1. Category: Boolean

Table 2.2. Suitable data that can be stored using a boolean data type

Exam Tip

Figure 2.3. Defining and assigning a primitive variable

Note

2.1.2. Category: signed numeric

Integers: byte, int, short, long

Table 2.3. Data that can be categorized as numeric (nondecimal numbers) data type

Table 2.4. Ranges of values stored by the signed numeric Java primitive data types

Figure 2.4. Converting an integer from decimal to octal

Figure 2.5. Converting an integer from decimal to hexadecimal

Figure 2.6. Converting an integer from decimal to binary

Exam Tip

Rules to remember

Twist in the Tale 2.1

Floating-point numbers: float and double

Table 2.5. Data that’s stored as floating-point numbers

Table 2.6. Range of values for decimal numbers

2.1.3. Category: character (unsigned integer)

Figure 2.7. Never use double quotes to assign a letter as a char value.

Exam Tip

Note

Figure 2.8. The output of assigning a character using the integer value 122 versus the Unicode value \u0122

Figure 2.9. The output of assigning a negative value to a character variable

Exam Tip

2.1.4. Confusion with the names of the primitive data types

Exam Tip

2.2. Identifiers

2.2.1. Valid and invalid identifiers

Table 2.7. Ingredients of valid and invalid identifiers

Table 2.8. Java keywords and reserved words that can’t be used as names for Java variables

2.3. Object reference variables

2.3.1. What are object reference variables?

Figure 2.10. The creation and assignment of a reference variable

Figure 2.11. An object reference variable and the referenced object in memory

Figure 2.12. Dog leash analogy for understanding objects

Note

2.3.2. Differentiating between object reference variables and primitive variables

Figure 2.13. Primitive variables store the actual values, whereas object reference variables store the addresses of the objects they refer to.

Figure 2.14. Differences between object reference variables and primitive variables

2.4. Operators

Table 2.9. Operator types and the relevant operators

Note

2.4.1. Assignment operators

Figure 2.15. Assigning a bigger value (long) to a variable (int) that’s only capable of storing a smaller value range

Figure 2.16. Assigning a smaller value (int) to a variable (long) that’s capable of storing a larger value range

Exam Tip

Twist in the Tale 2.2

2.4.2. Arithmetic operators

Table 2.10. Use of arithmetic operators with examples

Exam Tip

Exam Tip

Implicit widening of data types in an arithmetic operation

Exam Tip

++ and -- (unary increment and decrement operators)

Figure 2.17. Evaluation of an expression that has multiple occurrences of unary operators in postfix and prefix notation

Twist in the Tale 2.3

2.4.3. Relational operators

Exam Tip

Comparing primitives for equality (using == and !=)

Exam Tip

Comparing primitives using the assignment operator (=)

Note

2.4.4. Logical operators

Table 2.11. Outcome of using boolean literal values with the logical operators AND, OR, and NOT

&& and || are short-circuit operators

Note

Twist in the Tale 2.4

Example use of the short-circuit operator && in real projects

2.4.5. Operator precedence

Table 2.12. Precedence of operators

Note

Note

Table 2.2. Suitable data that can be stored using a `boolean` data type

Figure 2.7. Never use double quotes to assign a letter as a `char` value.

Figure 2.8. The output of assigning a character using the integer value `122` versus the Unicode value `\u0122`

Figure 2.15. Assigning a bigger value (`long`) to a variable (`int`) that’s only capable of storing a smaller value range

Figure 2.16. Assigning a smaller value (`int`) to a variable (`long`) that’s capable of storing a larger value range

Table 2.11. Outcome of using `boolean` literal values with the logical operators `AND`, `OR`, and `NOT`

Example use of the short-circuit operator `&&` in real projects