Java

Хранит целые числа небольшого диапазона от -128 до 127.

byte a = 10;

Хранит целые числа среднего диапазона от -32,768 до 32,767.

short a = 1000;

Хранит целые числа от -2³¹ до 2³¹-1. Обеспечивает хороший баланс между диапазоном значений и объемом занимаемой памяти.

int number = 100;

Хранит целые числа большого диапазона от -2⁶³ до 2⁶³-1. Можно указать литерал L.

long bigNumber = 10000000000L;

Хранит числа с плавающей точкой одинарной точности. Требует суффикс f или F. Точность - примерно 6-7 цифр.

float pi = 3.14f;

Хранит числа с плавающей точкой двойной точности. По умолчанию все дробные значения считаются double. Точность - примерно 15-16 цифр. Можно указать литерал D.

double pi = 3.1415926535d;

Храненит логические значения true или false.

boolean isJavaFun = true;

Храненит символы Unicode. Символы указываются в одиночных кавычках.

char letter = 'A';
char unicodeChar = '\u0041'; // 'A' в Unicode

Не требует явного приведения, так как long (64-бита) шире, чем int (32-бита). Преобразование происходит автоматически (implicit casting).

int intVal = 42;
long longVal = intVal;

Не требует явного приведения типов. Преобразование происходит автоматически (implicit cast), так как float может точно представлять все значения int.

int intVal = 100;
float floatVal = intVal;

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

int intVal = 42;
double doubleVal = intVal;

Требует явное приведение типов (explicit cast), так как int (32 бита) уже, чем long (64 бита). Возможна потеря данных, если значение не помещается в диапазон int.

long longVal = 123456789L;
int intVal = (int) longVal; 

Требует явное приведение типов (explicit cast), так как long (64-битное целое) шире, чем float (32-битное число с плавающей точкой). Возможна потеря точности, особенно для больших значений.

long longVal = 123456789012345L;
float floatVal = (float) longVal;

Не требует явного приведения, так как double (64-бита) может точно представлять все значения long (также 64-бита), но с плавающей точкой.

long longVal = 123456789L;
double doubleVal = longVal;

Требует явное приведение (explicit cast), так как int — целочисленный тип, а float — дробный. Дробная часть будет отброшена без округления.

float floatVal = 5.99f;
int intVal = (int) floatVal;

Требует явное приведение типов, так как float — это число с плавающей точкой, а long — целочисленный тип. Дробная часть отбрасывается.

float floatVal = 12345.67f;
long longVal = (long) floatVal;

Не требует явного кастинга, так как double (64-бита) шире, чем float (32-бита). Преобразование происходит автоматически.

float floatVal = 3.14f;
double doubleVal = floatVal;

Требует явное приведение типов, так как дробная часть (double) будет отброшена, а значение округляется в сторону нуля.

double doubleVal = 3.99;
int intVal = (int) doubleVal;

Требует явное приведение, так как double (64-битное число с плавающей точкой) содержит дробную часть, которая отбрасывается, и может выходить за пределы диапазона long.

double doubleVal = 123456789.99;
long longVal = (long) doubleVal;

Требуется явное приведение типов (explicit cast), так как float (32 бита) менее точный, чем double (64 бита). Возможна потеря точности.

double doubleVal = 3.141592653589793;
float floatVal = (float) doubleVal; 

Целое число от -128 до 127.

Byte b = 127;

Целое число от -32,768 до 32,767.

Short s = 32000;

Целое число от -2³¹ до 2³¹-1.

Integer i = 100000;

Целое число от -2⁶³ до 2⁶³-1.

Long l = 10000000000L;

Дробное число с одинарной точностью.

Float f = 3.14f;

Дробное число с двойной точностью.

Double d = 3.14159265359;

Значение true или false.

Boolean bool = true;

Символ в Unicode.

Character c = 'A';

Процесс преобразования примитивного типа данных в объект его соответствующего типа-обертки.

