public void processOrder(Order order) {
    if (order == null) {
        throw new NullPointerException("Order cannot be null");
    }
    // Основная логика
}

// 1. Базовая версия без сообщения
public static <T> T requireNonNull(T obj)

// 2. Версия со статическим сообщением
public static <T> T requireNonNull(T obj, String message)

// 3. Версия с ленивым сообщением через Supplier
public static <T> T requireNonNull(T obj, Supplier<String> messageSupplier)

public class OrderService {
    private final OrderRepository repository;
    
    public OrderService(OrderRepository repository) {
        this.repository = Objects.requireNonNull(repository);
    }
}

public void updateInventory(Inventory inventory, String warehouseId) {
    Objects.requireNonNull(inventory, "Inventory object cannot be null");
    Objects.requireNonNull(warehouseId, "Warehouse ID must be specified");
    
    inventory.adjustStock(warehouseId);
}

public void processTransaction(Transaction tx) {
    Objects.requireNonNull(tx, 
        () -> String.format("Transaction cannot be null at %s", Instant.now()));
    
    // Сложное форматирование выполняется только если tx == null
}

// Избыточно: сообщение формируется всегда
Objects.requireNonNull(user, "User " + userId + " not found in database " + dbName);

// Эффективно: сообщение формируется только при null
Objects.requireNonNull(user, 
    () -> "User " + userId + " not found in database " + dbName);

public class PaymentProcessor {
    private final PaymentGateway gateway;
    private final TransactionLogger logger;
    
    public PaymentProcessor(PaymentGateway gateway, TransactionLogger logger) {
        this.gateway = Objects.requireNonNull(gateway, "PaymentGateway is required");
        this.logger = Objects.requireNonNull(logger, "TransactionLogger is required");
    }
    
    public PaymentResult process(PaymentRequest request) {
        Objects.requireNonNull(request, "PaymentRequest cannot be null");
        
        gateway.authorize(request);
        logger.log(request);
        return new PaymentResult();
    }
}

public Customer getCustomer(String customerId) {
    Customer customer = customerRepository.findById(customerId);
    return Objects.requireNonNull(customer, 
        () -> "Customer not found for ID: " + customerId);
}

public class CachedDataProvider {
    private DataProvider delegate;
    
    public void initialize(DataProvider provider) {
        this.delegate = Objects.requireNonNull(provider);
    }
    
    public Data fetchData() {
        return Objects.requireNonNull(delegate, "Provider not initialized").fetch();
    }
}

/**
 * Обрабатывает платеж через указанный шлюз.
 *
 * @param request запрос на платеж, не может быть null
 * @param gateway платежный шлюз, не может быть null
 * @return результат обработки платежа
 * @throws NullPointerException если request или gateway равны null
 */
public PaymentResult process(PaymentRequest request, PaymentGateway gateway) {
    Objects.requireNonNull(request, "PaymentRequest is required");
    Objects.requireNonNull(gateway, "PaymentGateway is required");
    
    return gateway.process(request);
}

// package-info.java
@NullMarked
package com.example.service;

import org.jspecify.annotations.NullMarked;

package com.example.service;

import org.jspecify.annotations.Nullable;

public class UserService {
    // Не требует @NonNull — non-null по умолчанию благодаря @NullMarked
    public User findById(String id) {
        // ...
    }
    
    // Явно указано, что может вернуть null
    public @Nullable User findByEmail(String email) {
        // ...
    }
    
    // Параметр явно nullable
    public void updateNickname(String id, @Nullable String nickname) {
        // ...
    }
}

import org.jspecify.annotations.NullMarked;
import org.jspecify.annotations.Nullable;

@NullMarked
public class OrderService {
    private final PaymentGateway gateway;
    
    public OrderService(PaymentGateway gateway) {
        // Runtime-защита: выбросит NPE с сообщением
        this.gateway = Objects.requireNonNull(gateway, "PaymentGateway is required");
    }
    
    // Метод принимает non-null по умолчанию (благодаря @NullMarked)
    public Order processOrder(String orderId) {
        Objects.requireNonNull(orderId, "Order ID is required");
        return gateway.process(orderId);
    }
    
    // Явно nullable параметр
    public Order processOrderWithNotes(String orderId, @Nullable String notes) {
        Objects.requireNonNull(orderId, "Order ID is required");
        // notes может быть null — допустимо по контракту
        return gateway.process(orderId, notes);
    }
}

import java.util.Objects;

public class Task300426 {
    public static void main(String[] args) {
        String s1 = null;
        String s2 = "hello";
        
        String result = Objects.requireNonNull(
            Objects.requireNonNull(s1, "first is null"),
            "second is null"
        );
        
        System.out.println(result);
    }
}

public class ArraysAsListExample {
    
    public static void main(String[] args) {
        String[] colorsArray = {"Red", "Green", "Blue"};
        
        //Антипаттерн: модификация списка из Arrays.asList()
        List<String> fixedList = Arrays.asList(colorsArray);
        System.out.println("Fixed list: " + fixedList); // [Red, Green, Blue]
        
        try {
            fixedList.add("Yellow"); // UnsupportedOperationException
        } catch (UnsupportedOperationException e) {
            System.out.println("Cannot add: " + e);
        }
        
        try {
            fixedList.remove(0); // UnsupportedOperationException
        } catch (UnsupportedOperationException e) {
            System.out.println("Cannot remove: " + e);
        }
        
        try {
            fixedList.clear(); // Тоже UnsupportedOperationException
        } catch (UnsupportedOperationException e) {
            System.out.println("Cannot clear: " + e);
        }
        
        //Можно изменять существующие элементы
        fixedList.set(0, "Cyan");
        System.out.println("After set: " + fixedList); // [Cyan, Green, Blue]
        // Обратите внимание: исходный массив тоже изменился!
        System.out.println("Original array: " + Arrays.toString(colorsArray)); // [Cyan, Green, Blue]
        
        //Решение 1: копирование в новый ArrayList
        List<String> mutableList = new ArrayList<>(Arrays.asList(colorsArray));
        mutableList.add("Yellow");
        mutableList.remove(0);
        System.out.println("Mutable list: " + mutableList);
        
        //Решение 2: Java 8+ Stream для примитивов
        List<Integer> numbers = Arrays.stream(new int[]{1, 2, 3})
            .boxed()
            .collect(Collectors.toList());
        numbers.add(4);
        System.out.println("From stream: " + numbers);
        
        //Решение 3: Java 9+ неизменяемые списки
        List<String> immutable = List.of("A", "B", "C");
        // immutable.add("D"); // UnsupportedOperationException
        // immutable.set(0, "Z"); // Также выбрасывает исключение!
        
        //Решение 4: явное создание ArrayList с инициализацией
        List<String> explicit = new ArrayList<>();
        explicit.add("X");
        explicit.add("Y");
        explicit.add("Z");
}

import java.util.Arrays;
import java.util.List;

public class Task010526 {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("A", "B", "C");
        String[] array = {"X", "Y", "Z"};
        List<String> list2 = Arrays.asList(array);
        
        list.set(1, "B2");
        array[2] = "Z2";
        
        System.out.print(list.get(1) + " ");
        System.out.print(list2.get(2) + " ");
        
        try {
            list.add("D");
        } catch (Exception e) {
            System.out.print("Exception1 ");
        }
        
        try {
            list2.remove(0);
        } catch (Exception e) {
            System.out.print("Exception2");
        }
    }
}