జావా సింటాక్స్: ప్రోగ్రామింగ్ లాంగ్వేజ్‌కి చాలా సంక్షిప్త పరిచయం

జావా సింటాక్స్ అంటే ఏమిటి?

జావా సింటాక్స్ అనేది భాష యొక్క ప్రాథమికమైనది, కంపైలర్ మరియు కంప్యూటర్ "అర్థం చేసుకునే" ప్రోగ్రామ్‌లను వ్రాయడానికి అన్ని ప్రధాన నియమాలు, ఆదేశాలు, నిర్మాణాలు. ప్రతి ప్రోగ్రామింగ్ భాషకు దాని సింటాక్స్ అలాగే మానవ భాష ఉంటుంది. ఈ వ్యాసం జావా ప్రోగ్రామింగ్ భాష యొక్క ప్రాథమిక వాక్యనిర్మాణంపై దృష్టి పెడుతుంది మరియు ఇది అనుభవం లేని డెవలపర్‌లు లేదా మరొక ప్రోగ్రామింగ్ భాష తెలిసిన వారి కోసం ఉద్దేశించబడింది. ప్రారంభకులకు కొన్ని అంశాలు స్పష్టంగా తెలియకపోవచ్చు. అలా అయితే, వాటిని దాటవేయడం మరియు ఉదాహరణలపై దృష్టి పెట్టడం ఉత్తమం. అన్నింటిలో వలె, ప్రోగ్రామింగ్ భాషను చక్రీయంగా నేర్చుకోవడం మంచిది, క్రమంగా కొన్ని భావనలపై లోతైన అవగాహన వస్తుంది. ప్రతి జావా ప్రోగ్రామ్ అనేది డేటా (వేరియబుల్స్) మరియు బిహేవియర్ (ఫంక్షన్‌లు లేదా మెథడ్స్)తో ఒకదానికొకటి చేర్చుకునే వస్తువుల సమూహం. జావా ప్రోగ్రామ్ కూడా ఒక తరగతి లేదా కొన్ని తరగతులు. వస్తువు అనేది తరగతికి ఉదాహరణ. మీరు తరగతిని మోడల్‌గా అర్థం చేసుకోవచ్చు, ఉదాహరణకు, కుకీ కట్టర్లు మరియు కుక్కీల వంటి వస్తువులు. లేదా వియుక్త "జావా ప్రోగ్రామర్" మరియు ఆబ్జెక్ట్ "జావా ప్రోగ్రామర్ జాన్" లేదా "జావా ప్రోగ్రామర్ ఐవీ"గా వర్గీకరించండి.

జావాలో ఆబ్జెక్ట్

జావాలోని వస్తువులు రాష్ట్రాలు మరియు ప్రవర్తనలను కలిగి ఉంటాయి. ఉదాహరణ: పిల్లికి ఇలా ఉన్నాయి: దాని పేరు బొచ్చు, రంగు ఎరుపు, యజమాని జాన్; పిల్లికి కూడా ప్రవర్తన ఉంది ఇప్పుడు బొచ్చు నిద్రపోతోంది. అతను పర్ర్, నడవడం మొదలైనవాటిని కూడా చేయగలడు. వస్తువు అనేది తరగతికి ఉదాహరణ.

జావాలో క్లాస్

తరగతి అనేది వస్తువు యొక్క నమూనా లేదా టెంప్లేట్ లేదా బ్లూప్రింట్. ఇది ప్రవర్తనను వివరిస్తుంది మరియు దాని రకమైన వస్తువుకు మద్దతు ఇస్తుందని పేర్కొంది. ఉదాహరణకు, క్యాట్ క్లాస్ దాని పేరు, రంగు, యజమాని; పిల్లి కూడా తినడం, పుక్కిలించడం, నడవడం, నిద్రపోవడం వంటి ప్రవర్తనను కలిగి ఉంటుంది.

జావాలో పద్ధతులు

పద్ధతులు లాజిక్‌లను వివరించడం, డేటాను మార్చడం మరియు అన్ని చర్యలను అమలు చేయడం. ప్రతి పద్ధతి ప్రవర్తనను నిర్వచిస్తుంది. ఒక తరగతి అనేక పద్ధతులను కలిగి ఉంటుంది. ఉదాహరణకు మనం క్యాట్ క్లాస్ (స్లీప్) కోసం స్లీప్() లేదా పర్ర్ ( పుర్ర్ ) కోసం ఒక పద్ధతిని వ్రాయవచ్చు.

జావాలో ఉదాహరణ వేరియబుల్స్

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

సాధారణ జావా ప్రోగ్రామ్: హలో, జావా!

ఇక్కడ ఒక సాధారణ జావా ప్రోగ్రామ్ ఉంది:

class HelloJava {
   public static void main(String[] args) {
       System.out.println("Hello, Java!");
   }
}

