జావా డేటా రకాలు మరియు జావా ఆదిమ రకాలు



డేటా రకాలు జావా ఆదిమ

జావాలోని డేటా రకాలు విలువ రకం వేరియబుల్ పట్టుకోగలదు. మునుపటి వ్యాసంలో, a ని ఎలా ప్రకటించాలో చూశాము వేరియబుల్. ఈ ట్యుటోరియల్‌లో, వేర్వేరు డేటా రకాలను గురించి మరియు వాటిని వేరియబుల్ డిక్లరేషన్‌లో ఎలా ఉపయోగించాలో నేర్చుకుంటాము. మేము ఈ వ్యాసంలో ప్రిమిటివ్ డేటా రకాలు మరియు నాన్-ప్రిమిటివ్ డేటా రకాలను చర్చిస్తాము.

మనం ప్రకటించే ఏదైనా వేరియబుల్ కోసం, డేటా రకం తప్పనిసరి ఎందుకంటే ఇది విలువను నిల్వ చేయడానికి వేరియబుల్‌కు ఎంత మెమరీ అవసరమో సూచిస్తుంది. వేరియబుల్ డిక్లరేషన్ గుర్తుకు తెచ్చుకుందాం. ఉదాహరణకు, దిగువ కోడ్‌లో, మేము విలువ 10 తో పూర్ణాంక వేరియబుల్‌ను ప్రకటించాము మరియు ప్రారంభించాము.

int a = 10;

జావాలో డేటా రకాలు 2 వర్గాలు ఉన్నాయి:

  • ఆదిమ డేటా రకాలు - ఇందులో బైట్, షార్ట్, ఇంటెంట్, లాంగ్, చార్, డబుల్, ఫ్లోట్ మరియు బూలియన్ ఉన్నాయి.
  • నాన్ ప్రిమిటివ్ డేటా రకాలు - ఇది స్ట్రింగ్, అర్రే, క్లాస్ మరియు ఇంటర్‌ఫేస్‌ను వర్తిస్తుంది.

జావాలో డేటా రకాలు

ఈ ట్యుటోరియల్‌లో, ఆదిమ డేటా రకాలను గురించి వివరంగా నేర్చుకుంటాము. యొక్క ఆదిమ డేటా రకాలు స్ట్రింగ్ మరియు అర్రే ప్రత్యేక ట్యుటోరియల్లో ఉన్నాయి.

జావా ప్రిమిటివ్ డేటా రకాలు

జావాలో 8 వేర్వేరు రకాల ప్రిమిటివ్ డేటా రకాలు వేరియబుల్ యొక్క రకాన్ని మరియు విలువను తెలుపుతాయి.

సమాచార తరహాపరిమాణం<span style="font-family: Mandali; "> టెండర్‌ వివరణ</span>డిఫాల్ట్ విలువ
బైట్1 బైట్-128 నుండి 127 వరకు మొత్తం సంఖ్యలను నిల్వ చేస్తుంది0 (సున్నా)
చిన్న2 బైట్లుమొత్తం సంఖ్యను -32768 నుండి 32767 వరకు నిల్వ చేస్తుంది0 (సున్నా)
పూర్ణాంకానికి4 బైట్లు-2,147,483,648 నుండి 2,147,483,647 వరకు మొత్తం సంఖ్యలను నిల్వ చేస్తుంది0 (సున్నా)
దీర్ఘ8 బైట్లు-9,223,372,036,854,775,808 నుండి 9,223,372,036,854,775,807 వరకు మొత్తం సంఖ్యలను నిల్వ చేస్తుంది0L
ఫ్లోట్4 బైట్లుపాక్షిక సంఖ్యలను 6-7 దశాంశ అంకెలు వరకు నిల్వ చేస్తుంది0.0f
డబుల్8 బైట్లు15 దశాంశ అంకెలతో పాక్షిక సంఖ్యలను నిల్వ చేస్తుంది0.0d
చార్2 బైట్లుఒకే అక్షరం / అక్షరాన్ని నిల్వ చేస్తుంది'\ u0000'
బూలియన్20 బిట్నిజం లేదా తప్పు అని నిల్వ చేస్తుందితప్పుడు

బైట్ డేటా రకం

