హాయ్! ఈ రోజు మనం చాలా ముఖ్యమైన అంశాన్ని పరిశీలిస్తాము, అవి జావాలోని సంఖ్యా ఆపరేటర్లు .
![జావాలో న్యూమరిక్ ఆపరేటర్లు - 1]()
ప్రోగ్రామింగ్‌లో, సంఖ్యలు ప్రతిచోటా ఉంటాయి. మీరు లోతుగా త్రవ్వి, ఉన్నత పాఠశాలను గుర్తుంచుకుంటే, కంప్యూటర్ మొత్తం సమాచారాన్ని సంఖ్యా ఆకృతిలో సూచిస్తుందని మీరు గుర్తుచేసుకోవచ్చు: సున్నాలు మరియు వాటి కలయికలు, బైనరీ కోడ్ అని కూడా పిలుస్తారు.
![జావాలో న్యూమరిక్ ఆపరేటర్లు - 2]()
ప్రోగ్రామింగ్‌లో చాలా సంఖ్యా ఆపరేటర్లు ఉన్నారు, కాబట్టి వాటిలో ముఖ్యమైన వాటిని అన్వేషించడానికి మేము ఉదాహరణలను ఉపయోగిస్తాము :) సరళమైన వాటితో ప్రారంభిద్దాం: అంకగణిత ఆపరేటర్లు . ఇవి బాగా తెలిసిన సంకలనం (
![జావాలో న్యూమరిక్ ఆపరేటర్లు - 3]()
+), తీసివేత ( -), గుణకారం ( *) మరియు భాగహారం ( /) ఆపరేటర్లు.
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);
}
}
%.
public class Main {
public static void main(String[] args) {
int x = 33;
int y = 33%2;
System.out.println(y);
}
}
==( ) కి సమానం>( ) కంటే ఎక్కువ<( ) కంటే తక్కువ>=( ) కంటే ఎక్కువ లేదా సమానం<=( ) కంటే తక్కువ లేదా సమానం- సమానం కాదు (
!=)
==, కాదు =. జావాలో, సింగిల్ =అనేది అసైన్‌మెంట్ ఆపరేటర్, ఇది వేరియబుల్‌కు నంబర్, స్ట్రింగ్ లేదా మరొక వేరియబుల్ విలువను కేటాయించినప్పుడు ఉపయోగించబడుతుంది .
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
}
}
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);
}
}
x = y = z) దశల్లో అమలు చేయబడుతుంది:
y = z, అంటే,y = 256x = 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);
}
}
- పెంపు (++) మరియు తగ్గింపు (--)
++ఒక సంఖ్యను పెంచుతాడు మరియు --ఆపరేటర్ ఒక సంఖ్యను అదే మొత్తంలో తగ్గిస్తాడు.
public class Main {
public static void main(String[] args) {
int x = 999;
x++;
System.out.println(x);
x--;
System.out.println(x);
}
}
x++- పోస్ట్‌ఫిక్స్ ++x- ఉపసర్గ సంఖ్యకు ముందు లేదా తర్వాత ప్లస్‌లు/మైనస్‌లను పెట్టడం మధ్య ప్రాథమిక తేడా ఏమిటి? మేము ఈ క్రింది ఉదాహరణలో చూస్తాము:
public class Main {
public static void main(String[] args) {
int x = 999;
int y = x++;
System.out.println(y);
}
}
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);
}
}
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);
}
}
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) నిజం అయితే పూర్తిగా సరిపోతుంది.
GO TO FULL VERSION