జావా కార్యక్రమాలు ఎలా నిర్వహించబడతాయి

1. వస్తువులు మరియు తరగతులు

ఈ రోజు మీరు సాధారణ జావా ప్రోగ్రామ్ ఎలా పనిచేస్తుందనే దాని గురించి కొంచెం నేర్చుకుంటారు. ఇక్కడ పెద్ద వార్త ఉంది: ప్రతి జావా ప్రోగ్రామ్‌లో తరగతులు మరియు వస్తువులు ఉంటాయి.

తరగతులు ఏమిటో మీకు ఇప్పటికే తెలుసు, కానీ వస్తువులు ఏమిటి?

నేను ఒక సారూప్యతతో ప్రారంభిస్తాను. మీరు ఒక చిన్న ఓడను తయారు చేయాలనుకుంటున్నారని ఊహించుకోండి. మొదట మీరు బ్లూప్రింట్‌ను రూపొందించి, ఆపై దానిని ఫ్యాక్టరీకి ఇవ్వాలి, ఇక్కడ బ్లూప్రింట్ ప్రకారం ఓడ నిర్మించబడుతుంది. లేదా బహుశా డజను. లేదా మీకు నచ్చినన్ని ఓడలు. ఒకే బ్లూప్రింట్ ప్రకారం డజన్ల కొద్దీ ఒకేలాంటి ఓడలు నిర్మించబడ్డాయి. అదే ఇక్కడ ముఖ్యమైన విషయం.

జావా ప్రోగ్రామింగ్‌లో కూడా అంతే.

బ్లూప్రింట్‌లు

ప్రోగ్రామర్ ఒక డిజైనర్ లాంటివాడు. ఒక డిజైనర్ బ్లూప్రింట్‌లను సృష్టిస్తాడు మరియు జావా ప్రోగ్రామర్ తరగతులను వ్రాస్తాడు. బ్లూప్రింట్‌ల ఆధారంగా భాగాలు సృష్టించబడతాయి మరియు తరగతుల ఆధారంగా వస్తువులు సృష్టించబడతాయి.

మొదట, మేము తరగతులను వ్రాస్తాము (బ్లూప్రింట్లను తయారు చేస్తాము), ఆపై, ప్రోగ్రామ్ నడుస్తున్నప్పుడు, జావా యంత్రం ఈ తరగతుల ఆధారంగా వస్తువులను సృష్టిస్తుంది. అదే విధంగా బ్లూప్రింట్‌ల నుండి నౌకలు సృష్టించబడతాయి.

ఒక బ్లూప్రింట్ మాత్రమే ఉంది, కానీ చాలా నౌకలు ఉండవచ్చు. ఓడలు విభిన్నంగా ఉంటాయి - అవి వేర్వేరు పేర్లను కలిగి ఉంటాయి మరియు వేర్వేరు సరుకులను తీసుకువెళతాయి. కానీ అవి చాలా పోలి ఉంటాయి: అవన్నీ ఒకే డిజైన్‌ను పంచుకుంటాయి మరియు ఇలాంటి పనులను చేయగలవు.

లేదా ఇక్కడ మరొక సారూప్యత ఉంది...

పుట్ట

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

ప్రతి తరగతి చీమల సంఖ్య భిన్నంగా ఉంటుంది. పుట్ట మొత్తానికి ఒకే రాణి ఉంది, కానీ డజన్ల కొద్దీ సైనికులు మరియు వందల సంఖ్యలో కార్మికుల చీమలు ఉన్నాయి. మూడు తరగతులు మరియు వందలాది వస్తువులు. చీమలు ఒకదానితో ఒకటి సంకర్షణ చెందుతాయి - వారి ఒకే తరగతి చీమలతో మరియు ఇతర తరగతుల చీమలతో - కఠినమైన నియమాల ప్రకారం.

