జావాలో న్యూమరిక్ ఆపరేటర్లు

హాయ్! ఈ రోజు మనం చాలా ముఖ్యమైన అంశాన్ని పరిశీలిస్తాము, అవి జావాలోని సంఖ్యా ఆపరేటర్లు . ప్రోగ్రామింగ్‌లో, సంఖ్యలు ప్రతిచోటా ఉంటాయి. మీరు లోతుగా త్రవ్వి, ఉన్నత పాఠశాలను గుర్తుంచుకుంటే, కంప్యూటర్ మొత్తం సమాచారాన్ని సంఖ్యా ఆకృతిలో సూచిస్తుందని మీరు గుర్తుచేసుకోవచ్చు: సున్నాలు మరియు వాటి కలయికలు, బైనరీ కోడ్ అని కూడా పిలుస్తారు. ప్రోగ్రామింగ్‌లో చాలా సంఖ్యా ఆపరేటర్‌లు ఉన్నారు, కాబట్టి వాటిలో ముఖ్యమైన వాటిని అన్వేషించడానికి మేము ఉదాహరణలను ఉపయోగిస్తాము :) సరళమైన వాటితో ప్రారంభిద్దాం: అంకగణిత ఆపరేటర్లు . ఇవి బాగా తెలిసిన సంకలనం ( +), తీసివేత ( -), గుణకారం ( *) మరియు భాగహారం ( /) ఆపరేటర్లు.

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = 33;

       System.out.println(x+y);
       System.out.println(x-y);
       System.out.println(x*y);
       System.out.println(x/y);
   }
}

కన్సోల్ అవుట్‌పుట్: 1032 966 32967 30 మీరు ఇప్పటికే ఇవన్నీ ఉపయోగించారు. ఈ సమూహానికి, మీరు మిగిలిన లేదా మాడ్యులో ( ) ఆపరేటర్‌కి జోడించవచ్చు %.

public class Main {

   public static void main(String[] args) {

       int x = 33;
       int y = 33%2;
       System.out.println(y);
   }
}

కన్సోల్ అవుట్‌పుట్: 1 ఈ ఉదాహరణలో, మేము 33ని 2తో భాగిస్తాము. ఇది 2చే భాగించబడని అదనపు "తోక" (ఒకటి)తో 16ని ఇస్తుంది. ఈ "టెయిల్" అనేది "విభజన నుండి మిగిలిన" ఆపరేషన్ యొక్క ఫలితం. జావా కంపారిజన్/రిలేషనల్ ఆపరేటర్‌లను కూడా అమలు చేస్తుంది (గణితంలో వలె). వారు మీకు పాఠశాల నుండి కూడా సుపరిచితులు కావచ్చు:

• ==( ) కి సమానం
• >( ) కంటే ఎక్కువ
• <( ) కంటే తక్కువ
• >=( ) కంటే ఎక్కువ లేదా సమానం
• <=( ) కంటే తక్కువ లేదా సమానం
• సమానం కాదు ( !=)

ఇక్కడ మీరు చాలా మంది ప్రారంభకులకు తప్పులు చేయడానికి కారణమయ్యే ఒక ముఖ్యమైన అంశానికి శ్రద్ధ వహించాలి. "సమానాలు" ఆపరేటర్ వ్రాయబడింది ==, కాదు =. జావాలో, సింగిల్ =అనేది అసైన్‌మెంట్ ఆపరేటర్, ఇది వేరియబుల్‌కు నంబర్, స్ట్రింగ్ లేదా మరొక వేరియబుల్ విలువను కేటాయించినప్పుడు ఉపయోగించబడుతుంది .

public class Main {

   public static void main(String[] args) {

       int x = 33;
       int y = 999;
       System.out.println(x=y);// We expect false to be displayed
   }
}

కన్సోల్ అవుట్‌పుట్: 999 అయ్యో! ఇది మనం ఆశించిన ఫలితం కాదు. ఇది పూర్తిగా భిన్నమైన డేటా రకం: మేము బూలియన్‌ని చూడాలని అనుకున్నాము , కానీ మాకు ఒక సంఖ్య వచ్చింది. అన్నీ ఎందుకంటే మేము కుండలీకరణాల్లో పోలికకు బదులుగా అసైన్‌మెంట్ ఆపరేటర్‌ని ఉపయోగించాము . (999) విలువ వేరియబుల్‌కు కేటాయించబడింది , ఆపై మేము విలువను ప్రదర్శిస్తాము . దీన్ని చేయడానికి సరైన మార్గం ఇక్కడ ఉంది: x=yyxx

public class Main {

   public static void main(String[] args) {

       int x = 33;
       int y = 999;
       System.out.println(x==y);
   }
}

