ಜಾವಾ ಡೇಟಾ ಪ್ರಕಾರಗಳು ಮತ್ತು ಜಾವಾ ಪ್ರಾಚೀನ ಪ್ರಕಾರಗಳು



ಡೇಟಾ ಪ್ರಕಾರಗಳು ಜಾವಾ ಪುರಾತನ

ಜಾವಾದಲ್ಲಿನ ಡೇಟಾ ಪ್ರಕಾರಗಳನ್ನು ಸೂಚಿಸುತ್ತದೆ ಮೌಲ್ಯದ ಪ್ರಕಾರ ಒಂದು ವೇರಿಯೇಬಲ್ ಹಿಡಿದಿಟ್ಟುಕೊಳ್ಳಬಹುದು. ಹಿಂದಿನ ಲೇಖನದಲ್ಲಿ, ಎ ಅನ್ನು ಹೇಗೆ ಘೋಷಿಸಬೇಕು ಎಂದು ನಾವು ನೋಡಿದ್ದೇವೆ ವೇರಿಯಬಲ್. ಈ ಟ್ಯುಟೋರಿಯಲ್ ನಲ್ಲಿ, ನಾವು ವಿಭಿನ್ನ ಡೇಟಾ ಪ್ರಕಾರಗಳ ಬಗ್ಗೆ ಮತ್ತು ಅವುಗಳನ್ನು ವೇರಿಯಬಲ್ ಡಿಕ್ಲರೇಶನ್‌ನಲ್ಲಿ ಹೇಗೆ ಬಳಸುವುದು ಎಂದು ಕಲಿಯುತ್ತೇವೆ. ಈ ಲೇಖನದಲ್ಲಿ ನಾವು ಪ್ರಾಚೀನ ದತ್ತಾಂಶ ಪ್ರಕಾರಗಳು ಮತ್ತು ಪ್ರಾಚೀನವಲ್ಲದ ದತ್ತಾಂಶ ಪ್ರಕಾರಗಳನ್ನು ಚರ್ಚಿಸುತ್ತೇವೆ.

ನಾವು ಘೋಷಿಸುವ ಯಾವುದೇ ವೇರಿಯೇಬಲ್‌ಗೆ, ಡೇಟಾ ಪ್ರಕಾರವು ಅತ್ಯಗತ್ಯವಾಗಿರುತ್ತದೆ ಏಕೆಂದರೆ ಅದು ಮೌಲ್ಯವನ್ನು ಸಂಗ್ರಹಿಸಲು ವೇರಿಯೇಬಲ್‌ಗೆ ಎಷ್ಟು ಮೆಮೊರಿ ಅಗತ್ಯವಿದೆ ಎಂಬುದನ್ನು ಸೂಚಿಸುತ್ತದೆ. ವೇರಿಯಬಲ್ ಘೋಷಣೆಯನ್ನು ನಾವು ನೆನಪಿಸಿಕೊಳ್ಳೋಣ. ಉದಾಹರಣೆಗೆ, ಕೆಳಗಿನ ಕೋಡ್‌ನಲ್ಲಿ, ನಾವು ಮೌಲ್ಯ 10 ರೊಂದಿಗೆ ಒಂದು ಪೂರ್ಣಾಂಕ ವೇರಿಯೇಬಲ್ ಅನ್ನು ಘೋಷಿಸಿದ್ದೇವೆ ಮತ್ತು ಪ್ರಾರಂಭಿಸಿದ್ದೇವೆ.

int a = 10;

ಜಾವಾದಲ್ಲಿ ಡೇಟಾ ಪ್ರಕಾರಗಳ 2 ವರ್ಗಗಳಿವೆ:

  • ಪ್ರಾಚೀನ ಡೇಟಾ ಪ್ರಕಾರಗಳು - ಇದು ಬೈಟ್, ಸಣ್ಣ, ಇಂಟ್, ಉದ್ದ, ಚಾರ್, ಡಬಲ್, ಫ್ಲೋಟ್ ಮತ್ತು ಬೂಲಿಯನ್ ಅನ್ನು ಒಳಗೊಂಡಿದೆ.
  • ಪ್ರಾಚೀನವಲ್ಲದ ಡೇಟಾ ಪ್ರಕಾರಗಳು - ಇದು ಸ್ಟ್ರಿಂಗ್, ಅರೇ, ಕ್ಲಾಸ್ ಮತ್ತು ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ಒಳಗೊಂಡಿದೆ.

