03. జావా సింటాక్స్, క్లాస్ స్ట్రక్చర్ & main() అనాటమీ (Java Syntax, Class Structure & main() Anatomy)
జావా ప్రోగ్రామింగ్ భాషలో ప్రతి ఒక్క అక్షరం, బ్రాకెట్, మరియు సెమీకోలన్ వెనుక ఒక బలమైన ఇంజనీరింగ్ ఆర్కిటెక్చర్ దాగి ఉంది. సి లేదా పైథాన్ లాగా ఇక్కడ గాల్లో కోడ్ రాయడం కుదరదు; ప్రతి కోడ్ స్టేట్మెంట్ కచ్చితంగా ఒక తరగతి (Class) పరిధిలోనే జన్మించాలి. ఎంటర్ప్రైజ్ అప్లికేషన్లు మిలియన్ల కొద్దీ యూజర్లకు ఎందుకు క్రాష్ కాకుండా సేవలందిస్తాయో అర్థం కావాలంటే జావా సింటాక్స్ పునాదులను క్షుణ్ణంగా తెలుసుకోవాలి.
ఇంటి నిర్మాణం & మెయిన్ ఎంట్రన్స్ డోర్ అనాలజీ (The House Architecture & Grand Front Door Analogy):
1. Source File (.java) (ప్లాట్ లేదా బిల్డింగ్ సైట్ - The Plot Site): మీ కంప్యూటర్లో సేవ్ చేసిన .java ఫైల్ ఒక స్థలం లాంటిది. ఒక స్థలంలో ఎన్ని చిన్న చిన్న గదులైనా నిర్మించుకోవచ్చు కానీ వీధికి అభిముఖంగా ఉండే ప్రధాన సింహద్వారం గల బిల్డింగ్ (public class) ఒక్కటే ఉండాలి. ఆ భవనం పేరుతోనే స్థలం రిజిస్టర్ (ఫైల్ పేరు) కావాలి.
2. Class Blueprint (భవన నిర్మాణం & గదులు - The Blueprint): క్లాస్ అనేది మొత్తం ఇంటి బ్లూప్రింట్. దీని లోపల డేటా నిల్వ చేసే బీరువాలు (వేరియబుల్స్ / ఫీల్డ్స్) మరియు పనులు చేసే మెషీన్లు (మెథడ్స్ / ఫంక్షన్స్) భద్రంగా ఉంటాయి.
3. public static void main(String[] args) (ప్రధాన సింహద్వారం - The Main Entrance Gate): మొత్తం భవనంలోకి JVM అడుగుపెట్టే ఏకైక అధికారిక ఎంట్రీ పాయింట్!
• public: ఈ గేట్ వద్ద సెక్యూరిటీ అడ్డంకులు లేవు, బయటి ప్రపంచం (JVM) నేరుగా లోపలికి ప్రవేశించవచ్చు.
• static: ఇల్లు ఇంకా పూర్తిగా సిద్ధం కాకముందే (ఆబ్జెక్ట్ సృష్టించకముందే) ఈ గేట్ అందుబాటులో ఉంటుంది.
• void: కార్యక్రమం పూర్తయ్యాక లోపలికి వచ్చిన అతిథికి (JVM) ఎలాంటి రిటర్న్ గిఫ్ట్ ఇవ్వాల్సిన పనిలేదు.
• main: JVM ప్రోగ్రామ్ను ప్రారంభించడానికి వెతికే ప్రామాణికమైన కోడ్ పేరు.
• String[] args: ఇంటికి వచ్చే అతిథులు చేతుల్లో మోసుకొచ్చే లగేజ్ బ్యాగులు (కమాండ్ లైన్ ఆర్గ్యుమెంట్స్).
ఈ మూడవ అధ్యాయంలో జావా సింటాక్స్ నియమాలు, సోర్స్ ఫైల్ నిబంధనలు, main() మెథడ్ యొక్క ప్రతి కీవర్డ్ అంతర్గత ప్రయోజనం, మరియు System.out.println() యొక్క పూర్తి ఆర్కిటెక్చర్ను లోతుగా నేర్చుకుందాం!
1 జావా కేస్-సెన్సిటివిటీ & బేసిక్ సింటాక్స్ నియమాలు
జావా ఒక ఖచ్చితమైన నియమాలు గల భాష (Strictly Typed, Case-Sensitive Language). అంటే ఇక్కడ క్యాపిటల్ అక్షరానికి (Uppercase) మరియు స్మాల్ అక్షరానికి (Lowercase) ఆకాశమంత తేడా ఉంటుంది. ఉదాహరణకు myVariable, MyVariable, మరియు MYVARIABLE అనేవి జావా కంపైలర్ దృష్టిలో మూడు వేర్వేరు గుర్తింపులు (Identifiers).
| సింటాక్స్ ఎలిమెంట్ | జావా నిబంధన (Syntax Rule) | సరైన ఉదాహరణ | తప్పు ఉదాహరణ (కంపైలర్ ఎర్రర్) |
|---|---|---|---|
| స్టేట్మెంట్ టెర్మినేషన్ | ప్రతి ఎగ్జిక్యూటబుల్ స్టేట్మెంట్ ఖచ్చితంగా సెమీకోలన్ (;) తో ముగియాలి. |
int age = 25; |
int age = 25 (ఎర్రర్: ';' expected) |
| బ్లాక్ స్కోప్ (Curly Braces) | క్లాస్, మెథడ్, మరియు లూప్ల కోడ్ కర్లీ బ్రాకెట్స్ { } లో ఉండాలి. |
public class App { } |
బ్రాకెట్ సరిగ్గా క్లోజ్ చేయకపోతే 'reached end of file while parsing' |
| కీవర్డ్స్ (Keywords) | జావాలో 50కి పైగా రిజర్వ్డ్ కీవర్డ్స్ ఉన్నాయి, ఇవన్నీ కేవలం స్మాల్ లెటర్స్లోనే ఉండాలి. | public, class, static, void |
Public, CLASS, Void (గుర్తించబడవు) |
| స్పేసింగ్ & ఇండెంటేషన్ | వైట్స్పేస్ కంపైలర్కు ముఖ్యం కాదు, కానీ కోడ్ రీడబిలిటీ కోసం 4-స్పేసెస్ ఇండెంట్ తప్పనిసరి. | క్లీన్ స్ట్రక్చర్డ్ కోడ్ | అడ్డదిడ్డంగా రాస్తే కోడ్ రివ్యూలో రిజెక్ట్ అవుతుంది. |
2 సోర్స్ ఫైల్ నియమాలు: public class vs ఫైల్ పేరు
ఒక జావా సోర్స్ ఫైల్ (.java) లో కోడ్ రాసేటప్పుడు జావా కంపైలర్ అమలుచేసే 4 ప్రాథమిక నిబంధనలు:
📜 Golden Rules for Java Source Files:
1. గరిష్టంగా ఒకే ఒక public class: ఒక .java ఫైల్లో ఎన్ని డిఫాల్ట్ (నాన్-పబ్లిక్) క్లాసులైనా ఉండవచ్చు, కానీ గరిష్టంగా ఒకే ఒక్క public class మాత్రమే ఉండటానికి అనుమతి ఉంది.
2. ఫైల్ పేరుతో ఖచ్చితమైన సమన్వయం: ఆ ఫైల్లోని public class పేరు ఏది ఉందో, ఆ ఫైల్ పేరు కూడా అక్షరాలా అదే అయి ఉండాలి (ఉదాహరణకు క్లాస్ పేరు PaymentGateway అయితే ఫైల్ పేరు ఖచ్చితంగా PaymentGateway.java అయి ఉండాలి).
3. public class లేకపోతే?: ఒకవేళ ఫైల్లో ఎలాంటి public class లేకపోతే, ఫైల్కు అందులోని ఏ క్లాస్ పేరైనా లేదా సంబంధం లేని మరేదైనా పేరు పెట్టుకోవచ్చు.
4. కంపైలేషన్ ఫలితం: ఒక .java ఫైల్ లో 3 క్లాసులు ఉంటే, javac కంపైల్ చేసినప్పుడు 3 వేర్వేరు .class బైట్కోడ్ ఫైల్స్ జనరేట్ అవుతాయి!
3 ప్యాకేజ్ డిక్లరేషన్ & ఇంపోర్ట్ స్టేట్మెంట్ల స్థానం
ఒక జావా సోర్స్ ఫైల్ లోపల కోడ్ లైన్ల క్రమం (Order of Declarations) ముందస్తుగా నిర్ణయించబడి ఉంటుంది. ఈ క్రమాన్ని ఉల్లంఘిస్తే కంపైలర్ ఎర్రర్ ఇస్తుంది:
package com.ourcompiler.banking;
// 2. రెండవ స్థానం: Import Statements (బయటి క్లాసులను ప్రాజెక్టులోకి తీసుకురావడానికి)
import java.util.Scanner;
import java.time.LocalDateTime;
// 3. మూడవ స్థానం: Class / Interface Declaration
public class AccountManager {
// 4. నాల్గవ స్థానం: Variables, Methods & Constructors
public static void main(String[] args) {
System.out.println("Account Manager Active");
}
}
4 జావా కోడింగ్ కన్వెన్షన్స్ (Naming Standards & Clean Code)
ప్రపంచవ్యాప్తంగా గూగుల్, ఒరాకిల్, మరియు మైక్రోసాఫ్ట్ సంస్థలలో పనిచేసే జావా ఇంజనీర్లు పాటించే అధికారిక నేమింగ్ కన్వెన్షన్స్:
| ఎలిమెంట్ | కేసింగ్ రూల్ (Naming Convention) | ప్రొఫెషనల్ ఉదాహరణలు |
|---|---|---|
| Classes & Interfaces | PascalCase (UpperCamelCase): ప్రతి పదం యొక్క మొదటి అక్షరం క్యాపిటల్ కావాలి. నౌన్ (నామవాచకం) అయి ఉండాలి. | BankCustomer, StringTokenizer, PaymentProcessor |
| Methods | camelCase: మొదటి పదం స్మాల్, తర్వాతి పదాల మొదటి అక్షరం క్యాపిటల్. వెర్బ్ (క్రియ) అయి ఉండాలి. | calculateInterest(), getUserDetails(), printReport() |
| Variables | camelCase: సంక్షిప్తమైన, అర్థవంతమైన పేర్లు ఉండాలి. | accountBalance, customerAge, isEligible |
| Constants (స్థిరరాశులు) | ALL_CAPS_SNAKE_CASE: అన్ని అక్షరాలు క్యాపిటల్, పదాల మధ్య అండర్స్కోర్ _ ఉండాలి. |
MAX_RETRY_COUNT, DATABASE_URL, DEFAULT_TIMEOUT |
| Packages | all_lowercase: కంపెనీ డొమైన్ రివర్స్ ఆర్డర్లో ఉండాలి. | com.ourcompiler.core, org.apache.commons |
5 public static void main(String[] args) డీకోడింగ్
జావా ఇంటర్వ్యూలలో అత్యధికంగా అడిగే ప్రశ్న — "public static void main(String[] args) లోని ప్రతి కీవర్డ్ అర్థం ఏమిటి?". ఈ 6 పదాల లోతైన ఇంజనీరింగ్ విశ్లేషణను చూద్దాం:
| కీవర్డ్ | రకం | ఎందుకు తప్పనిసరి? (Technical Reason) |
|---|---|---|
public |
Access Modifier | ఈ మెథడ్ను క్లాస్ బయట ఉన్న జావా రన్టైమ్ (JVM) నేరుగా యాక్సెస్ చేయడానికి అనుమతి ఇస్తుంది. ఇది private అయితే JVM కి యాక్సెస్ ఉండదు. |
static |
Class-level Modifier | అత్యంత కీలకం: JVM ఈ క్లాస్కు సంబంధించి ఎలాంటి ఆబ్జెక్ట్ (new ClassName()) క్రియేట్ చేయకుండానే నేరుగా క్లాస్ పేరుతో (ClassName.main()) కాల్ చేయడానికి వీలు కల్పిస్తుంది. |
void |
Return Type | మెయిన్ మెథడ్ తన పని పూర్తి చేసుకున్న తర్వాత JVM కి ఎలాంటి వాల్యూను రిటర్న్ చేయదు (సి లాంగ్వేజ్లో int main() రిటర్న్ 0 ఉన్నట్లు జావాలో అవసరం లేదు). |
main |
Identifier / Method Name | ఇది జావా ఆర్కిటెక్చర్లో ముందే కాన్ఫిగర్ చేయబడిన ప్రామాణికమైన ఎంట్రీ పాయింట్ పేరు. ఈ పేరు మార్చితే JVM ప్రోగ్రామ్ను గుర్తించలేదు. |
String[] |
Data Type (Array of Strings) | కమాండ్ లైన్ నుండి యూజర్ పాస్ చేసే ఆర్గ్యుమెంట్లను (సంఖ్యలైనా, పదాలైనా) టెక్స్ట్ రూపంలో స్వీకరించే స్ట్రింగ్ అర్రే. |
args |
Parameter Name | ఇది వేరియబుల్ పేరు మాత్రమే. దీని స్థానంలో String[] params లేదా String[] data అని కూడా పెట్టుకోవచ్చు. |
6 String[] args కమాండ్ లైన్ ఆర్గ్యుమెంట్స్ మెకానిక్స్
మనం టెర్మినల్ నుండి జావా అప్లికేషన్ను రన్ చేసే సమయంలో ప్రోగ్రామ్కు కావలసిన ఇన్పుట్ పారామీటర్లను సులభంగా పంపవచ్చు. JVM ఈ విలువలను ఖాళీల (Spaces) ఆధారంగా విడదీసి args[0], args[1] లలో నిల్వ చేస్తుంది:
java App Hyderabad 500081 true
// జావా మెయిన్ మెథడ్ లోపల వీటి విలువలు:
args[0] = "Hyderabad"
args[1] = "500081"
args[2] = "true"
args.length = 3
⚠️ Java 22+ Unnamed Classes & Instance Main (Modern Java Update):
జావా 21 ప్రివ్యూ మరియు జావా 22 నుండి బిగినర్ల కోసం జావా ఒక కొత్త ఫీచర్ను పరిచయం చేసింది: చిన్న స్క్రిప్ట్ల కోసం public class రాయకుండానే కేవలం void main() { System.out.println("Hello"); } అని సింపుల్గా రాసే సౌలభ్యం అందుబాటులోకి వచ్చింది! అయినప్పటికీ, ఎంటర్ప్రైజ్ ప్రొడక్షన్ సిస్టమ్స్లో ఇప్పటికీ public static void main(String[] args) మాత్రమే పరిశ్రమ ప్రామాణికం.
7 System.out.println() అంతర్గత ఆర్కిటెక్చర్
మనం తరచుగా వాడే System.out.println() లైన్ వెనుక ఉండే మూడు కీలక భాగాల అంతర్గత సంబంధం:
🔬 The Architecture of System.out.println():
1. System: ఇది java.lang ప్యాకేజీలో ఉండే ఒక ప్రామాణిక final class. దీనిని మనం కొత్తగా ఆబ్జెక్ట్ సృష్టించలేము.
2. out: ఇది System క్లాస్ లోపల ఉండే ఒక public static final PrintStream ఆబ్జెక్ట్ రిఫరెన్స్. ఇది మీ కంప్యూటర్ స్టాండర్డ్ అవుట్పుట్ డివైస్ (కమాండ్ ప్రాంప్ట్ / కన్సోల్) కు కనెక్ట్ అయి ఉంటుంది.
3. println(): ఇది PrintStream క్లాస్ లోపల ఓవర్లోడ్ చేయబడిన మెథడ్. ఇది ఇచ్చిన డేటాను స్ట్రింగ్గా మార్చి ప్రింట్ చేసి కర్సర్ను నెక్స్ట్ లైన్కు తరలిస్తుంది.
| మెథడ్ | పనితీరు (Behavior) | ఉపయోగం |
|---|---|---|
System.out.print() |
టెక్స్ట్ను ప్రింట్ చేస్తుంది, కానీ కర్సర్ అదే లైన్లో కొనసాగుతుంది. | ప్రోగ్రెస్ బార్లు లేదా యూజర్ ఇన్పుట్ ప్రాంప్ట్లు (ఉదా: "Enter name: "). |
System.out.println() |
టెక్స్ట్ను ప్రింట్ చేసిన వెంటనే కర్సర్ను కొత్త లైన్ (
) కు తరలిస్తుంది. |
సాధారణ లాగింగ్ మరియు లైన్-బై-లైన్ అవుట్పుట్. |
System.out.printf() |
C భాష తరహాలో ఫార్మాట్ స్పెసిఫైయర్స్ (%d, %s, %.2f, %n) తో ఫార్మాట్ చేస్తుంది. |
కరెన్సీలు, దశాంశాలు, మరియు అలైన్డ్ టేబుల్స్ ప్రింట్ చేయడానికి. |
8 జావాలో కామెంట్స్: Single-line, Multi-line & Javadoc
కోడ్ రాయడం ఎంత ముఖ్యమో, భవిష్యత్తులో ఆ కోడ్ను చదివే ఇతర డెవలపర్ల కోసం వివరణాత్మకమైన కామెంట్స్ రాయడం కూడా అంతే ముఖ్యం. జావా 3 రకాల కామెంట్లను సమర్ధిస్తుంది:
int maxUsers = 1000; // గరిష్ట యూజర్ల పరిమితి
/*
* 2. Multi-line Comment:
* పెద్ద పెద్ద అల్గారిథమ్స్ లేదా క్లిష్టమైన లాజిక్ వివరించడానికి
* బహుళ లైన్ల కామెంట్స్ ఉపయోగిస్తాం.
*/
/**
* 3. Javadoc Documentation Comment (అధికారిక API డాక్యుమెంటేషన్):
* ఈ కామెంట్స్ నుండి 'javadoc' టూల్ ఆటోమేటిక్గా HTML డాక్యుమెంటేషన్ను జనరేట్ చేస్తుంది.
* @param principal మొత్తం అసలు మొత్తం
* @param rate వార్షిక వడ్డీ రేటు
* @return లెక్కించిన చక్రవడ్డీ మొత్తం
*/
public double calculateCompoundInterest(double principal, double rate) {
return principal * Math.pow(1 + rate / 100, 2);
}
9 కోడ్ డెమో 1: CLI ఆర్గ్యుమెంట్స్ ప్రాసెసర్ & వాలిడేషన్ ఇంజిన్
కమాండ్ లైన్ ఆర్గ్యుమెంట్లను స్వీకరించి, వాటి పొడవును సరిచూసి, సురక్షితంగా డేటాను పార్స్ చేసే లైవ్ ప్రోగ్రామ్:
public class CommandLineParser {
public static void main(String[] args) {
System.out.println("==================================================");
System.out.println(" COMMAND LINE ARGUMENTS PROCESSOR ENGINE ");
System.out.println("==================================================");
// Checking if user supplied arguments
if (args.length == 0) {
System.out.println("[INFO] No external CLI arguments detected.");
System.out.println("[INFO] Defaulting to demo developer credentials:");
String defaultUser = "Kiran Kumar";
String defaultRole = "FullStack Java Engineer";
System.out.printf(" User : %s%n Role : %s%n", defaultUser, defaultRole);
} else {
System.out.println("[SUCCESS] Received " + args.length + " argument(s) from Terminal:");
for (int i = 0; i < args.length; i++) {
System.out.printf(" Arg [%d]: %s%n", i, args[i]);
}
}
System.out.println("--------------------------------------------------");
System.out.println("Status: CLI Processing Completed Flawlessly!");
System.out.println("==================================================");
}
}
==================================================
COMMAND LINE ARGUMENTS PROCESSOR ENGINE
==================================================
[INFO] No external CLI arguments detected.
[INFO] Defaulting to demo developer credentials:
User : Kiran Kumar
Role : FullStack Java Engineer
--------------------------------------------------
Status: CLI Processing Completed Flawlessly!
==================================================
10 కోడ్ డెమో 2: మల్టిపుల్ క్లాసెస్ ఇన్ సింగిల్ ఫైల్ & కంపైలేషన్ బిహేవియర్
ఒకే .java ఫైల్లో బహుళ సహాయక తరగతులను (Helper Classes) రాసి, వాటి మధ్య సంబంధాన్ని ప్రదర్శించే ఎగ్జాంపుల్:
// Main public class - Must match the file name: MultiClassDemo.java
public class MultiClassDemo {
public static void main(String[] args) {
System.out.println("--------------------------------------------------");
System.out.println(" MULTI-CLASS COMPILATION DEMO ENGINE ");
System.out.println("--------------------------------------------------");
// Using helper classes defined in the same source file
ServerTelemetry telemetry = new ServerTelemetry("Cluster-AP-South-1", "ACTIVE");
telemetry.displayStatus();
AuditLogger.logEvent("MultiClassDemo executed successfully.");
System.out.println("--------------------------------------------------");
}
}
// Non-public helper class 1
class ServerTelemetry {
private String serverId;
private String status;
public ServerTelemetry(String serverId, String status) {
this.serverId = serverId;
this.status = status;
}
public void displayStatus() {
System.out.println(" [SERVER ID] " + serverId);
System.out.println(" [STATUS] " + status);
}
}
// Non-public helper class 2
class AuditLogger {
public static void logEvent(String message) {
System.out.println(" [AUDIT LOG] " + message);
}
}
--------------------------------------------------
MULTI-CLASS COMPILATION DEMO ENGINE
--------------------------------------------------
[SERVER ID] Cluster-AP-South-1
[STATUS] ACTIVE
[AUDIT LOG] MultiClassDemo executed successfully.
--------------------------------------------------
11 కోడ్ డెమో 3: CLI Syntax Inspector & Greeting Engine (Capstone Mini Project)
యూజర్ పేరు, ప్రోగ్రామింగ్ భాష మరియు అనుభవాన్ని విశ్లేషించి, ఆధునిక ఫార్మాట్ స్పెక్స్ మరియు సింటాక్స్ ధృవీకరణతో స్వాగత పత్రాన్ని రూపొందించే Java Syntax & CLI Greeting Engine:
public class SyntaxInspectorCapstone {
public static void main(String[] args) {
String developerName = "నవీన్ చంద్ర";
String trackName = "Enterprise Java 21+ Masterclass";
int chapterNum = 3;
int totalChapters = 25;
boolean isSyntaxValid = true;
System.out.println("==================================================");
System.out.println(" JAVA 21 SYNTAX INSPECTION & REPORT ");
System.out.println("==================================================");
// Printing formatted diagnostics
System.out.printf(" [DEVELOPER] %s%n", developerName);
System.out.printf(" [CURRICULUM] %s%n", trackName);
System.out.printf(" [MODULE] Chapter %02d of %02d%n", chapterNum, totalChapters);
System.out.printf(" [STATUS] Class Structure: %s%n", isSyntaxValid ? "VERIFIED (100% OK)" : "INVALID");
System.out.println("--------------------------------------------------");
// Multi-line Text Block documentation
String summary = """
[SYNTAX VERIFICATION REPORT]
• Public Class Name Matches File: YES
• Main Method Signature Valid : YES
• Statement Semicolons Checked : YES
• Code Block Scopes Balanced : YES
""";
System.out.println(summary.trim());
System.out.println("==================================================");
}
}
==================================================
JAVA 21 SYNTAX INSPECTION & REPORT
==================================================
[DEVELOPER] నవీన్ చంద్ర
[CURRICULUM] Enterprise Java 21+ Masterclass
[MODULE] Chapter 03 of 25
[STATUS] Class Structure: VERIFIED (100% OK)
--------------------------------------------------
[SYNTAX VERIFICATION REPORT]
• Public Class Name Matches File: YES
• Main Method Signature Valid : YES
• Statement Semicolons Checked : YES
• Code Block Scopes Balanced : YES
==================================================
12 టాప్ 6 కామన్ సింటాక్స్ మిస్టేక్స్ & 5 క్విజ్లు
బిగినర్లు తరచుగా చేసే 6 ప్రధాన సింటాక్స్ తప్పులు మరియు వాటిని కనుగొనే ఉపాయాలు:
| ఎర్రర్ వర్ణన | తప్పు కోడ్ | సరైన సరిదిద్దిన కోడ్ |
|---|---|---|
| సెమీకోలన్ మిస్ అవ్వడం | int x = 100 |
int x = 100; |
| కర్లీ బ్రాకెట్ అసమతుల్యత | public class App { public static void main(...) { } (చివర } మిస్) |
ప్రతి ఓపెన్ బ్రాకెట్ { కి కచ్చితంగా క్లోజ్ బ్రాకెట్ } ఉండాలి. |
| మెయిన్ మెథడ్ స్పెల్లింగ్ తప్పు | public static void Main(String[] args) (క్యాపిటల్ M) |
public static void main(String[] args) (స్మాల్ m). |
| స్ట్రింగ్ డబుల్ కోట్స్ బదులు సింగిల్ కోట్స్ | String s = 'Hello'; |
జావాలో అక్షరానికి (char) 'A', పదానికి (String) "Hello" వాడాలి. |
| రిజర్వ్డ్ కీవర్డ్స్ వేరియబుల్స్గా వాడటం | int class = 10; |
int classId = 10; (కీవర్డ్స్ను వేరియబుల్ పేర్లుగా వాడకూడదు). |
| కేస్ సెన్సిటివిటీ గందరగోళం | system.out.println("Hi"); (స్మాల్ s) |
System.out.println("Hi"); (క్యాపిటల్ S). |
🧠 మీ అవగాహనను పరీక్షించుకోండి (5 Interactive Quizzes):
ప్రశ్న 1: ఒక జావా సోర్స్ ఫైల్లో ఎన్ని public క్లాసులు ఉండవచ్చు?
సమాధానం: గరిష్టంగా కేవలం ఒకే ఒక public class మాత్రమే ఉండవచ్చు! ఆ పబ్లిక్ క్లాస్ పేరే ఫైల్ పేరుగా ఉండాలి. అయితే నాన్-పబ్లిక్ క్లాసులు ఎన్ని అయినా ఉండవచ్చు.
ప్రశ్న 2: main() మెథడ్ కి 'static' కీవర్డ్ ఎందుకు అత్యవసరం?
సమాధానం: JVM ప్రోగ్రామ్ను స్టార్ట్ చేసే సమయానికి మెమరీలో ఎలాంటి ఆబ్జెక్ట్ ఉండదు. static ఉన్నందున JVM ఆబ్జెక్ట్ క్రియేట్ చేయకుండానే నేరుగా క్లాస్ పేరుతో మెథడ్ను కాల్ చేయగలదు.
ప్రశ్న 3: 'String[] args' లోని 'args' పేరు మార్చవచ్చా?
సమాధానం: అవును! args అనేది కేవలం వేరియబుల్ ఐడెంటిఫైయర్ మాత్రమే. దాని స్థానంలో String[] options లేదా String[] data అని కూడా వాడుకోవచ్చు.
ప్రశ్న 4: Javadoc కామెంట్లను ఎలా ప్రారంభిస్తారు?
సమాధానం: Javadoc కామెంట్లను /** తో ప్రారంభించి */ తో ముగిస్తారు. ఇందులో @param, @return, @author వంటి ట్యాగ్లు వాడతారు.
ప్రశ్న 5: System.out.println() లో 'out' దేనిని సూచిస్తుంది?
సమాధానం: System క్లాస్లోని ఒక public static final PrintStream ఆబ్జెక్ట్ను సూచిస్తుంది. ఇది కన్సోల్ స్టాండర్డ్ అవుట్పుట్ స్ట్రీమ్కు మ్యాప్ చేయబడి ఉంటుంది.