Ссылочные типы данных в Java

Ссылочные типы данных (reference types) являются неотъемлемой частью объектно-ориентированной модели Java. В отличие от примитивов, они представляют объекты и хранят ссылки (адреса) на область памяти, где находится фактическое содержимое.

1. Концепция и философия

Java — строго объектно-ориентированный язык, и ссылки — основа его динамической природы.

Зачем нужны ссылочные типы:
Инкапсуляция данных и поведения. Объекты объединяют данные и методы, действующие над ними.
Гибкость. Ссылочные типы позволяют моделировать сложные структуры (например, графы, деревья, коллекции).
Полиморфизм и наследование. Через ссылки возможна работа с объектами по интерфейсам и абстрактным типам.

List<String> names = new ArrayList<>(); // ссылка на объект ArrayList

2. Представление и поведение ссылок

Ссылочная переменная не содержит сам объект, а только указатель на него.

String a = "Hello";
String b = a;
Обе переменные a и b ссылаются на один и тот же объект "Hello" в куче (heap). Изменение объекта (если он мутабелен) через одну ссылку отразится на другой.

Пример с мутабельным объектом:

List<Integer> list1 = new ArrayList<>();
List<Integer> list2 = list1;
list1.add(10);
System.out.println(list2); // [10]

3. Классы, интерфейсы и массивы

К ссылочным типам относятся:
Классы (например, String, Object, Scanner, ArrayList)
Интерфейсы (например, List, Runnable, Serializable)
Массивы (int[], String[], Object[][]) — в Java массивы — это объекты!
Специальный тип null — означает отсутствие объекта

4. Работа JVM с ссылками

При работе со ссылочными типами:
Объекты размещаются в куче (heap).
Ссылки могут храниться в стеке вызовов, в полях объектов, в массиве и т.д.
JVM использует сборку мусора (GC) для очистки неиспользуемых объектов.

class User {
    String name;
}

User user1 = new User();
User user2 = user1;
user1 = null; // объект всё ещё доступен через user2

5. Особенности ссылочных типов

a) Сравнение ссылок

String a = new String("Java");
String b = new String("Java");
System.out.println(a == b);      // false — разные объекты
System.out.println(a.equals(b)); // true — сравнение содержимого
== сравнивает ссылки, а equals() — содержимое (если метод переопределён корректно).

b) NullPointerException

String s = null;
System.out.println(s.length()); // исключение
Поэтому рекомендуется использовать Objects.requireNonNull, Optional, или делать явные проверки на null.

6. Автоматическая работа с памятью

Одно из главных преимуществ Java — автоматическое управление памятью. Не нужно вручную освобождать объекты, как в C/C++.

Но важно помнить:
Объекты "висят" в памяти, пока есть активные ссылки.
Циклические ссылки не мешают сборке мусора (в отличие от простых reference counting-систем).

7. Массивы как ссылочные типы

Массивы в Java — полноценные объекты.

int[] nums = {1, 2, 3};
System.out.println(nums.length); // 3
Массивы имеют поля и методы (length — поле, а не метод), и их тип — int[], String[] и т.д.

8. Использование в обобщениях

Ссылочные типы активно применяются в дженериках (обобщениях).

List<Integer> list = new ArrayList<>();

Нельзя использовать примитивы в параметрах типа:

List<int> wrongList; // ошибка
Поэтому применяются классы-обёртки: Integer, Double, Boolean и т.д.

9. Влияние на производительность

Работа со ссылками может быть дороже, чем с примитивами:
Дополнительные обращения к памяти
Участие в GC
Наличие виртуального вызова методов (vtable)
Частые создания объектов (например, при упаковке/распаковке)

Оптимизации:
Избегать ненужных аллокаций
Использовать StringBuilder вместо + в циклах
Применять ObjectPool, если объекты часто переиспользуются

#Java #для_новичков #beginner #reference_types

Интеграция Liquibase с другими инструментами

Maven / Gradle

Maven

Добавьте зависимость в pom.xml:

<dependency>
    <groupId>org.liquibase</groupId>
    <artifactId>liquibase-core</artifactId>
    <version>4.25.0</version>
</dependency>