జావాలో బైట్ డేటా రకం పరిధి మధ్య మొత్తం సంఖ్యలను నిల్వ చేస్తుంది -3 నుండి 128 వరకు. ఈ డేటా రకం ప్రధానంగా మెమరీని ఆదా చేయడానికి ఉపయోగిస్తారు, ఎందుకంటే ఇది పూర్ణాంకానికి 4 రెట్లు చిన్నది మరియు మొత్తం సంఖ్య ఈ పరిమితిలో ఉందని మనకు తెలిసినప్పుడు.

public class DataTypeDemo {

  public static void main(String[] args) {
    byte b = 100;
    System.out.println(b);
    
  }
}
100

మేము పేర్కొన్న పరిమితులకు మించి విలువ కలిగిన బైట్ వేరియబుల్‌ను ప్రారంభిస్తే, అది సంకలన లోపాన్ని విసిరివేస్తుంది.

public class DataTypeDemo {

  public static void main(String[] args) {
    byte b = 130;
    System.out.println(b);
    
  }
}
Exception in thread "main" java.lang.Error: Unresolved compilation problem: 
  Type mismatch: cannot convert from int to byte

  at DataTypeDemo.main(DataTypeDemo.java:5)

చిన్న డేటా రకం

చిన్న డేటా రకం బైట్ కంటే పరిమాణంలో ఎక్కువ కాని పూర్ణాంకం కంటే తక్కువ. ఇది మధ్య విలువలను కలిగి ఉంటుంది -32768 నుండి 32767 వరకు. జావాలోని డేటా రకం పూర్ణాంకంతో పోల్చినప్పుడు మెమరీని కూడా ఆదా చేస్తుంది. మేము పరిమితికి మించి విలువలను ప్రారంభిస్తే ఇది “టైప్ అసమతుల్యత” లోపాన్ని కూడా విసురుతుంది.

public class DataTypeDemo {

  public static void main(String[] args) {
    short s = 10000;
    System.out.println(s);
    
  }
}
10000

Int డేటా రకం

మొత్తం సంఖ్యలను నిల్వ చేయడానికి జావాలో సాధారణంగా ఉపయోగించే డేటా రకం Int. ఇది విలువలను పరిధిలో నిల్వ చేయగలదు -2,147,483,648 నుండి 2,147,483,647 వరకు.ఇది మరేమీ కాదు -2 ^ 31 నుండి 2 ^ 31 - 1 వరకు

public class DataTypeDemo {

  public static void main(String[] args) {
    int i = 50000;
    System.out.println(i);
    
  }
}
50000

లాంగ్ డేటా రకం

పూర్ణాంక పరిమితి కంటే ఎక్కువ విలువను నిల్వ చేయాల్సిన అవసరం వచ్చినప్పుడు మేము జావాలో లాంగ్ డేటా రకాన్ని ఉపయోగిస్తాము. దీని మధ్య సామర్థ్యం ఉంది -3 నుండి 9,223,372,036,854,775,808 వరకు ఇది పరిధిలో ఉంది -2 ^ 63 నుండి 2 ^ 63 - 1 వరకు. ఇది చాలా తరచుగా ఉపయోగించబడదు.

public class DataTypeDemo {

  public static void main(String[] args) {
    long l = 1023435235235235L;
    System.out.println(l);
    
  }
}
1023435235235235

ఫ్లోట్ డేటా రకం

మేము నిల్వ చేయడానికి జావాలో ఫ్లోట్ డేటా రకాన్ని ఉపయోగిస్తాము పాక్షిక విలువ ఒకే-ఖచ్చితత్వం 20 బిట్ IEEE754 ఫ్లోటింగ్ పాయింట్. ఈ డేటా రకం రెట్టింపు కంటే చిన్నది కాని ఖచ్చితమైన పాక్షిక విలువలను నిల్వ చేయడానికి మేము దీనిని ఉపయోగించలేము.

public class DataTypeDemo {

  public static void main(String[] args) {
    float f = 4.5678f;
    System.out.println(f);
    
  }
}
4.5678

డబుల్ డేటా రకం

జావాలో డబుల్ డేటా రకం కూడా a పాక్షిక విలువ కానీ డబుల్-ప్రెసిషన్ 20 బిట్ IEEE 754 ఫ్లోటింగ్ పాయింట్. ఫ్లోట్ మాదిరిగానే దశాంశ విలువల కోసం మనం దీనిని ఉపయోగించవచ్చు.