ఇది సరైన ఉదాహరణ. ఒక సాధారణ ప్రోగ్రామ్‌లో ప్రతిదీ సరిగ్గా ఇలాగే ఉంటుంది. అన్ని ఇతర తరగతుల వస్తువులను సృష్టించే ప్రాథమిక వస్తువు ఉంది. వస్తువులు ఒకదానితో ఒకటి మరియు ప్రోగ్రామ్ యొక్క "బయటి ప్రపంచం"తో పరస్పర చర్య చేయడం ప్రారంభిస్తాయి. వస్తువుల ప్రవర్తన అంతర్గతంగా హార్డ్‌కోడ్ చేయబడింది.

ఈ రెండు సారూప్యతలు ఒకే నాణానికి రెండు వైపులా ఉంటాయి. నిజం మధ్యలో ఉంది. మొదటి ఉదాహరణ (బ్లూప్రింట్ మరియు నౌకల గురించి) తరగతి మరియు ఆ తరగతి వస్తువుల మధ్య సంబంధాన్ని చూపుతుంది. ఇది బలమైన సారూప్యత. రెండవ ఉదాహరణ (ఒక పుట్ట గురించి) వ్రాతపూర్వక తరగతులు మరియు ప్రోగ్రామ్ నడుస్తున్నప్పుడు ఉన్న వస్తువుల మధ్య సంబంధాన్ని చూపుతుంది.

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

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

డాక్యుమెంటేషన్

మరియు పద్ధతులకు ఏ డేటాను పాస్ చేయాలో మీకు ఎలా తెలుసు? నీకంటే ముందు వచ్చిన వాళ్ళు అంతా అనుకున్నారు.

ప్రతి తరగతి సాధారణంగా దేని కోసం సృష్టించబడిందో చెప్పే వివరణను కలిగి ఉంటుంది. అలాగే, ప్రతి పబ్లిక్ పద్దతి సాధారణంగా అది ఏమి చేస్తుందో మరియు దానికి ఏ డేటాను పంపాలి అనే వివరణను కలిగి ఉంటుంది.

తరగతిని ఉపయోగించడానికి, అది ఏమి చేస్తుందో మీకు సాధారణ ఆలోచన ఉండాలి. మరియు ప్రతి పద్ధతి ఏమి చేస్తుందో మీరు ఖచ్చితంగా తెలుసుకోవాలి. కానీ అది ఎలా చేస్తుందో మీరు తెలుసుకోవలసిన అవసరం లేదు. ఇది మంత్రదండం లాంటిది.

ఫైల్‌ను కాపీ చేయడానికి కోడ్‌ను చూద్దాం:

package com.codegym.lesson2;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileCopy
{
   public static void main(String[] args) throws IOException
   {
      FileInputStream fileInputStream = new FileInputStream("c:\\data.txt");
      FileOutputStream fileOutputStream = new FileOutputStream("c:\\result.txt");

      while (fileInputStream.available() > 0)
      {
         int data = fileInputStream.read();
         fileOutputStream.write(data);
      }

      fileInputStream.close();
      fileOutputStream.close();
   }
}

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

2. ప్రోగ్రామ్ రూపకల్పన

ప్రోగ్రామ్ రూపకల్పన మొత్తం కళ. ఇది ఏకకాలంలో సులభం మరియు కష్టం. సరళమైనది, ఎందుకంటే కఠినమైన చట్టాలు లేవు: నిషేధించబడని ఏదైనా అనుమతించబడుతుంది. బాగా, మరియు అది కూడా కష్టతరం చేస్తుంది: ఏదైనా చేయడానికి చాలా మార్గాలు ఉన్నాయి మరియు ఉత్తమమైనదాన్ని కనుగొనడం సులభం కాదు.

ప్రోగ్రాం డిజైన్ చేయడమంటే పుస్తకం రాయడం లాంటిదే. ఒక వైపు, మీరు కేవలం అక్షరాలు, పదాలు మరియు వాక్యాలను వ్రాస్తారు. మరోవైపు ఇతివృత్తం, పాత్రలు, అంతర్గత వైరుధ్యాలు, సంఘర్షణలు, కథన శైలి, చమత్కారం మొదలైనవి ముఖ్యమైనవి.

ప్రధాన విషయం ఏమిటంటే మీరు ఎవరి కోసం కోడ్ వ్రాస్తున్నారో అర్థం చేసుకోవడం. మరియు మీరు ఇతర ప్రోగ్రామర్ల కోసం కోడ్ వ్రాస్తారు .

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

