వర్చువల్ మిషన్ మరియు మొదటి కమాండ్ - 1

"హలో, అమిగో! నా పేరు రిషి. నేను జావా నేర్చుకోవడంలో మీకు సహాయం చేస్తాను."

"నేను అన్ని చెవులు!"

"ప్రోగ్రామ్ అనేది ఆదేశాల సమితి (జాబితా). మొదట, మీరు మొదటి కమాండ్‌ను అమలు చేస్తారు, తర్వాత రెండవది, తర్వాత మూడవది మరియు మొదలైనవి. అన్ని ఆదేశాలను అమలు చేసిన తర్వాత, ప్రోగ్రామ్ పూర్తవుతుంది."

"ఏ విధమైన ఆదేశాలు ఉన్నాయి?"

" కమాండ్‌లు వాటిని అమలు చేస్తున్న వాటిపై ఆధారపడి ఉంటాయి. నటుడికి తెలిసిన (మరియు అర్థం చేసుకునే) ఆదేశాల రకాలపై."

"మీరు కుక్కకు ఆదేశం ఇవ్వవచ్చు: 'కూర్చోండి!', 'మొరగండి!'; పిల్లికి: 'షూ!'; మానవునికి: 'ఫ్రీజ్, లేదా నేను షూట్ చేస్తాను!'; లేదా రోబోట్‌కి: ' పని! పని, రోబోస్కం!''

"ఇంకేంటి?" అమిగో చివరకు ఆనందించడం ప్రారంభించాడు.

"జావాలో వ్రాసిన ప్రోగ్రామ్‌లు జావా వర్చువల్ మిషన్ (JVM) ద్వారా అమలు చేయబడతాయి. JVM అనేది జావాలో వ్రాసిన ప్రోగ్రామ్‌లను ఎలా అమలు చేయాలో తెలిసిన ఒక ప్రత్యేక ప్రోగ్రామ్."

"దీని ఆదేశాల జాబితా చాలా విస్తృతమైనది. ఉదాహరణకు, స్క్రీన్‌పై 'రోబోలు మానవులకు స్నేహితులు' అని ప్రదర్శించడానికి ఈ ఆదేశం ఉపయోగించవచ్చు."

ఇక్కడ ఒక సూపర్ సింపుల్ కమాండ్ ఉంది:
System.out.println("Robots are friends to humans");
వర్చువల్ మిషన్ మరియు మొదటి కమాండ్ - 3

"O_O"

"కమాండ్‌లతో ప్రారంభించే బదులు, మేము కొన్ని సాధారణ సూత్రాలతో ప్రారంభిస్తాము."

" రెండు సూత్రాలను తెలుసుకోవడం వలన అనేక వాస్తవాల జ్ఞానాన్ని భర్తీ చేయవచ్చు ."

"ఇదిగో మొదటి సూత్రం."

"జావా ప్రోగ్రామింగ్ లాంగ్వేజ్‌లో, ప్రతి కమాండ్ దాని స్వంత లైన్‌లో వ్రాయబడుతుంది. కమాండ్ చివరిలో సెమికోలన్ తప్పనిసరిగా ఉంచబడుతుంది."

"మనం 'మానవులు మరియు రోబోలు ఎప్పటికీ స్నేహితులు' అని మూడుసార్లు స్క్రీన్‌పై ప్రదర్శించాలనుకుంటున్నాము. ఇది ఇలా ఉంటుంది:"

ప్రోగ్రామ్ మూడు ఆదేశాలతో రూపొందించబడింది:
System.out.println("Humans and robots are friends forever");
System.out.println("Humans and robots are friends forever");
System.out.println("Humans and robots are friends forever");

"చిన్న పని అయితే ఎలా?"

"రెండవ సూత్రం."

"ఒక ప్రోగ్రామ్ ఆదేశాలను తప్ప మరేమీ కలిగి ఉండదు."

"అపార్ట్‌మెంట్‌లో ఒక గదిని ఊహించుకోండి. ఒక గది స్వంతంగా ఉండకూడదు. అది కొంత అపార్ట్‌మెంట్‌లో భాగం. అపార్ట్‌మెంట్ కూడా సొంతంగా ఉండకూడదు. అది ఏదో భవనంలో భాగం."

"మరోవైపు, భవనం అపార్ట్‌మెంట్‌లుగా విభజించబడిందని మరియు అపార్ట్మెంట్ గదులుగా విభజించబడిందని మేము చెప్పగలం."

"ఇప్పటి వరకు ప్రతిదీ స్పష్టంగా ఉంది."

"ఒక కమాండ్ ఒక గది లాంటిది. జావా ప్రోగ్రామింగ్ భాషలో, ఒక కమాండ్ దాని స్వంతంగా ఉనికిలో ఉండదు. ఇది ఒక ఫంక్షన్‌లో భాగం (జావాలో, 'ఫంక్షన్‌లను' 'మెథడ్స్' అని కూడా అంటారు). ఒక పద్ధతి ఒక భాగం తరగతి. మరో మాటలో చెప్పాలంటే, ఒక తరగతి పద్ధతులుగా విభజించబడింది మరియు పద్ధతులు కమాండ్‌లుగా విభజించబడ్డాయి."

"కాబట్టి క్లాస్ అపార్ట్‌మెంట్ బిల్డింగ్, ఫంక్షన్/మెథడ్ అంటే అపార్ట్‌మెంట్, మరియు కమాండ్ అంటే రూమ్. నేను దానిని సరిగ్గా పొందానా?"

