Философия Java3 - Брюс Эккель

В Java отсутствует sizeof()

В С и С++ оператор sizeof() выдает количество байтов, выделенных для хранения данных. Главная причина для использования sizeof() — переносимость программы. Различным типам данных может отводиться различное количество памяти на разных компьютерах, поэтому для программиста важно определить размер этих типов перед проведением операций, зависящих от этих величин. Например, один компьютер выделяет под целые числа 32 бита, а другой — всего лишь 16 бит. В результате на первой машине программа может хранить в целочисленном представлении числа из большего диапазона. Конечно, аппаратная совместимость создает немало хлодот для программистов на С и С++.

В Java оператор sizeof() не нужен, так как все типы данных имеют одинаковые размеры на всех машинах. Вам не нужно заботиться о переносимости на низком уровне — она встроена в язык.

Сводка операторов

Следующий пример показывает, какие примитивные типы данных используются с теми или иными операторами. Вообще-то это один и тот же пример, повторенный много раз, но для разных типов данных. Файл должен компилироваться без ошибок, поскольку все строки, содержащие неверные операции, предварены символами //!.

// operators/AHOps java

// Проверяет все операторы со всеми

// примитивными типами данных, чтобы показать,

// какие операции допускаются компилятором Java

public class AT 1 Ops {

// для получения результатов тестов типа boolean: void f(boolean b) {} void boolTest(boolean x, boolean y) { // Арифметические операции-//' x = x * у; //! x = x / у;

//! х = х % у; III х = х + у; III х = х - у; III х++; //! х--; //! х = +у; //! х = -у;

// Операции сравнения и логические операции:

III f(х > у),

//! f(х >= у);

III f(х < у).

Ill f(х <= у);

f(x == у),

f(х != у);

f(!y);

х = х && у: х = х || у.

// Поразрядные операторы:

III х =

X = X =

II II II // // // // // // // // // X &= у: х А= у: х |= у.

// Приведение-

-у; & у.

у:

У:

х « 1; х » 1, х »> 1; Совмещенное присваивание: х += у: х у. *= У; /= у; := У. «= 1; »= 1. »>= 1;

II

char с =

(char)x,

II

byte В =

(byte)x:

II

short s :

= (short)x;

II

int i =

(int)x:

П

long 1 =

(long)x:

п

float f ;

= (float)x;

II

double d

= (double)x;

void charTest(char х, char у) {

// Арифметические операции-х = (char)(x * у): х = (char)(x / у). х = (char)(x % у), (char)Сх + у), (char)(x - у),

х = х

х++, х- -,

X = X =

(char)+y; (char)-y:

// Операции сравнения и логические операции:

f(x > у);

f(x >= у);

f(x < у);

f(x <= у);

f(x == у);

fCx != у);

//! f(!x);

//! f(x && у);

//! f(x || у).

// Поразрядные операции:

х= (charby;

х = (char)(x & у).

х = (char)(x | у):

х = (char)(x А у):

х = (char)(x « 1):

х = (char)(x » 1):

х = (char)(x »> 1):

// Совмещенное присваивание:

х += у,

х -= у:

х *= у;

х /= у:

х Х- у:

х «= 1.

X »= 1,

х »>= 1: х &= у; х А= у; х |= У.

// Приведение-

//! boolean b = (boolean)x:

byte В = (byte)x:

short s = (short)x;

int i = (int)x;

long 1 = (long)x:

float f = (float)x;

double d = (double)x,

}

void byteTest(byte x. byte y) {

// Арифметические операции-x = (byte)(x* у): x = (byte)(x / y): x = (byte)(x % y), x = (byte)Cx + y); x = (byte)(x - y), x++: x--:

x = (byte)+ y: x = (byte)- y:

// Операции сравнения и логические операции:

f(x > у);

f(x >= у):

f(x < у);

f(x <= у):

f(x == у):

f(x != у):

//! f(!x):

//! f(x && у),

//! f(x || у); // Поразрядные операции: х = (byte)-y; х = (byte)(х & у): х = (byte)(x | у); х = (byte)(x А у); х = (byte)(x « 1); х = (byte)(x » 1); х = (byte) (х »> 1). // Совмещенное присваивание: х += у: х -= у: х *= у: х /= у: х у. х «= 1; х »= 1, х »>= 1, х &= у; х у. х |= У,

// Приведение:

//! boolean b = (boolean)x,

char с = (char)x;

short s = (short)x;

int i = (int)x:

long 1 = (long)x:

float f = (float)x.

double d = (double)x,

}

void shortTest(short x. short y) { // Арифметические операции: x = (shortKx * y): x = (shortKx / y), x = (shortKx % y): x = (shortKx + y); x = (shortKx - y): x++; x--:

x = (short)+y, x = (short)-y;

// Операции сравнения и логические

f(x > у);

f(x >= у):

f(x < у):

f(x <= у);

f(x == у);

f(x != у);

//! f(!x);

//! f(x && у);

//! f(x || у):

// Поразрядные операции:

х = (short)~у,

х = (shortKx & у);

х = (shortKx | у):

х = (short)(х А у):

х = (shortKx « 1);

х = (shortKx » 1);

операции:

х = (short)(х »> 1); // Совмещенное присваивание: х += у. х -= у. х *= у. х /= у: х %= у: х «= 1.

X »= 1. X »>= 1.

X &= у: х А= у. х |= у:

// Преобразование

//> boolean b = (boolean)x.

char с = (char)x.

byte В = (byte)x,

int i = (int)x.

long 1 = (long)x,

float f = (float)x;

double d = (double)x.

}

void intTest(int x, int y) {

// Арифметические операции:

x = x * у:

x = x / у.

х = х % у,

х = х + у,

х = х - у,

х++;

х- -:

х = +у;

х = -у.

// Операции сравнения и логические операции:

f(х > у).

f(х >= у).

f(х < у):

f(x <= у):

f(х == у).

f(х у).

//! f(!x):

//' f(x && у).

//! f(x || у),

// Поразрядные операции:

х = -у.

X = X & у,

X = X I у,

х = х А у:

х = х « 1;

х = х » 1:

х = х »> 1.

// Совмещенное присваивание-х += у; х -= у. х *= у. х /= у. х Х- у, х «= 1;

X »= 1.

х »>= 1; х &= у; х А= у. х |= у:

// Приведение-

//' boolean b = (boolean)x;

char с = (char)x,

byte В = (byte)x;

short s = (short)x;

long 1 = (long)x;

float f = (float)x,

double d = (double)x;

}

void longTestdong x, long y) {

// Арифметические операции:

x = x * у:

x = x / у;

x = x % у.

х = х + у:

х = х - у,

х++,

х- -;

х = +у;

х = -у:

// Операции сравнения и логические

f(х > у):

f(х >= у):

f(х < у),

f(х <= у):

f (х == у).

f(х != у).

//! f(!x).

//! f(x && у),

//! f(x || у):

// Поразрядные операции.

х = ~у.

х = х & у:

х = х | у:

х = х А у.

х = х « 1:

х = х » 1;

х = х »> 1:

// Совмещенное присваивание: х += у: х -= у. х *= у: х /= у: х у. х «= 1. х »= 1: х »>= 1: х &= у: х А= у: х |= у.

// Приведение-

//! boolean b = (boolean)x: . char с = (char)x.

операции:

byte В = (byte)x; short s = (short)x; int i = (int)x; float f = (float)x; double d = (double)x;

}

