Primitive types

Java`da 8 primitiv tip var:

Açar söz	Ölçü	Dəyər aralığı		Varsayılan dəyər	Nümunə
Açar söz	Ölçü	min	max	Varsayılan dəyər	Nümunə
`byte`	8 bit	-128	127	0	123
`short`	16 bit	-32,768	32,767	0	123
`int`	32 bit	-2³¹	2³¹-1	0	123
`long`	64 bit	-2⁶³	2⁶³-1	0L	123
`float`	32 bit float			0.0f	123,45f
`double`	64 bit float			0.0d	123,456
`boolean`	N/A			false	true
`char`	16 bit unicode	‘\u0000’	‘\uffff’	‘\u0000’	‘m’

Bu tiplərin qiymət aralıqları aşağıdakı qaydada hesablanır (nümunə üçün byte götürülür):

byte = 8 bit = 2⁸ = 256

256`nın yarısı pozitiv və yarısı da neqativ dəyər üçün ayrılır:

256/2 ⇒ -128 < byte < 127 (0 pozitiv ədəd hesab edildiyindən 127 olur)

Aldığı dəyərin böyüklüyünə görə ardıcılıq belə gedir (azdan çoxa):

byte ⇒ short ⇒ int ⇒ long ⇒ float ⇒ double

Kod nümunələri:

long i1 = 1_000_000_000;    // does compile

/* bunu int hesab edir və int dəyişəninin max dəyəri keçdiyini görüb compile error verir, mütləq sonuna L artırmaq lazımdı.*/
long i2 = 1_000_000_0000;   // doesn't compile

float f1 = 10;
float f2 = 1_000_000_000_000_000_000L;
float f3 = 10.0;  // compile error verir, çünki bunu double kimi görür, mütləq sonuna f əlavə etmək lazımdır.
int i3 = 9f;      // compile error
int a = new Integer(5);

Char tipinə 0-65535 aralığında istənilən rəqəm tipli dəyəri mənimsətmək olar. Ancaq mənfi dəyər mənimsətmək mümkün deyil, compile error verir. (char is equivalent to an unsigned short in Java)

char c1 = 0;
char c2 = 65535;
char c3 = 65536;  //doesn't compile
char c4 = -0;
char c5 = -10;    //doesn't compile
System.out.println((int)'a');  // output: 97

Java`da onluq ədədlərdən başqa 8-lik, 16-lıq və 2-lik ədədlər də var:

octal (digits 0-7) – 8-lik ədədlər 0-7 arasındakı (0 və 7 daxil olmaqla) rəqəmləri götürür və prefix olaraq 0 qəbul edir, yəni 0 ilə başlayır: 017, 07, 023567
hexadecimal (digits 0-9 and letters A-F) – 16-lıq ədədlər 0-9 arasındakı rəqəmlər və A, B, C, D, E, F rəqəmlərini qəbul edir. Prefix kimi 0x və yaxud 0X istifadə edir: 0xFF, 0Xff, 0x198D
binary (digits 0-1) – 2-lik ədədlər ancaq 0 və 1 rəqəmlərindən ibarət ola bilər və prefix 0b və ya 0B: 0b10, 0B0_0011_10_0

byte b1 = 07;
byte b2 = (byte) 023567;   // byte`ın max qiymətindən > olduğu üçün cast olunmalıdı
byte b3 = 08;              // doesn’t compile, max 7 olmalıdı

class Hexadecimal {
    public static void main(String[] args) {
        int x = 0X0001;
        int y = 0x7fffffff;
        int z = 0xDeadCafe;
        System.out.printf("x=%d; y=%d; z=%d %n", x, y, z);
    }
}

class Octal {
    public static void main(String[] args) {
        int six = 06;      // Equal to decimal 6
        int seven = 07;    // Equal to decimal 7
        int eight = 010;   // Equal to decimal 8
        int nine = 011;    // Equal to decimal 9
        System.out.println("Octal 010 = " + eight);
    }
}

public class Q6 {
    public static void main(String[] args) {
        int a[] = {1, 2, 053, 4};
        int b[][] = { {1, 2, 4}, {2, 2, 1}, {0, 43, 2} };
        System.out.println(a[2]);  // 053 -> 0*(8^2) + 5*(8^1) + 3*(8^0) = 43
        System.out.println(a[3] == b[0][2]);       // true
        System.out.println((a[2] == b[2][1]));     // true
    }
}

0-dan 15-dək onluq ədədlərin digər say qarşılığına aşağıdakı cədvəldən baxa bilərsiniz*:

Rəqəmlərin yaxşı oxunması üçün java 7 ilə yeni xüsusiyyət gəlib – altxətt (underscore)

int million1 = 1000000;
int million2 = 1_000_000;

Altxətti rəqəmlərin əvvəlinə və sonuna, həmçinin onluq nöqtənin (decimal point) sağına və soluna əlavə etmək olmaz. Bir sözlə, altxətt ancaq 2 rəqəm arasında işlədilə bilər.

