public class NumberPolymorphism {
    
    //Полиморфный метод, принимающий любой числовой тип
    public static double square(Number num) {
        double d = num.doubleValue();
        return d * d;
    }
    
    //С проверкой типа для сохранения точности
    public static Number add(Number a, Number b) {
        // Для точных вычислений нужно знать тип
        if (a instanceof Integer && b instanceof Integer) {
            return a.intValue() + b.intValue();
        }
        if (a instanceof Double || b instanceof Double) {
            return a.doubleValue() + b.doubleValue();
        }
        if (a instanceof BigDecimal || b instanceof BigDecimal) {
            return toBigDecimal(a).add(toBigDecimal(b));
        }
        return a.doubleValue() + b.doubleValue();
    }
    
    private static BigDecimal toBigDecimal(Number n) {
        if (n instanceof BigDecimal) return (BigDecimal) n;
        return BigDecimal.valueOf(n.doubleValue());
    }
    
    //Ошибка: Number абстрактный
    // Number n = new Number(); // не компилируется
    
    //Правильно: создаем конкретные типы
    Number intNum = 42;           // autoboxing -> Integer
    Number doubleNum = 3.14;      // autoboxing -> Double
    Number longNum = 100L;        // autoboxing -> Long
    Number bigDec = new BigDecimal("123.45");
    
    //Демонстрация полиморфизма
    public static void main(String[] args) {
        List<Number> numbers = Arrays.asList(10, 3.14, 100L, new BigDecimal("99.99"));
        
        // Полиморфная обработка
        for (Number n : numbers) {
            System.out.println("Value: " + n);
            System.out.println("  int: " + n.intValue());
            System.out.println("  double: " + n.doubleValue());
            System.out.println("  square: " + square(n));
        }
        
        //Потеря точности при преобразовании
        Double precise = 123.456;
        Number asNumber = precise;
        int truncated = asNumber.intValue(); // 123 — потеряна дробная часть
        System.out.println("Truncated: " + truncated);
    }
}

import java.util.ArrayList;
import java.util.List;

public class Task290526 {
    public static void main(String[] args) {
        List<Number> numbers = new ArrayList<>();
        numbers.add(10);
        numbers.add(5.5);
        numbers.add(3);
        numbers.add(2L);

        Number sum = numbers.get(0).intValue() + numbers.get(1).doubleValue();
        System.out.println(sum.getClass().getSimpleName());

        Number product = numbers.get(2).longValue() * numbers.get(3).longValue();
        System.out.println(product.getClass().getSimpleName());
    }
}

// read() возвращает int, но данные прошли путь: диск -> page cache -> нативный буфер -> heap
int byteValue = fileInputStream.read();

// BufferedInputStream внутренне содержит byte[] buf размером по умолчанию 8192 байт
try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream("data.bin"))) {
    int b;
    while ((b = bis.read()) != -1) {
        processByte(b);
    }
}

// Маленький буфер: частые системные вызовы, но быстрое освобождение GC
byte[] smallBuffer = new byte[1024];

// Большой буфер: редкие системные вызовы, но большое выделение памяти
byte[] largeBuffer = new byte[1024 * 1024]; // 1MB

// Переиспользование буфера вместо создания нового при каждой операции
private static final ThreadLocal<byte[]> BUFFER = ThreadLocal.withInitial(() -> new byte[8192]);

public void processFile(String path) throws IOException {
    byte[] buffer = BUFFER.get(); // Переиспользование, не создание
    
    try (InputStream in = new FileInputStream(path)) {
        int bytesRead;
        while ((bytesRead = in.read(buffer)) != -1) {
            processChunk(buffer, bytesRead);
        }
    }
    // Буфер остается в ThreadLocal, не подлежит GC между вызовами
}

// Антипаттерн: чтение байта за байтом без буферизации
public void readByteByByte(InputStream in) throws IOException {
    int byteValue;
    while ((byteValue = in.read()) != -1) {
        processByte(byteValue);
    }
}

// Паттерн: буферизованное чтение с обработкой частичного заполнения
public void readBuffered(InputStream in) throws IOException {
    byte[] buffer = new byte[8192]; // 8KB — типичный размер страницы ОС
    int bytesRead;
    
    while ((bytesRead = in.read(buffer)) != -1) {
        processBuffer(buffer, bytesRead);
    }
}

// Пример: flush перед ожиданием ответа
public void sendRequest(OutputStream out, byte[] request) throws IOException {
    out.write(request);
    out.flush(); // Гарантирует, что запрос отправлен до чтения ответа
    
    // Теперь можно читать ответ, не рискуя deadlock из-за буферизации
}

// Цепочка оберток: буферизация + типизированное чтение + сжатие
try (InputStream fis = new FileInputStream("data.bin");
     BufferedInputStream bis = new BufferedInputStream(fis, 8192);
     DataInputStream dis = new DataInputStream(bis);
     GZIPInputStream gzis = new GZIPInputStream(dis)) {
    
    int magicNumber = dis.readInt();      // Чтение 4-байтового int
    long timestamp = dis.readLong();      // Чтение 8-байтового long
    double value = dis.readDouble();      // Чтение 8-байтового double
    String label = dis.readUTF();         // Чтение строки в модифицированном UTF-8
}

public void copyBinaryFile(String sourcePath, String destPath) throws IOException {
    // Буфер 8KB — оптимальный размер для большинства файловых систем
    byte[] buffer = new byte[8192];
    
    try (InputStream in = new FileInputStream(sourcePath);
         OutputStream out = new FileOutputStream(destPath)) {
        
        int bytesRead;
        while ((bytesRead = in.read(buffer)) != -1) {
            out.write(buffer, 0, bytesRead);
        }
        
        out.flush(); // Явный flush перед закрытием
    }
}