ఈ ప్రోగ్రామ్ “హలో, జావా!” అనే స్ట్రింగ్‌ను ప్రింట్ చేస్తుంది. ఓదార్చడానికి. JDK మరియు IntelliJ IDEAలను ఇన్‌స్టాల్ చేసి, మీరు పైన చూసే కోడ్‌ను వ్రాయడానికి ప్రయత్నించమని నేను మీకు సిఫార్సు చేస్తున్నాను. లేదా మొదటి ప్రయత్నంలో అదే విధంగా చేయడానికి ఆన్‌లైన్ IDEని కనుగొనండి. ఇప్పుడు ఈ ప్రోగ్రామ్‌ని లైన్ ద్వారా తీసుకుందాం, కానీ అనుభవశూన్యుడుకి అవసరం లేని కొన్ని వివరాలను వదిలివేయండి.

class HelloJava 

జావాలోని ప్రతి ప్రోగ్రామ్ ఒక తరగతి లేదా చాలా తరచుగా అనేక తరగతులు. లైన్ క్లాస్ హలోజావా అంటే ఇక్కడ మనం కొత్త క్లాస్‌ని క్రియేట్ చేస్తాము మరియు దాని పేరు హలోజావా. మేము పైన నిర్వచించినట్లుగా, తరగతి అనేది ఒక రకమైన టెంప్లేట్ లేదా బ్లూప్రింట్, ఇది తరగతి వస్తువుల ప్రవర్తన మరియు స్థితిని వివరిస్తుంది. అనుభవం లేని ప్రోగ్రామర్‌లకు ఇది కఠినంగా ఉండవచ్చు, మీరు ఈ కాన్సెప్ట్‌ను కొంచెం తర్వాత నేర్చుకుంటారు. ప్రస్తుతానికి హలోజావా క్లాస్ మీ ప్రోగ్రామ్ యొక్క ప్రారంభం మాత్రమే. మీరు అదే పంక్తిలో మరియు వచనం అంతటా కర్లీ బ్రేస్ { ని గమనించి ఉండవచ్చు . ఒక జత కర్లీ బ్రేస్‌లు {} ఒక బ్లాక్‌ని సూచిస్తాయి, ఒకే యూనిట్‌గా పరిగణించబడే ప్రోగ్రామింగ్ స్టేట్‌మెంట్‌ల సమూహం. ఇక్కడ { అంటే యూనిట్ ప్రారంభం మరియు }దాని ముగింపు. బ్లాక్‌లు ఒకదానికొకటి గూడులో ఉంటాయి లేదా అవి వరుసగా ఉండవచ్చు. పై ప్రోగ్రామ్‌లో రెండు సమూహ బ్లాక్‌లు ఉన్నాయి. బాహ్యమైనది హలో తరగతి యొక్క శరీరాన్ని కలిగి ఉంది . లోపలి బ్లాక్ మెయిన్() పద్ధతి యొక్క బాడీని కలిగి ఉంటుంది .

public static void main (String args []) {

ఇక్కడ ప్రధాన పద్ధతి ప్రారంభం. పద్ధతి అనేది ప్రవర్తన లేదా ప్రోగ్రామ్‌లో ఆపరేషన్ చేయడానికి మిమ్మల్ని అనుమతించే ఆదేశాల క్రమం. ఉదాహరణకు 2 సంఖ్యలను గుణించండి లేదా స్ట్రింగ్‌ను ప్రింట్ చేయండి. మరో మాటలో చెప్పాలంటే, ఒక పద్ధతి ఒక ఫంక్షన్. కొన్ని ఇతర ప్రోగ్రామింగ్ భాషలలో, పద్ధతులను తరచుగా "ఫంక్షన్లు"గా సూచిస్తారు. జావా ప్రోగ్రామ్‌లోని అన్ని ఎలిమెంట్స్ లాగానే మెథడ్స్ కూడా క్లాస్‌లో ఉంటాయి. ప్రతి తరగతికి ఒకటి, అనేకం లేదా పద్ధతులు ఉండకపోవచ్చు. పబ్లిక్ అనేది యాక్సెస్ మాడిఫైయర్. పబ్లిక్ మాడిఫైయర్‌తో మార్క్ చేయబడిన వేరియబుల్, పద్ధతి లేదా తరగతిని ప్రోగ్రామ్‌లో ఎక్కడి నుండైనా యాక్సెస్ చేయవచ్చు. జావాలో వాటిలో నాలుగు ఉన్నాయి: పబ్లిక్, ప్రైవేట్, ప్రొటెక్టెడ్ మరియు డిఫాల్ట్ (ఖాళీ). మేము వాటి గురించి కొంచెం తరువాత మాట్లాడుతాము. మొదటి దశ కోసం మీ అన్ని పద్ధతులను పబ్లిక్ చేయడం మంచిది. శూన్యంపద్ధతి యొక్క రిటర్న్ రకం. శూన్యం అంటే అది ఏ విలువను తిరిగి ఇవ్వదు. ప్రధాన కార్యక్రమం యొక్క ప్రారంభ బిందువును సూచిస్తుంది. ఇదే పద్ధతి పేరు. String[] args అనేది ఒక ప్రధాన పద్ధతి వాదన. ప్రస్తుతానికి, దాదాపు ప్రతి జావా ప్రోగ్రామ్‌కు ప్రధాన పద్ధతి ఉందని తెలుసుకోవడం సరిపోతుంది , ఇది ప్రోగ్రామ్‌ను ప్రారంభిస్తుంది మరియు పబ్లిక్ స్టాటిక్ శూన్య మెయిన్ (స్ట్రింగ్[] ఆర్గ్స్) క్లాస్‌తో పనిచేయడానికి స్టాటిక్ పద్ధతులు వంటివి ప్రకటిస్తాయి. వారి డిక్లరేషన్‌లో స్టాటిక్ కీవర్డ్‌ను ఉపయోగించే పద్ధతులు నేరుగా స్థానిక మరియు స్టాటిక్ వేరియబుల్‌లతో మాత్రమే పని చేయగలవు.

 System.out.println("Hello, Java!"); 

అధికారికంగా ఈ లైన్ అవుట్ ఆబ్జెక్ట్ యొక్క println పద్ధతిని అమలు చేస్తుంది. అవుట్‌పుట్‌స్ట్రీమ్ క్లాస్‌లో అవుట్ ఆబ్జెక్ట్ ప్రకటించబడింది మరియు సిస్టమ్ క్లాస్‌లో స్థిరంగా ప్రారంభించబడుతుంది . అయితే ఇది మొత్తం కొత్తవారికి కొంచెం క్లిష్టంగా ఉంటుంది. ఈ లైన్ "హలో, జావా!" అనే పదాలను ప్రింట్ చేస్తుందని ఒక అనుభవశూన్యుడు తెలుసుకోవడం సరిపోతుంది. కన్సోల్‌కి. కాబట్టి మీరు మీ IDEలో ప్రోగ్రామ్‌ను అమలు చేస్తే, మీరు కన్సోల్‌లో అవుట్‌పుట్ పొందుతారు:

జావా ప్రాథమిక సింటాక్స్ నియమాలు

జావాలో ప్రోగ్రామింగ్ చేసేటప్పుడు అనుసరించాల్సిన కొన్ని ప్రధాన సింటాక్స్ నియమాలు ఉన్నాయి:

• ఫైల్ పేరు తప్పనిసరిగా తరగతి పేరుకు సమానంగా ఉండాలి;
• చాలా తరచుగా ప్రతి తరగతి .java పొడిగింపుతో ప్రత్యేక ఫైల్‌లో ఉంటుంది. తరగతి ఫైల్‌లు సాధారణంగా ఫోల్డర్‌లుగా సమూహం చేయబడతాయి. ఈ ఫోల్డర్లను ప్యాకేజీలు అంటారు;
• అక్షరాలు కేస్ సెన్సిటివ్. స్ట్రింగ్ స్ట్రింగ్కు సమానం కాదు ;
• జావా ప్రోగ్రామ్ ప్రాసెసింగ్ ప్రారంభం ఎల్లప్పుడూ ప్రధాన పద్ధతిలో ప్రారంభమవుతుంది: పబ్లిక్ స్టాటిక్ వాయిడ్ మెయిన్ (స్ట్రింగ్ [] ఆర్గ్స్) . ప్రధాన () పద్ధతి ఏదైనా జావా ప్రోగ్రామ్‌లో అవసరమైన భాగం;
• మెథడ్ (విధానం, ఫంక్షన్) అనేది ఆదేశాల క్రమం. మెథడ్స్ ఆన్ వస్తువు యొక్క ప్రవర్తనను నిర్వచిస్తుంది;
• ప్రోగ్రామ్ ఫైల్‌లోని పద్ధతుల క్రమం అసంబద్ధం;
• తరగతి పేరు యొక్క మొదటి అక్షరం పెద్ద అక్షరంలో ఉందని గుర్తుంచుకోండి. మీరు బహుళ పదాలను ఉపయోగిస్తుంటే, ప్రతి పదంలోని మొదటి అక్షరానికి పెద్ద అక్షరాన్ని ఉపయోగించండి (“MyFirstJavaClass”);
• జావా సింటాక్స్‌లోని అన్ని పద్ధతుల పేర్లు చిన్న అక్షరంతో ప్రారంభమవుతాయి. బహుళ పదాలను ఉపయోగిస్తున్నప్పుడు, తదుపరి అక్షరాలు క్యాపిటలైజ్ చేయబడతాయి ("పబ్లిక్ శూన్యమైన myFirstMethodName ()");
• ఫైల్‌లు తరగతి పేరు మరియు .java పొడిగింపు ("MyFirstJavaClass.java")తో సేవ్ చేయబడతాయి;
• జావా సింటాక్స్‌లో, కోడ్ బ్లాక్ మరియు కోడ్ యొక్క కొత్త ప్రాంతాన్ని సూచించే డీలిమిటర్లు "{...}" ఉన్నాయి;
• ప్రతి కోడ్ స్టేట్‌మెంట్ తప్పనిసరిగా సెమికోలన్‌తో ముగియాలి.

జావా వేరియబుల్స్ మరియు డేటా రకాలు వేరియబుల్స్ డేటాను నిల్వ చేయడానికి ఉపయోగించే ప్రత్యేక ఎంటిటీలు. ఏదైనా డేటా. జావాలో, మొత్తం డేటా వేరియబుల్స్‌లో నిల్వ చేయబడుతుంది. వేరియబుల్ అనేది రిజర్వ్ చేయబడిన స్థలం లేదా వేరియబుల్‌ని ఉంచడానికి పెట్టె అని మీరు చెప్పవచ్చు. ప్రతి వేరియబుల్ దాని డేటా రకం, పేరు (ఐడెంటిఫైయర్) మరియు విలువను కలిగి ఉంటుంది. డేటా రకాలు ఆదిమ మరియు నాన్-ప్రిమిటివ్ లేదా రిఫరెన్స్ కావచ్చు. ప్రాథమిక డేటా రకాలు కావచ్చు:

• పూర్ణాంకాలు: బైట్, షార్ట్, పూర్ణాంక, పొడవు
• భిన్నాలు: ఫ్లోట్ మరియు డబుల్
• తార్కిక విలువలు: బూలియన్
• సింబాలిక్ విలువలు (అక్షరాలు మరియు సంఖ్యలను సూచించడానికి): చార్

జావా వేరియబుల్స్ ఉదాహరణ:

int s;
s = 5;  
char myChar = ‘a’; 

ఈ కోడ్‌లో మేము పూర్ణాంకం వేరియబుల్ s (ఖాళీ కంటైనర్) సృష్టించాము మరియు దానిలో 5 విలువను ఉంచాము. myChar అనే వేరియబుల్‌తో అదే కథనం . మేము దానిని చార్ డేటా రకంతో సృష్టించాము మరియు దానిని a అక్షరంగా నిర్వచించాము . ఈ సందర్భంలో మేము వేరియబుల్‌ను సృష్టించాము మరియు ఏకకాలంలో దానికి విలువను కేటాయించాము. జావా సింటాక్స్ ఈ విధంగా చేయడానికి మిమ్మల్ని అనుమతిస్తుంది. రిఫరెన్స్ రకాలు విలువలు లేదా ఇతర వస్తువులకు సూచనలను ఉంచే కొన్ని వస్తువులు. అవి శూన్యానికి సూచనను కూడా కలిగి ఉంటాయి. శూన్యం అనేది విలువ లేకపోవడాన్ని సూచించడానికి ఒక ప్రత్యేక విలువ. సూచన రకాల్లో స్ట్రింగ్, అర్రేలు మరియు మీకు కావలసిన ప్రతి క్లాస్ ఉన్నాయి. మీకు వయోలిన్ క్లాస్ ఉంటే, మీరు ఈ క్లాస్ యొక్క వేరియబుల్‌ని సృష్టించవచ్చు. జావా రిఫరెన్స్ టైప్ వేరియబుల్స్ ఉదాహరణ:

String s = “my words”; 
Violin myViolin; 

మీరు వాటి గురించి తర్వాత మరింత నేర్చుకుంటారు. నాన్-ప్రిమిటివ్ రకాల వేరియబుల్స్ క్యాపిటల్ లెటర్స్ నుండి మొదలవుతాయని గుర్తుంచుకోండి, అయితే ప్రిమిటివ్ - చిన్న అక్షరాల నుండి. ఉదాహరణ:

int i = 25;
String s = “Hello, Java!”; 

జావా శ్రేణులు

శ్రేణులు ఒకే రకమైన బహుళ వేరియబుల్‌లను నిల్వ చేసే వస్తువులు. అయితే, శ్రేణి అనేది కుప్పపై ఉన్న వస్తువు. మేము రాబోయే అధ్యాయాలలో ఎలా ప్రకటించాలో, నిర్మించాలో మరియు ప్రారంభించాలో పరిశీలిస్తాము. అర్రే ఉదాహరణ:

int[] myArray = {1,7,5};

ఇక్కడ మనకు మూడు పూర్ణాంకాల (1,7 మరియు 5) నుండి ఉన్న శ్రేణి ఉంది.

జావా ఎనమ్స్

ఆదిమ డేటా రకాలతో పాటు జావాలో ఎన్యూమ్ లేదా ఎన్యుమరేషన్ వంటి రకాన్ని కలిగి ఉంటుంది. గణనలు తార్కికంగా సంబంధిత స్థిరాంకాల సేకరణను సూచిస్తాయి. ఎనమ్ ఆపరేటర్‌ని ఉపయోగించి గణన ప్రకటించబడుతుంది, దాని తర్వాత గణన పేరు ఉంటుంది. అప్పుడు గణన మూలకాల యొక్క కామాతో వేరు చేయబడిన జాబితా వస్తుంది:

enum DayOfWeek {
     MONDAY,
     TUESDAY,
     WEDNESDAY,
     THURSDAY,
     FRIDAY,
     SATURDAY,
     SUNDAY
}

ఒక గణన వాస్తవానికి కొత్త రకాన్ని సూచిస్తుంది, కాబట్టి మనం ఆ రకం యొక్క వేరియబుల్‌ని నిర్వచించవచ్చు మరియు దానిని ఉపయోగించవచ్చు. గణనను ఉపయోగించే ఉదాహరణ ఇక్కడ ఉంది.

జావా ఎనమ్ ఉదాహరణ

public class MyNum{      
    public static void main(String[] args) {
          
        Day myDay = DayOfWeek.FRIDAY;
        System.out.println(myDay);	//print a day from the enum     
}
}
enum DayOfWeek{
  
    MONDAY,
    TUESDAY,
    WEDNESDAY,
    THURSDAY,
    FRIDAY,
    SATURDAY,
    SUNDAY
}

మీరు ప్రోగ్రామ్‌ను అమలు చేస్తే, కన్సోల్‌లో FRIDAY ముద్రించబడుతుంది. మీరు మీ Enum మరియు MyNum క్లాస్ కోడ్‌ను ఒక ఫైల్‌లో ఉంచవచ్చు, కానీ రెండు వేర్వేరు ఫైల్‌లను సృష్టించడం మంచిది: ఒకటి MyNum తరగతికి మరియు ఒకటి డే enum కోసం. IntelliJ IDEA సృష్టించేటప్పుడు enumని ఎంచుకోవడానికి మిమ్మల్ని అనుమతిస్తుంది.

జావాలో వేరియబుల్స్ ప్రకటించడం

వాస్తవానికి మేము పైన కొన్ని వేరియబుల్స్ ప్రకటించాము మరియు వాటిని గుర్తించాము. డిక్లరేషన్ అనేది ఒక నిర్దిష్ట రకం యొక్క వేరియబుల్ కోసం మెమరీని కేటాయించడం మరియు దానికి పేరు పెట్టడం. అలాంటిది ఏదో:

int i; 
boolean boo; 

అసైన్‌మెంట్ ఆపరేటర్ (=)ని ఉపయోగించి వేరియబుల్‌ని ప్రారంభించమని కూడా మేము ప్రకటించవచ్చు. అంటే మనం కేటాయించిన మెమరీకి నిర్దిష్ట విలువను ఉంచుతాము. మేము డిక్లరేషన్ యొక్క క్షణంలో లేదా తర్వాత దాన్ని సరిగ్గా చేయగలము.

వేరియబుల్ ఉదాహరణను ప్రకటించడం

String str; 
int i = 5; 
Str = “here is my string”; 

మీరు ప్రారంభించకుండా వేరియబుల్‌ను ప్రకటిస్తే అది కొంత డిఫాల్ట్ విలువను పొందుతుంది. Int కోసం ఈ విలువ 0, స్ట్రింగ్ లేదా ఏదైనా ఇతర సూచన రకం కోసం ఇది ప్రత్యేక శూన్య ఐడెంటిఫైయర్.

జావా ఐడెంటిఫైయర్లు

ఐడెంటిఫైయర్‌లు కేవలం జావా భాగాల పేర్లు - తరగతులు, వేరియబుల్స్ మరియు పద్ధతులు. అన్ని జావా భాగాలకు పేర్లు ఉండాలి.

Class Violin {
int age; 
String masterName;  
}

వయోలిన్ క్లాస్ ఐడెంటిఫైయర్. వయస్సు మరియు మాస్టర్‌నేమ్ వేరియబుల్స్ ఐడెంటిఫైయర్‌లు. ఇక్కడ కొన్ని జావా ఐడెంటిఫైయర్ నియమాలు:

• అన్ని ఐడెంటిఫైయర్‌లు లాటిన్ అక్షరం (A నుండి Z లేదా a నుండి z), కరెన్సీ అక్షరం ($) లేదా అండర్‌స్కోర్ (_)తో ప్రారంభమవుతాయి.
• మొదటి అక్షరం తర్వాత, ఐడెంటిఫైయర్‌లు ఏవైనా అక్షరాల కలయికను కలిగి ఉండవచ్చు.
• జావా కీవర్డ్ ఐడెంటిఫైయర్ కాదు (మీరు కీలకపదాలను కొంచెం తర్వాత కనుగొంటారు).
• ఐడెంటిఫైయర్‌లు కేస్ సెన్సిటివ్.

ఐడెంటిఫైయర్ల ఉదాహరణ

లీగల్ ఐడెంటిఫైయర్‌లు: జావా, $mySalary, _సమ్‌థింగ్ చట్టవిరుద్ధమైన ఐడెంటిఫైయర్‌లు: 1వ భాగం, -ఒకటి

జావా సవరణలు

మాడిఫైయర్‌లు అనేవి మీరు ఎలిమెంట్‌లను (తరగతులు, పద్ధతులు, వేరియబుల్స్) సవరించడానికి ఉపయోగించే జావా భాష యొక్క ప్రత్యేక పదాలు. Java మాడిఫైయర్‌ల యొక్క రెండు వర్గాలను కలిగి ఉంది: యాక్సెస్ మరియు నాన్-యాక్సెస్ మోడిఫైయర్‌లు.

యాక్సెస్ మాడిఫైయర్‌ల ఉదాహరణ

జావాలో 4 యాక్సెస్ మాడిఫైయర్‌లు ఉన్నాయి:

• పబ్లిక్ . పబ్లిక్ ఎలిమెంట్ ఇది తరగతి నుండి, తరగతి వెలుపల, ప్యాకేజీ లోపల మరియు వెలుపల యాక్సెస్ చేయవచ్చు
• డిఫాల్ట్ (ఖాళీ) మాడిఫైయర్‌తో మూలకం ప్యాకేజీలో మాత్రమే యాక్సెస్ చేయబడుతుంది
• రక్షిత మాడిఫైయర్‌ను చైల్డ్ క్లాస్ ద్వారా ప్యాకేజీ లోపల మరియు వెలుపల యాక్సెస్ చేయవచ్చు
• ప్రైవేట్ మూలకం అది ప్రకటించిన తరగతిలో మాత్రమే అందుబాటులో ఉంటుంది.

నాన్-యాక్సెస్ మాడిఫైయర్స్ ఉదాహరణ

వాటిలో 7 ఉన్నాయి

• స్థిరమైన
• చివరి
• నైరూప్య
• సమకాలీకరించబడింది
• క్షణికమైన
• త్వరగా ఆవిరి అయ్యెడు
• స్థానికుడు

జావా కీలకపదాలు

జావా కీవర్డ్‌లు అనేవి జావాలో ఉపయోగించాల్సిన ప్రత్యేక పదాలు, ఇవి కోడ్‌కి కీలకం. అవి రిజర్వ్ చేయబడిన పదాలుగా కూడా ప్రసిద్ధి చెందాయి: మీరు వాటిని వేరియబుల్స్, మెథడ్స్, క్లాస్‌లు మొదలైన ఐడెంటిఫైయర్‌ల కోసం ఉపయోగించలేరు. అవి ఇక్కడ ఉన్నాయి:

• abstract : నైరూప్య తరగతిని ప్రకటించడానికి కీలకపదం.
• boolean : వేరియబుల్‌ను బూలియన్ రకంగా ప్రకటించడానికి జావా బూలియన్ కీవర్డ్. ఇటువంటి వేరియబుల్స్ నిజం మరియు తప్పు మాత్రమే కావచ్చు.
• బ్రేక్ : లూప్ లేదా స్విచ్ స్టేట్‌మెంట్‌ను విచ్ఛిన్నం చేయడానికి జావా బ్రేక్ కీవర్డ్‌ని ఉపయోగించండి.
• బైట్ : ఒక బైట్ పూర్ణ సంఖ్య వేరియబుల్ డిక్లరేషన్ కోసం జావా బైట్ కీవర్డ్.
• కేసు : టెక్స్ట్ బ్లాక్‌లను గుర్తించడానికి స్విచ్ స్టేట్‌మెంట్‌లతో ఉపయోగించబడుతుంది.
• క్యాచ్ : ట్రై బ్లాక్ తర్వాత మినహాయింపులను పట్టుకోవడానికి ఉపయోగించబడుతుంది .
• char : అక్షర వేరియబుల్ కోసం జావా చార్ కీవర్డ్. ఇది సంతకం చేయని 16-బిట్ యూనికోడ్ అక్షరాలను కలిగి ఉంటుంది.
• తరగతి : తరగతిని ప్రకటించడానికి జావా క్లాస్ కీవర్డ్.
• continue : లూప్‌ని కొనసాగించడానికి జావా కీవర్డ్.
• డిఫాల్ట్ : స్విచ్ స్టేట్‌మెంట్‌లో కోడ్ యొక్క డిఫాల్ట్ బ్లాక్‌ను పేర్కొనడానికి జావా డిఫాల్ట్ కీవర్డ్.
• do : do-while లూప్ నిర్మాణంలో ఉపయోగించబడుతుంది.
• డబుల్ : నంబర్ వేరియబుల్‌ను ప్రకటించడానికి జావా డబుల్ కీవర్డ్ ఉపయోగించబడుతుంది. ఇది 8 బైట్ ఫ్లోటింగ్ పాయింట్ నంబర్‌లను కలిగి ఉంటుంది.
• else : మీరు దీన్ని else-if షరతులతో కూడిన స్టేట్‌మెంట్‌లలో ఉపయోగించవచ్చు.
• enum : స్థిర స్థిరాంకాల సమితిని నిర్వచించడానికి ఉపయోగించబడుతుంది.
• పొడిగిస్తుంది : జావా ఒక తరగతి మరొక తరగతిని విస్తరిస్తుందని సూచించడానికి కీవర్డ్‌ని విస్తరిస్తుంది (ఇతర తరగతికి చెందిన చైల్డ్ క్లాస్).
• ఫైనల్ : వేరియబుల్ స్థిరమైనదని సూచించడానికి కీవర్డ్.
• చివరగా : మినహాయింపు నిర్వహించబడిందా లేదా అనే దానితో పాటుగా అమలు చేయబడే కోడ్ బ్లాక్‌ను సూచిస్తుంది.
• float : 4-బైట్ ఫ్లోటింగ్ పాయింట్ సంఖ్యను కలిగి ఉండే వేరియబుల్.
• కోసం : a for loop ప్రారంభించడానికి ఒక కీవర్డ్. కొన్ని షరతులు నిజం అయితే సూచనల సమితిని పదేపదే అమలు చేయడానికి ఇది ఉపయోగించబడుతుంది.
• if : పరిస్థితిని తనిఖీ చేయడానికి కీవర్డ్. షరతు నిజమైతే ఇది బ్లాక్‌ని అమలు చేస్తుంది.
• ఇంప్లిమెంట్స్ : ఇంటర్‌ఫేస్‌ను అమలు చేయడానికి కీలకపదం.
• దిగుమతి : ప్యాకేజీ, తరగతి లేదా ఇంటర్‌ఫేస్‌ను దిగుమతి చేయడానికి జావా దిగుమతి కీవర్డ్.
• instanceof : ఆబ్జెక్ట్ నిర్దిష్ట తరగతి లేదా ఇంటర్‌ఫేస్ యొక్క ఉదాహరణ కాదా అని తనిఖీ చేస్తుంది.
• int : 4-బైట్ సంతకం చేసిన పూర్ణాంకం సంఖ్యను కలిగి ఉండే వేరియబుల్.
• ఇంటర్‌ఫేస్ : ఇంటర్‌ఫేస్‌ను ప్రకటించడానికి జావా ఇంటర్‌ఫేస్ కీవర్డ్ ఉపయోగించబడుతుంది.
• పొడవు : 8-బైట్ సంతకం చేసిన పూర్ణాంకం సంఖ్యను కలిగి ఉండే వేరియబుల్.
• స్థానిక : JNI (జావా స్థానిక ఇంటర్‌ఫేస్) ఉపయోగించి స్థానిక కోడ్‌లో ఒక పద్ధతి అమలు చేయబడుతుందని నిర్దేశిస్తుంది.
• కొత్త : కొత్త వస్తువులను సృష్టించడానికి జావా కొత్త కీవర్డ్.
• ప్యాకేజీ : జావా క్లాస్‌ల ఫైల్‌ల కోసం జావా ప్యాకేజీ (ఫోల్డర్) ప్రకటించింది.
• ప్రైవేట్ : ఒక పద్ధతి లేదా వేరియబుల్ ప్రకటించబడిన తరగతిలో మాత్రమే కనిపించవచ్చని యాక్సెస్ మాడిఫైయర్ సూచిస్తుంది.
• ప్రొటెక్టెడ్ : చైల్డ్ క్లాస్ ద్వారా ప్యాకేజీ లోపల మరియు వెలుపల ఒక పద్ధతి లేదా వేరియబుల్ యాక్సెస్ చేయవచ్చని యాక్సెస్ మాడిఫైయర్ సూచిస్తుంది.
• పబ్లిక్ : యాక్సెస్ మాడిఫైయర్ మూలకం ఎక్కడైనా అందుబాటులో ఉంటుందని సూచిస్తుంది.
• రిటర్న్ : ఒక పద్ధతి యొక్క అమలు ఫలితాన్ని అందిస్తుంది.
• short : 2-బైట్ సంతకం చేసిన పూర్ణాంకం సంఖ్యను కలిగి ఉండే వేరియబుల్.
• స్టాటిక్ : వేరియబుల్ లేదా మెథడ్ అనేది ఒక క్లాస్, ఆబ్జెక్ట్, పద్ధతి కాదు అని సూచిస్తుంది.
• strictfp : ఫ్లోటింగ్ పాయింట్ లెక్కలను పరిమితం చేస్తుంది.
• సూపర్ : మాతృ తరగతి వస్తువును సూచిస్తుంది.
• స్విచ్ : అమలు చేయడానికి కోడ్ బ్లాక్‌ను (లేదా వాటిలో చాలా వరకు) ఎంచుకుంటుంది.
• synchronized : ఒక నాన్-యాక్సెస్ మాడిఫైయర్. ఒక సమయంలో ఒక థ్రెడ్ ద్వారా మాత్రమే పద్ధతిని యాక్సెస్ చేయవచ్చని ఇది నిర్దేశిస్తుంది.
• ఇది : ఒక పద్ధతి లేదా కన్స్ట్రక్టర్‌లో ప్రస్తుత వస్తువును సూచిస్తుంది.
• త్రో : మినహాయింపును స్పష్టంగా విసిరేందుకు ఉపయోగించబడుతుంది.
• విసురుతాడు : మినహాయింపు ప్రకటించింది.
• తాత్కాలికం : తాత్కాలిక డేటా భాగాన్ని సీరియలైజ్ చేయడం సాధ్యం కాదు.
• ప్రయత్నించండి : మినహాయింపుల కోసం తనిఖీ చేయబడే కోడ్ బ్లాక్‌ని ప్రారంభిస్తుంది.
• void : ఒక పద్ధతి విలువను తిరిగి ఇవ్వదని పేర్కొంటుంది.
• అస్థిరత : ఒక వేరియబుల్ అసమకాలికంగా మారవచ్చని సూచిస్తుంది.
• అయితే : కాసేపు లూప్ ప్రారంభమవుతుంది. షరతు నిజం అయినప్పుడు ప్రోగ్రామ్‌లోని కొంత భాగాన్ని అనేకసార్లు పునరావృతం చేస్తుంది.

Javaలో వ్యాఖ్యలు

జావా సింగిల్-లైన్ మరియు బహుళ-లైన్ వ్యాఖ్యలకు మద్దతు ఇస్తుంది. ఏదైనా వ్యాఖ్యలో అన్ని అక్షరాలు అందుబాటులో ఉంటాయి మరియు అవి జావా కంపైలర్ ద్వారా విస్మరించబడతాయి. డెవలపర్‌లు కోడ్‌ను వివరించడానికి లేదా ఏదైనా గుర్తుకు తెచ్చుకోవడానికి వాటిని ఉపయోగిస్తారు. వ్యాఖ్యాన ఉదాహరణలు:

//single-line comment 
/*here we have a multi-line comment. As you can see it uses slash and asterisks from both sides of it.*/   

public class HelloJava {
   /* this program was created to demonstrate comments in Java. This one is a multi-line comment.
   You can use such comments anywhere in your programs*/
   public static void main(String[] args) {
       //here is a single-line comment
       String j = "Java"; //This is my string
       int a = 15; //here I have an integer
       System.out.println("Hello, " + j + " " + a + "!");
       int[] myArray = {1,2,5};
       System.out.println(myArray.length);
   }
}

జావాలో అక్షరాలు

జావాలోని లిటరల్స్ అనేది వేరియబుల్‌కు కేటాయించిన కొన్ని స్థిరమైన విలువలు. అవి విలువను సూచించడానికి సంఖ్యలు లేదా వచనాలు లేదా మరేదైనా కావచ్చు.

• సమగ్ర అక్షరాలు
• ఫ్లోటింగ్ పాయింట్ లిటరల్స్
• చార్ అక్షరాలు
• స్ట్రింగ్ లిటరల్స్
• బూలియన్ అక్షరాలు

జావా అక్షరాల ఉదాహరణలు

 int i = 100; //100 is an integral  literal 
double d = 10.2;//10.2 is a floating point literal 
char c = ‘b’; //b is a char literal 
String myString = “Hello!”; 
boolean bool = true; 

గమనిక: శూన్య కూడా అక్షరార్థం.

జావాలో ప్రాథమిక ఆపరేటర్లు

వివిధ రకాల ఆపరేటర్లు ఉన్నారు: అంకగణితం

• + (సంఖ్యల జోడింపు మరియు స్ట్రింగ్ సంయోగం)
• - (మైనస్ లేదా తీసివేత)
• * (గుణకారం)
• / (విభజన)
• % (మాడ్యులస్ లేదా మిగిలినవి)

పోలిక

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

లాజికల్

• && (మరియు)
• || (OR)
• ! (కాదు)
• ^ (XOR)

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

public class NumbersOperations {
   int a;
   int b;
   public static int add(int a,int b){
       return a+b;
   }
   public static int sub (int a, int b){
       return a-b;
   }
   public static double div (double a, int b){
       return a/b;
   }
}

ఇక్కడ మేము 2 సంఖ్యలతో మానిప్యులేట్ చేయడానికి చెట్టు పద్ధతులతో కూడిన తరగతిని కలిగి ఉన్నాము. ఈ ప్రోగ్రామ్‌లో 2 సంఖ్యలను గుణించడానికి మీరు 4వ పద్ధతి int mul (int a, int b)ని వ్రాయడానికి ప్రయత్నించవచ్చు . NumberOprations పనిని ప్రదర్శించడానికి ఒక తరగతిని కూడా సృష్టిద్దాం :

public class NumberOperationsDemo {
   public static void main(String[] args) {
       int c = NumbersOperations.add(4,5);
       System.out.println(c);
       double d = NumbersOperations.div(1,2);
       System.out.println(d);
   }
}

మీరు NumberOperationsDemoని అమలు చేస్తే , మీరు తదుపరి అవుట్‌పుట్‌ని పొందుతారు:

ముగింపులు

ఇవి జావా భాష యొక్క ప్రాథమిక అంశాలు మరియు చాలా విషయాలు గందరగోళంగా ఉండవచ్చు. ఏది ఏమిటో గుర్తించడానికి చాలా ప్రోగ్రామింగ్ అవసరం. మీరు ఈ భాషను నేర్చుకునే ఏకైక మార్గం - అభ్యాసం ద్వారా. ఇప్పుడే కోడింగ్ ప్రారంభించండి, కోడ్‌జిమ్ ప్రాక్టికల్ జావా కోర్సు యొక్క మొదటి అన్వేషణను పూర్తి చేయడానికి ప్రయత్నించండి . మీ జావా అభ్యాసంలో అదృష్టం!