Как работает процесс компиляции Java-кода?

А, ну это ж классика, блядь! Сидишь такой, пишешь на Java, думаешь — о, красота, сейчас всё заработает. А под капотом-то, сука, целый цирк с конями разворачивается, ёпта!

Вот смотри, как это работает, если по-человечьи, а не по-умному.

Пишешь ты свой Main.java, кряхтишь, хуяришь код. А потом говоришь javac — ну-ка, дружок, сделай из этой писанины что-то понятное для железки. И он начинает свою магию, блядь.

Этапы, или как javac ебёт твой код, чтобы он стал послушным:

1. Разбор полётов (Лексический анализ): Он берёт твой файл и начинает его дробить, как мясорубка. Все эти public, class, int, result — всё это превращается в мелкие кусочки, токены. Просто читает и сортирует, сука, по полочкам.

2. Построение дерева (Синтаксический анализ): А дальше он из этих кусочков начинает строить абстрактное синтаксическое дерево. Представь ёлку, блядь, но вместо шариков — твои операторы и переменные. Если структура кривая — сразу пиздец, ошибка. «Где, сука, точка с запятой? А? В рот мне чих-пых!»

3. Проверка на вшивость (Семантический анализ): Тут начинается самое интересное. Дерево есть, но компилятор приглядывается: «А ты, блядь, переменную result объявил как int, а пытаешься запихнуть в неё строку? Да иди ты нахуй!» Или: «Метод println вызываешь, а ты System.out импортировал? А, это встроенное... ладно, проехали». Короче, проверяет, чтобы всё было по правилам, а не как попало.

4. Перевод на язык тайных знаний (Генерация байт-кода): Вот тут твоё красивое дерево превращается в эту... байт-код хуйню. Непонятные инструкции для Виртуальной Машины. Не машинный код для процессора, а типа универсальный язык для этой абстрактной JVM. 0x10, 0x3e, 0xb2 — вот эта вся ебола.

5. Лёгкая подтяжка (Оптимизация): javac не сильно заморачивается. Скажет: «О, final int x = 5+2; Так я тебя, сука, сразу в 7 превращу, нехуй в рантайме считать». А все тяжёлые оптимизации — это уже потом, когда программа бежит.

Пример, чтобы не быть пиздаболом:

// Main.java - тут мы гении
public class Main {
    public static void main(String[] args) {
        int result = 2 + 3; // Гениальная математика
        System.out.println(result); // Показать миру наш результат
    }
}

# Тыкаем в консоль
javac Main.java
# И рождается файлик Main.class — наш ребёнок, конвертированный в байт-код.

А теперь, блядь, главное отличие от таких нативных зверей, как C++:

• Java (Хитрый лис): .java → (компиляция javac) → .class (байт-код, платформо-независимый) → (потом JVM его либо интерпретирует, либо на лету JIT'ом в машинный код превращает). Два этапа, блядь! Сначала в байт-код, потом — в нативное говно.
• C++ (Прямолинейный бык): .cpp → (компиляция g++) → объектный файл → (компоновка ld) → готовый исполняемый файл (уже машинный код под конкретную ОС и процессор). Раз — и готово, но под другую систему уже не побежит, сука.

И где же тут JVM, спросишь ты? А JVM — это как тот самый строгий надзиратель в тюрьме байт-кода. Она загружает .class файлы, проверяет байт-код своим верификатором (чтобы там не было запрещённых трюков), а потом JIT-компилятор (Just-In-Time), этот ебучий трудяга, смотрит на горячие участки кода и говорит: «Да это же, блядь, каждый раз вызывается! Щас я тебя нативно скомпилирую, чтобы быстрее летало!». Вот так из интерпретируемого кода получается охуенная производительность.

Короче, Java — не компилируется сразу в машинный код, а идёт окольным путём через байт-код. Зато «написано однажды — работает везде». Ну, почти везде, если не считать косяков с версиями, блядь.