Конфигурация через pom.xml:

<plugin>
    <groupId>org.liquibase</groupId>
    <artifactId>liquibase-maven-plugin</artifactId>
    <version>4.25.0</version>
    <configuration>
        <changeLogFile>src/main/resources/db/changelog/db.changelog-master.yaml</changeLogFile>
        <url>jdbc:postgresql://localhost:5432/mydb</url>
        <username>user</username>
        <password>pass</password>
    </configuration>
</plugin>

Запуск миграций:

mvn liquibase:update

Gradle

Добавьте в build.gradle:

plugins {
    id 'org.liquibase.gradle' version '2.2.0'
}

dependencies {
    liquibaseRuntime 'org.liquibase:liquibase-core:4.25.0'
    liquibaseRuntime 'org.postgresql:postgresql:42.6.0'
}

liquibase {
    changeLogFile 'src/main/resources/db/changelog/db.changelog-master.yaml'
    url 'jdbc:postgresql://localhost:5432/mydb'
    username 'user'
    password 'pass'
}

Запуск:

gradle liquibaseUpdate

Spring Boot (автоконфигурация)

Spring Boot автоматически настраивает Liquibase, если он обнаружен в classpath.

Настройки в application.yml:

spring:
  datasource:
    url: jdbc:postgresql://localhost:5432/mydb
    username: user
    password: pass
  liquibase:
    change-log: classpath:db/changelog/db.changelog-master.yaml
    enabled: true
    contexts: dev  # Фильтрация по контексту

Поведение:
Миграции запускаются при старте приложения.
Можно отключить через spring.liquibase.enabled=false.

Расширенные функции Liquibase

Динамические свойства (property)

Позволяют выносить повторяющиеся значения в переменные.

Пример (YAML):

databaseChangeLog:
  - property:
      name: default.schema
      value: public
  - changeSet:
      id: 1
      author: dev
      changes:
        - createTable:
            tableName: ${default.schema}.users
            columns:
              - column:
                  name: id
                  type: INT

В liquibase.properties:

default.schema=public

Через командную строку:

liquibase update -Ddefault.schema=public

Контексты (contexts) и фильтрация changeSet’ов

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

Пример (YAML):

- changeSet:
    id: 2
    author: dev
    context: "dev,test"  # Будет выполнен только в dev и test
    changes:
      - insert:
          tableName: users
          columns:
            - column:
                name: username
                value: "test_user"

- changeSet:
    id: 3
    author: dev
    context: "prod"  # Только в production
    changes:
      - createIndex:
          tableName: users
          indexName: idx_user_email
          columns:
            - column:
                name: email

Как передать контекст?

Через командную строку:

liquibase update --contexts="dev"

В Spring Boot:

spring:
  liquibase:
    contexts: dev

#Java #middle #Liquibase

Best Practices

Организация changelog-файлов

Рекомендуемая структура:

src/main/resources/db/changelog/
├── db.changelog-master.yaml  # Главный файл
├── changes/
│   ├── 001-create-tables.yaml
│   ├── 002-add-indexes.yaml
│   └── 003-insert-data.yaml
└── rollback/
    ├── 001-rollback.yaml    # Ручные откаты

Главный файл (db.changelog-master.yaml):

databaseChangeLog:
  - includeAll:
      path: db/changelog/changes/
      relativeToChangelogFile: true

Почему так?

Удобно управлять версиями.
Легко находить изменения.

Тестирование миграций

Стратегии:
Локальная проверка:

liquibase validate  # Проверка синтаксиса
liquibase update    # Применение в test-DB

Интеграционные тесты (JUnit + Testcontainers):

@Testcontainers
@SpringBootTest
class LiquibaseMigrationTest {
    @Container
    static PostgreSQLContainer<?> postgres = new PostgreSQLContainer<>("postgres:15");

    @Test
    void testMigrations() {
        // Spring Boot автоматически применит миграции
        assertTrue(true);  # Если не упало — значит, успешно
    }
}

Работа в команде (избежание конфликтов)

Правила:
Именование changeSet’ов:
Используйте id: <дата>-<номер> (например, id: 20240315-1).
Указывайте автора (author: github_username).

