☕ Вопросы интервью по Java

Ответ: Wrapper Class — это класс, который преобразует примитивный тип данных в объект и наоборот. Это позволяет использовать примитивные значения там, где требуются объекты, например в Collections и generic классах.

// Примитивный тип
int a = 5;

// Wrapper класс
Integer obj = new Integer(5);
// или через autoboxing:
Integer obj = 5;

// Распаковка (unboxing)
int value = obj;
                

Ответ: Wrapper classes — это объектные классы, которые инкапсулируют примитивные типы данных. Они нужны по нескольким причинам:

• Wrapper classes являются final и immutable: Их значения не могут быть изменены после создания
• Предоставляют методы: Методы как valueOf(), parseInt() для преобразований
• Поддержка autoboxing и unboxing: Автоматическое преобразование между примитивами и объектами
• Использование в Collections: Collections (ArrayList, HashMap) могут хранить только объекты, не примитивы
• Использование в Generics: Generic классы требуют объектов, а не примитивных типов

// Collections требуют объектов
List<Integer> numbers = new ArrayList<>();
numbers.add(10);      // autoboxing
numbers.add(20);      // autoboxing

// Без wrapper classes это было бы невозможно
// List<int> numbers = new ArrayList<>();  // Ошибка!
                

Ответ: Instance и local переменные — это два разных типа переменных в Java с важными отличиями:

public class MyClass {
    int instanceVar;      // Instance variable (по умолчанию 0)
    
    public void myMethod() {
        int localVar;     // Local variable (нет значения по умолчанию)
        // System.out.println(localVar);  // Ошибка! не инициализирована
        
        localVar = 10;    // Теперь инициализирована
        System.out.println(localVar);  // OK
    }
}
                

Ответ: Когда instance переменные не инициализируются, компилятор инициализирует их значениями по умолчанию. Значения зависят от типа данных:

public class DefaultValues {
    static byte b;
    static int i;
    static long l;
    static boolean bool;
    static String str;
    static Object obj;
    
    public static void main(String[] args) {
        System.out.println("byte: " + b);          // 0
        System.out.println("int: " + i);           // 0
        System.out.println("long: " + l);          // 0
        System.out.println("boolean: " + bool);    // false
        System.out.println("String: " + str);      // null
        System.out.println("Object: " + obj);      // null
    }
}
                

Ответ: Class Variable (также известна как static variable) — это переменная, объявленная внутри класса с использованием static ключевого слова. Она принадлежит самому классу, а не отдельным объектам.

• Объявляется с static ключевым словом внутри класса, но вне методов
• Существует только одна копия, независимо от количества созданных объектов
• Может быть доступна через имя класса без создания объекта
• Инициализируется один раз при загрузке класса

public class Counter {
    public static int count = 0;  // Class variable
    
    public Counter() {
        count++;  // Увеличивается для каждого нового объекта
    }
    
    public static void main(String[] args) {
        Counter obj1 = new Counter();
        Counter obj2 = new Counter();
        Counter obj3 = new Counter();
        
        System.out.println("Создано объектов: " + Counter.count);  // 3
        // Доступ через имя класса, а не через объект!
    }
}
                

Ответ: Local variables НЕ имеют значения по умолчанию. Примитивные переменные и объекты не получают никаких значений по умолчанию.

• Local переменные должны быть инициализированы перед использованием
• Использование неинициализированной local переменной приведёт к ошибке компиляции
• В отличие от instance переменных, local переменные не получают автоматическое значение

public class LocalVarExample {
    public static void main(String[] args) {
        int x;  // Local variable, нет значения по умолчанию
        
        // System.out.println(x);  // Ошибка компиляции!
        // "variable x might not have been initialized"
        
        x = 10;  // Теперь инициализирована
        System.out.println(x);  // OK, выводит 10
    }
}
                

Ответ: Instance и class переменные — это два разных типа переменных в классе с различным назначением:

public class Car {
    int speed;              // Instance variable
    static int totalCars;   // Class variable
    
    public Car() {
        totalCars++;
    }
}

public class Main {
    public static void main(String[] args) {
        Car car1 = new Car();
        car1.speed = 100;
        
        Car car2 = new Car();
        car2.speed = 120;
        
        // Instance variables разные для каждого объекта
        System.out.println("car1.speed: " + car1.speed);  // 100
        System.out.println("car2.speed: " + car2.speed);  // 120
        
        // Class variable одна на всех
        System.out.println("Всего машин: " + Car.totalCars);  // 2
    }
}
                

Ответ: Static variable (static ключевое слово) используется для общего доступа к одной переменной или методу в данном классе. Static переменные — это переменные, которые один раз объявлены и одна копия переменной создаётся и общая для всех объектов.

• Когда переменная объявлена как static, одна копия существует независимо от количества объектов
• Static переменная инициализируется только один раз, при загрузке класса
• Все объекты класса общают одну и ту же static переменную
• Static переменные могут быть доступны непосредственно из класса

public class Student {
    String name;           // Instance variable
    static int totalStudents; // Static variable
    
    public Student(String name) {
        this.name = name;
        totalStudents++;   // Увеличивается для каждого студента
    }
}

public class Main {
    public static void main(String[] args) {
        Student s1 = new Student("Alice");
        Student s2 = new Student("Bob");
        Student s3 = new Student("Charlie");
        
        System.out.println("Всего студентов: " + Student.totalStudents);  // 3
    }
}
                

Ответ: System.out, System.err и System.in — это три стандартных потока ввода-вывода, предоставляемые Java:

• System.out выводит в стандартный output консоли (обычно чёрный текст)
• System.err выводит в стандартный error поток (обычно красный текст в IDE)
• Оба используют PrintStream, но System.err используется для ошибок
• Оба выводят на консоль, но могут быть перенаправлены отдельно

import java.util.Scanner;

public class InputExample {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        
        System.out.print("Введите число: ");
        int num = sc.nextInt();
        
        System.out.println("Вы ввели: " + num);
    }
}
                

Ответ: IO (Input/Output) Stream в Java — это поток данных между программой и внешним источником или пунктом назначения, таким как файл, клавиатура, сеть или другая программа. Потоки предоставляют способ чтения данных из входного источника и записи данных в выходное назначение.

• Input Streams: Используются для чтения данных из источника (файл, клавиатура, сеть)
• Output Streams: Используются для написания данных в пункт назначения (файл, консоль, сеть)

• Java предоставляет классы в пакете java.io для эффективной обработки операций ввода-вывода
• Существуют byte streams (для бинарных данных) и character streams (для текстовых данных)
• Все byte input streams наследуются от класса InputStream
• Все byte output streams наследуются от класса OutputStream

import java.io.FileInputStream;
import java.io.IOException;

public class StreamExample {
    public static void main(String[] args) {
        try {
            // Создание input stream для чтения файла
            FileInputStream fis = new FileInputStream("file.txt");
            
            int data;
            while ((data = fis.read()) != -1) {
                System.out.print((char) data);
            }
            
            fis.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}