కోడ్‌కు చాలా ముఖ్యమైనది ఏమిటంటే అది ఇతర ప్రోగ్రామర్‌లకు అర్థమయ్యేలా ఉండాలి. అర్థమయ్యే సరికాని కోడ్ సరిదిద్దవచ్చు. సరైనది కాని అపారమయిన కోడ్‌ని మెరుగుపరచడం సాధ్యం కాదు.  మీరు చేయగలిగినదంతా దానిని విస్మరించడమే.

కాబట్టి మీరు మంచి, క్లీన్ కోడ్ ఎలా వ్రాయగలరు?

దీన్ని చేయడానికి మూడు విషయాలు అవసరం:

• పద్ధతుల లోపల మంచి మరియు అర్థమయ్యే కోడ్ రాయడం - ఇది సులభమైన అవసరం
• ప్రోగ్రామ్‌లో ఏ ఎంటిటీలను చేర్చాలో నిర్ణయించడం
• ప్రోగ్రామ్‌ను సరిగ్గా తార్కిక భాగాలుగా విభజించడం

ఈ భావనల వెనుక ఏమి ఉంది?

మెథడ్స్ లోపల మంచి కోడ్ రాయడం

మీకు ప్రాథమిక ఆంగ్ల నైపుణ్యాలు కూడా ఉంటే, కొన్నిసార్లు కోడ్‌ని ఆంగ్ల వాక్యాలుగా చదవడం ఎంత సులభమో మీరు గమనించి ఉండవచ్చు:

• class Cat extends Pet— దీని అర్థం క్యాట్ క్లాస్ పెట్ క్లాస్‌ని విస్తరించింది
• while(stream.ready())- స్ట్రీమ్ సిద్ధంగా ఉన్నంత కాలం...
• if (a<b) return a; else return b- aకంటే తక్కువగా ఉంటే b, తిరిగి ఇవ్వండి a, లేకపోతే తిరిగి ఇవ్వండి b.

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

కోడ్ వ్రాస్తున్నప్పుడు, మీ పని వీలైనంత సరళంగా మరియు సంక్షిప్తంగా చేయడం. మీ కోడ్ చదవడం సులభం కాదా అని ఆలోచించండి మరియు మీరు సరైన దిశలో వెళ్లడం ప్రారంభిస్తారు.

జావాలో, సులభంగా చదవగలిగే కోడ్ రాయడం ఆచారం. ప్రాధాన్యంగా, ఒక పద్ధతికి సంబంధించిన అన్ని కోడ్‌లు ఒకే స్క్రీన్‌పై సరిపోతాయి (అంటే 20-30 లైన్లు). ఇది మొత్తం జావా కమ్యూనిటీకి ప్రమాణం. కోడ్‌ని మెరుగుపరచగలిగితే, దాన్ని మెరుగుపరచాలి.

మంచి కోడ్ ఎలా వ్రాయాలో తెలుసుకోవడానికి ఉత్తమ మార్గం అభ్యాసం. చాలా కోడ్‌లను వ్రాయండి, ఇతరుల కోడ్‌ను అధ్యయనం చేయండి మరియు మీ కోడ్‌ని సమీక్షించమని మరింత అనుభవజ్ఞులైన సహోద్యోగులను అడగండి.

మరియు "తగినంతగా ఒంటరిగా వదిలేయండి" అని మీరు చెప్పుకున్న క్షణం మీ ఎదుగుదల ఆగిపోతుందని గుర్తుంచుకోండి.

ప్రోగ్రామ్‌లో ఏ ఎంటిటీలను చేర్చాలో నిర్ణయించడం

మీరు ఇతర ప్రోగ్రామర్లు అర్థం చేసుకోగలిగే కోడ్ రాయాలి. ప్రోగ్రామ్ రూపకల్పనలో 10 మంది ప్రోగ్రామర్‌లలో 9 మంది A, B మరియు C తరగతులను కలిగి ఉంటే, మీరు మీ ప్రోగ్రామ్‌లో A, B మరియు C తరగతులను కూడా చేయాలి. ఇతరులు అర్థం చేసుకునేలా మీరు తప్పనిసరిగా కోడ్ రాయాలి.