Порядок изменений:
Не зависеть от порядка выполнения (например, не предполагать, что таблица A уже существует при создании B).

Использование preConditions:

- changeSet:
    id: 20240315-1
    author: dev
    preConditions:
      - tableExists:
          tableName: users
    changes:
      - addColumn:
          tableName: users
          column:
            name: phone
            type: VARCHAR(20)

Регулярные обновления:
Перед началом работы выполняйте liquibase update, чтобы получить актуальную схему.

#Java #middle #Liquibase

Настройка OAuth2 для Gmail

Для Gmail предпочтительно использовать OAuth2.

Пример конфигурации:

@Configuration
public class MailConfig {

    @Bean
    public JavaMailSender javaMailSender() {
        JavaMailSenderImpl mailSender = new JavaMailSenderImpl();
        mailSender.setHost("smtp.gmail.com");
        mailSender.setPort(587);
        mailSender.setUsername("your.email@gmail.com");

        Properties props = mailSender.getJavaMailProperties();
        props.put("mail.smtp.auth", "true");
        props.put("mail.smtp.starttls.enable", "true");
        props.put("mail.smtp.auth.mechanisms", "XOAUTH2");

        // Настройка OAuth2 токена через Google API Client Library
        // Подробности: https://developers.google.com/identity/protocols/oauth2
        return mailSender;
    }
}

Примечание: Зарегистрируйте приложение в Google Cloud Console и используйте библиотеку google-auth-library-oauth2-http для получения accessToken.

Создание сервиса отправки почты

Создадим сервис EmailService для отправки писем.

@Service
public class EmailService {

    @Autowired
    private JavaMailSender mailSender;

    @Autowired
    private TemplateEngine templateEngine;

    private static final Logger logger = LoggerFactory.getLogger(EmailService.class);

    public void sendSimpleEmail(String to, String subject, String text) {
        SimpleMailMessage message = new SimpleMailMessage();
        message.setTo(to);
        message.setSubject(subject);
        message.setText(text);
        mailSender.send(message);
    }

    public void sendHtmlEmail(String to, String subject, String htmlBody) throws MessagingException {
        MimeMessage message = mailSender.createMimeMessage();
        MimeMessageHelper helper = new MimeMessageHelper(message, true, "UTF-8");
        helper.setTo(to);
        helper.setSubject(MimeUtility.encodeText(subject, "UTF-8", null));
        helper.setText(htmlBody, true);
        mailSender.send(message);
    }

    public void sendEmailWithAttachment(String to, String subject, String text, File attachment) throws MessagingException {
        MimeMessage message = mailSender.createMimeMessage();
        MimeMessageHelper helper = new MimeMessageHelper(message, true, "UTF-8");
        helper.setTo(to);
        helper.setSubject(MimeUtility.encodeText(subject, "UTF-8", null));
        helper.setText(text);
        FileSystemResource file = new FileSystemResource(attachment);
        helper.addAttachment(attachment.getName(), file);
        mailSender.send(message);
    }

    @Async
    public CompletableFuture<Void> sendSimpleEmailAsync(String to, String subject, String text IMPORTANT: text) {
        SimpleMailMessage message = new SimpleMailMessage();
        message.setTo(to);
        message.setSubject(MimeUtility.encodeText(subject, "UTF-8", null));
        message.setText(text);
        mailSender.send(message);
        return CompletableFuture.completedFuture(null);
    }

    public void sendTemplatedEmail(String to, String subject, String username) throws MessagingException {
        MimeMessage message = mailSender.createMimeMessage();
        MimeMessageHelper helper = new MimeMessageHelper(message, true, "UTF-8");
        Context context = new Context();
        context.setVariable("username", username);
        String htmlBody = templateEngine.process("email-template", context);
        helper.setTo(to);
        helper.setSubject(MimeUtility.encodeText(subject, "UTF-8", null));
        helper.setText(htmlBody, true);
        mailSender.send(message);
    }
}

Конфигурация асинхронности:

@Configuration
@EnableAsync
public class AsyncConfig {
    @Bean
    public Executor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(5);
        executor.setMaxPoolSize(10);
        executor.setQueueCapacity(100);
        executor.initialize();
        return executor;
    }
}

