04. వేరియబుల్స్, 8 ప్రిమిటివ్ డేటా టైప్స్ & మెమరీ మోడల్ (Variables, Primitive Data Types & Memory Model)

☕ Java (Java 21+ LTS) 🟢 Lesson 04 of 25 📂 Part 01: Basics & JVM (Page 4 of 5) ⏱️ 22 min read
📌 Covered in this lesson: Warehouse Storage Analogy · Variable Declaration & Initialization · 8 Primitive Types (byte to double) · Precision & IEEE 754 Floating Points · Stack vs Heap Allocation · Modern Java 'var' Local Variable Type Inference · 5 Interactive Quizzes

సాఫ్ట్‌వేర్ అప్లికేషన్లు చేసే ముఖ్యమైన పని — డేటాను భద్రపరచడం, దానిపై లెక్కలు చేయడం మరియు ఫలితాలను యూజర్లకు చూపించడం. కంప్యూటర్ యొక్క తాత్కాలిక జ్ఞాపకశక్తి అయిన RAM (Random Access Memory) లో డేటాను క్రమపద్ధతిలో నిర్వహించడానికి జావా ఒక బలమైన టైప్-సేఫ్ ఆర్కిటెక్చర్‌ను అందిస్తుంది. ఇక్కడ ప్రతి డేటా అంశానికి ఒక నిర్దిష్టమైన రకం (Data Type) మరియు నిర్ణీత మెమరీ పరిమాణం ఉంటాయి.

గోదాము పెట్టెలు & బ్యాంక్ లాకర్ల అనాలజీ (The Warehouse Boxes & Bank Locker Analogy):
1. Variables (లేబుల్ అంటించిన స్టోరేజ్ పెట్టెలు - Labelled Storage Boxes): ఒక పెద్ద గోదాములో వస్తువులను పడేయకుండా, ప్రతి పెట్టెపై "బియ్యం", "చక్కెర", లేదా "బట్టలు" అని పేరు రాసి భద్రపరిచినట్లే — RAM మెమరీ చిరునామాకు మనం పెట్టుకునే సులభమైన పేరే వేరియబుల్ (Variable).
2. 8 Primitive Data Types (నిర్దిష్ట సైజు గల ప్యాకింగ్ యూనిట్లు - Standard Size Units):
  • చిన్న మేకు కోసం అగ్గిపెట్టె (byte — 1 Byte)
  • పుస్తకాల కోసం మీడియం బాక్స్ (short — 2 Bytes)
  • రోజువారీ సామాను కోసం స్టాండర్డ్ కార్టన్ (int — 4 Bytes)
  • భారీ మెషీన్ల కోసం ఎక్స్‌ట్రా లార్జ్ కంటైనర్ (long — 8 Bytes)
  • ద్రవాలు పోసేందుకు లీటర్ బాటిల్ (float — 4 Bytes, double — 8 Bytes)
  • ఒక్క అక్షరం ముద్రించే యూనికోడ్ స్టాంప్ (char — 2 Bytes)
  • లైట్ స్విచ్ ON లేదా OFF స్థితి (boolean — 1 Bit).
3. Stack vs Heap (డెస్క్ పై ఫైళ్లు vs సెంట్రల్ స్టోరేజ్ రూమ్): ప్రిమిటివ్ విలువలు మీ వర్కింగ్ డెస్క్ (Stack) పై వేగంగా అందుబాటులో ఉంటాయి; పెద్ద పెద్ద ఆబ్జెక్టులు మరియు స్ట్రింగ్స్ సెంట్రల్ లాకర్ (Heap) లో నిల్వ చేయబడి వాటి కీలు మాత్రమే డెస్క్ పై ఉంటాయి.

ఈ నాల్గవ పాఠంలో 8 ప్రిమిటివ్ డేటా టైప్స్, వాటి కనీస-గరిష్ట పరిధులు (Ranges), Stack vs Heap మెమరీ కేటాయింపు, మరియు Modern Java 10+ లో వచ్చిన విప్లవాత్మక 'var' లోకల్ వేరియబుల్ టైప్ ఇన్ఫరెన్స్ ను సమగ్రంగా నేర్చుకుందాం!