గొప్పది, పని చేస్తుంది, వేగవంతమైనది, కానీ ప్రామాణికం కాని కోడ్ చెడ్డ కోడ్.

మీరు ఇతర వ్యక్తుల ప్రాజెక్ట్‌లను అధ్యయనం చేయాలి: దశాబ్దాలుగా IT పరిశ్రమలో పేరుకుపోయిన అన్ని జ్ఞానాన్ని నానబెట్టడానికి ఇది ఉత్తమమైన, వేగవంతమైన మరియు సులభమైన మార్గం.

అలాగే, మీరు ఇప్పటికే అద్భుతమైన, జనాదరణ పొందిన మరియు చక్కగా డాక్యుమెంట్ చేయబడిన ప్రాజెక్ట్‌కి ప్రాప్యతను కలిగి ఉన్నారు — Java SDK . దానితో ప్రారంభించండి.

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

మీరు ఈ ప్రశ్నలన్నింటికీ సమాధానాలను అర్థం చేసుకోవడం ప్రారంభించిన తర్వాత, ఇతరులు అర్థం చేసుకోగలిగే కోడ్‌ను మీరు వ్రాయగలరు.

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

ప్రోగ్రామ్‌ను సరిగ్గా తార్కిక భాగాలుగా విభజించడం

దాదాపు ప్రతి ప్రోగ్రామ్ భాగాలు లేదా మాడ్యూల్స్‌గా విభజించబడింది. ప్రతి భాగం ప్రోగ్రామ్ యొక్క దాని స్వంత అంశానికి బాధ్యత వహిస్తుంది.

కంప్యూటర్‌లో మదర్‌బోర్డు, మానిటర్ మరియు కీబోర్డ్ ఉంటాయి - ఇవన్నీ విడివిడిగా, వదులుగా-కపుల్డ్ భాగాలు. ఇంకా ఏమిటంటే, అవి ప్రామాణిక మార్గాల్లో పరస్పర చర్య చేస్తాయి: USB, HDMI, మొదలైనవి. మీరు మీ కీబోర్డ్‌పై కాఫీని చిమ్మితే, మీరు దానిని సింక్‌లో శుభ్రం చేసి, ఆరనివ్వండి, ఆపై దాన్ని ఉపయోగించడం కొనసాగించవచ్చు.

కానీ ల్యాప్‌టాప్ అనేది ఏకశిలా నిర్మాణానికి ఒక ఉదాహరణ: మనం విడివిడిగా తార్కిక భాగాలను గుర్తించగలమని అనిపిస్తుంది, కానీ అవి చాలా సమీకృతంగా ఉంటాయి. MacBookProలో, మీరు కీబోర్డ్‌ను శుభ్రం చేయడానికి ల్యాప్‌టాప్‌లో సగం భాగాన్ని విడదీయాలి. మరియు మీ కాఫీని ల్యాప్‌టాప్‌లో చిందించడం కొత్త ల్యాప్‌టాప్‌ను ఆర్డర్ చేయడానికి ఒక కారణం. కొత్త కప్పు కాఫీ కాదు.

3. మీ స్వంత తరగతులను సృష్టించడం

కానీ మీరు ప్రోగ్రామ్ చేయడం నేర్చుకుంటున్నందున, మీ స్వంత తరగతులను సృష్టించడం నేర్చుకోవడం ద్వారా మీరు చిన్నగా ప్రారంభించాలి.

అయితే, మీరు ఇప్పటికే తరగతులను సృష్టించారు, కానీ ప్రోగ్రామ్‌లో ఏ తరగతులను చేర్చాలి, వాటికి ఎలా పేరు పెట్టాలి మరియు వాటికి ఏ పద్ధతులు ఉండాలి అనే విషయాలను మీరు అర్థం చేసుకోవడం నేర్చుకోవాలి. మరియు వారు ఒకరితో ఒకరు ఎలా వ్యవహరించాలి.