#Java #middle #on_request #JavaMailSender

Примеры кода

Простой текст:

SimpleMailMessage message = new SimpleMailMessage();
message.setTo("user@example.com");
message.setSubject("Тестовое письмо");
message.setText("Привет из Spring Boot!");
mailSender.send(message);

HTML-письмо:

MimeMessage message = mailSender.createMimeMessage();
MimeMessageHelper helper = new MimeMessageHelper(message, true, "UTF-8");
helper.setTo("user@example.com");
helper.setSubject(MimeUtility.encodeText("HTML письмо", "UTF-8", null));
helper.setText("<h1>Привет!</h1><p>Это HTML письмо.</p>", true);
mailSender.send(message);

Вложение:

File file = new File("/path/to/file.pdf");
FileSystemResource resource = new FileSystemResource(file);
MimeMessage message = mailSender.createMimeMessage();
MimeMessageHelper helper = new MimeMessageHelper(message, true, "UTF-8");
helper.setTo("user@example.com");
helper.setSubject(MimeUtility.encodeText("Письмо с вложением", "UTF-8", null));
helper.setText("Смотри вложение!");
helper.addAttachment("file.pdf", resource);
mailSender.send(message);

Обработка ошибок и логирование

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

Основные исключения:

MailAuthenticationException
MailSendException
MessagingException

Пример отлова:

try {
    mailSender.send(message);
} catch (MailException e) {
    logger.error("Ошибка отправки письма", e);
    throw e;
}

Повторные попытки
Используйте @Retryable из Spring Retry:

@Retryable(value = MailException.class, maxAttempts = 3)
public void sendSimpleEmail(String to, String subject, String text) {
    SimpleMailMessage message = new SimpleMailMessage();
    message.setTo(to);
    message.setSubject(subject);
    message.setText(text);
    mailSender.send(message);
}

Зависимость:

<dependency>
    <groupId>org.springframework.retry</groupId>
    <artifactId>spring-retry</artifactId>
</dependency>

Мониторинг и метрики

Для продакшен-приложений полезно отслеживать метрики отправки писем с помощью Spring Actuator:

@Service
public class EmailService {

    @Autowired
    private JavaMailSender mailSender;

    @Autowired
    private MeterRegistry meterRegistry;

    public void sendSimpleEmail(String to, String subject, String text) {
        SimpleMailMessage message = new SimpleMailMessage();
        message.setTo(to);
        message.setSubject(subject);
        message.setText(text);
        try {
            mailSender.send(message);
            meterRegistry.counter("email.sent.success").increment();
        } catch (MailException e) {
            meterRegistry.counter("email.sent.failure").increment();
            throw e;
        }
    }
}

Зависимость:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
<dependency>
    <groupId>io.micrometer</groupId>
    <artifactId>micrometer-registry-prometheus</artifactId>
</dependency>

Безопасность и защита данных

Никогда не храните пароли в открытом виде в git-репозиториях.

Рекомендации:
Используйте переменные окружения или секреты (например, Kubernetes Secrets).
Применяйте Spring Cloud Vault или HashiCorp Vault.
Используйте шифрование с Jasypt.
Настройте OAuth2 для Gmail.

Пример с переменными окружения:

spring.config.import=optional:configserver:http://config-server
spring.mail.password=${MAIL_PASSWORD}

#Java #middle #on_request #JavaMailSender

Тестирование отправки почты

Интеграционные тесты с Testcontainers:

@Testcontainers
@SpringBootTest
public class EmailServiceTest {

    @Container
    private static final GreenMailContainer greenMail = new GreenMailContainer();

    @Autowired
    private EmailService emailService;

    @Test
    void shouldSendEmail() {
        emailService.sendSimpleEmail("test@example.com", "Test Subject", "Test Body");
        assertEquals(1, greenMail.getReceivedMessages().length);
    }
}

Зависимость:

<dependency>
    <groupId>org.testcontainers</groupId>
    <artifactId>greenmail</artifactId>
    <version>2.2.0</version>
    <scope>test</scope>
</dependency>

Unit-тестирование:

@MockBean
private JavaMailSender mailSender;