1 వేరియబుల్ డిక్లరేషన్, ఇనిషియలైజేషన్ & స్కోప్

జావా ఒక Statically-Typed Language. అంటే ఒక వేరియబుల్‌ను ఉపయోగించడానికి ముందే దాని డేటా టైప్‌ను కంపైలర్‌కు స్పష్టంగా తెలియజేయాలి. వేరియబుల్ అనేది కంప్యూటర్ RAM మెమరీలో డేటాను భద్రపరిచే ఒక నిర్దిష్టమైన ప్రదేశానికి మనం ఇచ్చే గుర్తింపు పేరు (Identifier).

// దశ 1: డిక్లరేషన్ (Declaration) - మెమరీ స్పేస్ రిజర్వ్ అవుతుంది కానీ విలువ ఉండదు
int employeeId;

// దశ 2: ఇనిషియలైజేషన్ (Initialization) - మొదటిసారి విలువ కేటాయింపు
employeeId = 101;

// ఒకే లైన్‌లో డిక్లరేషన్ & ఇనిషియలైజేషన్ (Industry Best Practice)
double basicSalary = 75000.50;

// ఒకే టైప్ గల బహుళ వేరియబుల్స్ ఒకేసారి డిక్లేర్ చేయడం
int x = 10, y = 20, z = 30;

🔍 Variable Scope & Lifecycle (వేరియబుల్ పరిధి):

జావాలో వేరియబుల్స్ వాటి స్కోప్ ఆధారంగా మూడు వర్గాలుగా విభజించబడతాయి:
1. Local Variables: మెథడ్ లేదా బ్లాక్ { } లోపల డిక్లేర్ చేయబడినవి. ఇవి స్టాక్ మెమరీలో జీవిస్తాయి. వీటికి ఎలాంటి డిఫాల్ట్ విలువలు ఉండవు. ఇనిషియలైజ్ చేయకుండా ఉపయోగిస్తే కంపైలర్ ఎర్రర్ ఇస్తుంది.
2. Instance Variables (Fields): క్లాస్ లోపల, మెథడ్ల బయట డిక్లేర్ చేయబడినవి. ఇవి హీప్ మెమరీలో ఆబ్జెక్ట్‌తో పాటు జీవిస్తాయి. వీటికి జావా ఆటోమేటిక్‌గా డిఫాల్ట్ విలువలను (0, 0.0, false, null) కేటాయిస్తుంది.
3. Static Variables (Class Variables): static కీవర్డ్‌తో డిక్లేర్ చేయబడినవి. ఇవి మెటాస్పేస్ లేదా మెథడ్ ఏరియాలో క్లాస్ లోడ్ అయినప్పుడు ఒకేసారి క్రియేట్ చేయబడి అన్ని ఆబ్జెక్టులచే పంచుకోబడతాయి.

2 8 ప్రిమిటివ్ డేటా టైప్స్ మాస్టర్ టేబుల్

జావా భాషలో పునాది రాళ్ళు లాంటి 8 ప్రిమిటివ్ డేటా టైప్స్ సమగ్ర పోలిక పట్టిక:

డేటా టైప్ సైజు (Bits / Bytes) డిఫాల్ట్ వాల్యూ కనీస మరియు గరిష్ట పరిధి (Range) ఉదాహరణ
byte 8 bits (1 byte) 0 -128 నుండి 127 వరకు byte age = 28;
short 16 bits (2 bytes) 0 -32,768 నుండి 32,767 వరకు short year = 2026;
int 32 bits (4 bytes) 0 -2,147,483,648 నుండి 2,147,483,647 (సుమారు 2 బిలియన్లు) int count = 500000;
long 64 bits (8 bytes) 0L -9 క్వాడ్రిలియన్ల నుండి +9 క్వాడ్రిలియన్లు long aadhaar = 987654321012L;
float 32 bits (4 bytes) 0.0f ~6-7 డెసిమల్ డిజిట్స్ ప్రిసిషన్ float rating = 4.8f;
double 64 bits (8 bytes) 0.0d ~15-16 డెసిమల్ డిజిట్స్ ప్రిసిషన్ (Standard) double pi = 3.1415926535;
char 16 bits (2 bytes) '\u0000' 0 నుండి 65,535 (యూనికోడ్ అక్షరాలు) char grade = 'A';
boolean 1 bit (JVM డిపెండెంట్) false కేవలం true లేదా false boolean isActive = true;

