03. జావా సింటాక్స్, క్లాస్ స్ట్రక్చర్ & main() అనాటమీ (Java Syntax, Class Structure & main() Anatomy)

☕ Java (Java 21+ LTS) 🟢 Lesson 03 of 25 📂 Part 01: Basics & JVM (Page 3 of 5) ⏱️ 24 min read
📌 Covered in this lesson: House Architecture Analogy · Java Case-Sensitivity & Statements · Source File Rules (One public class per file) · public static void main(String[] args) Deep Anatomy · String[] args CLI Array · System.out.println vs print vs printf · Comments & Javadoc · Top 6 Common Syntax Pitfalls

జావా ప్రోగ్రామింగ్ భాషలో ప్రతి ఒక్క అక్షరం, బ్రాకెట్, మరియు సెమీకోలన్ వెనుక ఒక బలమైన ఇంజనీరింగ్ ఆర్కిటెక్చర్ దాగి ఉంది. సి లేదా పైథాన్ లాగా ఇక్కడ గాల్లో కోడ్ రాయడం కుదరదు; ప్రతి కోడ్ స్టేట్‌మెంట్ కచ్చితంగా ఒక తరగతి (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() యొక్క పూర్తి ఆర్కిటెక్చర్‌ను లోతుగా నేర్చుకుందాం!

📋 ఈ Page లో ఏముంది? (Contents)

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) ముందస్తుగా నిర్ణయించబడి ఉంటుంది. ఈ క్రమాన్ని ఉల్లంఘిస్తే కంపైలర్ ఎర్రర్ ఇస్తుంది:

// 1. మొదటి స్థానం: Package Declaration (ఐచ్ఛికం, కానీ ఉంటే ఫైల్‌లో మొదటి నాన్-కామెంట్ లైన్ ఇదే కావాలి)
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] లలో నిల్వ చేస్తుంది:

# కమాండ్ లైన్ ద్వారా 3 విలువలను పాస్ చేయడం:
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 రకాల కామెంట్లను సమర్ధిస్తుంది:

// 1. Single-line Comment: ఒకే లైన్ వివరణ కోసం డబుల్ స్లాష్ వాడతాం.
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 ఆర్గ్యుమెంట్స్ ప్రాసెసర్ & వాలిడేషన్ ఇంజిన్

కమాండ్ లైన్ ఆర్గ్యుమెంట్లను స్వీకరించి, వాటి పొడవును సరిచూసి, సురక్షితంగా డేటాను పార్స్ చేసే లైవ్ ప్రోగ్రామ్:

CommandLineParser.java
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("==================================================");
    }
}
💻 Console Output (CommandLineParser)
==================================================
      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) రాసి, వాటి మధ్య సంబంధాన్ని ప్రదర్శించే ఎగ్జాంపుల్:

MultiClassDemo.java
// 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);
    }
}
💻 Console Output (MultiClassDemo)
--------------------------------------------------
      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:

SyntaxInspectorCapstone.java
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("==================================================");
    }
}
💻 Console Output (SyntaxInspectorCapstone)
==================================================
      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 ఆబ్జెక్ట్‌ను సూచిస్తుంది. ఇది కన్సోల్ స్టాండర్డ్ అవుట్‌పుట్ స్ట్రీమ్‌కు మ్యాప్ చేయబడి ఉంటుంది.

← మునుపటి పాఠం: 02. Setup & First Program తర్వాతి పాఠం: 04. Variables & Data Types →