@Test
void shouldSendMail() {
    SimpleMailMessage message = new SimpleMailMessage();
    emailService.sendSimpleEmail("to", "subject", "body");
    verify(mailSender, times(1)).send(any(SimpleMailMessage.class));
}

Интеграция с очередями

Для отложенной отправки используйте RabbitMQ(ну или другой брокер сообщений):

@Service
public class EmailService {

    @Autowired
    private JavaMailSender mailSender;

    @Autowired
    private RabbitTemplate rabbitTemplate;

    public void sendEmailToQueue(String to, String subject, String text) {
        EmailMessage email = new EmailMessage(to, subject, text);
        rabbitTemplate.convertAndSend("emailQueue", email);
    }

    @RabbitListener(queues = "emailQueue")
    public void processEmail(EmailMessage email) {
        SimpleMailMessage message = new SimpleMailMessage();
        message.setTo(email.getTo());
        message.setSubject(email.getSubject());
        message.setText(email.getText());
        mailSender.send(message);
    }

    @Data
    static class EmailMessage {
        private String to;
        private String subject;
        private String text;
    }
}

Зависимость:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>

Распространенные ошибки и подводные камни

Неверная конфигурация SMTP (порт, шифрование).
Проблемы с двухфакторной авторизацией (особенно Gmail).
Ограничения на массовую рассылку (например, Gmail: ~500 писем/день для бесплатных аккаунтов).
Проблемы с кодировкой (например, кириллица в теме письма).
Отсутствие MIME-типа у вложений.
Блокировка сервером (например, Mail.ru требует DKIM и SPF).

Решение для кодировки:

helper.setSubject(MimeUtility.encodeText("Тема на кириллице", "UTF-8", null));

#Java #middle #on_request #JavaMailSender

Объекты в Java

Объекты являются фундаментальным понятием в Java и лежат в основе всей объектно-ориентированной парадигмы языка. Каждый объект представляет собой экземпляр класса и объединяет в себе состояние (поля) и поведение (методы).

1. Введение

В Java всё, что не является примитивным типом, относится к ссылочным типам, а основные единицы этих типов — это объекты.

Объект-ориентированная модель основана на трёх ключевых принципах:
Инкапсуляция: объединение данных и методов для управления ими.
Наследование: возможность создавать новые классы на основе уже существующих, унаследовав их состояние и поведение.
Полиморфизм: возможность работать с объектами через их общий (абстрактный) тип, подставляя разные конкретные реализации.

Вся динамика и гибкость Java-приложений строится на том, что объекты создаются во время выполнения программы, передаются по ссылке, могут образовывать сложные графы связей и автоматически удаляться сборщиком мусора.

2. Создание объектов

2.1. Ключевое слово new

Самый распространённый способ создания объекта — использование оператора new, который выполняет два основных действия:
Выделяет память в куче (heap) под новый объект.
Вызывает конструктор соответствующего класса, чтобы инициализировать поля объекта.

Person person1 = new Person("John", 25);

Здесь:
new Person("John", 25) — порождает новый объект класса Person, вызывая конструктор Person(String name, int age).
Полученная ссылка на вновь созданный объект присваивается переменной person1 типа Person.
Переменная person1 не содержит непосредственно самого объекта, а лишь указывает на область памяти, где объект расположен.

2.2. Фабричные методы и другие способы

Кроме new, объекты могут создаваться через:
Фабричные методы (static factory methods), например, List.of(...) или Optional.of(...).
Клонирование (когда класс поддерживает интерфейс Cloneable и реализует метод clone()).
Десериализация (с помощью API сериализации или при работе с JSON/XML).
Рефлексия (пересоздание экземпляра через Class.newInstance() или Constructor.newInstance()).

Однако в подавляющем большинстве случаев для явного создания объекта используется именно new.

2.3. Размещение ссылок и объектов

Объекты всегда размещаются в куче (heap).

Ссылочные переменные (person1 в примере) могут храниться:
В стеке вызовов (если это локальная переменная метода).
В полях других объектов (если объект содержится в качестве поля другого объекта).
В элементах массива (если это массив ссылок).
В статических полях классов (в специальной области памяти, связанной с загрузчиком классов).

