Присвоение данных между переменными разных типов
JAVA
И нициализацию переменных можно производить как прямым присваиванием значений (прямая инициализация), так и через использование уже инициализированных переменных (косвенная инициализация).
Приведем несколько примеров такой прямой и косвенной инициализации переменных:
Прямая инициализация
int a=4;
int b;
b=-8;
int x=reader.nextInt();
Косвенная инициализация
int a=6,b;
b=a;
int x,y;
x=-8;
b=10*a;
int x=reader.nextInt();
y=-x;
Как правило, никаких проблем не возникает, когда прямая и косвенная инициализации производятся в рамках одного и того же типа переменных и типа данных. Иными словами, когда переменная типа "простое целое" (int) получает значение, лежащее в рамках диапазона этого типа (например, 8). Или – переменная типа "длинное десятичное" (double) получает, например, значение 5,7.
Однако совершенно необязательно, чтобы в классе передача значений осуществлялась только и только между переменными одного и того же типа!
В языке Java предусмотрена возможность присвоения данных одного типа переменным другого типа. Допускается делать это и через явное использование переменной одного типа и значения другого типа, а также и через использование выражений с переменными (инициализированными, разумеется) разных типов.
При этом, разумеется, происходит (или – должно быть произведено!) преобразование данных – такой процесс называется "приведением типов", (casting). Он может быть как неявным (фактически – автоматически производимым самим языком), так и явным, то есть требующим написания соответствующих операторов (подобно явному использованию оператора "плюс" (+) для вычисления суммы).
Неявное приведение типов (implicit) происходит, когда значение более узкого диапазона помещается в переменную более широкого диапазона.
Можно вместо термина "диапазон" использовать популярный в математике термин "множество", и тогда только что сформулированное правило будет выглядеть так: значение из подмножества можно помещать в переменную, относящуюся к множеству, включающему подмножество.
Например, во множестве рациональных чисел есть множество целых чисел: то есть любое целое число формально можно записать как дробь, но не любую дробь можно записать как целое число.
Например, посмотрите на следующий фрагмент класса:
int a=4;
long b;
b=a;
Как видите, переменная типа "длинное целое" ( long ) может принимать значение типа "простое целое" ( int ) – это допустимо потому, что тип "простое целое" является внутренним подмножеством типа "длинное целое". Иными словами, подобное действие возможно потому, что любое значение типа "простое целое" находится внутри множества значений "длинное целое".
А вот наоборот – это не так; и именно потому, что это не так, для приведения типа "из подмножества в множество" (например, из типа long в тип int ) требуются специальные, записываемые в явном виде, действия.
Явное (explicit) приведение типов требует использования специальных операторов.
Они представляют из себя описание типа, к которому (в который) надо выполнить приведение, заключенное в скобки и поставленное перед значением (или переменной), над которым (которой) надо выполнить действие приведения.
Перед тем, что надо привести, следует в скобках указать тип, к которому надо привести.
Например: int x = (int)3957.229 ;
В этом примере значение множества "длинное десятичное" (десятичная дробь) заносится в переменную из "внутреннего подмножества" ("простое целое", int ), для чего и используется указание на явное приведение в виде заключенного в скобки типа ( int ).
В таком случае теряется часть значения (как правило, происходит понижение степени точности) – в приведенном примере переменная х будет иметь значение 3957.
Аналогично выполняется операция приведения с переменными:
double a=4.95;
int b=(int)a;
Кстати, можно выполнять явное приведение типов и для случаев, когда в этом нет необходимости – то есть когда язык Java может произвести неявное приведение.
Например :
double a=(double)4;
или
int a=4;
doubleb =( double ) a ;
Следует обязательно иметь в виду следующее ограничение, существующее в языке Java: все дробные значение язык автоматически относит к типу double, поэтому запись float a=4.95 считается ошибочной и требует выполнения явного приведения типа, то есть записи float a=(float)4.95
Операторы приведения типов окажутся особенно важными, когда потребуется подсчитать, например, среднее арифметическое двух целочисленных значений! Дело в том, что в этом случае мы снова сталкиваемся с необходимостью выполнить операцию деления – а она в языке Java требует быть чрезвычайно внимательным именно из-за использования разных типов.
Математические и специальные операторы
Для выполнения основных математических действий в языке Java используются следующие операторы:
Оператор
Действие
+
Сложение двух значений
-
Вычитание из одного значения другого
*
Умножение двух значений
Разумеется, операторы эти могут использоваться как с числовыми значениями, так и с переменными – и порядок выполнения действий в сложных выражениях точно соответствует порядку выполнения действий, принятому в математике.
Аналогичным образом используются и скобки – только в языке Java, в отличие от математики, для записи сложных выражений используются только круглые скобки.
Гораздо сложнее обстоит дело с, казалось бы, простым оператором деления – это действия в языке Java обозначается символом "наклонная черта" (/), а также символом "процент" (%). Нередко можно встретить такие определения:
Оператор деления (/) и
оператор вычисления остатка (%).
Как видите, действие деления оказывается очень "многоликим" и далеко не всегда и в самом деле является оператором деления; все зависит от того, с переменными (и значениями) какого типа он используется!
Рассмотрим в качестве примера следующий фрагмент класса
(программный блок, набор кодов – можно использовать разные термины):
Пример 1
int a=reader.nextInt();
int b=2;
int c=a/b;
System.out.println(c);
При введении с клавиатуры (для переменной а) значения 4 – на экран выводится значение 2.
При введении с клавиатуры (для переменной а) значения 5 – на экран выводится тоже значение 2.
Дело в том, что при использовании с переменными только типа "целое число" знак "наклонная черта" (/) является оператором "вычисление частного", а вовсе не оператором "деление".
А теперь изменим этот фрагмент так, чтобы он выглядел следующим образом:
Пример 2
double a=reader.nextInt();
double b=2;
double c=a/b;
System.out.println(c);
При введении с клавиатуры (для переменной а) значения 4 – на экран выводится значение 2.0
При введении с клавиатуры (для переменной а) значения 5 – на экран выводится значение 2.5
Все дело в том, что в этом случае знак "наклонная черта" (/) действительно является оператором "деление".
В случае же использование переменных и значений разных типов то, какое действие будет выполнять знак "наклонная черта" (/), будет зависеть от комбинации переменных и использования операторов приведения типов…
Как видите, один и тот же символ ("наклонная черта") при всех своих использованиях так или иначе связан с операцией деления (ведь вычисление частного производится тоже в результате деления), однако значения, которые получаются в результате его использования, могут численно отличаться друг от друга.
Все это просто необходимо иметь в виду каждый раз, когда вы собираетесь использовать этот знак – и заранее, еще до написания кодов, четко себе представлять, какой из результатов вы хотите получить: "настоящий результат деления" или "частное от деления".
Кроме того, в языке Java имеются
Специальные (дополнительные) операторы для выполнения математических действий.
Оператор
Действие
++
Пример и объяснение
Увеличение значения переменной на 1
int х =reader.nextInt();
x++;
Если х получил с клавиатуры значение 6, то после выполнения оператора ++ переменная будет иметь значение 7
--
Уменьшение значения переменной на 1
+=
Увеличение значения переменной на значение, записанное после знака =
int х =reader.nextInt();
x--;
Если х получил с клавиатуры значение 6, то после выполнения оператора -- переменная будет иметь значение 5
int х =reader.nextInt();
x+=10;
Если х получил с клавиатуры значение 6, то после выполнения оператора +=10 переменная будет иметь значение 16
-=
*=
Уменьшение значения переменной на значение, записанное после знака =
int х =reader.nextInt();
x-=10;
Если х получил с клавиатуры значение 16, то после выполнения оператора -=10 переменная будет иметь значение 6
Увеличение значения переменной в число раз, равное значению, записанному после знака =
int х =reader.nextInt();
x*=10;
Если х получил с клавиатуры значение 6, то после выполнения оператора *=10 переменная будет иметь значение 60
/ =
Деление (или вычисление частного) значения переменной на значение, записанное после знака =
%=
Вычисление остатка при делении значения переменной на значение, записанное после знака =
int х =reader.nextInt();
x/=10;
Если х получил с клавиатуры значение 67, то после выполнения оператора /=10 переменная будет иметь значение 6
int х =reader.nextInt();
x%=4;
Если х получил с клавиатуры значение 6, то после выполнения оператора *=10 переменная будет иметь значение 2
Разумеется, все эти операции можно записать в ином, без специфики языка Java, виде:
х++ можно записать как х=х+1;
х-- можно записать как х=х-1;
х+=10 можно записать как х=х+10;
х-=10 можно записать как х=х-10;
х*=10 можно записать как х=х*10;
Следует знать оба варианта, поскольку кроме умения писать собственные коды, надо уметь и понимать коды, написанные кем-то другим. Кроме того, каждый, разумеется, может сам для себя решить, какую из форм записи он предпочтет использовать.
И хотя любой оператор с присваиванием с точки зрения получаемого результата эквивалентен выполнению соответствующей операции с последующим присваиванием, но работает он обычно быстрее.
В самом общем виде типичная для языка Java "сокращенная" форма записи строится следующим образом:
Существует одна особенность, связанная с использованием этих специальных операторов для изменения значения не одной и той же переменной, а разных переменных. Особенность эта связана с тем, где записывается указание на изменение – до или после переменной (пользуясь профессиональной терминологией: префиксная или постфиксная форма записи).
Вид блока команд
Что выво
дится на экран?
int a=6,b;
b=a++;
System.out.println(a+" &"+b);
7 & 6
int a=6,b;
b=++a;
System.out.println(a+" "+b);
Объяснение
7 & 7
Во второй строке переменная b сначала получает от переменной а значение 6 – и только потом значение переменной а увеличивается на 1
Во второй строке сначала значение переменной а увеличивается на 1, а только потом это увеличенное значение получает переменная b
Иными словами:
- команда b=a++; эквивалента командам b=a; a=a+1;
- команда b=++a; эквивалента командам a=a+1; b=a;
Это означает, что в такого рода командах чрезвычайно важным является то, записаны ли специальные операторы языка Java до или после соответствующей переменной.
Получите свидетельство
Вход
Присвоение данных между переменными разных типов (0.17 MB)
0
484
38
Нравится
0