కన్సోల్ అవుట్‌పుట్: తప్పు ఇప్పుడు మేము రెండు సంఖ్యలను సరిగ్గా పోల్చాము! :) అసైన్‌మెంట్ ఆపరేటర్ ( =) యొక్క మరొక ఫీచర్ ఇక్కడ ఉంది: దీనిని "చైన్" చేయవచ్చు:

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = 33;
       int z = 256;

       x = y = z;
       System.out.println(x);
   }
}

కన్సోల్ అవుట్‌పుట్: 256 అసైన్‌మెంట్ కుడి నుండి ఎడమకు అని గుర్తుంచుకోండి . ఈ వ్యక్తీకరణ ( x = y = z) దశల్లో అమలు చేయబడుతుంది:

• y = z, అంటే,y = 256
• x = y, అంటే,x = 256

Unary ఆపరేటర్లు.

వాటిని " ఉనో " అనే పదం నుండి " యూనరీ " అని పిలుస్తారు , దీని అర్థం " ఒకటి ". మునుపటి ఆపరేటర్ల వలె కాకుండా, వారు ఒకే సంఖ్యలో పని చేస్తారు, అనేకం కాదు కాబట్టి వారికి ఈ పేరు వచ్చింది. వీటితొ పాటు:

• యునారీ మైనస్. ఇది సంఖ్య యొక్క చిహ్నాన్ని తిప్పుతుంది.

public class Main {

   public static void main(String[] args) {

       int x = 999;

       // Change the sign for the first time
       x = -x;
       System.out.println(x);

       // Change the sign for the second time
       x= -x;
       System.out.println(x);
   }
}

కన్సోల్ అవుట్‌పుట్: -999 999 మేము యునరీ మైనస్ ఆపరేటర్‌ని రెండుసార్లు ఉపయోగించాము. ఫలితంగా, మా సంఖ్య మొదట ప్రతికూలంగా ఉంది, ఆపై అది మళ్లీ సానుకూలంగా మారింది!

• పెంపు (++) మరియు తగ్గింపు (--)

ఆపరేటర్ ++ఒక సంఖ్యను పెంచుతాడు మరియు --ఆపరేటర్ ఒక సంఖ్యను అదే మొత్తంలో తగ్గిస్తాడు.

public class Main {

   public static void main(String[] args) {

       int x = 999;
       x++;
       System.out.println(x);

       x--;
       System.out.println(x);
   }
}

కన్సోల్ అవుట్‌పుట్: 1000 999 మీరు C++ భాష గురించి విన్నట్లయితే ఈ సంజ్ఞామానం మీకు తెలిసి ఉండవచ్చు. "C++ అనేది C లాంగ్వేజ్ యొక్క పొడిగింపు" అనే ఆలోచనను తెలియజేయడానికి దీని సృష్టికర్తలు ఈ ఆసక్తికరమైన పేరును ఉపయోగించారు" నోట్‌ప్యాడ్ యొక్క ప్రసిద్ధ మెరుగుపరచబడిన సంస్కరణ నోట్‌ప్యాడ్ ++ ఇక్కడ ఒక ముఖ్యమైన విషయం ఉంది. ఇంక్రిమెంట్ మరియు డిక్రిమెంట్ ఆపరేటర్లలో రెండు రకాలు ఉన్నాయి: పోస్ట్‌ఫిక్స్ మరియు ప్రిఫిక్స్ . x++- పోస్ట్‌ఫిక్స్ ++x- ఉపసర్గ సంఖ్యకు ముందు లేదా తర్వాత ప్లస్‌లు/మైనస్‌లను పెట్టడం మధ్య ప్రాథమిక తేడా ఏమిటి? మేము ఈ క్రింది ఉదాహరణలో చూస్తాము:

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = x++;
       System.out.println(y);
   }
}

కన్సోల్ అవుట్‌పుట్: 999 ఏదో సరిగ్గా లేదు! మేము 1 ద్వారా పెంచాలనుకుంటున్నాము xమరియు వేరియబుల్ yకి కొత్త విలువను కేటాయించాలనుకుంటున్నాము. మరో మాటలో చెప్పాలంటే, y 1000 అయి ఉండాలి. కానీ దానికి బదులుగా మనం వేరొకదాన్ని పొందుతాము: 999. x పెంచబడనట్లు మరియు ఇంక్రిమెంట్ ఆపరేటర్ పని చేయనట్లు కనిపిస్తోంది? కానీ అది పని చేసింది. మిమ్మల్ని మీరు ఒప్పించుకోవడానికి, xచివరిలో ప్రదర్శించడానికి ప్రయత్నించండి :)

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = x++;
       System.out.println(y);
       System.out.println(x);
   }
}