3. Существование и удаление объектов

3.1. Существование объектов

Объект продолжает «жить» в памяти до тех пор, пока на него существует хотя бы одна активная ссылка.

Пример:

Person person1 = new Person("John", 25);
Person person2 = person1;   // person2 ссылается на тот же самый объект
person1 = null;            // теперь единственная ссылка на объект — person2

В момент создания объекта через new в куче появляется новый экземпляр Person.
Переменные person1 и person2 указывают на одну и ту же область памяти.
Когда мы присвоили person1 = null;, объект всё ещё существует, поскольку на него ссылается person2.
Как только все ссылки будут убраны (например, person2 = null; или метод, в котором была локальная ссылка, завершится и стек «очистится»), объект становится недостижимым.

Java применяет алгоритм mark-and-sweep для сборки мусора, поэтому даже если два объекта ссылаются друг на друга, но на них никто извне не ссылается, они будут помечены как недостижимые и удалены.

#Java #для_новичков #beginner #reference_types #Object

3.2. Состояние объектов при сборке мусора

Touchable (доступный): объекты, на которые есть хотя бы одна живая ссылка.
Resurrectible (возродимый): объекты, на которые больше нет обычных ссылок, но в методе finalize() ещё есть возможность «оживить» объект (устаревший механизм, не рекомендуется к использованию).
Untouchable (недоступный): объекты, окончательно помеченные для удаления сборщиком мусора.

Иерархия переходов такова:
Пока есть ссылки — объект «доступен» и используется.
Если ссылок нет, но метод finalize() ещё не вызывался — объект попадает в очередь финализации.
После выполнения finalize() (или если он не переопределён) объект окончательно переходит в состояние «недоступен» и убирается сборщиком мусора.

3.3. Удаление объектов

Перечислять и освобождать память вручную, как в C++, в Java не нужно.
Можно лишь рекомендовать запуск сборщика мусора через System.gc(), но вызов этого метода не гарантирует немедленного выполнения GC.
Метод finalize() устаревает (deprecated) и не рекомендуется к использованию, поскольку его выполнение непредсказуемо и может негативно влиять на производительность.
При работе с ресурсами (файлы, сокеты, потоки) рекомендуется применять конструкцию try-with-resources или явно закрывать ресурсы в блоке finally, а не полагаться на GC или finalize().

4. Использование объектов

4.1. Вызов методов и доступ к полям

После того как объект создан и на него есть ссылка, мы можем обращаться к его полям и методам:

person1.sayHello();       // вызов метода объекта
int age = person1.getAge(); // чтение свойства через геттер

Ключевое понимание:
Любой метод вызывается через ссылку на объект.
Внутри метода this указывает на тот же объект, на который указывает переменная, через которую мы вызвали метод.

4.2. Инкапсуляция и модульность

Объекты позволяют:
Инкапсулировать внутреннее состояние (часто делая поля private и предоставляя доступ через геттеры/сеттеры).
Скрыть детали реализации, предоставляя только публичный интерфейс (методы).
Повторно использовать код: один и тот же класс можно инстанцировать в разных местах программы.

4.3. Передача объектов в методы

Когда мы передаём объект в метод, копируется сама ссылка, а не весь объект.

Это значит, что метод получает «копию адреса», указывающую на тот же экземпляр:

void modifyList(List<Integer> list) {
    list.add(10);                    // модифицирует оригинальный список
    list = new ArrayList<>();        // переприсвоение локальной переменной — не влияет на внешний список
    list.add(20);                    // меняет уже новый (локальный) список
}

List<Integer> numbers = new ArrayList<>();
modifyList(numbers);
System.out.println(numbers);         // [10], но не [10, 20]

Вызов list.add(10) изменил тот же объект, что и numbers.
А переприсваивание list = new ArrayList<>() коснулось только локальной копии ссылки внутри метода.

5. Трудности и подводные камни

5.1. NullPointerException

Самая распространённая ошибка при работе с объектами — попытка вызвать метод или обратиться к полю на null-ссылке:

String s = null;
int length = s.length(); // NullPointerException