int primitiveInt = 42;             // Примитивный тип
Integer wrappedInt = primitiveInt; // Боксинг, превращает примитив в объект

Процесс преобразования объекта типа-обертки в соответствующий примитивный тип.

Integer wrappedInt = 42;       // Объект типа Integer
int primitiveInt = wrappedInt; // Анбоксинг, превращает объект в примитив

Используется для создания нового экземпляра класса. Выделяет память под объект и вызывает конструктор класса.

Person person = new Person("Alice", 30); // Создание нового объекта Person

Используется для наследования классов. Позволяет одному классу (подклассу) наследовать свойства и методы другого класса (суперкласса).

class Animal {
    void sound() {
        System.out.println("Animal sound");
    }
}

class Dog extends Animal { // Dog наследует Animal
    void sound() {
        System.out.println("Bark");
    }
}

Используется для реализации интерфейсов. Позволяет классу реализовывать методы, объявленные в интерфейсе.

interface Drawable {
    void draw(); // Метод без тела
}

class Circle implements Drawable { // Circle реализует интерфейс Drawable
    public void draw() {
        System.out.println("Drawing a circle");
    }
}

Проверяет, является ли объект экземпляром определенного класса или его подкласса.

• Можно использовать для проверки интерфейсов.

String text = "Hello, world!";

if (text instanceof String) {
    System.out.println("Это строка!");
}

Класс для неизменяемых объектов. Он автоматически создаёт конструктор, геттеры, equals, hashCode и toString.

public record Point(int x, int y) {}

Происходит во время компиляции. Компилятор знает о классах и их зависимостях заранее. Статическая загрузка используется, когда класс загружается до его первого использования. Например, при инициализации статических переменных или вызове статических методов.

// В этом примере статический блок будет выполнен до вызова метода main.

public class StaticLoading {
    static {
        System.out.println("Static block executed");
    }

    public static void main(String[] args) {
        System.out.println("Main method executed");
    }
}

Происходит во время выполнения программы. Классы загружаются по мере необходимости, что позволяет уменьшить время начальной загрузки и память. Динамическая загрузка используется с помощью механизма рефлексии или в контексте загрузки классов в ответ на определенные действия.

// В этом примере класс SomeClass загружается динамически во время выполнения программы.

public class DynamicLoading {
    public static void main(String[] args) {
        try {
            Class<?> clazz = Class.forName("SomeClass"); // Динамическая загрузка класса
            Object obj = clazz.getDeclaredConstructor().newInstance(); // Создание экземпляра
        } catch (ClassNotFoundException | InstantiationException | IllegalAccessException | NoSuchMethodException | InvocationTargetException e) {
            e.printStackTrace();
        }
    }
}

Добавляет метод с реализацией в интерфейс. Классы, которые его реализуют, могут не переопределять этот метод.

interface Example {
    default void show() {
        System.out.println("Default method in interface");
    }
}

Позволяет получить доступ к методу, переменной или классу из любого места в программе.

• Может использоваться с классами, методами, конструкторами, интерфейсами и переменными.

public class Example {
    public int number;

    public void display() {
        System.out.println("This is a public method.");
    }
}

Открывает доступ к методу или переменной внутри класса, его подклассов и классов в том же пакете.

class Animal {
    protected void makeSound() {
        System.out.println("Some sound");
    }
}

class Dog extends Animal {
    public void bark() {
        makeSound(); // доступ через наследование
        System.out.println("Woof");
    }
}

Закрывает доступ к методу или переменной для всех, кроме самого класса. Такие данные недоступны для подклассов и других классов даже в одном пакете.

class Account {
    private double balance;

    private void updateBalance(double amount) {
        balance += amount;
    }

    public void deposit(double amount) {
        if (amount > 0) {
            updateBalance(amount); // доступ только внутри класса
        }
    }
}

