"హాయ్, అమిగో! తప్పుల గురించి మాట్లాడటం కొనసాగిద్దాం. ఈసారి, కంపైలర్ మీకు ఎల్లప్పుడూ సహాయం చేయని తప్పులను మేము విశ్లేషిస్తాము. శ్రద్ధ వహించండి మరియు మీరు మీ గురించి కొంత నేర్చుకుంటారు."
"నేను వినడానికి సిద్ధంగా ఉన్నాను, డియెగో. ఇది నాకు చాలా ఇబ్బందిగా ఉండదని నేను ఆశిస్తున్నాను."
వస్తువులతో పోల్చడం==
"మా అగ్ర ఇష్టమైన కొత్త ప్రోగ్రామర్ తప్పుల జాబితా ఆపరేటర్ని ఉపయోగించి వస్తువులను (ముఖ్యంగా స్ట్రింగ్లు) పోల్చడంతో ప్రారంభమవుతుంది ==
"
ఉదాహరణ:
Scanner console = new Scanner(System.in);
String s1 = console.nextLine();
String s2 = console.nextLine();
if (s1 == s2)
{
System.out.println("The strings are equal");
}
"నేను చాలా తరచుగా చేసాను. ఇప్పుడు ఈ కోడ్ "ది స్ట్రింగ్స్ ఈక్వల్" అని ఎప్పటికీ ప్రదర్శించదని నేను స్పష్టంగా చూడగలను, ఎందుకంటే స్టేట్మెంట్ if
రెండు వేర్వేరు స్ట్రింగ్ ఆబ్జెక్ట్లతో రిఫరెన్స్లను పోలుస్తుంది."
"అవును. అందుకే సరైన ఎంపిక:
Scanner console = new Scanner(System.in);
String s1 = console.nextLine();
String s2 = console.nextLine();
if (s1.equals(s2))
{
System.out.println("The strings are equal");
}
String
వస్తువును మార్చడం
"క్లాస్లోని అన్ని వస్తువులు మార్పులేనివని మరియు తరగతిలోని ప్రతి పద్ధతి String
కొత్త వస్తువును తిరిగి ఇస్తుందని కొత్త ప్రోగ్రామర్లు తరచుగా మరచిపోతారు - ప్రస్తుత వస్తువు ఎప్పటికీ మారదు."
" మార్పులేని అర్థం ఏమిటో నేను చాలా కాలం క్రితం నేర్చుకున్నాను , కానీ నేను దీన్ని చేశానని అనుకుంటున్నాను.
"నేను దాని గురించి చాలా ఖచ్చితంగా ఉన్నాను. ఉదాహరణ:
String s = "Hello";
s.toUpperCase (); // Convert to uppercase
"ఈ కోడ్ సరైన కోడ్కి చాలా పోలి ఉంటుంది, కానీ ఇది ఊహించిన విధంగా పని చేయదు. పద్ధతి toUpperCase()
అది పిలిచే వస్తువును మార్చదు. సరైన కోడ్ ఇలా ఉంటుంది:
String s = "Hello";
String result = s.toUpperCase(); // Convert to uppercase
"సరిగ్గా. నేను అలా చేసాను, కానీ నాకు నిజంగా తప్పు ఏమిటో కూడా అర్థం కాలేదు. క్లారిఫికేషన్ కోసం ధన్యవాదాలు!"
శ్రేణి యొక్క మూలకాలు అయిన వస్తువులను ప్రారంభించడం మర్చిపోవడం
"అరే వేరియబుల్ని ప్రారంభించడం మర్చిపోవడం మరొక సాధారణ తప్పు. ఉదాహరణ:
int[] array;
array[0] = 1;
array[0] = 2;
"ఈ కోడ్ పని చేయదు: మీరు శ్రేణి యొక్క మూలకాలను నిల్వ చేసే కంటైనర్ ఆబ్జెక్ట్కు సూచనకు సమానమైన అర్రే వేరియబుల్ను స్పష్టంగా సెట్ చేయాలి. సరైన వెర్షన్:
int[] array = new int[10];
array[0] = 1;
array[0] = 2;
ఇన్స్టాన్స్ వేరియబుల్కు బదులుగా లోకల్ వేరియబుల్ని ఉపయోగించడం.
"కొత్తవారు వేరియబుల్స్ కోసం పొడవైన మరియు అర్థవంతమైన పేర్లతో రావడానికి ఇష్టపడరు."
"ఇది చాలా నిజం. పనులు త్వరగా పూర్తి చేయడం కోసం, నేను కొన్నిసార్లు a
, b
, మరియు వంటి వేరియబుల్స్ పేర్లను ఇస్తాను i
."
"అలా చేయవద్దు. కోడ్లో ఇలాంటి అనేక వేరియబుల్స్ ఉన్నప్పుడు చేయడం చాలా క్రూరమైన పని:
శ్రేణిలోని 100 సెల్లలో 99 సంఖ్యను ఉంచండి |
---|
|
"సరైన పేర్లతో కోడ్లో తప్పులు చేయడం చాలా కష్టం. సరైన సంస్కరణ ఇలా కనిపిస్తుంది:
శ్రేణిలోని 100 సెల్లలో 99 సంఖ్యను ఉంచండి |
---|
|
సేకరణ అంశాన్ని తీసివేయడం
"మీరు ఇప్పటికే కలెక్షన్లను పరిశీలించారా?"
"అక్షరాలా కేవలం ఒక కన్నుతో."
"నేను దేని గురించి మాట్లాడుతున్నానో మీకు తెలియకుంటే, భవిష్యత్తులో పరిశీలించడానికి మీరే ఒక గమనికను రూపొందించుకోండి. చాలా తరచుగా సేకరణ నుండి నిర్దిష్ట మూలకాన్ని తీసివేయాల్సిన సందర్భాలు ఉంటాయి. కోడ్ దాదాపు ఇలా కనిపిస్తుంది ఇది:
ArrayList<Integer> list = new ArrayList<Integer>();
Collections.addAll(list, 0, -5, -7, -12, 5, 15);
for (Integer value: list)
if (value < 0)
list.remove(value);
"ఈ కోడ్ పని చేయదు, ఎందుకంటే మీరు for-each
సేకరణలోని మూలకాలను ఏకకాలంలో దాటడానికి మరియు ఆ సేకరణను సవరించడానికి లూప్ని ఉపయోగించలేరు.
"అనేక పరిష్కారాలు ఉన్నాయి. ముందుగా, మీరు ఒక సేకరణను దాటవచ్చు మరియు మరొక సేకరణను మార్చవచ్చు:
పరిష్కారం 1 |
---|
|
"రెండవది, జావా 8 నుండి, సేకరణలు ఒక removeIf()
పద్ధతిని కలిగి ఉన్నాయి, దానికి మీరు ఏ మూలకాలను తొలగించాలో సూచించే నియమాన్ని (లాంబ్డా ఫంక్షన్) పాస్ చేయవచ్చు. ఉదాహరణ:
పరిష్కారం 2 |
---|
|
మాడిఫైయర్తో అనేక తరగతులను public
ఒకే ఫైల్లో ఉంచడం
"ఒక ఫైల్లో ఒక పబ్లిక్ క్లాస్ మాత్రమే ఉంటుంది. ఫైల్లో మరిన్ని తరగతులు ప్రకటించబడతాయి, కానీ అవి తప్పనిసరిగా పబ్లిక్ క్లాస్ యొక్క అంతర్గత తరగతులుగా ఉండాలి లేదా మాడిఫైయర్ను కలిగి ఉండకూడదు. ఉదాహరణ public
:
Solution.java ఫైల్ యొక్క కంటెంట్లు | గమనిక |
---|---|
|
ఇది అనుమతించబడదు: ఒకే ఫైల్లో రెండు పబ్లిక్ తరగతులు. |
|
కానీ మీరు దీన్ని చేయవచ్చు. ప్రధాన తరగతి పబ్లిక్ కాదు |
|
మరియు మీరు దీన్ని చేయవచ్చు. ప్రధాన తరగతి ఒక సమూహ తరగతి |
main()
స్టాటిక్ పద్ధతి నుండి తరగతి యొక్క సాధారణ (నాన్-స్టాటిక్) పద్ధతులను పిలవడం
"కొన్నిసార్లు కొత్త ప్రోగ్రామర్లు నాన్-స్టాటిక్ వేరియబుల్స్ మరియు మెథడ్లను మెథడ్ లేదా ఇతర స్టాటిక్ మెథడ్స్ నుండి యాక్సెస్ చేయడానికి ప్రయత్నిస్తారు main()
. అలాంటి కోడ్ పని చేయదు.
public class Solution
{
public int n = 100;
public int[] createArray()
{
return new int[n];
}
public static void main(String[]args)
{
int[] array = createArray();
}
}
" main
పద్ధతి స్టాటిక్ మెథడ్స్/వేరియబుల్స్ను మాత్రమే సూచించగలదు. సరే, లేదా అది మొదట క్లాస్ యొక్క ఉదాహరణను సృష్టించాలి Solution
, ఆపై మాత్రమే ఆ ఆబ్జెక్ట్ యొక్క నాన్-స్టాటిక్ పద్ధతులను కాల్ చేయాలి. ఉదాహరణ:
పరిష్కారం 1 | పరిష్కారం 2 |
---|---|
|
|
ఒక పద్ధతి వలె కన్స్ట్రక్టర్ను ప్రకటించడం
"తరగతి కన్స్ట్రక్టర్ను తప్పుగా ప్రకటించడం మరొక సాధారణ తప్పు. కన్స్ట్రక్టర్ పేరు తప్పనిసరిగా తరగతి పేరు వలె ఉండాలి మరియు కన్స్ట్రక్టర్కు ఫలిత రకం లేదు. అత్యంత సాధారణ తప్పులు ఇలా కనిపిస్తాయి:
|
ఇక్కడ రిటర్న్ రకం ఉండకూడదు |
|
కన్స్ట్రక్టర్ పేరు చెల్లదు. ఇది తప్పనిసరిగా తరగతి పేరుతో సరిపోలాలి |
|
this కనబడుట లేదు. వేరియబుల్ value దానికే కేటాయించబడుతుంది |
|
అదంతా కరెక్ట్. |
ఇంటర్ఫేస్ల యొక్క సరికాని వారసత్వం
"జావా సృష్టికర్తలు దీనిని ఆంగ్లానికి చాలా దగ్గరగా చేయడానికి ప్రయత్నించారు, కాబట్టి వారు నిర్దిష్ట సంబంధిత భావనల కోసం విభిన్న కీలకపదాలను ఎంచుకున్నారు.
తరగతి తరగతిని వారసత్వంగా పొందినప్పుడు, మీరు కీవర్డ్ని ఉపయోగించాలి extends
:
class Pet
{
}
class Cat extends Pet
{
}
"ఒక తరగతి ఇంటర్ఫేస్ను వారసత్వంగా పొందినప్పుడు లేదా, మరింత ఖచ్చితంగా, దానిని అమలు చేసినప్పుడు, మీరు కీవర్డ్ని ఉపయోగించాలి implements
:
interface Meow
{
}
class Cat implements Meow
{
}
"ఒక ఇంటర్ఫేస్ ఇంటర్ఫేస్ను వారసత్వంగా పొందినప్పుడు, extends
కీవర్డ్ని ఉపయోగించండి:
interface Meow
{
}
interface Voice extends Meov
{
}
break
ఒక switch
ప్రకటనలో విస్మరిస్తున్నారు
"మరియు నేటి చివరి తప్పు, కానీ ప్రారంభకులకు చివరిది కాదు, break
ప్రకటనలో ప్రకటనను చేర్చడంలో విఫలమవడం switch
. ఉదాహరణ:
తప్పు | కుడి |
---|---|
|
|
"మీకు తెలుసా, డియెగో... మీరు ఇక్కడ అందించిన లోపాల సెట్ను బట్టి చూస్తే, మీరు నా వ్యక్తిగత పత్రికను చదువుతున్నట్లు అనిపిస్తుంది... లేదా నేను పనులను పరిష్కరించడాన్ని మీరు చూస్తున్నట్లు అనిపిస్తుంది."
"హా! ఇందులో సందేహం లేదు. నేను చదివాను, ట్రాక్ చేసాను, అలాగే కొనసాగించాను. కాబట్టి అప్రమత్తంగా ఉండండి!"
"???"
"మీరు చింతించకండి. నేను తమాషా చేస్తున్నాను. అప్రమత్తంగా ఉండండి మరియు తక్కువ తెలివితక్కువ తప్పులు చేయండి."
GO TO FULL VERSION