3 పూర్ణాంకాలు: byte, short, int, long & 'L' సఫిక్స్

దశాంశాలు లేని సంఖ్యలను నిల్వ చేయడానికి జావా 4 ఇంటిజర్ టైప్స్‌ను అందిస్తుంది. జావాలో మీరు రాసే ఏదైనా సాధారణ సంఖ్య (ఉదా: 100) బై-డిఫాల్ట్‌గా int గానే పరిగణించబడుతుంది.

⚠️ The Crucial 'L' Suffix for Long:

మీరు ఒక సంఖ్య 2 బిలియన్లు దాటినప్పుడు (int రేంజ్ దాటినప్పుడు), చివర తప్పనిసరిగా L లేదా l సఫిక్స్ చేర్చాలి:
• long population = 8000000000; ❌ (కంపైల్ ఎర్రర్: integer number too large)
• long population = 8000000000L; ✅ (సరైన విధానం - కంపైలర్ దీనిని 64-bit లిటరల్‌గా గుర్తిస్తుంది).
• పెద్ద సంఖ్యలను చదవడానికి వీలుగా అండర్‌స్కోర్స్ వాడవచ్చు: long balance = 1_00_00_000L; (Java 7+ ఫీచర్).

4 ఫ్లోటింగ్ పాయింట్స్: float vs double & IEEE 754

దశాంశ బిందువు (Decimal Point) గల సంఖ్యల కోసం float మరియు double వాడతాం. జావాలో డెసిమల్ సంఖ్యలు బై-డిఫాల్ట్‌గా double (Double Precision, 64-bit) గా పరిగణించబడతాయి:

  • float వాడేటప్పుడు చివర తప్పనిసరిగా f లేదా F సఫిక్స్ పెట్టాలి: float temp = 98.6f;. లేకపోతే కంపైలర్ possible lossy conversion from double to float ఎర్రర్ ఇస్తుంది.
  • double అత్యంత ఖచ్చితమైన గణనల కోసం పరిశ్రమలో 95% సందర్భాలలో ప్రామాణికంగా వాడబడుతుంది (సుమారు 15-16 దశాంశ స్థానాల కచ్చితత్వం).
  • IEEE 754 బైనరీ ఫ్లోటింగ్ పాయింట్ స్టాండర్డ్: కంప్యూటర్లు దశాంశ సంఖ్యలను బైనరీ (0s & 1s) రూపంలో నిల్వ చేస్తాయి. అందువల్ల కొన్ని దశాంశాలు (ఉదాహరణకు 0.1) బైనరీలో అనంతమైన రికరింగ్ ఫ్రాక్షన్లుగా మారతాయి. ఫలితంగా 0.1 + 0.2 కూడితే గణితంలో 0.3 వచ్చినప్పటికీ, కంప్యూటర్‌లో 0.30000000000000004 వస్తుంది!
  • బ్యాంకింగ్ & ఫైనాన్స్ గోల్డెన్ రూల్: ఈ రౌండింగ్ ఎర్రర్ల కారణంగా బ్యాంకింగ్, ఇ-కామర్స్ పేమెంట్స్ మరియు కరెన్సీ లెక్కలకు float లేదా double ఎట్టిపరిస్థితుల్లోనూ వాడకూడదు! వీటికి బదులుగా java.math.BigDecimal క్లాస్‌ను మాత్రమే ఉపయోగించాలి.

5 char డేటా టైప్ (16-bit Unicode & ASCII)

C భాషలో char కేవలం 1 బైట్ (ASCII — 128 అక్షరాలు) మాత్రమే. కానీ జావా ప్రపంచ భాషలన్నింటినీ (తెలుగు, హిందీ, చైనీస్, అరబిక్, ఎమోజీలు) సమర్ధించడానికి 16-bit Unicode (UTF-16) ను ఉపయోగిస్తుంది:

char letter = 'A'; // ఇంగ్లీష్ అక్షరం (ASCII 65)
char teluguLetter = 'అ'; // తెలుగు అక్షరం (Unicode \u0C05)
char unicodeSymbol = '\u20B9'; // భారతీయ రూపాయి చిహ్నం (₹)

6 boolean డేటా టైప్ & లాజికల్ ఫ్లాగ్స్

జావాలో boolean కేవలం రెండు విలువలనే అనుమతిస్తుంది: true లేదా false.

⚡ C vs Java Boolean Difference:

C లేదా C++ లో 1 అంటే true, 0 అంటే false గా వాడవచ్చు. కానీ జావాలో పూర్ణాంకాలను (1 లేదా 0) బూలియన్‌గా పరిగణించడం ఖచ్చితంగా నిషేధం! if (1) అని రాస్తే జావా కంపైలర్ incompatible types: int cannot be converted to boolean అని ఎర్రర్ ఇస్తుంది.

7 Stack vs Heap మెమరీ ఆర్కిటెక్చర్

జావా రన్‌టైమ్ మెమరీలో వేరియబుల్స్ ఎలా భద్రపరచబడతాయో స్పష్టంగా అర్థం చేసుకోవడం ఎంతో ముఖ్యం:

ఫీచర్ Stack మెమరీ Heap మెమరీ
ఏమి నిల్వ ఉంటాయి? ప్రిమిటివ్ వేరియబుల్స్ (int, double) మరియు ఆబ్జెక్ట్ రిఫరెన్స్ పాయింటర్లు. అన్ని అసలైన ఆబ్జెక్టులు (Objects), అర్రేలు (Arrays), మరియు స్ట్రింగ్స్ (Strings).
వేగం & ఆర్డర్ అత్యంత వేగవంతమైనది (LIFO — Last In First Out ఆర్డర్). స్టాక్ కంటే కాస్త నెమ్మదిగా కేటాయించబడుతుంది.
లైఫ్‌టైమ్ మెథడ్ ఎగ్జిక్యూషన్ ముగియగానే మెమరీ తక్షణమే క్లియర్ అవుతుంది. గార్బేజ్ కలెక్టర్ (GC) ద్వారా ఆటోమేటిక్‌గా రీక్లెయిమ్ చేయబడుతుంది.
ఎర్రర్ పరిమితి దాటితే StackOverflowError వస్తుంది. మెమరీ సరిపోకపోతే OutOfMemoryError వస్తుంది.

8 Modern Java 10+ 'var' లోకల్ వేరియబుల్ టైప్ ఇన్ఫరెన్స్

జావా 10 లో ప్రవేశపెట్టిన Local Variable Type Inference (var) ద్వారా డెవలపర్లు ఎడమవైపు డేటా టైప్‌ను మాటిమాటికీ రాయాల్సిన అవసరం లేకుండా కోడ్‌ను క్లీన్‌గా ఉంచవచ్చు:

// పాత లెగసీ పద్ధతి:
String message = "Hello Java 21";
double taxRate = 0.18;

// Modern Java 10+ 'var' పద్ధతి (కంపైలర్ ఆటోమేటిక్‌గా టైప్ గుర్తిస్తుంది):
var message = "Hello Java 21"; // కంపైలర్ String గా నిర్ణయిస్తుంది
var taxRate = 0.18; // కంపైలర్ double గా నిర్ణయిస్తుంది

⚠️ Rules for using 'var':

1. var కేవలం మెథడ్ లోపల ఉండే Local Variables కు మాత్రమే వర్తిస్తుంది.
2. var ను డిక్లేర్ చేసేటప్పుడే తప్పనిసరిగా ఇనిషియలైజ్ చేయాలి: var x; ❌ (ఎర్రర్: cannot infer type for local variable).
3. క్లాస్ ఫీల్డ్స్‌గా లేదా మెథడ్ పారామీటర్లుగా var వాడకూడదు.
4. var వాడినప్పటికీ జావా ఇప్పటికీ స్టాటికల్లీ టైప్డ్ భాషగానే ఉంటుంది (జావాస్క్రిప్ట్ లాగా డైనమిక్ టైపింగ్ కాదు).