కన్సోల్ అవుట్‌పుట్: 999 1000 వాస్తవానికి, ఈ ఆపరేషన్‌ను పోస్ట్‌ఫిక్స్ అని పిలుస్తారు: ఇది ప్రధాన వ్యక్తీకరణ తర్వాత నిర్వహించబడుతుంది. దీని అర్థం, మన విషయంలో: int y = x++; y = xముందుగా నిర్వహించబడుతుంది (మరియు వేరియబుల్ yవిలువకు ప్రారంభించబడుతుంది x), ఆపై మాత్రమే x++అమలు చేయబడుతుంది, ఇది మనకు కావలసిన ప్రవర్తన కాకపోతే? అప్పుడు మనం ఉపసర్గ సంజ్ఞామానాన్ని ఉపయోగించాలి :

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = ++x;
       System.out.println(y);
   }
}

ఈ సందర్భంలో, ++xమొదట ప్రాసెస్ చేయబడుతుంది మరియు తర్వాత మాత్రమే y = x; అమలు చేశారు. పోస్ట్‌ఫిక్స్‌కు బదులుగా ఉపసర్గను ఉపయోగించడం ద్వారా ప్రతిదీ తలక్రిందులుగా చేసే నిజమైన ప్రోగ్రామ్‌లో పొరపాట్లు చేయకుండా ఉండటానికి మీరు ఈ వ్యత్యాసాన్ని వెంటనే మెమరీకి అప్పగించాలి :)

కాంపౌండ్ ఆపరేటర్లు

అదనంగా, జావాలో సమ్మేళనం ఆపరేటర్లు అని పిలవబడేవి ఉన్నాయి. వారు ఇద్దరు ఆపరేటర్లను మిళితం చేస్తారు:

• అప్పగింత
• అరిథ్మెటిక్ ఆపరేటర్లు

వీటితొ పాటు:

• +=
• -=
• *=
• /=
• %=

ఒక ఉదాహరణను పరిశీలిద్దాం:

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = 33;

       x += y;
       System.out.println(x);
   }
}

కన్సోల్ అవుట్‌పుట్: 1032 x += y అంటే x = x + y. సంక్షిప్తత కోసం రెండు చిహ్నాలు వరుసగా ఉపయోగించబడతాయి. కలయికలు -=, *=మరియు ఇదే విధంగా పని చేస్తాయి /=.%=

లాజికల్ ఆపరేటర్లు

సంఖ్యా ఆపరేటర్లతో పాటు, జావా కూడా బూలియన్ విలువలను కలిగి ఉన్న కార్యకలాపాలను కలిగి ఉంది ( ఒప్పు మరియు తప్పు ). ఈ కార్యకలాపాలు లాజికల్ ఆపరేటర్లను ఉపయోగించి నిర్వహించబడతాయి

• !- తార్కికం కాదు . ఇది బూలియన్ విలువను తిప్పికొడుతుంది

public class Main {

   public static void main(String[] args) {

       boolean x = true;
       System.out.println(!x);
   }
}

కన్సోల్ అవుట్‌పుట్: తప్పు

• &&- తార్కిక మరియు . రెండు ఒపెరాండ్‌లు నిజమైతే మాత్రమే ఇది నిజం అని తిరిగి వస్తుంది .

public class Main {

   public static void main(String[] args) {

       System.out.println(100 > 10 && 100 > 200);
       System.out.println(100 > 50 && 100 >= 100);
   }
}

కన్సోల్ అవుట్‌పుట్: తప్పు నిజం మొదటి ఆపరేషన్ యొక్క ఫలితం తప్పు, ఎందుకంటే ఒపెరాండ్‌లలో ఒకటి తప్పు, అవి 100 > 200. ఒప్పు అని తిరిగి ఇవ్వడానికి, &&ఆపరేటర్‌కు రెండు ఒపెరాండ్‌లు నిజమైనవి (రెండవ పంక్తిలో ఉన్నట్లుగా) అవసరం.

• ||- తార్కిక OR . ఒపెరాండ్‌లలో కనీసం ఒక్కటైనా నిజం అయినప్పుడు ఇది నిజం అని తిరిగి వస్తుంది .

మేము ఈ ఆపరేటర్‌ని ఉపయోగించినప్పుడు, మా మునుపటి ఉదాహరణ వేరొక ఫలితాన్ని అందిస్తుంది:

public class Main {

   public static void main(String[] args) {

       System.out.println(100 > 10 || 100 > 200);
   }
}

కన్సోల్ అవుట్‌పుట్: నిజం వ్యక్తీకరణ 100 > 200ఇప్పటికీ తప్పు, కానీ OR ఆపరేటర్‌కు మొదటి భాగం ( 100 > 10) నిజం అయితే పూర్తిగా సరిపోతుంది.