public class DataTypeDemo {

  public static void main(String[] args) {
    Double d = 56.567891234d;
    System.out.println(d);
    
  }
}
56.567891234

చార్ డేటా రకం

సింగిల్‌ను నిల్వ చేయడానికి మేము జావాలో చార్ డేటా రకాన్ని ఉపయోగిస్తాము పాత్ర లేదా లేఖ. ఇది a 16-బిట్ యూనికోడ్ అక్షరం మరియు విలువ మధ్య ఉంటుంది 0 ('\ u0000') నుండి 65535 ('\ uffff')

public class DataTypeDemo {

  public static void main(String[] args) {
    char c ='j';
    System.out.println(c);
    
  }
}
j

బూలియన్ డేటా రకం

జావాలో సాధారణంగా ఉపయోగించే మరొక డేటా రకం ఇది విలువలను నిల్వ చేస్తుంది నిజమైన or తప్పుడు. మేము దీన్ని షరతులతో కూడిన ప్రయోజనాల కోసం జెండాలుగా ఉపయోగిస్తాము.

public class DataTypeDemo {

  public static void main(String[] args) {
    boolean b;
    int a = 4;
    int i = 8;
    if(a>i)
      b = true;
    else
      b = false;
    System.out.println(b);
    
  }
}
false

నాన్-ప్రిమిటివ్ డేటా రకాలు

జావాలో నాన్-ప్రిమిటివ్ డేటా రకాలు ఉన్నాయి స్ట్రింగ్, అర్రే, క్లాస్ మరియు ఇంటర్ఫేస్. మేము వాటిని కూడా పిలుస్తాము రిఫరెన్స్ డేటా రకాలు. రాబోయే ట్యుటోరియల్లో నాన్-ప్రిమిటివ్ డేటా రకాలను గురించి వివరంగా తెలియజేస్తాము.

స్ట్రింగ్

A స్ట్రింగ్ అక్షరాల శ్రేణిని సూచించే మరొక సాధారణంగా ఉపయోగించే డేటా రకం. విలువ ఎల్లప్పుడూ డబుల్ కోట్స్ (”“) లో ఉంటుంది.

String str = "Java Programming";

అర్రే

An అమరిక ఒకే డేటా రకం యొక్క బహుళ విలువలను కలిగి ఉంటుంది. మేము ఏ రకమైన డేటాను నిల్వ చేయడానికి శ్రేణిని ఉపయోగించవచ్చు.

String[] names = {"Ram","Leela","Tejas"};
int[] num = {3,6,12,89,24};

క్లాస్

జావాలో ఒక తరగతి చాలా ఉంది పద్ధతులు మరియు వేరియబుల్స్. మేము వాటిని ఉపయోగించడానికి తరగతి యొక్క ఒక ఉదాహరణను సృష్టించాలి. క్లాస్ లోపల ఏదైనా డేటాను యాక్సెస్ చేయడానికి మేము ఒకే వస్తువును ఉపయోగించవచ్చు. ఉదాహరణకు, మేము ఒక ఉదాహరణ లేదా వస్తువును సృష్టించాము d మేము తరగతి లోపల ఏదైనా పద్ధతులు లేదా వేరియబుల్స్ యాక్సెస్ చేయాలనుకుంటే.

public class DataTypeDemo {

  public static void main(String[] args) {
    DataTypeDemo d = new DataTypeDemo();
    
  }
}

ఇంటర్ఫేస్

ఇంటర్ఫేస్ అంటే ఫంక్షన్లు లేదా వేరియబుల్స్ మాత్రమే ఉన్న క్లాస్ లాగా ఉంటుంది కాని అమలు లేదు. ఈ విధుల అమలు మరెక్కడైనా ఉంటుంది. మరో మాటలో చెప్పాలంటే, ఇది ఒక తరగతి ఏమి చేస్తుందో చెబుతుంది మరియు అది ఎలా చేస్తుందో కాదు.

//interface
interface StudentDetails {
  public void getStudentName();
  public void getStudentDepartment();
}

//implementation of the methods
public class Student implements StudentDetails {
  
  @Override
  public void getStudentName() {
    
  }

  @Override
  public void getStudentDepartment() {
    
  }
}

సూచన