ಜಾವಾದಲ್ಲಿ ಡೇಟಾ ಪ್ರಕಾರಗಳು

ಈ ಟ್ಯುಟೋರಿಯಲ್ ನಲ್ಲಿ, ನಾವು ಪ್ರಾಚೀನ ಡೇಟಾ ಪ್ರಕಾರಗಳ ಬಗ್ಗೆ ವಿವರವಾಗಿ ಕಲಿಯುತ್ತೇವೆ. ನ ಪ್ರಾಚೀನವಲ್ಲದ ಡೇಟಾ ಪ್ರಕಾರಗಳು ಸ್ಟ್ರಿಂಗ್ ಮತ್ತು ಅರೇ ಪ್ರತ್ಯೇಕ ಟ್ಯುಟೋರಿಯಲ್ ಗಳಲ್ಲಿ ಒಳಗೊಂಡಿದೆ.

ಜಾವಾ ಪ್ರಾಚೀನ ಡೇಟಾ ಪ್ರಕಾರಗಳು

ಜಾವಾದಲ್ಲಿ 8 ವಿಭಿನ್ನ ರೀತಿಯ ಪ್ರಾಚೀನ ದತ್ತಾಂಶ ಪ್ರಕಾರಗಳಿವೆ, ಅದು ವೇರಿಯೇಬಲ್ ಪ್ರಕಾರ ಮತ್ತು ಮೌಲ್ಯವನ್ನು ಸೂಚಿಸುತ್ತದೆ.

ಡೇಟಾ ಪ್ರಕಾರಗಾತ್ರವಿವರಣೆಡೀಫಾಲ್ಟ್ ಮೌಲ್ಯ
ಬೈಟ್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'
ಬೂಲಿಯನ್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

ಇಂಟ್ ಡೇಟಾ ಪ್ರಕಾರ

ಸಂಪೂರ್ಣ ಸಂಖ್ಯೆಗಳನ್ನು ಸಂಗ್ರಹಿಸಲು ಜಾವಾದಲ್ಲಿ ಸಾಮಾನ್ಯವಾಗಿ ಬಳಸುವ ಡೇಟಾ ಪ್ರಕಾರ ಇಂಟ್ ಆಗಿದೆ. ಇದು ವ್ಯಾಪ್ತಿಯಲ್ಲಿ ಮೌಲ್ಯಗಳನ್ನು ಸಂಗ್ರಹಿಸಬಹುದು -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

ಫ್ಲೋಟ್ ಡೇಟಾ ಪ್ರಕಾರ

A ಅನ್ನು ಸಂಗ್ರಹಿಸಲು ನಾವು ಜಾವಾದಲ್ಲಿ ಫ್ಲೋಟ್ ಡೇಟಾ ಪ್ರಕಾರವನ್ನು ಬಳಸುತ್ತೇವೆ ಭಾಗಶಃ ಏಕ-ನಿಖರತೆಯ ಮೌಲ್ಯ 32 ಬಿಟ್ ಐಇಇಇ 754 ಫ್ಲೋಟಿಂಗ್ ಪಾಯಿಂಟ್. ಈ ಡೇಟಾ ಪ್ರಕಾರವು ದ್ವಿಗುಣಕ್ಕಿಂತ ಚಿಕ್ಕದಾಗಿದೆ ಆದರೆ ನಿಖರವಾದ ಭಾಗಶಃ ಮೌಲ್ಯಗಳನ್ನು ಸಂಗ್ರಹಿಸಲು ನಾವು ಇದನ್ನು ಬಳಸಲಾಗುವುದಿಲ್ಲ.

public class DataTypeDemo {

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

ಡಬಲ್ ಡೇಟಾ ಪ್ರಕಾರ

ಜಾವಾದಲ್ಲಿ ಡಬಲ್ ಡೇಟಾ ಪ್ರಕಾರವು ಸಹ ಹೊಂದಿದೆ ಭಾಗಶಃ ಮೌಲ್ಯ ಆದರೆ ಡಬಲ್-ನಿಖರತೆ 64 ಬಿಟ್ ಐಇಇಇ 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() {
    
  }
}

ರೆಫರೆನ್ಸ್