04. వేరియబుల్స్, 8 ప్రిమిటివ్ డేటా టైప్స్ & మెమరీ మోడల్ (Variables, Primitive Data Types & Memory Model)
సాఫ్ట్వేర్ అప్లికేషన్లు చేసే ముఖ్యమైన పని — డేటాను భద్రపరచడం, దానిపై లెక్కలు చేయడం మరియు ఫలితాలను యూజర్లకు చూపించడం. కంప్యూటర్ యొక్క తాత్కాలిక జ్ఞాపకశక్తి అయిన 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).
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 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 ప్రిమిటివ్ డేటా టైప్స్ యొక్క కనీస, గరిష్ట పరిధులు మరియు బైట్ పరిమాణాలను రాపర్ క్లాస్ కాన్స్టాంట్స్ ద్వారా ప్రింట్ చేసే లైవ్ ప్రోగ్రామ్:
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("==================================================");
}
}
==================================================
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 సింటాక్స్ ఎలా పని చేస్తుందో మరియు కంపైలర్ రన్టైమ్లో డేటా టైప్లను ఎలా లాక్ చేస్తుందో నిరూపించే ప్రోగ్రామ్:
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("--------------------------------------------------");
}
}
--------------------------------------------------
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) ను సమన్వయం చేస్తూ జీతం, అలవెన్సులు మరియు పన్నులను లెక్కించే కాప్స్టోన్ ప్రాజెక్ట్:
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("==================================================");
}
}
==================================================
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 లిటరల్స్ను మాత్రమే అంగీకరిస్తుంది.