ఎంటిటీల జాబితా

ఎక్కడ ప్రారంభించాలో మీకు తెలియకపోతే, మొదటి నుండి ప్రారంభించండి.

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

ఉదాహరణ

మీరు చెస్ గేమ్ రాయాలనుకుంటున్నారని అనుకుందాం. మీకు ఈ క్రింది అంశాలు అవసరం: ఒక చదరంగం బోర్డు మరియు 6 రకాల చెస్ ముక్కలు. ముక్కలు వేర్వేరు మార్గాల్లో కదులుతాయి మరియు విభిన్న విలువలను కలిగి ఉంటాయి. అవి ప్రత్యేక తరగతులు అని అర్ధమవుతుంది. నిజానికి, మీరు మొదట ప్రారంభించినప్పుడు, ఎక్కువ తరగతులు, మంచివి.

రెండు తరగతులకు బదులు పది తరగతులు రాసే కొత్త ప్రోగ్రామర్‌ను కలవడం చాలా అరుదు. పది తరగతులు రాయడానికి బదులుగా, ప్రారంభకులకు రెండు తరగతులు లేదా బహుశా ఒకటి రాయడానికి ఇష్టపడతారు. కాబట్టి దయచేసి మరిన్ని తరగతులను వ్రాయండి, నా తోటి ప్రోగ్రామర్లు. మరియు మీ కోడ్ మీకు తప్ప అందరికీ స్పష్టంగా కనిపిస్తుంది 😛

చదరంగం

మేము చదరంగం కోసం తరగతులు వ్రాయాలని నిర్ణయించుకున్నామని అనుకుందాం: ఈ తరగతులు ఎలా ఉంటాయి?

చదరంగం బోర్డు కేవలం 8 బై 8 శ్రేణి మాత్రమేనా? శ్రేణికి సూచనను అంతర్గతంగా నిల్వ చేసే ప్రత్యేక తరగతిని సృష్టించడం మంచిది. అప్పుడు మీరు "చెస్‌బోర్డ్" తరగతికి చాలా ఉపయోగకరమైన పద్ధతులను జోడించవచ్చు, ఉదాహరణకు, నిర్దిష్ట సెల్ ఖాళీగా ఉందో లేదా ఆక్రమించబడిందో తనిఖీ చేయడానికి

సాధారణంగా, మీరు ప్రారంభించినప్పుడు, ఎల్లప్పుడూ ఈ సూత్రం ద్వారా మార్గనిర్దేశం చేయండి: ప్రోగ్రామ్‌లో వివిధ ఎంటిటీలు ఉంటాయి మరియు ఒక ఎంటిటీకి ఒక రకం ఉంటుంది. ఈ రకం తరగతి.

4. స్టాటిక్ వేరియబుల్స్ మరియు పద్ధతులు

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

ప్రోగ్రామ్‌లో ఎక్కడి నుండైనా ప్రాప్తి చేయగల స్టాటిక్ వేరియబుల్స్ సాధారణంగా "ఎల్లప్పుడూ ఉనికిలో ఉన్న" వస్తువులకు సంబంధించిన సూచనలను నిరంతరం దాటవేయడానికి ఉపయోగించబడతాయి.

ఉదాహరణకు, ఇలా:

public class ChessBoard
{
   public static ChessBoard board = new ChessBoard();
   public ChessItem[][] cells = new ChessItem[8][8];
   ...
}

public class Game
{
   public static void main(String[] args)
   {
      var board = ChessBoard.board;
      board.cells[0][3] = new King(Color.WHITE);
      board.cells[0][4] = new Queen(Color.WHITE);
      ...
   }
}

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

public class ChessBoard
{
   private static ChessBoard board = new ChessBoard();
   public static ChessBoard getBoard()
   {
      return board;
   }

   public ChessItem[][] cells = new ChessItem[8][8];
   ...
}

public class Game
{
   public static void main(String[] args)
   {
      var board = ChessBoard.getBoard();
      board.cells[0][3] = new King(Color.WHITE);
      board.cells[0][4] = new Queen(Color.WHITE);
      ...
   }
}