 |
| Типы данных. Целые числа |
Решение домашнего задания из статьи: Основные конструкции - циклы и условия
Создаём новый проект, назовём WhatToEat, папка srс, new,javaClass, WhatToEat
- count [counted|counted]
пересчитывать, считать, складывать [скла́дывал|скла́дывал бы] принимать во внимание
- OfMoney
public class WhatToEat {
public static void main(String[] args) {
int countOfMoney = 200;
if (countOfMoney >= 500) {
System.out.println("Пицца");
} else if (countOfMoney >= 300) {
System.out.println("Шаурма");
} else if (countOfMoney >= 100) {
System.out.println("Гамбургер");
} else {
System.out.println("Доширак");
}
}
}
Гамбургер
Process finished with exit code 0
В случае ошибки jdk 11 is missing (jdk 11 отсутствует) в IDE , установить JDK.
 |
| SHAREWOOD - это братство разбойников-единомышленников, стремящихся к повышению своих профессиональных навыков или освоению новых. |
В этой статье продолжим изучать типы данных Java в предыдущих статьях мы уже изучили тип int
Всего в Java восемь примитивных или простых типов, их можно разделить на 4 категории.
1. Целые числа
- byte
Тип byte занимает 1 байт и может хранить в себе числа от -128 до 127. Этот тип удобно использовать, когда удобно работать с файлами из интернета или из файлов. Когда нам нужно получить эти данные, мы читаем эти файлы по-байтово и храним значение в переменной типа byte.
- short
Занимает 2 байта, и может хранить значение от -32768 до 32767.
- int
4 байта, может хранить от 2147483648 до 2147483647
- long
Все они представляют собой целое число. Отличаются по кол-ву значений, которые могут в себе хранить, соответственно по объему занимаемой памяти.
Используется в случае если нужно хранить слишком большие значения, которые слишком велики для типа int, используем тип long он занимает 8 байт может принимать такое значение 9223372036854775808 до 9223372036854775807.
Для того, что бы создать переменную, нужного типа, нужно указать тип, а затем через пробел название переменной, которую можно про-аналициализировать сразу же или позже.
byte number;
short number = 3500;
int number = 950000;
long number = 999999999999;
Решим небольшую задачу!
Кол-во дней 1000, скорость света 300000км.сек, какое расстояние пройдёт свет за это время?
Дана скорость света, которая составляет примерно 300000км.сек и дано кол-во дней. Нужно написать программу, которая считает и выводит кол-во километров, которое прошёл свет за эти дни.
А какую переменную использовать для сохранения наиболее лучшего результата?! Переходим в код для создания нового проекта!
File,NewProject,Variable (переменная)
src,New,JavaClass,Var
Создаём точку входа в программу psvm и добавляем переменные. В первой будет храниться количество дней, для неё достаточно типа int.
int days =1000;
Во второй будем хранить скорость света, которая является постоянной величиной, и для неё та-же достаточно типа int
int speed = 300000;
Так как скорость света это 300тыс.км.сек., то нам нужно из кол-ва дней получить количество секунд. Число будет достаточно больше. будем использовать тип long
long seconds = days (кол.во дней *кол.во часов в сутках) * 24 ( *на кол.во минут в часах) * 60 ( на кол.во сек. в минутах) * 60;
Теперь можем получить расстояние. Что бы получить расстояние, нужно скорость умножить на время, значение будет очень большим, поэтому будем использовать тип long.
long distance = speed * seconds;
Выведем результат: sout (distance)
public class Var {
public static void main(String[] args) {
int days = 1000;
int speed 300000;
long seconds = days * 24 * 60 * 60;
long distance = speed * seconds;
System.out.println(distance);
}
}
25920000000000
Получилось очень большое значение, которое больше двух миллиардов, и не влезло бы в тип int.
Попробуем изменить значение переменной на int
int distance = speed * seconds;будет высвечена ошибка: не совместимые типы, требуется int, обнаружен long
Нет, программа не вычисляло значение, и не пыталась угадать какой-же тип больше подходит.
Давайте посмотрим какие числа использовались в самом выражении.
Переменная speed является типом int
Переменная seconds является типом long
приводятся к самому большому типу, к типу long. То есть, что бы исправить ошибку, нужно к переменной seconds присвоить тип int
int seconds = days * 24 * 60 * 60;
В данном случае количество секунд будет составлять примерно 86000000, а тип int может хранить в себе до 2х.миллиардов. то-есть для переменной int проблем нет и это значение (days * 24 * 60 * 60) она сохраняет без проблем.
Теперь ошибки нет Run!
-127631360
Приложение выводит ответ, но он точно не правильный, как минимум потому что получилось отрицательное число. Посмотрим почему так получилось. на примере переменной byte
Создадим переменную byte a = (может хранить от 128 до 127) 127;
увеличим на 1, запись будет выглядеть вот так: a += 1;
Выведем на экран sout (a);
Удалим вывод System.out.println(distance);
и запустим приложение!
public class Var {
public static void main(String[] args) {
int days = 1000;
int speed = 300000;
int seconds = days * 24 * 60 * 60;
int distance = speed * seconds;
byte a = 127;
a += 1;
System.out.println(a);
}
}
-128
Так как в переменной byte не могут лежать числа не больше чем 127, то ей будет присвоено минимальное возможное значение -128, если прибавим 2, a += 2;
значение будет - 127 итд. При увеличении будет расти до 127 и потом начнёт свой отчет с - 128.
То же самое произошло и в нашем примере.
В результате значение distance получилось очень большим числом которое не влезло в тип int, поэтому значение дошло до 2хмлрд. и начало сначала, с - 2млрд. с лишним, потом опять до 2хмлрдв. итд. в итоге получилось отрицательное число.
Внимание!
Что если переменной distance присвоить тип long long distance = speed * seconds;
public class Var {
public static void main(String[] args) {
int days = 1000;
int speed = 300000;
int seconds = days * 24 * 60 * 60;
long distance = speed * seconds;
System.out.println(distance);
}
}
Run!
-127631360 Всё равно отрицательный!
Общий результат приводится к самому большому типу используемому в выражении.
В данном случае используется переменная speed, тип int и переменная seconds. Соответственно значение всего этого выражения будет приведено к типу int, который не может хранить настолько большое значение, и поэтому получается отрицательный результат.
Но почему не возникает ошибка?!
Почему к переменной типа long, можем присвоить значение типа int ?! - Это называется автоматическое приведение типов. Так как тип int занимает меньше места, чем тип long, то программа автоматически преобразует результат в тип long.
То же самое произойдёт, если будет byte преобразовывать в int
byte a = 10;
int b = a;
ошибок нет!
System.out.println(b);run!
10
byte занимает меньше места, и соответственно проблем не возникает, тип byte без проблем преобразуется в тип int
public class Var {
public static void main(String[] args) {
int a = 15;
byte b = a;
}
}
Будет ошибка! Она появляется автоматически, так как в java нету приведения типа к более мелкому типу.
Но если нам всё равно нужно привести переменную к типу byte, можно сделать это в ручную, тогда ответственность за то что значение переменной int поместиться в переменную byte ложится на нас!
Перед переменной ставим круглые скобки и пишем тип к которому хотим привести byte b = (byte) a;
sout(b);
public class Var {
public static void main(String[] args) {
int a = 15;
byte b = (byte) a;
System.out.println(b);
}
}
Run!
15
На этом всё!
2. Дробные, то-есть числа с плавающей точкой
- float
- double
3. Символы
- char (используется с буквами или цифрами)
4. Логические
- boolean (который может хранить в себе одно из двух значений true или false)
Продолжение в след. статье: Типы данных. Примитивные типы