9 కోడ్ డెమో 1: 8 ప్రిమిటివ్ టైప్స్ రేంజ్ & మెమరీ ఇన్స్పెక్టర్

జావాలోని 8 ప్రిమిటివ్ డేటా టైప్స్ యొక్క కనీస, గరిష్ట పరిధులు మరియు బైట్ పరిమాణాలను రాపర్ క్లాస్ కాన్‌స్టాంట్స్ ద్వారా ప్రింట్ చేసే లైవ్ ప్రోగ్రామ్:

PrimitiveRangeInspector.java
public class PrimitiveRangeInspector {
    public static void main(String[] args) {
        System.out.println("==================================================");
        System.out.println("       JAVA 8 PRIMITIVE DATA TYPES TELEMETRY      ");
        System.out.println("==================================================");

        System.out.printf("  %-8s : %d bytes | Range: %d to %d%n", 
                          "byte", Byte.BYTES, Byte.MIN_VALUE, Byte.MAX_VALUE);
        System.out.printf("  %-8s : %d bytes | Range: %d to %d%n", 
                          "short", Short.BYTES, Short.MIN_VALUE, Short.MAX_VALUE);
        System.out.printf("  %-8s : %d bytes | Range: %d to %d%n", 
                          "int", Integer.BYTES, Integer.MIN_VALUE, Integer.MAX_VALUE);
        System.out.printf("  %-8s : %d bytes | Range: %d to %d%n", 
                          "long", Long.BYTES, Long.MIN_VALUE, Long.MAX_VALUE);
        System.out.printf("  %-8s : %d bytes | Range: %e to %e%n", 
                          "float", Float.BYTES, Float.MIN_VALUE, Float.MAX_VALUE);
        System.out.printf("  %-8s : %d bytes | Range: %e to %e%n", 
                          "double", Double.BYTES, Double.MIN_VALUE, Double.MAX_VALUE);
        System.out.printf("  %-8s : %d bytes | Range: %d to %d (Unicode)%n", 
                          "char", Character.BYTES, (int) Character.MIN_VALUE, (int) Character.MAX_VALUE);
        System.out.println("  boolean  : 1 bit   | Values: true or false");

        System.out.println("--------------------------------------------------");
        System.out.println("Status: Primitive memory boundaries verified!");
        System.out.println("==================================================");
    }
}
💻 Console Output (PrimitiveRangeInspector)
==================================================
       JAVA 8 PRIMITIVE DATA TYPES TELEMETRY      
==================================================
  byte     : 1 bytes | Range: -128 to 127
  short    : 2 bytes | Range: -32768 to 32767
  int      : 4 bytes | Range: -2147483648 to 2147483647
  long     : 8 bytes | Range: -9223372036854775808 to 9223372036854775807
  float    : 4 bytes | Range: 1.401298e-45 to 3.402823e+38
  double   : 8 bytes | Range: 4.900000e-324 to 1.797693e+308
  char     : 2 bytes | Range: 0 to 65535 (Unicode)
  boolean  : 1 bit   | Values: true or false
--------------------------------------------------
Status: Primitive memory boundaries verified!
==================================================

10 కోడ్ డెమో 2: Modern Java 'var' టైప్ ఇన్ఫరెన్స్ & స్కోప్ వ్యాలిడేటర్

ఆధునిక var సింటాక్స్ ఎలా పని చేస్తుందో మరియు కంపైలర్ రన్‌టైమ్‌లో డేటా టైప్‌లను ఎలా లాక్ చేస్తుందో నిరూపించే ప్రోగ్రామ్:

