> For the complete documentation index, see [llms.txt](https://letas-organization.gitbook.io/letaats-lessons-online/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://letas-organization.gitbook.io/letaats-lessons-online/kolledzh-top/razdel-1/glava-6.-tipy-dannykh-i-preobrazovaniya.md).

# Глава 6. Типы данных и преобразования

### 6.1. Зачем нужны типы данных

Компьютер должен понимать, какие данные хранит переменная и какие операции с ними можно выполнять.

Числа можно складывать:

```java
int a = 5;
int b = 10;
System.out.println(a + b);
```

Результат:

```
15
```

Строки тоже можно “складывать”, но результат будет другим:

```java
String a = "5";
String b = "10";
System.out.println(a + b);
```

Результат:

```
510
```

Почему? Потому что это строки, а не числа. Java склеивает текст.

Тип данных определяет:

* какие значения можно хранить;
* сколько памяти нужно;
* какие операции доступны;
* как Java будет обрабатывать выражения.

***

### 6.2. Примитивные типы данных

Примитивные типы хранят простые значения.

Основные примитивы:

| Тип       | Что хранит                     | Пример         |
| --------- | ------------------------------ | -------------- |
| `int`     | целые числа                    | `10`           |
| `long`    | большие целые числа            | `10000000000L` |
| `double`  | дробные числа                  | `3.14`         |
| `float`   | дробные числа меньшей точности | `3.14f`        |
| `boolean` | истина/ложь                    | `true`         |
| `char`    | один символ                    | `'A'`          |
| `byte`    | маленькое целое число          | `100`          |
| `short`   | небольшое целое число          | `1000`         |

На практике начинающим чаще всего нужны:

* `int`;
* `double`;
* `boolean`;
* `char`.

***

### 6.3. int

`int` хранит целые числа.

```java
int age = 18;
int count = 5;
int temperature = -10;
```

Используется для:

* возраста;
* количества;
* индексов;
* счётчиков;
* баллов;
* попыток.

Нельзя записать дробное число:

```java
int price = 99.99; // ошибка
```

***

### 6.4. long

`long` хранит большие целые числа.

```java
long population = 8000000000L;
```

Буква `L` показывает, что число относится к типу `long`.

Используется, когда `int` может быть слишком маленьким.

***

### 6.5. double

`double` хранит дробные числа.

```java
double price = 99.99;
double average = 4.5;
double temperature = 36.6;
```

Используется для:

* цен;
* средних значений;
* процентов;
* температуры;
* координат;
* дробных вычислений.

***

### 6.6. float

`float` тоже хранит дробные числа, но с меньшей точностью.

```java
float x = 3.14f;
```

Суффикс `f` обязателен.

В учебных задачах обычно проще использовать `double`.

***

### 6.7. boolean

`boolean` хранит только два значения:

```java
true
false
```

Пример:

```java
boolean isAdult = true;
boolean hasAccess = false;
```

Используется в условиях:

```java
if (isAdult) {
    System.out.println("Доступ разрешён");
}
```

***

### 6.8. char

`char` хранит один символ.

```java
char letter = 'A';
char digit = '5';
char symbol = '!';
```

Важно: `char` пишется в одинарных кавычках.

```java
char c = 'A';   // правильно
char c = "A";   // ошибка
```

Двойные кавычки используются для `String`.

***

### 6.9. String

`String` хранит текст.

```java
String name = "Anna";
String message = "Hello Java";
```

`String` — это класс, а не примитив.

У строк есть методы.

```java
String text = "Java";

System.out.println(text.length());
System.out.println(text.toUpperCase());
System.out.println(text.contains("va"));
```

***

### 6.10. Сравнение строк

Нельзя надёжно сравнивать строки через `==`.

Плохо:

```java
String a = "Java";
String b = new String("Java");

System.out.println(a == b);
```

Может быть `false`, потому что `==` сравнивает ссылки.

Правильно:

```java
System.out.println(a.equals(b));
```

Метод `.equals()` сравнивает содержимое строк.

***

### 6.11. Склеивание строк

```java
String name = "Anna";
int age = 18;

System.out.println(name + " " + age);
```

Результат:

```
Anna 18
```

Если хотя бы одна часть выражения является строкой, `+` начинает работать как склеивание.

Пример:

```java
System.out.println("Возраст: " + 10 + 5);
```

Результат:

```
Возраст: 105
```

Почему? Сначала строка склеилась с `10`, потом с `5`.

Чтобы получить сумму:

```java
System.out.println("Возраст: " + (10 + 5));
```

Результат:

```
Возраст: 15
```

***

### 6.12. Приведение типов

Приведение типов — преобразование значения одного типа в другой.

### Автоматическое приведение

Java может автоматически преобразовать меньший тип в больший.

```java
int x = 5;
double y = x;
```

Результат:

```
y = 5.0
```

### Явное приведение

Если возможна потеря данных, нужно указать преобразование явно.

```java
double x = 5.9;
int y = (int) x;
```

Результат:

```
y = 5
```

Дробная часть отбрасывается.

***

### 6.13. Деление целых чисел

```java
int a = 5;
int b = 2;

System.out.println(a / b);
```

Результат:

```
2
```

Java выполняет целочисленное деление, потому что оба числа имеют тип `int`.

Чтобы получить `2.5`:

```java
System.out.println((double) a / b);
```

***

### 6.14. Остаток от деления

Оператор `%` возвращает остаток от деления.

```java
System.out.println(10 % 3);
```

Результат:

```
1
```

Используется для проверки чётности:

```java
if (number % 2 == 0) {
    System.out.println("Чётное");
}
```

***

### 6.15. Переполнение

У каждого числового типа есть предел.

Например, `int` не может хранить бесконечно большие числа.

```java
int x = 2147483647;
x = x + 1;

System.out.println(x);
```

Результат будет неожиданным:

```
-2147483648
```

Это называется переполнение.

На базовом уровне важно знать: если числа очень большие, используйте `long`.

***

### 6.16. Обёртки: Integer, Double, Boolean

У примитивов есть классы-обёртки:

| Примитив  | Обёртка     |
| --------- | ----------- |
| `int`     | `Integer`   |
| `double`  | `Double`    |
| `boolean` | `Boolean`   |
| `char`    | `Character` |

Пример:

```java
Integer age = 18;
Double price = 99.99;
Boolean active = true;
```

Обёртки нужны, например, в коллекциях:

```java
ArrayList<Integer> numbers = new ArrayList<>();
```

Нельзя написать:

```java
ArrayList<int> numbers = new ArrayList<>(); // ошибка
```

Коллекции работают с объектами, поэтому используется `Integer`.

***

### 6.17. Преобразование String в число

Часто пользователь вводит текст, а программе нужно число.

```java
String text = "123";
int number = Integer.parseInt(text);
```

Для `double`:

```java
String text = "99.99";
double price = Double.parseDouble(text);
```

Если строка не является числом:

```java
int x = Integer.parseInt("abc");
```

будет ошибка `NumberFormatException`.

Позже такие ошибки обрабатывают через `try catch`.

***

### 6.18. Связь с Android

В Android поле ввода `EditText` возвращает текст.

```java
String text = input.getText().toString();
```

Даже если пользователь ввёл число, сначала это `String`.

Чтобы получить число:

```java
int age = Integer.parseInt(text);
```

Именно поэтому понимание типов важно для Android. Иначе приложение будет падать на обычном вводе числа. Очень драматично для программы из трёх полей, но бывает.

***

### 6.19. Типичные ошибки новичков

#### Ошибка 1. Ждать дробь от int / int

```java
int a = 5;
int b = 2;
System.out.println(a / b); // 2
```

***

#### Ошибка 2. Сравнивать строки через ==

```java
if (name == "Anna")
```

Правильно:

```java
if (name.equals("Anna"))
```

***

#### Ошибка 3. Путать char и String

```java
char c = "A"; // ошибка
```

Правильно:

```java
char c = 'A';
String s = "A";
```

***

#### Ошибка 4. Использовать ArrayList

```java
ArrayList<int> numbers; // ошибка
```

Правильно:

```java
ArrayList<Integer> numbers;
```

***

### 6.20. Как могут спросить на экзамене

#### Вопрос

Чем `int` отличается от `double`?

#### Хороший ответ

> `int` хранит целые числа, а `double` хранит дробные числа. При делении `int` на `int` дробная часть отбрасывается, поэтому для точного деления нужно использовать `double`.

***

#### Вопрос

Почему строки сравнивают через `.equals()`?

#### Хороший ответ

> Потому что `==` сравнивает ссылки на объекты, а `.equals()` сравнивает содержимое строк.

***

#### Вопрос

Что такое приведение типов?

#### Хороший ответ

> Приведение типов — преобразование значения одного типа в другой. Например, `int` можно автоматически привести к `double`, а `double` к `int` нужно приводить явно через `(int)`.

***

### 6.21. Практические задания

#### Задание 1

Создайте переменные разных типов:

* `int`;
* `double`;
* `boolean`;
* `char`;
* `String`.

Выведите их.

***

#### Задание 2

Проверьте, что выведет программа:

```java
int a = 5;
int b = 2;
System.out.println(a / b);
```

Исправьте код так, чтобы результат был `2.5`.

***

#### Задание 3

Создайте две строки:

```java
String a = "Java";
String b = new String("Java");
```

Сравните их через `==` и `.equals()`. Объясните результат.

***

#### Задание 4

Пользователь вводит возраст как строку. Преобразуйте строку в `int` и выведите возраст через год.

***

### 6.22. Вопросы для самопроверки

1. Зачем нужны типы данных?
2. Что хранит `int`?
3. Что хранит `double`?
4. Что хранит `boolean`?
5. Чем `char` отличается от `String`?
6. Почему `5 / 2` даёт `2`?
7. Что делает `%`?
8. Что такое приведение типов?
9. Почему строки сравнивают через `.equals()`?
10. Почему в `ArrayList` используют `Integer`, а не `int`?