public class EnumInterfaces {
    
    // Общий интерфейс для всех перечислений с кодом
    interface Codified {
        int getCode();
        String getDescription();
    }
    
    // Базовый интерфейс с default методом
    interface Named {
        String getName();
        
        default String getFormattedName() {
            return "[" + getName() + "]";
        }
    }
    
    // Перечисление реализует оба интерфейса
    enum Status implements Codified, Named {
        NEW(1, "Новый"),
        PROCESSING(2, "В обработке"),
        COMPLETED(3, "Завершен");
        
        private final int code;
        private final String description;
        
        Status(int code, String description) {
            this.code = code;
            this.description = description;
        }
        
        @Override
        public int getCode() { return code; }
        
        @Override
        public String getDescription() { return description; }
        
        @Override
        public String getName() { return name(); }
    }
    
    enum Priority implements Codified {
        LOW(10, "Низкий"),
        HIGH(20, "Высокий");
        
        private final int code;
        private final String description;
        
        Priority(int code, String description) {
            this.code = code;
            this.description = description;
        }
        
        @Override
        public int getCode() { return code; }
        
        @Override
        public String getDescription() { return description; }
    }
    
    // Полиморфная работа через интерфейс
    public static void printCode(Codified c) {
        System.out.println(c.getCode() + " -> " + c.getDescription());
    }
    
    public static void main(String[] args) {
        printCode(Status.NEW);
        printCode(Priority.HIGH);
        
        // Использование default метода
        System.out.println(Status.COMPLETED.getFormattedName()); // [COMPLETED]
    }
}

public enum Task040626 {
    FIRST, SECOND;

    static String msg = getMsg();

    static String getMsg() {
        return "hello";
    }

    Task040626() {
        System.out.print(getLength());
    }

    static int getLength() {
        return msg.length();
    }

    public static void main(String[] args) {
        System.out.print("main");
    }
}

// Перезапись: если файл существует, содержимое уничтожается
public FileOutputStream(String name) throws FileNotFoundException

// Режим добавления: запись начинается с конца существующего файла
public FileOutputStream(String name, boolean append) throws FileNotFoundException

// Аналогичные конструкторы с File вместо String
public FileOutputStream(File file) throws FileNotFoundException
public FileOutputStream(File file, boolean append) throws FileNotFoundException

// Безопасное добавление в лог-файл из нескольких потоков
public void appendToLog(String message) throws IOException {
    byte[] data = message.getBytes(StandardCharsets.UTF_8);
    try (FileOutputStream fos = new FileOutputStream("app.log", true)) {
        fos.write(data);
        fos.write('\n');
    }
}

String text = "Hello, World!";
byte[] data = text.getBytes(StandardCharsets.UTF_8);
// data — массив в heap, содержит байты UTF-8: 48 65 6C 6C 6F 2C 20 57 6F 72 6C 64 21

// Путь данных для write(byte[]):
// 1. byte[] в heap JVM
// 2. Копирование в нативный буфер (JNI transition)
// 3. Системный вызов write() — данные попадают в page cache ядра
// 4. Ядро помечает страницы как dirty (грязные)
// 5. Асинхронная запись dirty-страниц на диск фоновыми потоками ядра

try (FileOutputStream fos = new FileOutputStream("critical.dat")) {
    fos.write(transactionData);
    fos.flush(); // Сброс буферов JVM в ОС
    fos.getFD().sync(); // fsync — гарантия физической записи
} // close() неявно вызывает flush(), но не fsync()

import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;

public class FileWriteExample {
    
    public void writeStringToFile(String path, String content) throws IOException {
        // Преобразование строки в байты UTF-8
        // Создается новый массив byte[] в heap Eden space
        byte[] data = content.getBytes(StandardCharsets.UTF_8);
        
        // FileOutputStream создается в heap
        // Нативный fd выделяется ОС, файл открывается или создается
        try (FileOutputStream fos = new FileOutputStream(path)) {
            
            // write(byte[]) — копирование из heap в page cache через нативный буфер
            fos.write(data);
            
            // Явный flush — гарантия сброса в ОС
            // Без flush данные могут оставаться в нативных буферах JVM
            fos.flush();
            
        } // close() вызывается автоматически
          // 1. flush() — сброс остатков в ОС
          // 2. Закрытие файлового дескриптора
          // 3. Объект fos становится недостижимым для GC
        
        // Массив data становится недостижимым после выхода из метода
        // GC собирает data и fos при следующей minor collection
    }
    
    // Режим добавления
    public void appendToFile(String path, String content) throws IOException {
        byte[] data = (content + System.lineSeparator()).getBytes(StandardCharsets.UTF_8);
        
        // append = true — открытие с O_APPEND, указатель в конце файла
        try (FileOutputStream fos = new FileOutputStream(path, true)) {
            fos.write(data);
            fos.flush();
        }
    }
}

public void processAndWrite(String outputPath, List<String> records) throws IOException {
    // records — ссылка в стеке, объект List в heap, элементы — объекты String в heap
    
    try (BufferedOutputStream bos = new BufferedOutputStream(
            new FileOutputStream(outputPath), 8192)) {
        
        for (String record : records) {
            // Каждая итерация:
            // 1. getBytes() создает новый byte[] в heap Eden
            // 2. write() копирует данные в buf BufferedOutputStream (heap)
            // 3. При заполнении buf — сброс в FileOutputStream -> ОС
            byte[] bytes = record.getBytes(StandardCharsets.UTF_8);
            bos.write(bytes);
            bos.write('\n');
            // bytes становится недостижимым после итерации
            // GC собирает bytes в следующей minor collection
        }
        
        // bos.flush() сбрасывает остаток buf в ОС
        
    } // bos и underlying fos закрыты
    
    // records все еще достижим, если используется дальше
}

public void optimizedWrite(String outputPath, List<String> records) throws IOException {
    // Переиспользуемый буфер в heap, создается один раз
    ByteArrayOutputStream baos = new ByteArrayOutputStream(8192);
    
    try (FileOutputStream fos = new FileOutputStream(outputPath);
         BufferedOutputStream bos = new BufferedOutputStream(fos)) {
        
        for (String record : records) {
            baos.reset(); // Сброс позиции, не создание нового объекта
            
            byte[] bytes = record.getBytes(StandardCharsets.UTF_8);
            baos.write(bytes);
            baos.write('\n');
            
            // Запись накопленных данных
            bos.write(baos.toByteArray(), 0, baos.size());
        }
    }
}

import java.io.*;

public class Task050626 {
    public static void main(String[] args) throws IOException {
        try (FileOutputStream fos = new FileOutputStream("data.bin")) {
            fos.write(300);
        }
        try (FileInputStream fis = new FileInputStream("data.bin")) {
            System.out.println(fis.read());
        }
    }
}