విషయము
- తరగతులు మరియు ఆబ్జెక్ట్ ఓరియెంటెడ్ ప్రోగ్రామింగ్‌ను అర్థం చేసుకోవడం
- క్రొత్త తరగతిని సృష్టిస్తోంది
- ప్రవర్తనలను కలుపుతోంది
- దాని వద్ద కుందేళ్ళు వంటివి
- ఫైబొనాక్సీ
- ఇక్కడ నుండి ఎటు వెళ్దాం? Android కోసం C # ఎలా నేర్చుకోవాలి
C # నేర్చుకోవడంపై ఈ Android ట్యుటోరియల్ సిరీస్‌లో ఒక భాగంలో, మేము C # ప్రోగ్రామింగ్ యొక్క సంపూర్ణ ప్రాథమికాలను పరిశీలించాము. మేము పద్ధతులు (నిర్దిష్ట పనులను చేసే కోడ్ సమూహాలు), కొన్ని ప్రాథమిక వాక్యనిర్మాణం (సెమీ కోలన్ల అవసరం వంటివి), వేరియబుల్స్ (డేటాను నిల్వ చేసే కంటైనర్లు) మరియు ప్రవాహ నియంత్రణ కోసం “ఉంటే స్టేట్‌మెంట్‌లు” (విలువలపై ఆధారపడే బ్రాంచింగ్ కోడ్) వేరియబుల్స్). పద్ధతుల మధ్య వాదనలుగా తీగలను వంటి వేరియబుల్స్ ఎలా పాస్ చేయాలో కూడా చూశాము.
మీరు ఇంతకు మునుపు చదవకపోతే మీరు తిరిగి వెళ్లి చూడండి.
ఈ సమయంలో, మీరు క్విజ్‌లు, డేటాను నిల్వ చేసే అనువర్తనాలు లేదా కాలిక్యులేటర్లు వంటి కొన్ని ప్రాథమిక కన్సోల్ అనువర్తనాలను తయారు చేయగలగాలి.
రెండవ భాగంలో, మేము కొంచెం ఎక్కువ ప్రతిష్టాత్మకంగా పొందబోతున్నాము, మరికొన్ని ప్రాథమికాలను - ఉచ్చులు వంటివి - మరియు తరగతులను ఎలా సృష్టించాలో మరియు ఎలా సంభాషించాలో అన్వేషిస్తాము. అంటే మేము Android అభివృద్ధిలో కత్తిపోటు ప్రారంభించగలుగుతాము మరియు ఆ అంతరాన్ని ఎలా తగ్గించాలో చూస్తాము. మీరు నిజంగా C # నేర్చుకోవాలనుకుంటే చదవడం కొనసాగించండి!
తరగతులు మరియు ఆబ్జెక్ట్ ఓరియెంటెడ్ ప్రోగ్రామింగ్‌ను అర్థం చేసుకోవడం
మొదటి భాగంలో క్లుప్తంగా, ఆబ్జెక్ట్ ఓరియెంటెడ్ ప్రోగ్రామింగ్ యొక్క ప్రాథమికాలను మేము వివరించాము, ఇది “వస్తువులను” వివరించడానికి “తరగతులు” ఉపయోగించి భాషల చుట్టూ తిరుగుతుంది. ఒక వస్తువు డేటా యొక్క భాగం, ఇది చాలా విషయాలను సూచిస్తుంది. ఇది స్ప్రింగ్ వంటి ఆట ప్రపంచంలో అక్షర వస్తువు కావచ్చు లేదా ఆటగాడి స్కోర్‌ను నిర్వహించే మేనేజర్ వంటి మరింత వియుక్తంగా ఉండవచ్చు.
ఒకే తరగతి బహుళ వస్తువులను సృష్టించగలదు. కాబట్టి మీరు ఒక “శత్రువు” తరగతిని వ్రాయవచ్చు, కాని చెడ్డవాళ్ళతో నిండిన మొత్తం స్థాయిని సృష్టించగలుగుతారు. ఆబ్జెక్ట్ ఓరియెంటెడ్ ప్రోగ్రామింగ్ ఉపయోగించడం వల్ల కలిగే పెద్ద ప్రయోజనాల్లో ఇది ఒకటి. లేకపోతే, శత్రువుల యొక్క ప్రవర్తనను నిర్వహించడానికి ఏకైక మార్గం చాలా వ్యక్తిగత పద్ధతులను ఉపయోగించడం, ప్రతి ఒక్కటి చెడ్డ వ్యక్తి వివిధ పరిస్థితులలో ఎలా ప్రవర్తించాలో సూచనలను కలిగి ఉంటుంది.
మీ తల చుట్టూ తిరగడానికి ఇది ఇంకా కొంచెం గమ్మత్తైనది అయితే, మీరు నిజంగా తెలుసుకోవలసినది ఏమిటంటే వస్తువులు లక్షణాలు మరియు ప్రవర్తనలను కలిగి ఉంటాయి. ఇది నిజమైన వస్తువుల మాదిరిగానే ఉంటుంది. ఉదాహరణకు, కుందేలు పరిమాణం, రంగు మరియు పేరు వంటి లక్షణాలను కలిగి ఉంటుంది; మరియు ఇది దూకడం, కూర్చోవడం మరియు తినడం వంటి ప్రవర్తనలను కలిగి ఉంటుంది. ముఖ్యంగా, లక్షణాలు వేరియబుల్స్ మరియు ప్రవర్తనలు పద్ధతులు.
చివరి పాఠంలో మేము నిర్మించిన ప్రోగ్రామ్ ఒక తరగతికి కూడా ఒక ఉదాహరణ. మేము ఇక్కడ వివరిస్తున్న “ఆబ్జెక్ట్” ఒకరకమైన పాస్‌వర్డ్ నియంత్రణ వ్యవస్థ. ఇది కలిగి ఉన్న ఆస్తి స్ట్రింగ్ యూజర్‌నేమ్, మరియు దాని ప్రవర్తన న్యూమెథడ్ (యూజర్ పేరును తనిఖీ చేసి వారిని పలకరించడం).
అది ఉంటేఇప్పటికీ కొంచెం గందరగోళంగా ఉంది, మన తలలను చుట్టుముట్టడానికి ఏకైక మార్గం క్రొత్త తరగతి లేదా రెండింటిని సృష్టించడం!
క్రొత్త తరగతిని సృష్టిస్తోంది
మీరు C # నేర్చుకోబోతున్నట్లయితే, మీరు కొత్త తరగతులను ఎలా చేయాలో తెలుసుకోవాలి. అదృష్టవశాత్తూ, ఇది చాలా సులభం. ప్రాజెక్ట్ మెను ఐటెమ్ క్లిక్ చేసి, ఆపై “+ క్లాస్ జోడించు” ఎంచుకోండి.
“C #” ని ఎంచుకుని “కుందేలు” అని పిలవండి. సంభావిత కుందేళ్ళను సృష్టించడానికి మేము ఈ తరగతిని ఉపయోగించబోతున్నాము. క్షణంలో నేను అర్థం ఏమిటో మీరు చూస్తారు.
మీరు కుడి వైపున ఉన్న మీ సొల్యూషన్ ఎక్స్‌ప్లోరర్‌లో తనిఖీ చేస్తే, ప్రోగ్రామ్.సి.ల క్రింద రాబిట్.సిస్ అనే క్రొత్త ఫైల్ సృష్టించబడిందని మీరు చూస్తారు. బాగా చేసారు - మీరు Android కోసం C # నేర్చుకోవాలనుకుంటే తెలుసుకోవలసిన కీలకమైన వాటిలో ఇది ఒకటి!
క్రొత్త Rabbit.cs ఫైల్‌లో మునుపటిలాగే అదే “బాయిలర్‌ప్లేట్” కోడ్ ఉంది. ఇది ఇప్పటికీ అదే నేమ్‌స్పేస్‌కు చెందినది, మరియు దీనికి ఫైల్ వలె అదే పేరుతో తరగతి ఉంది.
నేమ్‌స్పేస్ కన్సోల్అప్ 2 {క్లాస్ రాబిట్ {}}
ఇప్పుడు మేము మా కుందేలుకు “కన్స్ట్రక్టర్” అని పిలిచే కొన్ని లక్షణాలను ఇవ్వబోతున్నాము.
కన్స్ట్రక్టర్ అనేది ఒక తరగతిలో ఒక వస్తువు, ఇది వస్తువును ప్రారంభిస్తుంది, మేము దానిని మొదట సృష్టించినప్పుడు దాని లక్షణాలను నిర్వచించటానికి అనుమతిస్తుంది. ఈ సందర్భంలో, మేము చెప్పబోయేది ఇక్కడ ఉంది:
నేమ్‌స్పేస్ కన్సోల్అప్ 2 {క్లాస్ రాబిట్ {పబ్లిక్ స్ట్రింగ్ రాబిట్‌నేమ్; పబ్లిక్ స్ట్రింగ్ రాబిట్ కలర్; పబ్లిక్ ఇంటెంట్ రాబిట్ ఏజ్; పబ్లిక్ ఇంటెంట్ రాబిట్‌వైట్; పబ్లిక్ రాబిట్ (స్ట్రింగ్ పేరు, స్ట్రింగ్ రంగు, పూర్ణాంక వయస్సు, పూర్ణాంక బరువు) {రాబిట్ నేమ్ = పేరు; రాబిట్ కలర్ = రంగు; కుందేలు = వయస్సు; కుందేలు బరువు = బరువు; }}}
ఇది వేరే తరగతి నుండి కొత్త కుందేలును సృష్టించడానికి మరియు దాని లక్షణాలను మనం చేసే విధంగా నిర్వచించడానికి అనుమతిస్తుంది:
రాబిట్ రాబిట్ 1 = కొత్త రాబిట్ (“జెఫ్”, “బ్రౌన్”, 1, 1);
పునరాలోచన బరువులో దశాంశాలను అనుమతించడానికి ఫ్లోట్ లేదా డబుల్ అయి ఉండాలని నేను ఇప్పుడు గ్రహించాను, కానీ మీకు ఆలోచన వస్తుంది. మేము మా కుందేలును సమీప మొత్తం సంఖ్యకు చుట్టుముట్టబోతున్నాము.
మీరు మీ కుందేలును వ్రాసేటప్పుడు చూస్తారు, సరైన వాదనలు పంపమని మీరు ప్రాంప్ట్ చేయబడతారు. ఈ విధంగా, మీ తరగతి దాదాపుగా కోడ్‌లో ఒక భాగంగా మారింది.
నమ్మండి లేదా కాదు, ఈ కోడ్ కుందేలును సృష్టించింది! మీ కుందేలును మీరు చూడలేరు ఎందుకంటే మాకు గ్రాఫిక్స్ లేవు, కానీ అది ఉంది.
మరియు దానిని నిరూపించడానికి, మీరు ఇప్పుడు ఈ పంక్తిని ఉపయోగించవచ్చు:
Console.WriteLine (Rabbit1.RabbitName);
ఇది మీరు ఇప్పుడే సృష్టించిన కుందేలు పేరును మీకు తెలియజేస్తుంది!
మన కుందేలు యొక్క బరువును కూడా మనం పెంచవచ్చు:
Rabbit1.RabbitWeight ++; కన్సోల్.రైట్‌లైన్ (రాబిట్ 1.రాబిట్‌నేమ్ + "బరువు" + రాబిట్ 1.రాబిట్‌వైట్ + "కేజీ");
ఏదో చివర “++” ని జోడించడం వల్ల దాని విలువ ఒక్కొక్కటిగా పెరుగుతుందని ఇక్కడ గమనించండి (మీరు “రాబిట్‌వైట్ = రాబిట్‌వైట్ + 1” అని కూడా వ్రాయవచ్చు).
మా తరగతి మనకు నచ్చినంత ఎక్కువ కుందేళ్ళను చేయగలదు కాబట్టి, మనం వేర్వేరు కుందేళ్ళను సృష్టించవచ్చు, ఒక్కొక్కటి వాటి స్వంత లక్షణాలతో ఉంటాయి.
ప్రవర్తనలను కలుపుతోంది
అప్పుడు మేము మా కుందేలుకు ఒక రకమైన ప్రవర్తనను ఇవ్వడానికి కూడా ఎంచుకోవచ్చు. ఈ సందర్భంలో, వారిని తిననివ్వండి.
ఇది చేయుటకు, మేము “ఈట్” అనే పబ్లిక్ పద్దతిని సృష్టిస్తాము మరియు ఇది తినే శబ్దాన్ని చేస్తుంది, అదే సమయంలో కుందేలు బరువును కూడా పెంచుతుంది:
పబ్లిక్ శూన్యత తినండి () {కన్సోల్.రైట్‌లైన్ (రాబిట్‌నేమ్ + ": నిబుల్ నిబుల్!"); RabbitWeight ++; }
గుర్తుంచుకోండి, ”పబ్లిక్” అంటే తరగతి వెలుపల నుండి ప్రాప్యత చేయగలదు మరియు “శూన్యత” అంటే పద్ధతి ఏ డేటాను తిరిగి ఇవ్వదు.
అప్పుడు, Program.cs లోపల నుండి, మేము ఈ పద్ధతిని పిలవగలుగుతాము మరియు ఇది మనకు నచ్చిన కుందేలు తినడానికి మరియు పెద్దదిగా చేస్తుంది:
కన్సోల్.రైట్‌లైన్ (రాబిట్ 1.రాబిట్‌నేమ్ + "బరువు" + రాబిట్ 1.రాబిట్‌వైట్ + "కేజీ"); Rabbit1.Eat (); Rabbit1.Eat (); Rabbit1.Eat (); కన్సోల్.రైట్‌లైన్ (రాబిట్ 1.రాబిట్‌నేమ్ + "బరువు" + రాబిట్ 1.రాబిట్‌వైట్ + "కేజీ");
అది జెఫ్‌ను మూడుసార్లు తినడానికి కారణమవుతుంది, అప్పుడు మేము దానిని వింటాము మరియు అతను పెద్దవాడయ్యాడని చూడగలుగుతాము! సన్నివేశంలో మాకు మరొక కుందేలు ఉంటే, వారు కూడా తినవచ్చు!
కన్సోల్.రైట్‌లైన్ (రాబిట్ 1.రాబిట్‌నేమ్ + "బరువు" + రాబిట్ 1.రాబిట్‌వైట్ + "కేజీ"); కన్సోల్.రైట్‌లైన్ (రాబిట్ 2.రాబిట్‌నేమ్ + "బరువు" + రాబిట్ 2.రాబిట్‌వైట్ + "కేజీ"); Rabbit1.Eat (); Rabbit1.Eat (); Rabbit2.Eat (); Rabbit2.Eat (); Rabbit1.Eat (); కన్సోల్.రైట్‌లైన్ (రాబిట్ 1.రాబిట్‌నేమ్ + "బరువు" + రాబిట్ 1.రాబిట్‌వైట్ + "కేజీ"); కన్సోల్.రైట్‌లైన్ (రాబిట్ 2.రాబిట్‌నేమ్ + "బరువు" + రాబిట్ 2.రాబిట్‌వైట్ + "కేజీ");
దాని వద్ద కుందేళ్ళు వంటివి
ప్రతి కుందేలు కోసం మేము ఆదేశాలను మానవీయంగా వ్రాయవలసి ఉంటుంది మరియు మనకు కావలసినంతవరకు కుందేళ్ళ సంఖ్యను డైనమిక్‌గా పెంచలేము కాబట్టి ఇది చాలా వస్తువులను నిర్వహించడానికి ప్రత్యేకంగా సొగసైన మార్గం కాదు. మేము C # ను నేర్చుకోవాలనుకోవడం లేదు - శుభ్రమైన C # కోడ్‌ను ఎలా రాయాలో నేర్చుకోవాలనుకుంటున్నాము!
అందుకే మేము జాబితాను ఉపయోగించవచ్చు. జాబితా ఒక సేకరణ; వేరియబుల్ ప్రాథమికంగా ఇతర వేరియబుల్స్కు సూచనలను కలిగి ఉంటుంది. ఈ సందర్భంలో, మేము కుందేళ్ళ జాబితాను తయారు చేయవచ్చు మరియు శుభవార్త ఇది అర్థం చేసుకోవడం చాలా సులభం:
జాబితా ఇది మునుపటిలా కొత్త కుందేలును సృష్టిస్తుంది, కానీ ఏకకాలంలో కుందేలును జాబితాకు జోడిస్తుంది. సమానంగా, మేము దీనిని చెప్పగలం: రాబిట్ రాబిట్ 3 = కొత్త రాబిట్ ("జానీ", "ఆరెంజ్", 1, 1); RabbitList.Add (Rabbit3); ఎలాగైనా, ఒక వస్తువు సృష్టించబడింది మరియు జాబితాకు జోడించబడింది. మేము మా కుందేళ్ళ జాబితా నుండి సమాచారాన్ని ఈ విధంగా సౌకర్యవంతంగా మరియు చక్కగా తిరిగి ఇవ్వవచ్చు: foreach (రాబిట్ జాబితాలో var రాబిట్) {కన్సోల్.రైట్‌లైన్ (రాబిట్.రాబిట్‌నేమ్ + "బరువు" + రాబిట్.రాబిట్‌వైట్ + "కేజీ"); } మీరు గుర్తించగలిగినట్లుగా, “foreach” అంటే మీరు జాబితాలోని ప్రతి అంశానికి ఒకసారి ఒక అడుగు పునరావృతం చేస్తారు. మీరు మీ జాబితా నుండి సమాచారాన్ని కూడా తిరిగి పొందవచ్చు: RabbitList.Eat (); ఇక్కడ “1” అనేది సూచిక, అంటే మీరు మొదటి స్థానంలో నిల్వ చేసిన సమాచారాన్ని సూచిస్తున్నారు. ఇది జరిగినప్పుడు, అది వాస్తవానికి రెండవ మీరు జోడించిన కుందేలు: ఎందుకంటే ప్రోగ్రామింగ్‌లోని జాబితాలు ఎల్లప్పుడూ 0 వద్ద ప్రారంభమవుతాయి. మీరు ఇంకా ess హించకపోతే, మేము ఇప్పుడు ఫైబొనాక్సీ క్రమాన్ని సృష్టించడానికి ఈ సమాచారాన్ని ఉపయోగించబోతున్నాము. అన్నింటికంటే, మీరు Android కోసం C # నేర్చుకుంటుంటే, మీరు నిజంగా ఆ సిద్ధాంతంతో ఆసక్తికరంగా ఏదైనా చేయగలగాలి! ఫైబొనాక్సీ
ఫైబొనాక్సీ క్రమంలో, కుందేళ్ళను ఒక గదిలో మూసివేసి, సంతానోత్పత్తికి వదిలివేస్తారు. వారు ఒక నెల తరువాత పునరుత్పత్తి చేయగలరు, ఈ సమయంలో వారు లైంగికంగా పరిపక్వం చెందుతారు (ఇది సరైన రాబిట్ బయాలజీ కాదా అని నేను నిర్ధారించలేను). ప్రతి కుందేలు దంపతులు నెలకు ఒకసారి ఉత్పత్తి చేయగలిగితే, ఇద్దరు సంతానం ఉత్పత్తి చేస్తే, ఇక్కడ క్రమం ఎలా ఉంటుంది:
1,1,2,3,5,8,13,21,34
అద్భుతంగా, క్రమం లోని ప్రతి సంఖ్య మునుపటి రెండు సంఖ్యల విలువ. సైన్స్ ప్రకారం, ఇది ఒక పెద్ద విషయం.
మంచి విషయం ఏమిటంటే, మేము దానిని ప్రతిరూపం చేయవచ్చు.
మొదట, మేము క్రొత్త భావనను ప్రవేశపెట్టాలి: లూప్. షరతు నెరవేరే వరకు ఇది ఒకే కోడ్‌ను పదే పదే పునరావృతం చేస్తుంది. “ఫర్” లూప్ వేరియబుల్ సృష్టించడం ద్వారా, మనం కలుసుకోవాలనుకునే పరిస్థితులను సెట్ చేసి, ఆపై దానిపై పనిచేయడం ద్వారా దీన్ని అనుమతిస్తుంది - అన్నీ బ్రాకెట్లలో నిర్వచించబడ్డాయి:
(int నెలలు = 0; నెలలు <100; నెలలు ++) {// ఏదైనా చేయండి}
కాబట్టి మేము నెలలు అనే పూర్ణాంకాన్ని సృష్టిస్తున్నాము మరియు అది 100 కు సమానమయ్యే వరకు లూప్ చేస్తాము. అప్పుడు మేము నెలల సంఖ్యను ఒక్కొక్కటిగా పెంచుతాము.
ఇది ఫైబొనాక్సీ సీక్వెన్స్ ఎలా అవుతుందో చూడాలనుకుంటున్నారా? ఇదిగో:
నేమ్‌స్పేస్ కన్సోల్అప్ 2 {క్లాస్ ప్రోగ్రామ్ {స్టాటిక్ శూన్యత ప్రధాన (స్ట్రింగ్ అర్గ్స్) {జాబితా సరే, నేను అనుకున్నదానికన్నా కష్టం! నేను వీటన్నిటి గురించి వెళ్ళడం లేదు, కానీ మీరు ఇప్పటికే నేర్చుకున్న వాటిని ఉపయోగించి, మీరు దానిని రివర్స్ ఇంజనీర్ చేయగలగాలి. దీన్ని చేయడానికి ఖచ్చితంగా మరింత సొగసైన మార్గాలు ఉన్నాయి - నేను గణిత శాస్త్రజ్ఞుడు కాదు. అయితే, ఇది చాలా సరదా వ్యాయామం అని నేను భావిస్తున్నాను, ఒకసారి మీరు దీన్ని చేయగలిగితే, మీరు పెద్ద సమయం కోసం సిద్ధంగా ఉన్నారు. నేను ఇతర విధానాలను చూడటానికి ఇష్టపడతాను! మీ బెల్ట్ క్రింద ఉన్న అన్ని జ్ఞానంతో, మీరు పెద్ద విషయాలను ప్రారంభించడానికి సిద్ధంగా ఉన్నారు. ప్రత్యేకించి, మీరు Xamarin లేదా Unity లో C # తో Android ప్రోగ్రామింగ్‌లో కత్తిపోటు వేయడానికి సిద్ధంగా ఉన్నారు.ఇక్కడ నుండి ఎటు వెళ్దాం? Android కోసం C # ఎలా నేర్చుకోవాలి
ఇది భిన్నంగా ఉంటుంది ఎందుకంటే మీరు Google, Microsoft మరియు యూనిటీ అందించిన తరగతులను ఉపయోగిస్తున్నారు. మీరు “RigidBody2D.velocity” వంటిదాన్ని వ్రాసేటప్పుడు మీరు చేస్తున్నది తరగతి నుండి ఒక ఆస్తిని యాక్సెస్ చేయడం అని RigidBody2D. ఇది ఒకే విధంగా పనిచేస్తుంది, ఒకే తేడా ఏమిటంటే మీరు RigidBody2D ని చూడలేరు ఎందుకంటే మీరు దీన్ని మీరే నిర్మించలేదు.
మీ బెల్ట్ క్రింద ఉన్న ఈ సి # తో, మీరు ఈ ఎంపికలలో దేనినైనా దూకడానికి సిద్ధంగా ఉండాలి మరియు ఏమి జరుగుతుందో అర్థం చేసుకునేటప్పుడు పెద్ద ప్రారంభాన్ని కలిగి ఉండాలి:
- Xamarin తో Android అనువర్తనాన్ని ఎలా తయారు చేయాలి
- యూనిటీతో 7 నిమిషాల్లో మీ మొట్టమొదటి Android గేమ్‌ను రూపొందించండి
రాబోయే పాఠంలో, మీరు యు-టర్న్ తీసుకొని, విండోస్ అనువర్తనాలను రూపొందించడానికి దీన్ని ఎలా ఉపయోగించాలో కూడా మేము పరిశీలిస్తాము!