double notAtStart = _1000.00;            // does NOT compile
double notAtEnd = 1000.00_;              // does NOT compile
double notByDecimal = 1000_.00;          // does NOT compile
double annoyingButLegal = 1_00_0.0_0;    // does compile

float f1 = 1_00_0f;       // does compile
float f2 = 1_00_0_f;      // does NOT compile
long L1 = 1_000__000L;    // does compile
long L2 = 1_000_000_L;    // does NOT compile

float d = 0 * 1.5;   // does NOT compile, but float d = 0 * 1.5f; and float d = 0 * (float)1.5; are OK
float f1 = 43e1;     // DOES NOT COMPILE
float f2 = 43e1f;    // 430.0
double d1 = 43e;     // DOES NOT COMPILE
double d2 = 43e1;    // 430.0
double d3 = 43e4;    // 430000.0
double d4 = 43e6;    // 4.3E7
double d = .05;      // 0.05

float f5 = 43d;      // DOES NOT COMPILE
double d5 = 43d;     // 43.0

Suallarda diqqətinizdən yayına biləcək bir nüansı da nəzərinizə çatdırmaq istəyirəm. Yuxarıda qeyd etdiyimiz səbəblərə görə aşağıdakı kod compile olunmur:

long z = _123_456L;

Qeyd etdik ki, altxəttin əvvəldə gəlməsi doğru deyil. Amma dəyişən adlarında (identifier) altxətt əvvəldə gələ bilər, yəni _123_456L doğru elan edilmiş dəyişən adıdır. Bu səbəbdən aşağıdakı kod səhv deyil:

int _123_456L = 10;
long z = _123_456L;

Altxətt bütün tip – long, double, float, eləcə də 2-lik, 16-lıq say sistemində olan ədədlərlə də işlədilə bilər:

int hex = 0xCAFE_BABE;
float f = 9898_7878.333_333f;
int bin = 0b1111_0000_1100_1100;

Qeyd etdiyimiz primitiv dəyişən tipləri arasındakı əlaqələri daha yaxşı qavramaq və bəzi çaşdırıcı məqamları aydınlaşdırmaq üçün əlavə bəzi nümunələrə də nəzər salaq. Deməli qeyd etdik ki, char tipli dəyişənə 0 və 65535 aralığında olan istənilən dəyəri birbaşa mənimsətmək mümkündür. Amma bu aralığa daxil olan dəyəri int dəyişənə mənimsədib və sonra həmin dəyişəni char dəyişənə mənimsətdikdə compile xətası baş verir. Xətanın aradan qalxması üçün ya həmin dəyişən char`a cast olunmalıdır yaxud da final elan edilməlidir:

char a = 0x892;           // hexadecimal literal
char b = 982;             // int literal
int i = b;
final int m = b;
final int n = 982;
char c1 = i;             // DOES NOT COMPILE
char c2 = m;             // DOES NOT COMPILE
char c3 = n;

Amma 0 və 65535 aralığına daxil olmayan int dəyərləri birbaşa char`a mənimsətdikdə yenə xəta verir və cast mütləq tələb olunur:

// char e = -29;      // Possible loss of precision; needs a cast
// char f = 70000;    // Possible loss of precision; needs a cast

char c = (char) 70000;   // The cast is required; 70000 is out of char range
char d = (char) -98;     // Ridiculous, but legal

char dəyişəni short dəyişənə, short dəyişəni isə char dəyişənə cast etmədən mənimsətmək mümkün deyil. Amma char dəyişəni cast etmədən int dəyişənə mənimsətmək mümkündür, əksi isə doğru deyil:

char c = 'a';
long l = c;
int i = c;
c = i;          // DOES NOT COMPILE
short s = c;    // DOES NOT COMPILE
c = s;          // DOES NOT COMPILE

char c1 = Short.MAX_VALUE;

short s2 = Short.MAX_VALUE;
char c2 = s2;   // DOES NOT COMPILE

short s3 = Short.MAX_VALUE;
char c3 = (char) s3;

final short s4 = Short.MAX_VALUE;
char c4 = s4;

byte b5 = Byte.MAX_VALUE;
char c5 = b5;    // DOES NOT COMPILE

Eyni qaydalar digər primitiv dəyişənlər üçün də keçərlidir:

short s1 = 1;
byte b1 = s1;       // DOES NOT COMPILE

short s2 = 1;
byte b2 = (byte) s2;

final short s3 = 1;
byte b3 = s3;

final short s4 = 200;
byte b4 = s4;      // DOES NOT COMPILE, final olsa da aralıqdan kənar dəyərdi

Bütün mövzulara bax

*https://en.wikipedia.org/wiki/Quaternary_numeral_system

About the author

Mushfiq Mammadov

Leave a Comment X

You may also like

About the author

Mushfiq Mammadov

Leave a Comment X