Рекомендуемые практики:
При инициализации объектов делать явные проверки, либо использовать Objects.requireNonNull(obj).
При наличии неопределённости возвращать Optional<T> вместо потенциально null.
В местах, где возможно получение null, проверять ссылку прежде чем обращаться к её методам или полям.

#Java #для_новичков #beginner #reference_types #Object

5.2. Сравнение ссылок и содержимого

Оператор == сравнивает адреса в памяти, то есть проверяет, совпадают ли ссылки.
Метод equals() (если переопределён) сравнивает логическое содержание объектов.

String a = new String("hello");
String b = new String("hello");

System.out.println(a == b);      // false (разные объекты)
System.out.println(a.equals(b)); // true  (одинаковое содержимое)
Неверное использование == вместо equals() приводит к тому, что два «логически одинаковых» объекта будут считаться разными.

5.3. Изменяемые (mutable) и неизменяемые (immutable) объекты

Изменяемые объекты (например, ArrayList, StringBuilder) позволяют изменять своё внутреннее состояние после создания. Если несколько ссылок указывают на один и тот же экземпляр, то изменение через одну ссылку будет видно через все остальные.
Неизменяемые объекты (например, String, Integer, LocalDate) после создания не меняются; операции, которые «меняют» их, на самом деле возвращают новый экземпляр.

Непонимание этого может привести к неожиданным результатам:

List<String> list = new ArrayList<>();
list.add("A");
List<String> another = list;
another.clear();              // очищает список для обеих ссылок
System.out.println(list);     // []

5.4. Утечки памяти

В Java утечки памяти возникают не из-за отсутствия явного удаления объектов (как в C++), а из-за того, что на объекты остаются неожиданно живые ссылки, и GC не может их убрать:
Хранение объектов в static-полях и неочищаемых коллекциях.
Неправильная работа с кешами или пулом объектов, где ссылки не удаляются вовремя.
Анонимные внутренние классы или лямбда-выражения, сохраняющиеся после использования.

Пример простой утечки:

public class Cache {
    private static final Map<String, Object> CACHE = new HashMap<>();

    public static void put(String key, Object value) {
        CACHE.put(key, value);
    }

    // Если не реализовать метод удаления из CACHE, то объекты будут храниться в памяти постоянно
}

5.5. Производительность и частые аллокации

Частое создание небольших временных объектов может привести к частым запускам GC и общему снижению производительности.
Конкатенация строк в цикле через оператор + создаёт новые объекты String на каждом шаге.

Лучше использовать StringBuilder:

// Плохо:
String result = "";
for (int i = 0; i < 1000; i++) {
    result += i;                  // каждый раз создаётся новый String
}

// Лучше:
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 1000; i++) {
    sb.append(i);
}
String result = sb.toString();

5.6. Пограничные случаи при копировании — глубокое vs поверхностное копирование

Поверхностное копирование (shallow copy) копирует только поля-примитивы и ссылки; вложенные объекты не дублируются, а «разделяются» между двумя экземплярами.
Глубокое копирование (deep copy) предполагает создание новых экземпляров для всех вложенных объектов, чтобы изменения в одном объекте не затрагивали другой.

class Address {
    String street;
}

class Person implements Cloneable {
    String name;
    Address address;

    @Override
    protected Person clone() throws CloneNotSupportedException {
        Person cloned = (Person) super.clone();    // поверхностное копирование
        cloned.address = new Address();            // нужно вручную создать новый адрес
        cloned.address.street = this.address.street;
        return cloned;
    }
}
Если не учитывать глубокое копирование, можно случайно разделить внутреннее состояние между двумя объектами, что приведёт к трудноотлавливаемым ошибкам.

5.7. Потокобезопасность (thread-safety)

Когда объекты доступны из нескольких потоков, нужно грамотно синхронизировать доступ к их полям и методам:
Использовать synchronized, ReentrantLock, атомарные типы (AtomicInteger, AtomicReference).
Предпочитать неизменяемые объекты, так как они автоматически безопасны для чтения из разных потоков.
Избегать состояния, зависимого от порядка выполнения, или пользоваться высокоуровневыми абстракциями из java.util.concurrent.

#Java #для_новичков #beginner #reference_types #Object