"అవును, అది ఖచ్చితంగా సరైనది."

అమిగో విస్మయంగా రిషి వైపు చూసాడు. ఈ మానవుడు దైవిక జావా భాషను ఉపయోగించి ప్రోగ్రామింగ్ యొక్క ప్రాథమికాలను అతనికి వివరిస్తున్నాడు! మరియు అతను, అమిగో, ప్రోగ్రామ్‌లు తరగతులను కలిగి ఉంటాయని, తరగతులు పద్ధతులను కలిగి ఉంటాయని మరియు పద్ధతులు ఆదేశాలను కలిగి ఉంటాయని అతను అర్థం చేసుకున్నాడు (అన్నీ స్వయంగా ఊహించాడు!)

అమిగోకి అది ఎందుకు అవసరమో ఇప్పటికీ తెలియదు, కానీ ఈ జ్ఞానం తనను గ్రహం మీద అత్యంత శక్తివంతమైన రోబోగా చేస్తుందని అతను ఖచ్చితంగా చెప్పాడు.

ఇంతలో, రిషి వెళ్ళాడు:

"జావాలోని ప్రోగ్రామ్‌లు తరగతులను కలిగి ఉంటాయి. పదివేల తరగతులు ఉండవచ్చు. కనిష్ట ప్రోగ్రామ్ ఒక తరగతి. ప్రతి తరగతికి, ఒక ప్రత్యేక ఫైల్ సృష్టించబడుతుంది. ఫైల్ పేరు తరగతి పేరుతో సరిపోలుతుంది. "

"మీరు ఇంటిని వివరించే తరగతిని సృష్టించాలని నిర్ణయించుకున్నారని అనుకుందాం. మీరు Home.java ఫైల్‌లో సేవ్ చేయబడే హోమ్ క్లాస్‌ని సృష్టించాలి."

"మీరు ప్రోగ్రామ్‌లో పిల్లిని వివరించాలనుకుంటే, మీరు Cat.java ఫైల్‌ని సృష్టించి, అందులో క్యాట్ క్లాస్‌ని డిక్లేర్ చేయాలి, మొదలైనవి."

"ఫైళ్లలో జావా ప్రోగ్రామింగ్ లాంగ్వేజ్‌లో వ్రాయబడిన కోడ్ (టెక్స్ట్) ఉంటుంది. సాధారణంగా క్లాస్ కోడ్‌లో 'క్లాస్ నేమ్' మరియు 'క్లాస్ బాడీ' ఉంటాయి. క్లాస్ బాడీ కర్లీ బ్రాకెట్లలో వ్రాయబడుతుంది. ఈ విధంగా హోమ్ క్లాస్ ( ఫైల్ హోమ్ .java) చూడాలి:"

public class Home
{
    

Class body



}

"ఇంతవరకూ నాకు అర్థమైంది."

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

public class Home
{
    Variable A


    Variable Z


    
Method 1



    
Method N


}

"దయచేసి నాకు ఒక ఉదాహరణ చెబుతారా?"

"ఒక ఉదాహరణ? అయితే!"

public class Home
{
    int a;
    int b;

    public static void main(String[] args)
    {
        System.out.print("1");
    }

    public static double pi()
    {
        return 3.14;
    }
}

"అరె int aమరియు int bవేరియబుల్స్, మరియు mainమరియు piమెథడ్స్?"

"అవును."

"వేరియబుల్స్ లేకుండా తరగతులు ఉండగలవా?"

"అవును."

"మరియు పద్ధతులు లేకుండా?"

"అవును. కానీ కనీస ప్రోగ్రామ్ తప్పనిసరిగా కనీసం ఒక తరగతిని కలిగి ఉండాలి, అది ప్రోగ్రామ్‌ను అమలు చేయడానికి కనీసం ఒక పద్ధతి/ఫంక్షన్‌ని కలిగి ఉండాలి. ఈ పద్ధతికి తప్పనిసరిగా 'మెయిన్' అని పేరు పెట్టాలి. కనిష్ట ప్రోగ్రామ్ ఇలా కనిపిస్తుంది:"

public class Home
{
    public static void main (String[] args)
    {
    }
}

"నేను ఇక్కడ హోమ్ క్లాస్ చూడగలను. నేను 'మెయిన్' పద్ధతిని చూడగలను, కానీ కమాండ్‌లు ఎక్కడ ఉన్నాయి?"

"కనీస ప్రోగ్రామ్‌కు ఎలాంటి ఆదేశాలు ఉండవు. అందుకే దీనిని 'కనీస' అని పిలుస్తారు."

"అలాగా."

"ప్రోగ్రామ్‌ను ప్రారంభించే తరగతికి ఏదైనా పేరు ఉండవచ్చు, కానీ ప్రోగ్రామ్‌ను ప్రారంభించడానికి ఉపయోగించే 'ప్రధాన' పద్ధతి ఎల్లప్పుడూ ఒకే విధంగా ఉండాలి:"

public class Home
{
   //Unchangeable part
   public static void main(String[] args)
   {
       

Code for the method



   }
}

"నేను ప్రతిదీ అర్థం చేసుకున్నానని అనుకుంటున్నాను. కనీసం, ఇప్పుడైనా అలా అనిపిస్తోంది."

"తెలివైనది. మనం ఇంకా ముందుకు వెళ్లి కొన్ని లైన్ల కోడ్ వ్రాస్దాం