ఇతర ప్రసిద్ధ భాషల నుండి జావా ఎలా భిన్నంగా ఉంటుంది? నేర్చుకునే మొదటి భాష జావా ఎందుకు కావాలి? మొదటి నుండి మరియు ఇతర భాషలలో ప్రోగ్రామింగ్ నైపుణ్యాలను వర్తింపజేయడం ద్వారా జావాను నేర్చుకోవడంలో మీకు సహాయపడే ప్రణాళికను రూపొందించండి. జావాలో ప్రొడక్షన్ కోడ్‌ని సృష్టించడం మరియు ఇతర భాషలలో అభివృద్ధి చేయడం మధ్య తేడాలను జాబితా చేద్దాం. భవిష్యత్తులో పాల్గొనేవారి కోసం జరిగిన సమావేశంలో మిఖాయిల్ జాటెప్యాకిన్ ఈ నివేదికను చదివారు Yandex మరియు ఇతర ప్రారంభ డెవలపర్లు - జావా జూనియర్ సమావేశం.
- అందరికీ హలో, నా పేరు మిషా. నేను Yandex.Market నుండి డెవలపర్‌ని, మరియు ఈ రోజు నేను జావాను ఎందుకు నేర్చుకోవాలో మరియు దానిని ఎలా సమర్థవంతంగా చేయాలో మీకు చెప్తాను. మీరు ఒక సహేతుకమైన ప్రశ్న అడగవచ్చు: నేను ఈ కథను ఎందుకు చెబుతున్నాను మరియు చాలా సంవత్సరాల అనుభవం ఉన్న బలమైన డెవలపర్‌ను కాదా? వాస్తవం ఏమిటంటే, నేను జావాను ఇటీవలే, సుమారు ఒకటిన్నర సంవత్సరాల క్రితం చదివాను, కాబట్టి అది ఎలా ఉందో మరియు ఏ ఆపదలు ఉన్నాయో నాకు ఇప్పటికీ గుర్తుంది.
ఒక సంవత్సరం క్రితం నేను Yandex.Marketలో ఇంటర్న్‌షిప్ పొందాను. నేను బెరు కోసం బ్యాకెండ్‌ని అభివృద్ధి చేసాను, మార్కెట్ కోసం, మీరు బహుశా దీనిని ఉపయోగించారు. ఇప్పుడు నేను అక్కడ వేరే టీమ్‌లో పని చేస్తూనే ఉన్నాను. మేము వ్యాపార భాగస్వాముల కోసం Yandex.Market కోసం విశ్లేషణాత్మక వేదికను సృష్టిస్తాము.
ప్రారంభిద్దాం. ఆచరణాత్మక కోణం నుండి జావాను ఎందుకు నేర్చుకోవాలి? వాస్తవం ఏమిటంటే జావా చాలా ప్రసిద్ధ ప్రోగ్రామింగ్ భాష. ఇది చాలా పెద్ద సంఘాన్ని కలిగి ఉంది.
ఉదాహరణకు, అటువంటి TIOBE ఇండెక్స్ ఉంది, ప్రోగ్రామింగ్ లాంగ్వేజెస్ యొక్క ప్రజాదరణ యొక్క ప్రసిద్ధ సూచిక, మరియు జావా అక్కడ మొదటి స్థానంలో ఉంది. అలాగే, జాబ్ సైట్‌లలో, జావాలో చాలా ఖాళీలు ఉన్నాయని మీరు గమనించవచ్చు, అంటే జావాలో అభివృద్ధి చేయడం ద్వారా, మీరు ఎల్లప్పుడూ ఉద్యోగం పొందవచ్చు.
కమ్యూనిటీ చాలా పెద్దది కాబట్టి, మీకు ఏవైనా సందేహాలుంటే కొన్ని స్టాక్ ఓవర్‌ఫ్లో లేదా ఇతర సైట్‌లలో సమాధానాన్ని కనుగొనవచ్చు. అలాగే, జావాలో అభివృద్ధి చేస్తున్నప్పుడు, మీరు వాస్తవానికి JVMలో కోడ్‌ని వ్రాస్తున్నారు, కాబట్టి మీరు JVMని ఉపయోగించే కోట్లిన్, స్కాలా మరియు ఇతర భాషలకు సులభంగా మారవచ్చు.
సైద్ధాంతిక దృక్కోణం నుండి జావాలో ఏది మంచిది? వివిధ ప్రోగ్రామింగ్ భాషలు ఉన్నాయి. వారు వివిధ సమస్యలను పరిష్కరిస్తారు, మీకు తెలుసు. ఉదాహరణకు, శీఘ్ర సమస్యలను పరిష్కరించడానికి పైథాన్ వన్-లైన్ స్క్రిప్ట్‌లను వ్రాయడానికి గొప్పది.
ప్లస్ వైపు, మీరు ఎక్జిక్యూటబుల్ కోడ్‌ను పూర్తిగా నియంత్రించవచ్చు. ఉదాహరణకు, మాకు కార్లు ఉన్నాయి, Yandex డ్రైవర్‌లెస్ కార్లు, వాటి కోడ్ ప్లస్‌లలో వ్రాయబడింది. ఎందుకు? జావాలో అలాంటి విషయం ఉంది - చెత్త కలెక్టర్. ఇది అనవసరమైన వస్తువుల నుండి RAMని క్లియర్ చేస్తుంది. ఈ విషయం ఆకస్మికంగా ప్రారంభమవుతుంది మరియు ప్రపంచాన్ని ఆపివేస్తుంది, అంటే, ఇది మిగిలిన ప్రోగ్రామ్‌ను ఆపివేస్తుంది మరియు వస్తువులను లెక్కించడానికి వెళుతుంది, వస్తువుల జ్ఞాపకశక్తిని క్లియర్ చేస్తుంది. అలాంటిది డ్రోన్‌లో పనిచేస్తే, అది చల్లగా ఉండదు. మీ డ్రోన్ నేరుగా డ్రైవ్ చేస్తుంది, ఈ సమయంలో దాని మెమరీని క్లియర్ చేస్తుంది మరియు రహదారి వైపు చూడదు. అందువల్ల, డ్రోన్ ప్రోస్ మీద వ్రాయబడింది.
జావా ఏ సమస్యలను పరిష్కరిస్తుంది? ఇది ప్రధానంగా డజన్ల కొద్దీ లేదా వందలాది మంది వ్యక్తులచే సంవత్సరాలుగా వ్రాయబడిన పెద్ద ప్రోగ్రామ్‌లను అభివృద్ధి చేయడానికి ఒక భాష. ముఖ్యంగా, Yandex.Marketలో చాలా బ్యాకెండ్ జావాలో వ్రాయబడింది. మాకు అనేక నగరాల్లో పంపిణీ చేయబడిన బృందం ఉంది, ఒక్కొక్కటి పది మంది. మరియు కోడ్ నిర్వహించడం సులభం, దీనికి పది సంవత్సరాలు లేదా అంతకంటే ఎక్కువ కాలం మద్దతు ఉంది మరియు అదే సమయంలో కొత్త వ్యక్తులు వచ్చి ఈ కోడ్‌ను అర్థం చేసుకుంటారు.
ఒక భాష ఏ లక్షణాలను కలిగి ఉండాలి, తద్వారా దానిలోని కోడ్ సులభంగా మద్దతు ఇస్తుంది మరియు పెద్ద బృందాలలో సులభంగా అభివృద్ధి చేయబడుతుంది. అన్నింటిలో మొదటిది, ఇది చదవగలిగే కోడ్ అయి ఉండాలి మరియు సంక్లిష్ట నిర్మాణ పరిష్కారాలను అమలు చేయడం సులభం. అంటే, హై-లెవల్ అబ్‌స్ట్రాక్షన్స్ రాయడం సులువుగా ఉండాలి.. ఇవన్నీ జావా మనకు అందజేస్తుంది. ఇది ఆబ్జెక్ట్ ఓరియెంటెడ్ లాంగ్వేజ్. ఉన్నత-స్థాయి సంగ్రహణలు మరియు సంక్లిష్ట నిర్మాణాలను అమలు చేయడం నిజంగా సులభం.
జావా కోసం చాలా ఫ్రేమ్‌వర్క్‌లు మరియు లైబ్రరీలు కూడా ఉన్నాయి, ఎందుకంటే భాష 15 సంవత్సరాల కంటే ఎక్కువ పాతది. ఈ సమయంలో, వ్రాయగలిగే ప్రతిదీ దానిపై వ్రాయబడింది, కాబట్టి మీకు అవసరమైన ప్రతిదానికీ టన్నుల కొద్దీ లైబ్రరీలు ఉన్నాయి.
నా అభిప్రాయం ప్రకారం, ప్రారంభ JA ప్లేయర్‌కు ఏ ప్రాథమిక నైపుణ్యాలు ఉండాలి? అన్నింటిలో మొదటిది, ఇది జావా కోర్ భాష యొక్క జ్ఞానం. తదుపరిది డిపెండెన్సీ ఇంజెక్షన్ ఫ్రేమ్‌వర్క్. తదుపరి స్పీకర్ కిరిల్ దీని గురించి మరింత పూర్తిగా మాట్లాడతారు. నేను చాలా లోతుగా వెళ్ళను. తదుపరిది ఆర్కిటెక్చర్ మరియు డిజైన్ నమూనాలు. పెద్ద అప్లికేషన్‌లను వ్రాయాలంటే మనం వాస్తుపరంగా అందమైన కోడ్‌ను వ్రాయగలగాలి. మరియు ఇది డేటాబేస్తో పనిచేసే పనుల కోసం ఒక రకమైన SQL లేదా ORM. మరియు ఇది బ్యాకెండ్‌కు మరింత వర్తిస్తుంది.
వెళ్ళండి! జావా కోర్. నేను నిజంగా ఇక్కడ అమెరికాను కనుగొనలేను-మీరు భాషను తెలుసుకోవాలి. మీరు ఏమి శ్రద్ధ వహించాలి. మొదట, జావా ఇటీవలి సంవత్సరాలలో చాలా వెర్షన్‌లను విడుదల చేసింది, అంటే 2014-2015లో ఏడవది విడుదలైంది, ఆపై ఎనిమిదవ, తొమ్మిదవ, పదవ, చాలా కొత్త వెర్షన్లు మరియు వాటిలో చాలా కొత్త మంచి విషయాలు ప్రవేశపెట్టబడ్డాయి. , ఉదాహరణకు, Java Stream API , lambda, మొదలైనవి. ప్రొడక్షన్ కోడ్‌లో ఉపయోగించే చాలా చక్కని, తాజా, చక్కని విషయాలు, ఇంటర్వ్యూలలో వారు ఏమి అడుగుతారు మరియు మీరు తెలుసుకోవలసినవి. కాబట్టి, మీరు జావా-4 లైబ్రరీలోని షెల్ఫ్ నుండి పుస్తకాన్ని తీసుకోకండి మరియు దానిని నేర్చుకోకండి. ఇది మా ప్రణాళిక: మేము జావా-8 లేదా అంతకంటే ఎక్కువ నేర్చుకుంటాము.
Stream API, var మొదలైన ఆవిష్కరణలపై మేము చాలా శ్రద్ధ చూపుతాము. అవి ఇంటర్వ్యూల సమయంలో అడగబడతాయి మరియు ఉత్పత్తిలో నిరంతరం ఉపయోగించబడతాయి. అంటే, స్ట్రీమ్ API లూప్‌ల కంటే చాలా చల్లగా ఉంటుంది, సాధారణంగా, చాలా బాగుంది. శ్రద్ధ పెట్టాలని నిర్ధారించుకోండి.
మరియు ఇటరేటర్లు, మినహాయింపులు మొదలైన అన్ని రకాల విషయాలు ఉన్నాయి. కొన్ని చిన్న కోడ్‌లను మీరే వ్రాసుకున్నంత వరకు మీకు అప్రధానంగా అనిపించే అంశాలు. మీకు ఈ మినహాయింపులు అవసరం లేదు, ఏది ఏమైనా ఎవరికి అవసరం? కానీ వారు ఖచ్చితంగా ఇంటర్వ్యూలలో అడుగుతారు, వారు ఖచ్చితంగా ఉత్పత్తిలో మీకు ఉపయోగకరంగా ఉంటారు. సాధారణంగా, మీరు మినహాయింపులు, పునరావృత్తులు మరియు ఇతర విషయాలపై శ్రద్ధ వహించాలి.
డేటా నిర్మాణాలు. మీరు నిర్మాణాలు లేకుండా వెళ్లలేరు, కానీ సెట్‌లు, నిఘంటువులు మరియు షీట్‌లు ఉన్నాయని మీకు తెలియకపోతే అది చాలా బాగుంటుంది. మరియు నిర్మాణాల యొక్క వివిధ అమలులు కూడా. ఉదాహరణకు, Javaలోని అదే నిఘంటువు HashMap మరియు TreeMapతో సహా అనేక అమలులను కలిగి ఉంది. వారు వేర్వేరు అసింప్టోటిక్స్ కలిగి ఉంటారు, అవి లోపల విభిన్నంగా నిర్మించబడ్డాయి. అవి ఎలా విభిన్నంగా ఉంటాయి మరియు ఏది ఎప్పుడు ఉపయోగించాలో మీరు తెలుసుకోవాలి.
ఈ డేటా స్ట్రక్చర్‌లు అంతర్గతంగా ఎలా పనిచేస్తాయో మీకు తెలిస్తే కూడా చాలా బాగుంది. అంటే, వారి అసిమ్ప్టోటిక్‌లను తెలుసుకోవడం అంత సులభం కాదు - పందెం ఎంత పని చేస్తుంది, పాస్ ఎంతకాలం పని చేస్తుంది, కానీ లోపల నిర్మాణం ఎలా పనిచేస్తుంది - ఉదాహరణకు, HashMapలో బకెట్ అంటే ఏమిటి.
చెట్లు మరియు గ్రాఫ్‌లపై కూడా శ్రద్ధ చూపడం విలువ. ఇవి ప్రొడక్షన్ కోడ్‌లో చాలా సాధారణం కాని విషయాలు, కానీ అవి ఇంటర్వ్యూలలో ప్రసిద్ధి చెందాయి. దీని ప్రకారం, మీరు వెడల్పు మరియు లోతులో చెట్లను, గ్రాఫ్‌లను దాటగలగాలి. ఇవన్నీ సాధారణ అల్గోరిథంలు.
మీరు ఏదైనా పెద్ద కోడ్, కాంప్లెక్స్, లైబ్రరీలు, బహుళ-తరగతి కోడ్‌లను ఉపయోగించడం ప్రారంభించిన వెంటనే, సిస్టమ్‌లను నిర్మించకుండా మరియు డిపెండెన్సీలను పరిష్కరించకుండా మీకు కష్టమని మీరు గ్రహిస్తారు. ఇవి ప్రధానంగా మావెన్ మరియు గ్రేడిల్. మీ ప్రాజెక్ట్‌లోకి లైబ్రరీలను ఒక లైన్‌లో దిగుమతి చేసుకోవడానికి అవి మిమ్మల్ని అనుమతిస్తాయి. అంటే, మీరు ఒక-లైన్ xmlని వ్రాసి ప్రాజెక్ట్‌లోకి లైబ్రరీలను దిగుమతి చేయండి. గొప్ప వ్యవస్థలు. అవి దాదాపు ఒకే విధంగా ఉంటాయి, ఒకదానిని ఉపయోగించండి - మావెన్ లేదా గ్రాడిల్.
తదుపరి - ఒక రకమైన సంస్కరణ నియంత్రణ వ్యవస్థ. నేను Gitని సిఫార్సు చేస్తున్నాను ఎందుకంటే ఇది జనాదరణ పొందింది మరియు టన్నుల కొద్దీ ట్యుటోరియల్‌లు ఉన్నాయి. దాదాపు ప్రతి ఒక్కరూ Gitని ఉపయోగిస్తున్నారు, ఇది మంచి విషయం, మీరు అది లేకుండా జీవించలేరు.
మరియు ఒక రకమైన అభివృద్ధి వాతావరణం. నేను IntelliJ Ideaని సిఫార్సు చేస్తున్నాను. ఇది అభివృద్ధి ప్రక్రియను బాగా వేగవంతం చేస్తుంది, మీకు చాలా సహాయపడుతుంది, మీ కోసం అన్ని బాయిలర్‌ప్లేట్ కోడ్‌లను వ్రాస్తుంది, సాధారణంగా, ఇది బాగుంది.
స్లయిడ్ నుండి లింక్‌లు: ,
SQL. బ్యాకెండర్ల గురించి కొంచెం. నిజానికి ఇక్కడ ఒక తమాషా కేసు ఉంది. నా రెండవ ఇంటర్న్‌షిప్ ఇంటర్వ్యూకు రెండు రోజుల ముందు, ఒక HR అమ్మాయి నాకు ఫోన్ చేసి, రెండు రోజుల్లో SQL మరియు HTTP గురించి నన్ను అడుగుతానని, నేను దానిని నేర్చుకోవాలని చెప్పింది. మరియు నాకు SQL లేదా HTTP గురించి దాదాపు ఏమీ తెలియదు. మరియు నేను ఈ అద్భుతమైన సైట్‌ని కనుగొన్నాను - . నేను దానిపై SQLని 12 గంటల్లో నేర్చుకున్నాను, అంటే, SQL సింటాక్స్, SELECT ప్రశ్నలను ఎలా వ్రాయాలి, JOIN మొదలైనవి. చాలా కూల్ సైట్, నేను దీన్ని బాగా సిఫార్సు చేస్తున్నాను. నిజానికి, 12 గంటల్లో నేను ఇప్పుడు నాకు తెలిసిన వాటిలో 90% నేర్చుకున్నాను.
మరియు డేటాబేస్ ఆర్కిటెక్చర్ తెలుసుకోవడం కూడా చాలా బాగుంది. ఇవి అన్ని రకాల కీలు, సూచికలు, సాధారణీకరణ. హబ్రేలో దీని గురించి వరుస పోస్ట్‌లు ఉన్నాయి.
జావాలో, SQLతో పాటు, JPA వంటి అన్ని రకాల ఆబ్జెక్ట్-రిలేషనల్ మ్యాపింగ్ సిస్టమ్‌లు ఉన్నాయి. కొంత కోడ్ ఉంది. మొదటి పద్దతిలో కొన్ని SQL కోడ్ ఉంది - info.users నుండి ID పేరును ఎంచుకోండి, userIdsలో id ఎక్కడ ఉంది. వినియోగదారుల డేటాబేస్ నుండి, పట్టిక నుండి, వారి IDలు మరియు పేర్లు పొందబడతాయి.
తరువాత, ఒక నిర్దిష్ట మ్యాపర్ ఉంది, అది ఒక వస్తువును బేస్ నుండి జావా వస్తువుగా మారుస్తుంది. మరియు క్రింద మూడవ పద్ధతి ఉంది నిజానికి ఈ కోడ్ అమలు. ఇవన్నీ JPAని ఉపయోగించి ఒక లైన్‌తో భర్తీ చేయవచ్చు, ఇది క్రింద వ్రాయబడింది. ఇది అదే పనిని చేస్తుంది - అన్నీ ByIdIn కనుగొనండి. అంటే, పద్ధతి పేరు ఆధారంగా, ఇది మీ కోసం ఒక SQL ప్రశ్నను రూపొందిస్తుంది.
చాలా మంచి విషయం. నేనే, నాకు SQL తెలియనప్పుడు, JPAని ఉపయోగించాను. సాధారణంగా, శ్రద్ధ వహించండి. మీరు SQL నేర్చుకోవడానికి చాలా సోమరిగా ఉంటే, అది విపత్తు. మరియు, సాధారణంగా, అగ్ని!
వసంత. స్ప్రింగ్ ఫ్రేమ్‌వర్క్ వంటి దాని గురించి ఎవరు విన్నారు? మీలో ఎంతమంది ఉన్నారో మీరు చూస్తున్నారా? కారణం లేకుండా కాదు. ప్రతి రెండవ జావా బ్యాకెండ్ ఖాళీ అవసరాలలో స్ప్రింగ్ చేర్చబడుతుంది. అది లేకుండా, పెద్ద అభివృద్ధిలో ఎక్కడా లేదు. వసంతం అంటే ఏమిటి? అన్నింటిలో మొదటిది, ఇది డిపెండెన్సీ ఇంజెక్షన్ ఫ్రేమ్‌వర్క్. దీని గురించి కూడా తదుపరి స్పీకర్. కానీ సంక్షిప్తంగా, ఇది కొన్ని తరగతుల డిపెండెన్సీలను ఇతరులపైకి దిగుమతి చేయడాన్ని సులభతరం చేయడానికి మిమ్మల్ని అనుమతించే విషయం. అంటే, డిపెండెన్సీల జ్ఞానం సరళీకృతం చేయబడింది.
స్ప్రింగ్ బూట్ అనేది స్ప్రింగ్ యొక్క భాగం, ఇది మీ సర్వర్ అప్లికేషన్‌ను ఒక బటన్‌తో అమలు చేయడానికి మిమ్మల్ని అనుమతిస్తుంది. మీరు THIDకి వెళ్లి, రెండు బటన్‌లను నొక్కండి మరియు ఇప్పుడు మీరు మీ సర్వర్ అప్లికేషన్‌ని కలిగి ఉన్నారు మరియు లోకల్ హోస్ట్ 8080లో రన్ అవుతున్నారు. అంటే, మీరు ఇంకా ఒక లైన్ కోడ్ రాయలేదు, కానీ ఇది ఇప్పటికే పని చేస్తోంది. చాలా మంచి విషయం. సొంతంగా ఏదైనా రాస్తే నిప్పు!
స్ప్రింగ్ అనేది చాలా పెద్ద ఫ్రేమ్‌వర్క్. ఇది మీ సర్వర్ అప్లికేషన్‌ను తీయడమే కాకుండా డిపెండెన్సీ ఇంజెక్షన్‌ను పరిష్కరిస్తుంది. ఇది REST API పద్ధతులను సృష్టించడంతోపాటు అనేక విషయాలను చేయడానికి మిమ్మల్ని అనుమతిస్తుంది. అంటే, మీరు కొంత పద్ధతిని వ్రాసి దానికి గెట్ మ్యాపింగ్ ఉల్లేఖనాన్ని జోడించారు. మరియు ఇప్పుడు మీరు ఇప్పటికే లోకల్ హోస్ట్‌లో మీకు హలో వరల్డ్ అని వ్రాసే కొన్ని పద్ధతిని కలిగి ఉన్నారు. రెండు లైన్ల కోడ్ మరియు ఇది పనిచేస్తుంది. కూల్ స్టఫ్.
వసంతం పరీక్షలు రాయడం కూడా సులభతరం చేస్తుంది. పెద్ద అభివృద్ధిలో పరీక్ష లేకుండా మార్గం లేదు. కోడ్‌ను పరీక్షించాల్సిన అవసరం ఉంది. ఈ ప్రయోజనం కోసం, జావా కూల్ లైబ్రరీని కలిగి ఉంది JUnit 5. మరియు సాధారణంగా JUnit, కానీ తాజా వెర్షన్ ఐదవది. పరీక్ష కోసం ప్రతిదీ ఉంది, అన్ని రకాల వాదనలు మరియు ఇతర విషయాలు.
మరియు అద్భుతమైన మోకిటో ఫ్రేమ్‌వర్క్ ఉంది. మీరు పరీక్షించాలనుకుంటున్న కొన్ని కార్యాచరణలు ఉన్నాయని ఊహించుకోండి. ఫంక్షనాలిటీ చాలా పనులను చేస్తుంది, మధ్యలో ఎక్కడో, ఇది మీ IDతో VKontakte లోకి లాగిన్ అవుతుంది, ఉదాహరణకు, ID నుండి VKontakte వినియోగదారు యొక్క మొదటి మరియు చివరి పేరును అందుకుంటుంది. మీరు బహుశా పరీక్షలలో VKontakteని చేర్చలేరు, అది వింతగా ఉంది. కానీ మీరు ఫంక్షనాలిటీని పరీక్షించాలి, కాబట్టి మీరు మోకిటోని ఉపయోగించి ఈ తరగతిని తయారు చేసారు, దానిని మోక్ చేయండి, దానిని అనుకరించండి.
అటువంటి IDతో ఈ తరగతికి అభ్యర్థన వచ్చినప్పుడు, అది కొంత చివరి పేరును తిరిగి ఇస్తుంది, ఉదాహరణకు, Vasya Pupkin. మరియు అది పని చేస్తుంది. అంటే, మీరు మోక్ వన్ క్లాస్ కోసం అన్ని కార్యాచరణలను పరీక్షిస్తారు. చాలా మంచి విషయం.
డిజైన్ నమూనాలు. అదేంటి? ఇవి అభివృద్ధిలో ఉత్పన్నమయ్యే సాధారణ సమస్యలను పరిష్కరించడానికి టెంప్లేట్‌లు. అభివృద్ధిలో, ఒకేలా లేదా సారూప్య సమస్యలు తరచుగా తలెత్తుతాయి, అది ఏదో ఒకవిధంగా బాగా పరిష్కరించడానికి చాలా బాగుంటుంది. అందువల్ల, ప్రజలు ఈ సమస్యలను ఎలా పరిష్కరించాలో ఉత్తమ అభ్యాసాలు, నిర్దిష్ట టెంప్లేట్‌లతో ముందుకు వచ్చారు.
అత్యంత జనాదరణ పొందిన నమూనాలతో ఒక వెబ్‌సైట్ ఉంది - refactoring.guru, మీరు దానిని చదవవచ్చు, ఏ నమూనాలు ఉన్నాయో కనుగొనండి, సిద్ధాంతం యొక్క సమూహాన్ని చదవండి. సమస్య ఏమిటంటే ఇది ఆచరణాత్మకంగా పనికిరానిది. వాస్తవానికి, అభ్యాసం లేని నమూనాలు ప్రత్యేకంగా ఉపయోగపడవు.
మీరు Singletone లేదా Builder వంటి కొన్ని నమూనాల గురించి వినే ఉంటారు. ఈ మాటలు ఎవరు విన్నారు? చాలా మంది. మీరు మీరే అమలు చేయగల అటువంటి సాధారణ నమూనాలు ఉన్నాయి. కానీ చాలా నమూనాలు: వ్యూహం, ఫ్యాక్టరీ, ముఖభాగం - వాటిని ఎక్కడ దరఖాస్తు చేయాలో స్పష్టంగా లేదు.
మరియు మీరు మరొక వ్యక్తి కోడ్‌లో ఈ నమూనా వర్తించే స్థలాన్ని ఆచరణలో చూసే వరకు, మీరు దానిని మీరే వర్తింపజేయలేరు. అందువల్ల, నమూనాలతో సాధన చాలా ముఖ్యం. మరియు refactoring.guruలో వాటి గురించి చదవడం చాలా ఉపయోగకరంగా లేదు, కానీ ఇది ఖచ్చితంగా చేయడం విలువైనదే.
నమూనాలు ఎందుకు అవసరం? మీకు నిర్దిష్ట వినియోగదారు తరగతి ఉందని అనుకుందాం. దీనికి ఐడి మరియు పేరు ఉంది. ప్రతి వినియోగదారు తప్పనిసరిగా ఐడి మరియు పేరు రెండింటినీ కలిగి ఉండాలి. ఎగువ ఎడమవైపు తరగతి గది.
వినియోగదారుని ప్రారంభించే మార్గాలు ఏమిటి? రెండు ఎంపికలు ఉన్నాయి - కన్స్ట్రక్టర్ లేదా సెట్టర్. రెండు విధానాల యొక్క ప్రతికూలతలు ఏమిటి?
కన్స్ట్రక్టర్. కొత్త వినియోగదారు (7, "బాండ్"), సరే. ఇప్పుడు మనకు వినియోగదారు తరగతి లేదని చెప్పండి, కానీ ఏడు సంఖ్యా ఫీల్డ్‌లతో మరొకటి ఉంది. మీరు ఏడు వరుస సంఖ్యలను కలిగి ఉన్న కన్స్ట్రక్టర్‌ని కలిగి ఉంటారు. ఈ నంబర్లు ఏవి, వాటిలో ఏది ఏ ఆస్తికి చెందినదో స్పష్టంగా లేదు. డిజైనర్ గొప్పవాడు కాదు.
రెండవ ఎంపిక సెట్టర్. మీరు స్పష్టంగా వ్రాస్తారు: setId(7), setName("Bond"). ఏ ప్రాపర్టీ ఏ ఫీల్డ్‌కి చెందినదో మీకు అర్థమవుతుంది. కానీ సెట్టర్‌కి ఒక సమస్య ఉంది. మొదట, మీరు ఏదైనా కేటాయించడం మరచిపోవచ్చు మరియు రెండవది, మీ వస్తువు మార్చదగినదిగా మారుతుంది. ఇది థ్రెడ్ సురక్షితం కాదు మరియు కోడ్ రీడబిలిటీని కొద్దిగా తగ్గిస్తుంది. అందుకే ప్రజలు ఒక చల్లని నమూనాతో ముందుకు వచ్చారు - బిల్డర్.
ఇది దేని గురించి? రెండు విధానాల ప్రయోజనాలను-సెట్టర్ మరియు కన్స్ట్రక్టర్-ఒకదానిలో కలపడానికి ప్రయత్నిద్దాం. మేము బిల్డర్ అనే నిర్దిష్ట వస్తువును తయారు చేస్తాము, ఇందులో ఐడి మరియు నేమ్ ఫీల్డ్‌లు కూడా ఉంటాయి, ఇది సెట్టర్ ఆధారంగా నిర్మించబడుతుంది మరియు అన్ని పారామితులతో మీకు కొత్త వినియోగదారుని అందించే బిల్డ్ పద్ధతిని కలిగి ఉంటుంది. మనకు మార్పులేని వస్తువు మరియు సెట్టర్ లభిస్తుంది. కూల్!
సమస్యలు ఏమిటి? ఇక్కడ మనకు క్లాసిక్ బిల్డర్ ఉంది. సమస్య ఏమిటంటే, మనం ఇప్పటికీ ఏదో ఒక ఫీల్డ్‌లో తనిఖీ చేయడం మర్చిపోవచ్చు. మరియు మేము IDని సందర్శించడం మర్చిపోతే, ఈ సందర్భంలో బిల్డర్‌లో అది సున్నాకి ప్రారంభించబడుతుంది, ఎందుకంటే పూర్ణాంక రకం శూన్యమైనది కాదు. మరియు మనం "బాండ్" అనే పేరును తయారు చేసి, ID ఆఫీస్‌ని సందర్శించడం మర్చిపోతే, మనకు "0" ఐడి మరియు "బాండ్" అనే పేరు ఉన్న కొత్త యూజర్ వస్తుంది. చల్లగా లేదు.
దీనితో పోరాడటానికి ప్రయత్నిద్దాం. బిల్డర్‌లో మనం పూర్ణాంకానికి మారుస్తాము, తద్వారా అది శూన్యంగా ఉంటుంది. ఇప్పుడు అంతా చాలా బాగుంది.
మేము "బాండ్" పేరుతో వినియోగదారుని సృష్టించడానికి ప్రయత్నిస్తే, అతని IDని ఉంచడం మర్చిపోయి, మేము శూన్య పాయింటర్ మినహాయింపును పొందుతాము, ఎందుకంటే ID శూన్యమైనది కాదు మరియు బిల్డర్‌కు శూన్య, ప్రత్యేకంగా పాయింటర్ మినహాయింపు ఉంటుంది.
కానీ మనం ఇంకా పేరు పెట్టడం మర్చిపోవచ్చు, కాబట్టి మేము ఆబ్జెక్ట్ రీప్లేని శూన్యంగా సెట్ చేస్తాము. ఇప్పుడు, మేము బిల్డర్ నుండి మన వస్తువును నిర్మించినప్పుడు, ఫీల్డ్ శూన్యమైనది కాదని తనిఖీ చేస్తుంది. అంతే కాదు.
చివరి ఉదాహరణ చూద్దాం. ఈ సందర్భంలో, మేము ఏదో ఒకవిధంగా ID రన్‌టైమ్‌లో శూన్యతను ఉంచినట్లయితే, మీరు దీన్ని చేశారని వెంటనే తెలుసుకోవడం చాలా బాగుంది మరియు మీరు ఇప్పుడు పొరపాటు చేయడం మంచిది కాదు.
మీరు వినియోగదారుని సృష్టించే సమయంలో కాదు, కానీ మీరు IDకి శూన్యం సెట్ చేసినప్పుడు లోపాన్ని విసరాలి. అందువల్ల, బిల్డర్‌లో మేము సెట్టర్ పూర్ణాంకాన్ని పూర్ణాంకానికి మారుస్తాము మరియు అవి శూన్యతను విసిరాయని అతను వెంటనే ప్రమాణం చేస్తాడు.
సంక్షిప్తంగా, పాయింట్ ఏమిటి? సరళమైన బిల్డర్ నమూనా ఉంది, కానీ దాని అమలులో కూడా కొన్ని సూక్ష్మబేధాలు ఉన్నాయి, కాబట్టి నమూనాల యొక్క విభిన్న అమలులను చూడటం చాలా బాగుంది. ప్రతి నమూనా డజన్ల కొద్దీ అమలులను కలిగి ఉంటుంది. ఇదంతా చాలా ఆసక్తికరంగా ఉంది.
ప్రొడక్షన్ కోడ్‌లో బిల్డర్‌ని ఎలా వ్రాయాలి? ఇక్కడ మా వినియోగదారు ఉన్నారు. మేము దానికి లాంబాక్ లైబ్రరీ నుండి బిల్డర్ రొటేషన్‌ను జతచేస్తాము మరియు అది మన కోసం ఒక బిల్డర్‌ను ఉత్పత్తి చేస్తుంది. అంటే, మేము ఏ కోడ్‌ను వ్రాయము, కానీ జావా ఇప్పటికే ఈ తరగతికి బిల్డర్‌ని కలిగి ఉందని భావిస్తుంది మరియు మేము దానిని ఇలా పిలుస్తాము.
జావాలో దాదాపు అన్నింటికీ లైబ్రరీలు ఉన్నాయని నేను ఇప్పటికే చెప్పాను, లాంబాక్, బాయిలర్‌ప్లేట్ రాయకుండా ఉండటానికి మిమ్మల్ని అనుమతించే చల్లని లైబ్రరీ. బిల్డర్, GET.
నమూనాలు నిర్మాణపరంగా ఉంటాయి - ఒక తరగతికి మాత్రమే కాకుండా, మొత్తం వ్యవస్థకు సంబంధించినవి. సిస్టమ్ రూపకల్పనలో అటువంటి చల్లని సూత్రం ఉంది: ఒకే బాధ్యత సూత్రం. అతను దేని గురించి మాట్లాడుతున్నాడు? ప్రతి తరగతి దాని స్వంత కార్యాచరణకు బాధ్యత వహించాలి. ఈ సందర్భంలో, మేము వినియోగదారులు, JSON ఆబ్జెక్ట్‌లతో కమ్యూనికేట్ చేసే కంట్రోలర్‌ని కలిగి ఉన్నాము. ముఖభాగం ఉంది, ఇది JSON వస్తువులను మోడల్‌లుగా మారుస్తుంది, ఆ తర్వాత జావా అప్లికేషన్ పని చేస్తుంది. ఈ మోడల్‌లతో పనిచేసే సంక్లిష్ట తర్కాన్ని కలిగి ఉన్న సేవ ఉంది. ఈ మోడల్‌లను డేటాబేస్లో ఉంచి డేటాబేస్ నుండి తిరిగి పొందే డేటా యాక్సెస్ ఆబ్జెక్ట్ ఉంది. మరియు డేటాబేస్ కూడా ఉంది. మరో మాటలో చెప్పాలంటే, ఇదంతా ఒక తరగతిలో కాదు, కానీ మేము ఐదు వేర్వేరు తరగతులను తయారు చేస్తున్నాము మరియు అది మరొక నమూనా.
మీరు జావాను ఎక్కువ లేదా తక్కువ నేర్చుకున్న తర్వాత, మీ స్వంత ప్రాజెక్ట్‌ను వ్రాయడం చాలా బాగుంది, అది డేటాబేస్ కలిగి ఉంటుంది, ఇతర APIలతో పని చేస్తుంది మరియు మీ సర్వర్ అప్లికేషన్‌ను REST API క్లయింట్‌లకు బహిర్గతం చేస్తుంది. ఇది మీ రెజ్యూమ్‌కి జోడించడం గొప్ప విషయం, ఇది మీ విద్యకు చక్కని ముగింపు అవుతుంది. దీంతో వెళ్లి ఉద్యోగం చేసుకోవచ్చు.
నా సర్వర్ అప్లికేషన్ యొక్క ఉదాహరణ ఇక్కడ ఉంది. నా రెండవ సంవత్సరంలో, నేను అబ్బాయిలతో టర్మ్ పేపర్ వ్రాసాను. ఈవెంట్‌ల నిర్వహణ కోసం వారు మొబైల్ అప్లికేషన్‌ను వ్రాస్తున్నారు. అక్కడ, వినియోగదారులు VKontakte ద్వారా లాగిన్ చేయవచ్చు, మ్యాప్‌లో పాయింట్లను ఉంచవచ్చు, ఈవెంట్‌లను సృష్టించవచ్చు, వారి స్నేహితులను వారికి ఆహ్వానించవచ్చు, ఈవెంట్‌ల చిత్రాలను సేవ్ చేయవచ్చు.
ప్రాజెక్ట్‌లో నేను ఏమి చేసాను? SQLని ఉపయోగించకుండా స్ప్రింగ్ బూట్‌లో సర్వర్ అప్లికేషన్‌ను వ్రాశారు. నేను అతనిని తెలియదు, నేను JPA ఉపయోగించాను. అది ఏమి చేయగలదు? OAuth-2 ద్వారా VKకి లాగిన్ చేయండి. వినియోగదారు యొక్క టోకెన్ తీసుకోండి, దానితో VK కి వెళ్లండి, ఇది నిజమైన వినియోగదారు అని తనిఖీ చేయండి. VKontakte ద్వారా వినియోగదారుల గురించి సమాచారాన్ని స్వీకరించండి. ఇది JPA ద్వారా కూడా సమాచారాన్ని డేటాబేస్లో సేవ్ చేయగలిగింది. కంప్యూటర్ మెమరీలో చిత్రాలు మరియు ఇతర ఫైల్‌లను నైపుణ్యంగా సేవ్ చేయండి మరియు వాటికి లింక్‌లను డేటాబేస్లో సేవ్ చేయండి. ఆ సమయంలో డేటాబేస్లో CLOB వస్తువులు ఉన్నాయని నాకు తెలియదు, కాబట్టి నేను ఈ విధంగా చేసాను. వినియోగదారులు, క్లయింట్ అప్లికేషన్‌ల కోసం REST API ఉంది. మరియు ప్రాథమిక కార్యాచరణ కోసం యూనిట్ పరీక్షలు ఉన్నాయి.
[…] నేను జావాను విజయవంతంగా నేర్చుకోవడానికి ఒక చిన్న ఉదాహరణ. విశ్వవిద్యాలయంలో నా మొదటి సంవత్సరంలో, నాకు C# బోధించబడింది మరియు OOP ప్రోగ్రామింగ్‌పై అవగాహన కల్పించబడింది - తరగతులు, ఇంటర్‌ఫేస్‌లు, సంగ్రహణ ఏమిటి మరియు అవి ఎందుకు అవసరమవుతాయి. ఇది నాకు చాలా సహాయపడింది. ఇది లేకుండా, జావా నేర్చుకోవడం చాలా కష్టం; తరగతులు ఎందుకు అవసరమో స్పష్టంగా లేదు.
విశ్వవిద్యాలయంలో నా రెండవ సంవత్సరంలో, వారు మళ్లీ జావా కోర్ నేర్పించారు, కానీ నేను అక్కడితో ఆగలేదు, నేనే స్ప్రింగ్‌ని అధ్యయనం చేయడానికి వెళ్లి, నేను పైన పేర్కొన్న కోర్సు పేపర్, నా ప్రాజెక్ట్ రాశాను. మరియు వీటన్నింటితో, నేను Yandex వద్ద ఇంటర్న్‌షిప్ కోసం వెళ్ళాను, ఒక ఇంటర్వ్యూలో ఉత్తీర్ణత సాధించాను మరియు Yandex.Marketలోకి ప్రవేశించాను. అక్కడ నేను Beru కోసం బ్యాకెండ్ వ్రాసాను, ఇది మా మార్కెట్ ప్లేస్ మరియు Yandex.Market కోసం.
ఆ తర్వాత ఆరు నెలల క్రితం అదే మార్కెట్‌లోని మరో టీమ్‌కి బదిలీ అయ్యాను. మేము వ్యాపార భాగస్వాముల కోసం విశ్లేషణలు చేస్తాము. మేము విశ్లేషణాత్మక ప్లాట్‌ఫారమ్‌లో ఉన్నాము, బ్యాకెండ్‌లో మేము ముగ్గురు ఉన్నాము, కాబట్టి ప్రాజెక్ట్‌పై నాకు చాలా ఎక్కువ ప్రభావం ఉంది. ఇది చాలా ఆసక్తికరంగా ఉంది, నిజానికి. అంటే, మేము వాస్తవానికి మార్కెట్లో డేటాను అందిస్తాము - అమ్మకాలు ఏవి, ఏ వర్గాలలో, ఏ మోడల్‌లలో, వ్యాపార భాగస్వాములకు, పెద్ద ప్రసిద్ధ కంపెనీలకు. మరియు మనలో ముగ్గురు మాత్రమే ఉన్నారు, మేము ఈ కోడ్‌ను వ్రాస్తాము మరియు ఇది చాలా బాగుంది.
ధన్యవాదాలు! ఉపయోగకరమైన లింకులు:
- .
- .
- .
- .
- .
- .
- .
- .
మూలం: www.habr.com