Что такое система типов в Java?

А, система типов в Java, да? Ну, это такая штука, которая следит, чтобы ты, как программист, не начал складывать помидоры с гвоздями, а потом удивляться, почему салат не компилируется. Это как строгий бухгалтер на входе в клуб: «Извини, чувак, ты в списке? Нет? Иди нахуй». Всё по правилам, блядь.

Так, слушай сюда, что это за зверь такой:

Представь, что это набор не просто правил, а, блядь, законов, которые говорят, как можно называть данные, как их юзать и как они друг с другом общаются. А законы в Java — они статические, строгие, номинативные и безопасные. Звучит, как диагноз, но это хорошо.

• Статическая — это когда все твои косяки ловят ещё до того, как ты нажмёшь «запустить». Компилятор, такой бдительный стукач, орёт: «Эй, мудила, ты тут строку числу пытаешься присвоить! Исправляй, пока не поздно!». Ошибки на старте — это охуенно.
• Строгая — это про то, что «на авось» не прокатит. Нельзя просто взять и сказать «ну это же почти число, считай за число». Не, блядь. Или число, или иди нахуй. Никаких неявных фокусов, только чёткие правила.
• Номинативная — тут вообще цирк. Совместимость типов определяется не тем, что у них внутри (одинаковые поля, методы), а тем, как их назвали и кто их родил. Два класса могут быть один в один, но если они не в одной иерархии — нихуя они друг другу не родня. Чистая бюрократия, ёпта.
• Безопасная — это святое. Гарантия, что если у тебя в переменной Cat, то там не окажется внезапно NuclearReactor. Ну, кроме случаев, когда ты сам, кривыми ручками, начинаешь приводить типы вниз — тут уже на твоей совести, лови ClassCastException и радуйся.

А теперь, какие типы бывают, чтобы не путать грешное с праведным:

// 1. ПРИМИТИВЫ. Тупые, как пробка, но быстрые. Хранят значение прямо в себе.
int count = 10; // Просто число, не объект. Лёгкий, как пёрышко.
boolean flag = true; // Да или нет. Или пизда, или пропала.
double price = 99.95; // Число с хвостиком.

// 2. ССЫЛОЧНЫЕ ТИПЫ. Умные, но тяжёлые. Хранят адресок на объект в куче.
String name = "Java"; // Это уже объект, целая сущность.
List<String> list = new ArrayList<>(); // Интерфейс, абстракция, красота.
int[] numbers = {1, 2, 3}; // Массив — особый ссылочный уродец, но свой в доску.

// 3. ДЖЕНЕРИКИ (ПАРАМЕТРИЗОВАННЫЕ ТИПЫ). Магия на этапе компиляции.
Box<Integer> integerBox = new Box<>();
// Box<String> stringBox = integerBox; // Компилятор: «Ты ебобо? Это разные типы!» *стирает нахуй после компиляции*

Автоупаковка/распаковка — это вообще ебушки-воробушки.

Это когда язык, видя, что ты совсем обленился, сам додумывает за тебя. Примитив в ссылку и обратно — автоматом.

// Автоупаковка: примитив int стыдливо надевает костюмчик-обёртку Integer.
Integer boxed = 42; // За кулисами: Integer.valueOf(42). Невидимая магия.

// Автораспаковка: объект Integer снимает этот костюм и становится голым int.
int unboxed = boxed; // За кулисами: boxed.intValue(). Снова магия.

// Без этого счастья коллекции бы просто взвыли, ведь они жрут только объекты.
List<Integer> list = new ArrayList<>();
list.add(1); // Смотри-ка, int 1 сам превратился в Integer! Волшебство, блядь.
int first = list.get(0); // А тут Integer из списка сам стал int. Ёперный театр!

Ну и напоследок, про приведение типов (кастинг).

Тут два пути, как в анекдоте: прямой и кривой.

• Неявное (расширяющее): Когда маленькое становится большим (int -> long). Безопасно, компилятор сам всё сделает. «Расти, сынок».
• Явное (сужающее): Когда большое пытаются впихнуть в маленькое (double -> int). Опасно, можно потерять данные. Требует прямого указания: (int) 3.14. Результат? 3. Остальное — в помойку. «Терпи, сука, жмись».
• Со ссылками: Вверх по иерархии (к родителю) — всегда можно, автоматом. Вниз (к потомку) — нужно явно указывать и обязательно проверять instanceof, иначе в лучшем случае — исключение, в худшем — неведомая хуйня в рантайме. «Ты точно тот, за кого себя выдаёшь? Докажи!».

Вот и вся система, блядь. Кажется сложной, но она просто не даёт тебе выстрелить себе в ногу, пока ты не скажешь это очень чётко и громко.