ModernVarInferenceApp.java
public class ModernVarInferenceApp {
    public static void main(String[] args) {
        System.out.println("--------------------------------------------------");
        System.out.println("       MODERN JAVA 10+ 'var' INFERENCE DEMO       ");
        System.out.println("--------------------------------------------------");

        // Type inferred automatically at compile time
        var projectName = "Hyderabad Metro Smart Ticketing";
        var passengerCount = 450000;
        var ticketPrice = 55.75;
        var isSystemOnline = true;
        var currencySymbol = '₹';

        System.out.println("Project   : " + projectName + " (" + projectName.getClass().getSimpleName() + ")");
        System.out.println("Passengers: " + passengerCount);
        System.out.println("Ticket    : " + currencySymbol + ticketPrice);
        System.out.println("Live Status: " + (isSystemOnline ? "ONLINE" : "OFFLINE"));

        // Calculating total revenue using inferred variables
        var totalDailyRevenue = passengerCount * ticketPrice;
        System.out.printf("Total Est. Revenue: %c %,.2f%n", currencySymbol, totalDailyRevenue);
        System.out.println("--------------------------------------------------");
    }
}
💻 Console Output (ModernVarInferenceApp)
--------------------------------------------------
       MODERN JAVA 10+ 'var' INFERENCE DEMO       
--------------------------------------------------
Project   : Hyderabad Metro Smart Ticketing (String)
Passengers: 450000
Ticket    : ₹55.75
Live Status: ONLINE
Total Est. Revenue: ₹ 25,087,500.00
--------------------------------------------------

11 కోడ్ డెమో 3: Employee Salary & Financial Tax Computation Engine (Capstone Mini Project)

ఒక పూర్తిస్థాయి కార్పొరేట్ సాలరీ కాలిక్యులేషన్ సిస్టమ్: వివిధ ప్రిమిటివ్ డేటా టైప్స్ (int, double, char, boolean) ను సమన్వయం చేస్తూ జీతం, అలవెన్సులు మరియు పన్నులను లెక్కించే కాప్‌స్టోన్ ప్రాజెక్ట్:

PayrollComputationEngine.java
public class PayrollComputationEngine {
    public static void main(String[] args) {
        // Employee Information using accurate primitive types
        int employeeId        = 84201;
        String employeeName   = "సురేష్ వర్మ";
        char performanceGrade = 'A';
        boolean isPfEligible  = true;

        double basicSalary    = 85000.00;
        double hraPercentage  = 20.0; // 20% House Rent Allowance
        double daPercentage   = 10.0; // 10% Dearness Allowance
        double taxRate        = 12.5; // 12.5% Income Tax

        // Financial Computations
        double hraAmount     = (basicSalary * hraPercentage) / 100.0;
        double daAmount      = (basicSalary * daPercentage) / 100.0;
        double grossSalary   = basicSalary + hraAmount + daAmount;
        double taxDeduction  = (grossSalary * taxRate) / 100.0;
        double pfDeduction   = isPfEligible ? (basicSalary * 12.0) / 100.0 : 0.0;
        double netTakeHome   = grossSalary - (taxDeduction + pfDeduction);

        System.out.println("==================================================");
        System.out.println("       ENTERPRISE EMPLOYEE PAYSLIP ENGINE        ");
        System.out.println("==================================================");
        System.out.printf("  Emp ID   : #%d | Name: %s%n", employeeId, employeeName);
        System.out.printf("  Rating   : Grade %c | PF Status: %s%n", 
                          performanceGrade, isPfEligible ? "Enrolled" : "Exempt");
        System.out.println("--------------------------------------------------");
        System.out.printf("  Basic Pay     : ₹ %,10.2f%n", basicSalary);
        System.out.printf("  HRA (20%%)    : ₹ %,10.2f%n", hraAmount);
        System.out.printf("  DA  (10%%)    : ₹ %,10.2f%n", daAmount);
        System.out.printf("  Gross Salary  : ₹ %,10.2f%n", grossSalary);
        System.out.println("--------------------------------------------------");
        System.out.printf("  Tax (12.5%%)  : -₹ %,9.2f%n", taxDeduction);
        System.out.printf("  PF (12%%)     : -₹ %,9.2f%n", pfDeduction);
        System.out.println("--------------------------------------------------");
        System.out.printf("  NET TAKE HOME : ₹ %,10.2f%n", netTakeHome);
        System.out.println("==================================================");
    }
}
💻 Console Output (PayrollComputationEngine)
==================================================
       ENTERPRISE EMPLOYEE PAYSLIP ENGINE        
