స్టాటిక్ వేరియబుల్స్

1. స్టాటిక్ వేరియబుల్స్

ఒక తరగతిని మెమరీలోకి లోడ్ చేసినప్పుడు, ఒక స్థిరమైన వస్తువు వెంటనే సృష్టించబడుతుంది. ఈ వస్తువు స్టాటిక్ క్లాస్ వేరియబుల్స్ (స్టాటిక్ క్లాస్ ఫీల్డ్‌లు) నిల్వ చేస్తుంది. తరగతి యొక్క సాధారణ (నాన్-స్టాటిక్) వస్తువులు సృష్టించబడనప్పటికీ స్థిర వస్తువు ఉనికిలో ఉంటుంది.

మేము తరగతిలో వేరియబుల్‌లను ప్రకటించినప్పుడు, అవి ఒక్కసారి మాత్రమే సృష్టించబడతాయా లేదా ప్రతి ఆబ్జెక్ట్‌లో ఈ వేరియబుల్స్ యొక్క విభిన్న సందర్భాలు ఉండాలా అని మేము సూచిస్తాము. డిఫాల్ట్‌గా, ప్రతి వస్తువు కోసం ప్రతి వేరియబుల్ యొక్క కొత్త కాపీ సృష్టించబడుతుంది.

స్టాటిక్ వేరియబుల్ క్లాస్ యొక్క స్టాటిక్ ఆబ్జెక్ట్‌కు కట్టుబడి ఉంటుంది మరియు దాని యొక్క ఒకే ఉదాహరణ ఎల్లప్పుడూ ఉంటుంది.

తరగతిలో స్టాటిక్ వేరియబుల్‌ని సృష్టించడానికి, మీరు staticదాని పేరుకు ముందు కీవర్డ్‌ని వ్రాయాలి. స్టాటిక్ వేరియబుల్ డిక్లేర్ చేయడానికి సాధారణ ఫార్మాట్:

static Type name = value;

స్టాటిక్ వేరియబుల్ ప్రారంభ విలువను కేటాయించకపోతే, అది డిఫాల్ట్ విలువతో ప్రారంభించబడుతుంది:

byte

0

short

0

int

0

long

0

float

0.0

double

0.0

char

'\u0000'

0

boolean

false

Object

null

ఉదాహరణలు:

public static int WIDTH = 100;

public static String message = "Hello";

private static Scanner console;

private static int count = 0;

private static boolean flag;

తరగతి లోపల, మీరు వాటి పేర్లను ఉపయోగించడం ద్వారా దాని స్టాటిక్ వేరియబుల్‌లను సూచించవచ్చు. కానీ వాటిని మరొక తరగతి నుండి యాక్సెస్ చేయడానికి, మీరు స్టాటిక్ వేరియబుల్ పేరుకు ముందు తరగతి పేరును వ్రాయాలి.

ClassName.variable

ఉదాహరణ:

public static int WIDTH = 100;

Solution

Solution.WIDTH

public static String message = "Hello";

Main

Main.message

private static Scanner console;

JavaGame

private static int count = 0;

Counter

private static boolean flag;

Arithmetic

2. స్టాటిక్ మరియు నాన్-స్టాటిక్ వేరియబుల్స్ మధ్య వ్యత్యాసం

క్లాస్ యొక్క నాన్-స్టాటిక్ (సాధారణ) వేరియబుల్స్ కీవర్డ్ లేకుండా మాత్రమే స్టాటిక్ వాటిలాగానే ప్రకటించబడతాయి static.

సాధారణ వేరియబుల్స్ మరియు స్టాటిక్ వేరియబుల్స్ మధ్య తేడా ఏమిటి?

క్లాస్ యొక్క సాధారణ వేరియబుల్స్ క్లాస్ యొక్క వస్తువులకు (తరగతి యొక్క సందర్భాలు) కట్టుబడి ఉంటాయి, అయితే స్టాటిక్ వేరియబుల్స్ క్లాస్ యొక్క స్టాటిక్ ఆబ్జెక్ట్‌కు కట్టుబడి ఉంటాయి.

ఒక తరగతికి బహుళ సందర్భాలు ఉంటే, వాటిలో ప్రతి దాని స్వంత నాన్-స్టాటిక్ (సాధారణ) వేరియబుల్స్ కాపీని కలిగి ఉంటుంది. క్లాస్ యొక్క స్టాటిక్ వేరియబుల్స్ ఎల్లప్పుడూ దాని స్టాటిక్ ఆబ్జెక్ట్‌లో నిల్వ చేయబడతాయి మరియు వాటిలో ఒకే ఒక్క ఉదాహరణ మాత్రమే ఉంటుంది.