Запрещает изменение. Переменная становится неизменяемой после инициализации, метод нельзя переопределить в подклассе, а класс — наследовать.

final class Constants {
    final int MAX_USERS = 100;

    final void displayMax() {
        System.out.println("Max users: " + MAX_USERS);
    }
}

// Наследование и изменение метода запрещены
// class ExtendedConstants extends Constants {} // Ошибка

Делает метод, переменную или вложенный класс привязанными к классу, а не к его экземпляру. Доступ возможен без создания объекта.

class Outer {
    static class Inner {
        static void sayHello() {
            System.out.println("Hello from static class!");
        }
    }
}

Outer.Inner.sayHello(); // вызов без создания объектов

Используется для чтения данных из источника.

InputStream inputStream = new FileInputStream("file.txt");
int data;
while ((data = inputStream.read()) != -1) {
    System.out.print((char) data);
}
inputStream.close();

public class BufferedInputStreamExample {
    public static void main(String[] args) {
        try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream("file.txt"))) {
            int byteData;
            while ((byteData = bis.read()) != -1) {
                System.out.print((char) byteData);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Используется для записи данных в целевой объект.

OutputStream outputStream = new FileOutputStream("file.txt");
outputStream.write(65); // Запишет символ 'A'
outputStream.close();

public class Example {
    public static void main(String[] args) {
        try (BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("output.txt"))) {
            bos.write("Пример использования BufferedOutputStream.".getBytes());
            bos.flush(); // Сбрасываем буфер
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Абстрактный класс для чтения символов. Предназначен для обработки текстовых данных и поддерживает работу с различными кодировками.

Reader reader = new FileReader("file.txt");
int data;
while ((data = reader.read()) != -1) {
    System.out.print((char) data);
}
reader.close();

public class BufferedReaderExample {
    public static void main(String[] args) {
        try (BufferedReader br = new BufferedReader(new FileReader("input.txt"))) {
            String line;
            while ((line = br.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Абстрактный класс для записи символов. Он позволяет записывать текстовые данные в различные выходные источники.

Writer writer = new FileWriter("file.txt");
writer.write('A');
writer.close();

public class BufferedWriterExample {
    public static void main(String[] args) {
        try (BufferedWriter bw = new BufferedWriter(new FileWriter("output.txt"))) {
            bw.write("Пример использования BufferedWriter.");
            bw.newLine(); // Добавляем перенос строки
            bw.write("Записываем текст быстрее.");
            bw.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Исключения, которые обязательно нужно обработать либо с помощью try-catch, либо указав в сигнатуре метода throws. Если вы этого не сделаете, код не скомпилируется.

Исключения, которые не требуют обязательной обработки, обычно связаны с логическими ошибками в коде или некорректными входными данными.

Базовый класс для всех исключений, которые могут возникнуть в программе. От него наследуются Error и Exception.

Throwable
├── Error
│   ├── StackOverflowError
│   └── OutOfMemoryError
│
└── Exception
    ├── RuntimeException
    │   ├── NullPointerException
    │   ├── IllegalArgumentException
    │   └── IndexOutOfBoundsException
    ├── IOException
    └── SQLException

Cодержит код, который может вызвать исключение. Это обязательная часть конструкции.

try {
    int result = 10 / 0;
    System.out.println("Результат: " + result);
} catch (Exception e) {}

Перехватывает исключение, если оно возникло в try.

try {
    int result = 10 / 0; // ArithmeticException
} catch (ArithmeticException e) {
    System.out.println("Деление на ноль недопустимо: " + e.getMessage());
}

Выполняется всегда, независимо от того, было исключение или нет.

try {
    int result = 10 / 0;
} catch (ArithmeticException e) {
    System.out.println("Ошибка: " + e.getMessage());
} finally {
    System.out.println("Этот блок выполнится в любом случае.");
}

Используется для выброса исключения.

if (age < 18) {
    throw new IllegalArgumentException("Age must be 18 or older");
}

Указывает, какие исключения метод может выбросить.

public void readFile(String path) throws IOException {
    // Чтение файла
}

Возвращает имя константы enum как строку.

enum Day {
    MONDAY, TUESDAY, WEDNESDAY
}

public static void main(String[] args) {
    System.out.println(Day.MONDAY.name()); // "MONDAY"
}

Возвращает порядковый номер (индекс) константы.

enum Day {
    MONDAY, TUESDAY, WEDNESDAY
}

public static void main(String[] args) {
    System.out.println(Day.MONDAY.ordinal()); // 0
}

Оператор Method Reference используется для ссылки на методы или конструкторы, упрощая синтаксис лямбда-выражений.

• Ссылка на статический метод.

class Utils {
    public static void print(String s) {
        System.out.println(s);
    }
}

public static void main(String[] args) {
    List<String> list = List.of("Hello", "World");
    list.forEach(Utils::print); // Ссылка на метод
}

• Ссылка на метод экземпляра объекта.

public static void main(String[] args) {
    List<String> list = List.of("apple", "banana");
    list.forEach(System.out::println); // Ссылка на метод println объекта System.out
}

• Ссылка на метод экземпляра конкретного объекта.

class StringUtils {
    public void printUpperCase(String s) {
        System.out.println(s.toUpperCase());
    }
}

public static void main(String[] args) {
    StringUtils utils = new StringUtils();
    List<String> list = List.of("java", "kotlin");
    list.forEach(utils::printUpperCase);
}

• Ссылка на конструктор.

class User {
    String name;

    User(String name) {
        this.name = name;
    }
}

public static void main(String[] args) {
    Function<String, User> userFactory = User::new; // Ссылка на конструктор
    User user = userFactory.apply("Alice");
    System.out.println(user.name);
}

Используется для обозначения интерфейсов с единственным абстрактным методом. Указывает, что интерфейс предназначен для использования с лямбда-выражениями или ссылками на методы.

• Интерфейс с @FunctionalInterface должен содержать только один абстрактный метод.

• Могут быть дополнительные методы по умолчанию (default) или статические методы.

• Если в интерфейсе больше одного абстрактного метода, компилятор выдаст ошибку.

@FunctionalInterface
interface MyFunction {
    void sayHello(String name);
}

public class Example {
    public static void main(String[] args) {
        MyFunction greet = (name) -> System.out.println("Hello, " + name);
        greet.sayHello("World");
    }
}

Модификатор, который указывает, что поле не должно быть сериализовано. При сериализации значения таких полей будут пропущены и заменены на значение по умолчанию (например, null для объектов, 0 для чисел).

class User implements Serializable {
    String name;
    transient String password; // Поле не будет сериализовано

    User(String name, String password) {
        this.name = name;
        this.password = password;
    }
}

В режиме ручного управления в Serializable можно самостоятельно контролировать процесс сериализации и десериализации с помощью методов writeObject() и readObject(). Это полезно, когда требуется особая логика или нужно исключить чувствительные данные.

class User implements Serializable {
    String name;
    transient String password; // Поле не будет сериализовано автоматически

    User(String name, String password) {
        this.name = name;
        this.password = password;
    }

    // Метод для кастомной сериализации
    private void writeObject(ObjectOutputStream oos) throws IOException {
        oos.defaultWriteObject(); // Сериализуем обычные поля
        oos.writeObject(encrypt(password)); // Сериализуем пароль в зашифрованном виде
    }

    // Метод для кастомной десериализации
    private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
        ois.defaultReadObject(); // Десериализуем обычные поля
        password = decrypt((String) ois.readObject()); // Расшифровываем пароль
    }

    private String encrypt(String data) {
        return new StringBuilder(data).reverse().toString(); // Пример шифрования (реверс строки)
    }

    private String decrypt(String data) {
        return new StringBuilder(data).reverse().toString(); // Расшифровка
    }
}