==================================================
  Emp ID   : #84201 | Name: సురేష్ వర్మ
  Rating   : Grade A | PF Status: Enrolled
--------------------------------------------------
  Basic Pay     : ₹  85,000.00
  HRA (20%)    : ₹  17,000.00
  DA  (10%)    : ₹   8,500.00
  Gross Salary  : ₹ 110,500.00
--------------------------------------------------
  Tax (12.5%)  : -₹ 13,812.50
  PF (12%)     : -₹ 10,200.00
--------------------------------------------------
  NET TAKE HOME : ₹  86,487.50
==================================================

12 టాప్ 6 మెమరీ మిస్టేక్స్ & 5 క్విజ్‌లు

డేటా టైప్స్ మరియు మెమరీ వినియోగంలో డెవలపర్లు ఎదుర్కొనే 6 ప్రధాన సమస్యలు:

సమస్య తప్పు కోడ్ సరిదిద్దిన సరైన విధానం
ఇంటిజర్ ఓవర్‌ఫ్లో int x = 2147483647 + 1; (నెగెటివ్ సంఖ్యగా మారుతుంది) పెద్ద విలువలకు long వాడాలి: long x = 2147483647L + 1;
లాంగ్ లిటరల్‌కు 'L' మర్చిపోవడం long val = 5000000000; long val = 5000000000L;
ఫ్లోట్ లిటరల్‌కు 'f' మిస్ అవ్వడం float f = 3.14; (డబుల్ నుండి ఫ్లోట్‌కు కాస్ట్ కాదు) float f = 3.14f;
ఇనిషియలైజ్ చేయకుండా లోకల్ వేరియబుల్ వాడటం int x; System.out.println(x); ముందే డిఫాల్ట్ విలువ ఇవ్వాలి: int x = 0;
var ను ఇనిషియలైజ్ చేయకపోవడం var count; డిక్లరేషన్ సమయంలోనే విలువ ఇవ్వాలి: var count = 10;
కరెన్సీ లెక్కలకు double వాడటం double diff = 1.0 - 0.9; // 0.09999999999999998 ఆర్థిక లావాదేవీలకు BigDecimal క్లాస్ వాడాలి.

🧠 మీ అవగాహనను పరీక్షించుకోండి (5 Interactive Quizzes):

ప్రశ్న 1: జావాలో 'byte' డేటా టైప్ యొక్క గరిష్ట విలువ ఎంత?

సమాధానం: 127. (byte పరిధి -128 నుండి +127 వరకు ఉంటుంది).

ప్రశ్న 2: 'char' డేటా టైప్ జావాలో ఎన్ని బైట్ల మెమరీని తీసుకుంటుంది మరియు ఎందుకు?

సమాధానం: 2 బైట్లు (16 bits). ఎందుకంటే జావా అంతర్జాతీయ 16-bit Unicode (UTF-16) అక్షరాల వ్యవస్థను సమర్ధిస్తుంది.

ప్రశ్న 3: 'var' ను క్లాస్ లెవెల్ వేరియబుల్ (ఇన్‌స్టాన్స్ ఫీల్డ్) గా ఉపయోగించవచ్చా?

సమాధానం: లేదు! var కేవలం మెథడ్ లోపల ఉండే Local Variables కు మాత్రమే పరిమితం.

ప్రశ్న 4: ప్రిమిటివ్ వేరియబుల్స్ మెమరీలో ఎక్కడ నిల్వ చేయబడతాయి?

సమాధానం: లోకల్ ప్రిమిటివ్ వేరియబుల్స్ నేరుగా Stack మెమరీ లో మెరుపు వేగంతో కేటాయించబడతాయి.

ప్రశ్న 5: జావాలో 'boolean' విలువగా 1 లేదా 0 ఇవ్వవచ్చా?

సమాధానం: ఖచ్చితంగా ఇవ్వకూడదు! జావాలో boolean కేవలం true లేదా false లిటరల్స్‌ను మాత్రమే అంగీకరిస్తుంది.

← మునుపటి పాఠం: 03. Syntax & Main Method తర్వాతి పాఠం: 05. Operators & Type Casting →