మీరు తరగతికి చెందిన వస్తువుకు సూచనను కలిగి ఉంటే మాత్రమే మీరు తరగతి యొక్క సాధారణ వేరియబుల్స్ (ఫీల్డ్‌లు) యాక్సెస్ చేయవచ్చు. మరియు తరగతి లోపల పద్ధతులు, కోర్సు.

ఉదాహరణ:

public class DataInfo
{
   public int value = 100;
}

public class Solution
{
   public static void main(String[] args)
   {
      DataInfo info = new DataInfo();
      System.out.println(info.value);
   }
}

మీరు ఎక్కడి నుండైనా స్టాటిక్ వేరియబుల్స్‌ను యాక్సెస్ చేయవచ్చు (విజిబిలిటీ మాడిఫైయర్‌ల కోసం అకౌంటింగ్ తర్వాత): సాధారణ పద్ధతుల నుండి, అదే తరగతికి చెందిన స్టాటిక్ పద్ధతుల నుండి, ఇతర తరగతుల పద్ధతుల నుండి మొదలైనవి.

ఉదాహరణ:

public class DataInfo
{
   public static int value = 100;
}

public class Solution
{
   public static void main(String[] args)
   {
      System.out.println(DataInfo.value);
   }
}

మెమరీ ఎలా నిర్వహించబడుతుంది:

మనకు 4 ఫీల్డ్‌లతో క్లాస్ ఉందని అనుకుందాం Person: రెండు స్టాటిక్ మరియు రెండు కాదు.

public class Person
{
   public static int count = 0;
   public static int sum = 0;
   public int age = 0;
   public String name;
}

తరగతిని లోడ్ చేసిన వెంటనే

జావా మెషీన్ తరగతిని లోడ్ చేయడం పూర్తయినప్పుడు Person, మెమరీ ఇలా కనిపిస్తుంది:

మొదటి వస్తువును సృష్టించిన తర్వాత

మేము ఒక వస్తువును సృష్టిస్తే Person, అప్పుడు చిత్రం ఇలా అవుతుంది:

రెండు వస్తువులు రెండు వేరియబుల్స్ కలిగి ఉన్నప్పటికీ, ఇవి వేర్వేరు వేరియబుల్స్ అని దయచేసి గమనించండి: సాధారణ వస్తువులు సాధారణ వేరియబుల్స్ కలిగి ఉంటాయి మరియు స్టాటిక్ ఆబ్జెక్ట్ స్టాటిక్ వేరియబుల్స్ కలిగి ఉంటాయి.

మాకు మరిన్ని వస్తువులు కావాలి

మరో రెండు వస్తువులను సృష్టిద్దాం Person. ఇప్పుడు మెమరీ ఇలా కనిపిస్తుంది:

ప్రతి వస్తువుకు దాని స్వంత వయస్సు మరియు పేరు వేరియబుల్స్ ఉన్నాయని దయచేసి గమనించండి.

3. staticమాడిఫైయర్‌ని తీసివేయడం మరియు జోడించడం

స్టాటిక్ నుండి సాధారణ వరకు

మనం స్టాటిక్ వేరియబుల్‌ని తీసుకొని దాని మాడిఫైయర్‌ని తీసివేసి దానిని సాధారణమైనదిగా మార్చినట్లయితే ఏమి జరుగుతుంది static? ఉదాహరణకు, static int sumవేరియబుల్.

సవరించిన కోడ్ ఇలా కనిపిస్తుంది:

public class Person
{
   public static int count = 0;
   public int sum = 0;
   public int age = 0;
   public String name;
}

ఇప్పుడు మెమరీ ఇలా కనిపిస్తుంది:

స్టాటిక్ ఆబ్జెక్ట్ నుండి స్టాటిక్ వేరియబుల్ అదృశ్యమైంది మరియు ఇప్పుడు ప్రతి సాధారణ వస్తువు దాని స్వంత sumవేరియబుల్ కలిగి ఉంది.

సాధారణ నుండి స్టాటిక్ వరకు

మేము దీనికి విరుద్ధంగా చేయవచ్చు: staticమాడిఫైయర్‌ను తరగతి యొక్క సాధారణ వేరియబుల్స్‌కు జోడించండి. అవి అన్ని సాధారణ వస్తువుల నుండి అదృశ్యమవుతాయి మరియు స్థిరమైన వస్తువులో కనిపిస్తాయి. మరియు వేరియబుల్స్‌ను స్టాటిక్‌గా చేయాలని నిర్ణయించుకున్నాము . agenameఅప్పుడు కోడ్ ఇలా కనిపిస్తుంది:

public class Person
{
   public static int count = 0;
   public int sum = 0;
   public static int age = 0;
   public static String name;
}

మరియు ఇప్పుడు మెమరీ ఇలా కనిపిస్తుంది: