ജാവ ഡാറ്റ തരങ്ങളും ജാവ പ്രാകൃത തരങ്ങളും



ഡാറ്റ തരങ്ങൾ ജാവ ആദിമമായ

ജാവയിലെ ഡാറ്റ തരങ്ങൾ സൂചിപ്പിക്കുന്നത് മൂല്യത്തിന്റെ തരം ഒരു വേരിയബിളിന് പിടിക്കാൻ കഴിയും. മുമ്പത്തെ ലേഖനത്തിൽ, a എങ്ങനെ പ്രഖ്യാപിക്കാമെന്ന് ഞങ്ങൾ കണ്ടു വേരിയബിൾ. ഈ ട്യൂട്ടോറിയലിൽ, വ്യത്യസ്ത ഡാറ്റ തരങ്ങളെക്കുറിച്ചും വേരിയബിൾ ഡിക്ലറേഷനിൽ അവ എങ്ങനെ ഉപയോഗിക്കാമെന്നതിനെക്കുറിച്ചും ഞങ്ങൾ പഠിക്കും. ഈ ലേഖനത്തിൽ പ്രിമിറ്റീവ് ഡാറ്റ തരങ്ങളും നോൺ-പ്രിമിറ്റീവ് ഡാറ്റ തരങ്ങളും ഞങ്ങൾ ചർച്ച ചെയ്യും.

ഞങ്ങൾ പ്രഖ്യാപിക്കുന്ന ഏതൊരു വേരിയബിളിനും, ഒരു ഡാറ്റ തരം നിർബന്ധമാണ്, കാരണം മൂല്യം സംഭരിക്കാൻ വേരിയബിളിന് എത്ര മെമ്മറി ആവശ്യമാണെന്ന് ഇത് സൂചിപ്പിക്കുന്നു. നമുക്ക് വേരിയബിൾ ഡിക്ലറേഷൻ ഓർമ്മിക്കാം. ഉദാഹരണത്തിന്, ചുവടെയുള്ള കോഡിൽ, മൂല്യം 10 ​​ഉള്ള ഒരു സംഖ്യ വേരിയബിൾ ഞങ്ങൾ പ്രഖ്യാപിക്കുകയും സമാരംഭിക്കുകയും ചെയ്തു.

int a = 10;

ജാവയിൽ 2 തരം ഡാറ്റ തരങ്ങളുണ്ട്:

  • പ്രാകൃത ഡാറ്റ തരങ്ങൾ - ഇതിൽ ബൈറ്റ്, ഹ്രസ്വ, അന്തർ, നീളമുള്ള, ചാർ, ഇരട്ട, ഫ്ലോട്ട്, ബൂളിയൻ എന്നിവ ഉൾപ്പെടുന്നു.
  • പ്രാകൃതമല്ലാത്ത ഡാറ്റ തരങ്ങൾ - ഇത് സ്ട്രിംഗ്, അറേ, ക്ലാസ്, ഇന്റർഫേസ് എന്നിവ ഉൾക്കൊള്ളുന്നു.

ജാവയിലെ ഡാറ്റ തരങ്ങൾ

ഈ ട്യൂട്ടോറിയലിൽ, പ്രാകൃത ഡാറ്റ തരങ്ങളെക്കുറിച്ച് ഞങ്ങൾ വിശദമായി പഠിക്കും. പ്രാകൃതമല്ലാത്ത ഡാറ്റ തരങ്ങൾ സ്ട്രിംഗ് ഒപ്പം അറേ പ്രത്യേക ട്യൂട്ടോറിയലുകളിൽ ഉൾപ്പെടുത്തിയിരിക്കുന്നു.

ജാവ പ്രാകൃത ഡാറ്റ തരങ്ങൾ

വേരിയബിളിന്റെ തരവും മൂല്യവും വ്യക്തമാക്കുന്ന 8 വ്യത്യസ്ത തരം പ്രിമിറ്റീവ് ഡാറ്റ തരങ്ങൾ ജാവയിൽ ഉണ്ട്.

ഡാറ്റ തരംവലുപ്പംവിവരണംസ്ഥിര മൂല്യം
ബൈറ്റ്1 ബൈറ്റ്-128 മുതൽ 127 വരെയുള്ള മുഴുവൻ നമ്പറുകളും സംഭരിക്കുന്നു0 (പൂജ്യം)
കുറിയ2 ബൈറ്റുകൾ-32768 മുതൽ 32767 വരെ മുഴുവൻ നമ്പറും സംഭരിക്കുന്നു0 (പൂജ്യം)
int4 ബൈറ്റുകൾ-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 ദശാംശ അക്കങ്ങൾ വരെ ഭിന്നസംഖ്യകൾ സംഭരിക്കുന്നുക്സനുമ്ക്സഫ്
ഇരട്ട8 ബൈറ്റുകൾ15 ദശാംശ അക്കങ്ങൾ വരെയുള്ള ഭിന്നസംഖ്യകൾ സംഭരിക്കുന്നുഎൺപത്
പ്രതീകം2 ബൈറ്റുകൾഒരൊറ്റ പ്രതീകം / അക്ഷരം സംഭരിക്കുന്നു'\ u0000'
ബൂളിയൻ1 ബിറ്റ്ശരി അല്ലെങ്കിൽ തെറ്റ് സംഭരിക്കുന്നുതെറ്റായ

ബൈറ്റ് ഡാറ്റ തരം

ജാവയിലെ ബൈറ്റ് ഡാറ്റ തരം ശ്രേണികൾക്കിടയിൽ മുഴുവൻ നമ്പറുകളും സംഭരിക്കുന്നു -128 മുതൽ 127 വരെ. ഈ ഡാറ്റ തരം പ്രധാനമായും മെമ്മറി സംരക്ഷിക്കാൻ ഉപയോഗിക്കുന്നു, കാരണം ഇത് ഇന്റിനേക്കാൾ 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

ദൈർഘ്യമേറിയ ഡാറ്റ തരം

സംഖ്യ പരിധിയേക്കാൾ വലുതായ ഒരു മൂല്യം സംഭരിക്കേണ്ടിവരുമ്പോൾ ഞങ്ങൾ ജാവയിൽ ഒരു നീണ്ട ഡാറ്റ തരം ഉപയോഗിക്കുന്നു. ഇതിനിടയിൽ ശേഷി ഉണ്ട് -9,223,372,036,854,775,808 മുതൽ 9,223,372,036,854,775,807 വരെ അത് പരിധിയിലാണ് -2 ^ 63 മുതൽ 2 ^ 63 - 1 വരെ. ഇത് പതിവായി ഉപയോഗിക്കുന്നില്ല.

public class DataTypeDemo {

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

ഫ്ലോട്ട് ഡാറ്റ തരം

ഒരു സംഭരിക്കാൻ ഞങ്ങൾ ജാവയിലെ ഫ്ലോട്ട് ഡാറ്റ തരം ഉപയോഗിക്കുന്നു ഭിന്നസംഖ്യ ഒരൊറ്റ കൃത്യതയുള്ള മൂല്യം 32 ബിറ്റ് IEEE754 ഫ്ലോട്ടിംഗ് പോയിൻറ്. ഈ ഡാറ്റ തരം ഇരട്ടിയേക്കാൾ ചെറുതാണ്, പക്ഷേ കൃത്യമായ ഭിന്ന മൂല്യങ്ങൾ സംഭരിക്കാൻ ഞങ്ങൾക്ക് ഇത് ഉപയോഗിക്കാൻ കഴിയില്ല.

public class DataTypeDemo {

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

ഇരട്ട ഡാറ്റ തരം

ജാവയിലെ ഇരട്ട ഡാറ്റ തരവും a ഭിന്നസംഖ്യ മൂല്യം എന്നാൽ ഇരട്ട കൃത്യത 64 ബിറ്റ് 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() {
    
  }
}

അവലംബം