void floatTest(float x, float y) { // Арифметические операции: x = x * у, x = x / у. х = х % у; х = х + у: х = х - у; х++; х- -; х = +у; х = -у;

// Операции сравнения и логические операции:

f(x > у);

f(x >= у).

f(x < у);

f(x <= у),

f(х == у):

f(х != у),

//! f(!x):

//! f(х && у):

//! f(x || у):

// Поразрядные операции:

//! х = ~у;

//! х - х & у;

//! х = х | у;

//! х = х х у:

//! х = х « 1:

//! х = х » 1:

//! х = х »> 1;

// Совмещенное присваивание:

х += у:

х -= у;

х *= у:

х /= у;

х у;

//! х «= 1;

//! х »= 1:

//! х »>= 1:

//! х &= у;

//! х А= у;

//! х |= у;

// Приведение:

//! boolean b = (boolean)x;

char с = (char)x;

byte В = (byte)x;

short s = (short)x,

int i = (int)x;

long 1 = (long)x;

double d = (double)x:

}

void doubleTest(double x. double y) { // Арифметические операции:

х = х * у; х = х / у. х = х % у, х = х + у; х = х - у. х++, х- -; х = +у. х = -у;

// Операции сравнения и логические операции:

f(x > у).

f(x >= у):

f(x < у),

f(x <= у).

f(x == у);

f(x '= у):

//! f(!x).

//! f(x && у).

//! f(x || у):

// Поразрядные операции

//! х = ~у:

//! х = х & у,

//! х = х | у:

//! х = хАу;

//! х = х « 1:

//! х = х » 1;

//! х = х »> 1;

// Совмещенное присваивание:

х += у.

х у,

х *= у,

х /= у;

х %= у:

//! х «= 1;

//! х »= 1.

//! х »>= 1,

//! х &= у.

//! х ж= у:

//! х |= у:

// Приведение-

//! boolean b = (boolean)x.

char с = (char)x:

byte В = (byte)x:

short s = (short)x,

int i = (int)x;

long 1 = (long)x;

float f = (float)x:

}

} /// ~

Заметьте, что действия с типом boolean довольно ограничены. Ему можно присвоить значение true или false, проверить на истинность или ложность, но нельзя добавить логические переменные к другим типам или произвести с ними любые иные операции.

В случае с типами char, byte и short можно заметить эффект повышения при использовании арифметических операторов. Любая арифметическая операция с этими типами дает результат типа int, который затем нужно явно приводить к изначальному типу (сужающее приведение, при котором возможна потеря информации). При использовании значений типа int приведение осуществлять не придется, потому что все значения уже имеют этот тип. Однако не заблуждайтесь относительно безопасности происходящего. При перемножении двух достаточно больших целых чисел int произойдет переполнение. Следующий пример демонстрирует сказанное:

// operators/Overflow java

// Сюрприз! В Java можно получить переполнение.

public class Overflow {

public static void main(String[] args) { int big = Integer MAX_VALUE; System, out. рппЫпСболыиое = " + big); int bigger = big * 4;

System.out.printlnCeiue больше = " + bigger);

}

} /* Output большое = 2147483647 еще больше = -4 *///.-

Компилятор не выдает никаких ошибок или предупреждений, и во время исполнения не возникнет исключений. Язык Java хорош, но хорош не настолько.

Совмещенное присваивание не требует приведения для типов char, byte и short, хотя для них и производится повышение, как и в случае с арифметическими операциями. С другой стороны, отсутствие приведения в таких случаях, несомненно, упрощает программу.

Можно легко заметить, что за исключением типа boolean, любой примитивный тип может быть преобразован к другому примитиву. Как упоминалось ранее, необходимо остерегаться сужающего приведения при преобразованиях к меньшему типу, так как при этом возникает риск потери информации.