Неконтролируемые исключения unchecked обрабатывают ошибки

Экзаменационные вопросы по предмету «Программирование на языке Джава»

Если вы хотите помочь с заполнением вопросов или исправить ошибку, то создайте issue или pull request. Спасибо!

Тема 1. Особенности платформы Java. Синтаксис языка Java

1. К какому типу языков относится язык Джава

Java — строго типизированный объектно-ориентированный язык программирования общего назначения, разработанный компанией Sun Microsystems (в последующем приобретённой компанией Oracle). Разработка ведётся сообществом, организованным через Java Community Process; язык и основные реализующие его технологии распространяются по лицензии GPL. Права на торговую марку принадлежат корпорации Oracle.

Приложения Java обычно транслируются в специальный байт-код, поэтому они могут работать на любой компьютерной архитектуре, для которой существует реализация виртуальной Java-машины. Дата официального выпуска — 23 мая 1995 года. Занимает высокие места в рейтингах популярности языков программирования (2-е место в рейтингах IEEE Spectrum (2020) и TIOBE (2021)).

2. Особенности языка Джава

Некоторые из ключевых особенностей языка программирования Java:

• Объектно-ориентированность: Java является объектно-ориентированным языком, что означает, что он позволяет разработчикам определять объекты и манипулировать ими в своем коде.

• Независимость от платформы: Java-программы компилируются в байт-код, который можно запускать на любом устройстве, на котором установлена виртуальная машина Java (JVM). Это означает, что программы Java являются переносимыми, то есть их можно запускать на любом устройстве, поддерживающем Java, независимо от используемого оборудования и операционной системы.

• Многопоточность: Java позволяет разработчикам создавать многопоточные программы, что означает, что программа может выполнять несколько задач одновременно. Это полезно для разработки программ, которые должны выполнять несколько задач одновременно, например веб-серверов, которым необходимо обрабатывать несколько запросов одновременно.

• Надежность: Java обладает рядом функций, которые делают его надежным языком, включая механизм сборки мусора, который автоматически освобождает память, используемую объектами, которые больше не нужны, и строгую систему типов, помогающую предотвратить распространенные ошибки программирования.

• Безопасность: Java имеет встроенную поддержку функций безопасности, таких как возможность цифровой подписи и проверки кода, а также возможность шифрования и расшифровки данных.

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

• Широкое использование: Java является одним из самых популярных языков программирования в мире и используется для разработки широкого спектра приложений, включая веб-приложения, мобильные приложения, настольные приложения и серверные приложения.

3. Класс Scanner и его использование для чтения стандартного потока ввода

Класс Scanner — это класс Java, который используется для чтения входных данных из различных источников, таких как файлы, сетевые сокеты и стандартный поток ввода (stdin). Он является частью пакета java.util и может использоваться для чтения входных данных различных типов, таких как целые числа, двойные числа, строки и логические значения.

Чтобы использовать класс Scanner для чтения ввода из стандартного потока ввода, вы можете создать новый объект Scanner и передать стандартный поток ввода (System.in) в качестве аргумента конструктору. Например:

Scanner scanner = new Scanner(System.in);

После того, как вы создали объект Scanner, вы можно использовать его различные методы для чтения ввода из стандартного потока ввода. Например, чтобы прочитать целое число из стандартного потока ввода, вы можно использовать метод nextInt():

int i = scanner.nextInt();

Чтобы прочитать двойное число, вы можно использовать метод nextDouble():

double d = scanner.nextDouble();

Чтобы прочитать строку, вы можно использовать метод nextLine():

String s = scanner.nextLine();

Также можно передать объект File, URL-адрес или строку, содержащую входные данные, конструктору сканера для чтения входных данных из этих источников. Например, чтобы прочитать ввод из файла, можно сделать что-то вроде этого:

File file = new File("input.txt");
Scanner scanner = new Scanner(file);

Или, чтобы прочитать ввод с URL-адреса, можно сделать это:

URL url = new URL("http://www.example.com");
Scanner scanner = new Scanner(url.openStream());

Также можно использовать метод hasNext(), чтобы проверить, доступны ли дополнительные данные для чтения, и метод close(), чтобы закрыть Scanner и освободить все используемые им ресурсы.

Вот пример того, как можно использовать класс Scanner для чтения ряда целых чисел из стандартного потока ввода и вывода их суммы:

int sum = 0;
while (scanner.hasNextInt()) {
    int n = scanner.nextInt();
    sum += n;
}
System.out.println("Sum: " + sum);
scanner.close();

4. Класс Scanner, конструктор класса Scanner для чтения стандартного потока ввода

Дубликат вопроса 3.

5. Методы класса Scanner nextLine(), nextInt(), hasNextInt(), hasNextLine() и их использование для чтения ввода пользователя с клавиатуры

Можно использовать его различные методы для чтения ввода от пользователя. Вот некоторые распространенные методы класса Scanner и то, как их можно использовать для чтения ввода от пользователя:

• nextLine(): считывает строку ввода (то есть строку, которая заканчивается символом новой строки) от пользователя.

• nextInt(): считывает целое число от пользователя.

• hasNextInt(): возвращает true, если есть целое число, доступное для чтения, и false в противном случае.

• hasNextLine(): возвращает true, если есть строка ввода, доступная для чтения, и false в противном случае.

6. Примитивные типы данных, объявление и присваивание переменных

В Java примитивный тип данных — это базовый тип данных, встроенный в язык и представляющий одно значение. В Java существует восемь примитивных типов данных:

• boolean: логическое значение. Может быть либо true, либо false.
• char: символьное значение. это один символ, например «a» или «1».
• byte: значение с плавающей запятой, представляющее собой 8-битное целое число со знаком (от -128 до 127).
• short: целочисленное значение, представляющее собой 16-разрядное целое число со знаком (от -32 768 до 32 767).
• int: целочисленное значение, представляющее собой 32-разрядное целое число со знаком (от -2 147 483 648 до 2 147 483 647).
• long: целочисленное значение, представляющее собой 64-битное целое число со знаком (от -9 223 372 036 854 775 808 до 9 223 372 036 854 775 807).
• float: значение с плавающей запятой, представляющее собой 32-разрядное число с плавающей запятой одинарной точности.
• double: значение с плавающей запятой, представляющее собой 64-разрядное число с плавающей запятой двойной точности.

Чтобы объявить переменную в Java, вам нужно указать тип данных переменной и имя для переменной. Например:

Это объявляет две переменные, x и y, типа int и double соответственно.

Чтобы присвоить значение переменной, можно использовать оператор присваивания (=). Например:

int x = 5;
double y = 3.14;

Это присваивает значение 5 переменной x и значение 3,14 переменной y.

Важно отметить, что нельзя изменить тип данных переменной после ее объявления. Например, если вы объявите переменную типа int, вы не сможете впоследствии присвоить ей double значение.

7. Условные операторы, полное и неполное ветвление в Джава, синтаксис

В Java можно использовать условные операторы для выполнения ветвления, что означает выполнение различных блоков кода в зависимости от значения определенных условий.

В Java есть три основных типа условных операторов:

• Оператор if. Оператор if позволяет выполнить блок кода, если выполняется определенное условие. Например:

if (x > 0) {
    System.out.println("x is positive");
}

• Оператор if-else. Оператор if-else позволяет выполнять один блок кода, если определенное условие истинно, и другой блок кода, если условие ложно. Например:

if (x > 0) {
    System.out.println("x is positive");
} else {
    System.out.println("x is not positive");
}

• Оператор switch: оператор switch позволяет выполнять другой блок кода на основе значения переменной или выражения. Например:

switch (x) {
    case 1:
        System.out.println("x is 1");
        break;
    case 2:
        System.out.println("x is 2");
        break;
    default:
        System.out.println("x is something else");
        break;
}

Также можно использовать условный оператор (также известный как тернарный оператор) для выполнения простого ветвления в одной строке кода. Синтаксис условного оператора следующий:

условие? значение_если_истина : значение_если_ложь

Например:

int y = (x > 0) ? 1 : -1;

8. Оператор множественного выбора в Джава, синтаксис

Можно использовать оператор switch для выполнения нескольких ветвлений на основе значения переменной или выражения. Синтаксис оператора switch следующий:

switch (expression) {
    case value1:
        // code to execute if expression equals value1
        break;
    case value2:
        // code to execute if expression equals value2
        break;
    // ...
    default:
        // code to execute if expression does not match any of the case values
        break;
}

Необходмо обратить внимание, что каждый case в операторе switch должен завершаться оператором break, что приводит к выходу потока управления из оператора switch. Если опустить оператор break, поток управления продолжится до следующего случая, что может привести к непредвиденным последствиям.

9. Класс System. Работа со стандартами потоками вывода

Класс System — это встроенный класс Java, предоставляющий доступ к различным функциям и переменным системного уровня. Одной из функций, предоставляемых классом System, является возможность работы со стандартным потоком вывода, представляющим собой поток, который используется для вывода данных на консоль или в окно терминала.

Для вывода данных в стандартный поток вывода в Java можно использовать статический метод println() объекта System.out. Этот метод принимает один аргумент, то есть данные, которые вы хотите вывести, и выводит данные на консоль, за которыми следует символ новой строки.

Например, чтобы вывести строку «Hello, world!» в консоль можно использовать следующий код:

System.out.println("Hello, world!");

Также можно использовать статический метод print() объекта System.out для вывода данных в стандартный поток вывода без символа новой строки. Например:

System.out.print("Hello, ");
System.out.print("world!");

В дополнение к методам println() и print() объект System.out предоставляет несколько других методов для вывода данных в стандартный поток вывода, например, printf() для форматированного вывода и write() для записи необработанных байтов.

Метод printf() — это метод класса PrintStream (который является суперклассом объекта System.out), который используется для вывода форматированной строки в стандартный поток вывода. Он принимает строку формата и список аргументов и заменяет заполнители в строке формата соответствующими аргументами.

Вот пример того, как можно использовать метод printf() для вывода форматированной строки на консоль:

Метод write(), с другой стороны, является методом класса OutputStream (который является суперклассом класса PrintStream), который используется для записи для записи одиночных байтов или массива байтов в стандартный поток вывода. Он принимает массив байтов в качестве аргумента и записывает байты в поток.

byte[] data = {0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x2c, 0x20, 0x77, 0x6f, 0x72, 0x6c, 0x64, 0x21};
System.out.write(data);

Вот пример того, как вы можете использовать метод write() для вывода массива байтов на консоль:

int x = 10;
double y = 3.14;
System.out.printf("x is %d and y is %fn", x, y);

Этот код выведет строку «Hello, world!» к консоли. Массив байтов содержит коды ASCII для символов в строке, а метод write() записывает байты в стандартный поток вывода.

Метод write() не добавляет автоматически символ новой строки, поэтому вам нужно использовать отдельный вызов println(), если вы хотите включить новую строку в свой вывод.

10. Перегруженные методы out.println() класса System и их использование для вывода в консоль

Метод println() объекта System.out является перегруженным методом, что означает, что он имеет несколько версий, которые принимают различные типы аргументов. Различные версии метода println() позволяют вам выводить на консоль различные типы данных удобным и простым способом.

Вот список различных версий метода println() вместе с типами аргументов, которые они принимают, и соответствующим выводом, который они производят:

• println(boolean x): принимает логическое значение и выводит либо «true», либо «false».
• println(char x): принимает значение char и выводит символ,.
• println(int x): принимает значение int и выводит целое число.
• println(long x): принимает long значение и выводит целое число.
• println(float x): принимает значение с плавающей запятой и выводит число с плавающей запятой.
• println(double x): принимает значение с плавающей запятой и выводит число с плавающей запятой.
• println(char[] x): принимает массив значений char и выводит символы в массиве. В качестве типа массива можно использовать и другие типы.
• println(String x): принимает значение String и выводит строку.
• println(Object x): принимает любой объект и выводит результат вызова метода объекта toString().

11. Константы в Джава: объявление константы

В Java вы можете объявить константу, используя ключевое слово final. Константа — это значение, которое нельзя изменить после его инициализации.

Чтобы объявить константу в Java, вы можете использовать следующий синтаксис:

Также можно использовать ключевые слова static и final вместе, чтобы объявить константу, которая является переменной класса (т. е. переменной, которая является общей для всех экземпляров класса). Например:

public class MyClass {
    static final double PI = 3.14159;
    // ...
}

Константы должны быть инициализированы значением при их объявлении. Нельзя объявить константу и оставить ее неинициализированной.

12. В результате выполнения этой строчки

???

13. Объявление и использование бестиповых переменных в Джава

В Java нет концепции нетипизированных переменных. Все переменные в Java должны иметь определенный тип, который определяет значения, которые может содержать переменная, и операции, которые можно с ней выполнять.

Однако в Java есть тип Object, который можно использовать для хранения ссылки на любой объект. Тип Object является корнем иерархии классов в Java, и все классы являются подклассами Object.

Пример объявления:

Можно присвоить любой объект этой переменной, например:

obj = "Hello, world!"; // assign a String object to obj
obj = 123; // assign an Integer object to obj

Необходимо обратить внимание, что когда присваивается примитивное значение (например, int или double) переменной Object, это значение автоматически помещается в объект соответствующего класса-оболочки (например, Integer или Double). Это известно как Автобоксинг.

Чтобы получить доступ к значению, хранящемуся в переменной типа Object, необходимо привести его к соответствующему типу, а затем использовать соответствующие методы для извлечения значения. Например:

String str = (String) obj; // cast obj to a String and assign it to str
int x = ((Integer) obj).intValue(); // cast obj to an Integer and extract the int value

Важно быть осторожным при работе с нетипизированными переменными, так как они могут привести к ошибкам во время выполнения, если попытаться использовать их способом, несовместимым с их фактическим типом.

Как правило, рекомендуется использовать типизированные переменные, когда это возможно, так как они могут помочь предотвратить ошибки и сделать ваш код более понятным. Однако бывают ситуации, когда нетипизированные переменные могут быть полезны, например, когда вам нужно записать значение типа, неизвестного во время компиляции.

14. Объявление переменных и инициализация типа класс

Чтобы инициализировать переменную типа класса (т. е. переменную, которая содержит ссылку на объект), можно использовать оператор new для создания экземпляра класса и присвоения ссылки переменной.

Например:

String str = new String("Hello, world!");

Также можно использовать оператор new для создания экземпляра класса с конструктором, принимающим аргументы. Например:

public class MyClass {
    private int x;
    private int y;
    public MyClass(int x, int y) {
        this.x = x;
        this.y = y;
    }
}

Чтобы создать экземпляр MyClass и инициализировать его значениями 10 и 20, используем следующий код:

MyClass obj = new MyClass(10, 20);

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

Важно отметить, что необходимо инициализировать переменную типа класса, прежде чем использовать.

15. Арифметические операции, операции инкремента и декремента в Джава

В Java можно выполнять арифметические операции, используя стандартные арифметические операторы: + для сложения, - для вычитания, * для умножения, / для деления и % (остаток от деления).

Вы также можете использовать операторы ++ и -- для инкремента и декремента. Например:

int x = 10;
x++; // x will be 11
x--; // x will be 10 again

Операторы ++ и -- могут использоваться как префиксные операторы (например, ++x) или постфиксные операторы (например, x++). При использовании в качестве префиксного оператора инкремент или декремент применяется до того, как значение переменной будет использовано в выражении. При использовании в качестве постфиксного оператора инкремент или декремент применяется после того, как значение переменной используется в выражении.

int x = 10;
int y = ++x; // y will be 11, x will be 11
int z = x++; // z will be 11, x will be 12

Важно отметить, что операторы ++ и — имеют более высокий приоритет, чем арифметические операторы. Например:

int x = 10;
int y = 20;
int z = x++ * y; // z will be 200, x will be 11 

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

16. В результате выполнения фрагмента программы

???

17. Арифметические операции, приоритет выполнения операций

Список приоритетов арифметических операторов в Java, от высшего к низшему:

• ++, — (префикс инкремента и декремента)
• ! (логическое НЕ)
• *, / % (умножение, деление и остаток от деления)
• +, — (сложение и вычитание)
• <=, <, > и >= (операторы сравнения)
• ==, != (операторы равенства)
• && (логическое И)
• || (логическое ИЛИ)

18. Типы данных в языке Джава, классификация, примеры

В Java типы данных делят на две большие группы: примитивные и ссылочные. В состав примитивных типов (или просто примитивов) входят четыре подвида и восемь типов данных:

• целые числа (byte, short, int, long);

• числа с плавающей точкой (float, double);

• логический (boolean);

• символьный (char).

Ссылочные типы данных ещё называют ссылками. К ним относятся все классы, интерфейсы, массивы, а также тип данных String.

Хотя у примитивов и ссылок много общего, между ними есть существенные различия. И главное различие — в том, что именно в них хранится.

19. Массивы в Джава, объявление и инициализация массивов, длина массива, получение доступа к элементу массива

В Java массив представляет собой набор фиксированного размера элементов одного и того же типа данных. Вы можете объявить массив, указав тип данных элементов и имя массива, за которыми следуют квадратные скобки []. Например:

Инициалия массива означает создание массива определенного размера и заполнение его значениями по умолчанию (0 для числовых типов, false для логических и null для ссылочных типов). Можно инициализировать массив с помощью оператора new и указать размер массива в квадратных скобках []. Например:

int[] numbers = new int[10];

Также можно инициализировать массив определенными значениями, используя инициализатор массива. Инициализатор массива представляет собой список значений, заключенных в фигурные скобки {}.

int[] numbers = {1, 2, 3};

Важно отметить, что можно получать доступ только к элементам массива, которые находятся в пределах границ массива. Если вы попытаетесь получить доступ к элементу с отрицательным индексом или большим или равным размеру массива, вы вызовете исключение ArrayIndexOutOfBoundsException.

Вы можете использовать длину массива, используя length.

Размер массива фиксирован и не может быть изменен после создания массива. Если необходимо хранить переменное количество элементов, можно использовать, например, arrayList или LinkedList.

20. Массивы в Джава, как объектные типы данных, контроль доступа за выход за границы массива

В Java массивы — это объектные типы данных, что означает, что массив является экземпляром класса Array. Это означает, что массивы обладают некоторыми характеристиками объектов, такими как способность иметь поля (переменные) и методы (функции).

Одним из полей класса Array является поле length, которое содержит размер массива. Оно является константным полем, что означает, что оно не может быть изменено после инициализации массива.

Важно отметить, что можно получать доступ только к элементам массива, которые находятся в пределах границ массива. Если вы попытаетесь получить доступ к элементу с отрицательным индексом или большим или равным размеру массива, вы вызовете исключение ArrayIndexOutOfBoundsException.

Чтобы предотвратить это исключение, можно использовать поле length, чтобы проверить, находится ли индекс в пределах границ массива перед доступом к элементу. Например:

int[] numbers = {1, 2, 3};
int index = 5;
if (index >= 0 && index < numbers.length) {
    int element = numbers[index];
    System.out.println(element);
} else {
    System.out.println("Index out of bounds");
}

21. Операции над массивами, просмотр элементов массива, поиск по образцу, сортировка массива, сумма элементов массива

Чтобы просмотреть элементы массива, вы можете использовать цикл для перебора элементов массива. Например:

int[] numbers = {1, 2, 3, 4, 5};
for (int i = 0; i < numbers.length; i++) {
    int element = numbers[i];
    System.out.println(element);
}

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

int[] numbers = {1, 2, 3, 4, 5};
int target = 3;
for (int i = 0; i < numbers.length; i++) {
    if (numbers[i] == target) {
        System.out.println("Found at index " + i);
        break;
    }
}

Для сортировки массива можно использовать один из алгоритмов сортировки, предоставляемых стандартной библиотекой Java, например Arrays.sort(). Например:

int[] numbers = {4, 3, 2, 1, 5};
Arrays.sort(numbers);

Чтобы вычислить сумму элементов массива, вы можете использовать цикл для перебора элементов массива и добавления их к промежуточной сумме. Например:

int[] numbers = {1, 2, 3, 4, 5};
int sum = 0;
for (int i = 0; i < numbers.length; i++) {
    sum += numbers[i];
}
System.out.println("Sum: " + sum);

22. В результате выполнения фрагмента программы

???

23. Операция конкатенации строк в Джава, ее обозначение и использование и ее использование

В Java оператор + используется для конкатенации (объединения) строк. Например:

String s1 = "Hello";
String s2 = "World";
String s3 = s1 + " " + s2; // s3 = "Hello World"

Также можно использовать оператор + для объединения строки с нестроковым значением. В этом случае нестроковое значение будет преобразовано в строку с помощью метода toString().

int i = 123;
String s = "The value is " + i; // s = "The value is 123"

Важно отметить, что конкатенация строк является относительно дорогостоящей операцией, поскольку она включает в себя создание нового строкового объекта и копирование в него содержимого старых строк. Если вам нужно объединить большое количество строк, как правило, более эффективно использовать StringBuilder или StringBuffer.

Например, чтобы объединить большое количество строк с помощью StringBuilder, вы можете использовать метод append():

StringBuilder sb = new StringBuilder();
for (int i = 0; i < 1000; i++) {
    sb.append("x");
}
String s = sb.toString();

StringBuilder и StringBuffer похожи на String, но они изменяемы, что означает, что вы можете изменять их содержимое, не создавая новый объект. Это делает их более эффективными для объединения строк, поскольку они позволяют избежать расходов на создание новых объектов для каждого объединения.

24. Циклы в Джава, цикл с предусловием, цикл с постусловием, пример записи и использование. Условие окончания цикла

Цикл while — это цикл с предусловием, то есть условие цикла проверяется до выполнения тела цикла. Цикл while имеет следующий синтаксис:

while (condition) {
// loop body
}

Цикл do while похож на цикл while, но условие проверяется после выполнения тела цикла. Цикл do while имеет следующий синтаксис:

do {
    // loop body
} while (condition);

25. Циклы в Джава, итерационный цикл for(), синтаксис, счетчик цикла, условие окончания цикла, модификация счетчика, пример использования

Цикл for — это цикл с счетчиком. Цикл for имеет следующий синтаксис:

for (initialization; condition; iteration) {
    // loop body
}

Счетчик цикла инициализируетася перед выполнением цикла.

Условие окончания цикла проверяеттся перед каждой итерацией цикла. Если условие истинно, цикл продолжается; в противном случае цикл завершается.

Модификатор счетчика выполняется после каждой итерации цикла. Обычно он используется для обновления переменной цикла.

Пример использования:

for (int i = 1; i <= 10; i++) {
    System.out.println(i);
}

26. Способы объявления массивов в Джава, использование операции new для выделения памяти для элементов массива. Объявление с инициализацией, объявление массива определенного размера без инициализации

Дубликат 19 вопроса

Тема 2. Реализация ООП в Java

27. Объявление класса на Джава, пример объявления

В Java класс — это шаблон для создания объектов. Класс определяет данные и поведение (методы) типа объекта.

Чтобы объявить класс в Java, используется ключевое слово class, за которым следует имя класса. Тело класса заключено в фигурные скобки {}.

class MyClass {
    // class body
}

28. Использования this для доступа к компонентам класса

Иногда требуется, чтобы метод ссылался на вызвавший его объект. Ключевое слово this в Java используется в теле любого метода для ссылки на текущий объект.

class Point {
    private double x;
    private double y;
    void setLocation(double x, double y) {
        this.x = x; // refers to the "x" field of the current object
        this.y = y; // refers to the "y" field of the current object
    }
}

29. Создание или инстанцирование объектов типа класс

В Java вы можете создавать экземпляры (объекты) класса с помощью оператора new.

Например, рассмотрим следующий класс:

class Point {
    double x;
    double y;
}

Чтобы создать объект типа Point, можно использовать следующий код:

Можно инициализировать поля следующим образом:

Кроме того, можно инициализировать поля, заключив значения в фигурные скобки {}.

Point p = new Point { x = 3, y = 4 };

Когда создается объект с помощью оператора new, вызывается конструктор для данного объекта.

30. Что такое класс в Java?

Класс в Java — это шаблон для создания объекта, а объект — это экземпляр класса. Класс определяет структуру и поведение, которые будут совместно использоваться набором объектов. Класс содержит переменные и методы, которые называются элементами класса, членами класса.

31. Модификатор доступа или видимости в Джава, виды и использование

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

В Java используются следующие модификаторы доступа:

• public: публичный, общедоступный класс или член класса. Поля и методы, объявленные с модификатором public, видны другим классам из текущего пакета и из внешних пакетов.
• private: закрытый класс или член класса, противоположность модификатору public. Закрытый класс или член класса доступен только из кода в том же классе.
• protected: такой класс или член класса доступен из любого места в текущем классе или пакете или в производных классах, даже если они находятся в других пакетах
• Модификатор по умолчанию. Отсутствие модификатора у поля или метода класса предполагает применение к нему модификатора по умолчанию. Такие поля или методы видны всем классам в текущем пакете.

32. Чем отличаются static-метод класса от обычного метода класса

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

Обычный (нестатический) метод — это метод, связанный с экземпляром (объектом) класса. Обычный метод может быть вызван для объекта класса и может получить доступ к полям и методам объекта.

Методы с модификатором static не могут использовать ключевое слово this

33. Для чего используется оператор new?

Дубликат 29 вопроса

34. Можно ли вызвать static-метод внутри обычного метода?

Да, статический метод можно вызвать из обычного (нестатического) метода в Java.

Чтобы вызвать статический метод из обычного метода, можно исполльзовать имя класса, за которым следует точка и имя метода. Например:

double distanceFromOrigin() {
    return Math.sqrt(x * x + y * y);
}

35. Как вызвать обычный метод класса внутри static-метода?

Чтобы вызвать обычный метод из статического метода, нужно создать объект класса и вызвать обычный метод для этого объекта. Например:

static double distanceFromOrigin(Point p) {
    double dx = p.x;
    double dy = p.y;
    return Math.sqrt(dx * dx + dy * dy);
}

36. Для чего используется в Джава ключевое слово this?

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

public class Point {
    private double x;
    private double y;

    public Point(double x, double y) {
        this.x = x;
        this.y = y;
    }
}

37. Объявление и использование методов, объявленных с модификатором public static

В Java метод, объявленный с модификатором public static, является методом, доступным из любой точки программы и связанным с классом, а не с объектом класса. Методы могут быть вызваны без создания объекта класса. Например:

public class Point {
    public static double square(double x) {
        return x * x;
    }
}

public class Main {
    public static void main(String[] args) {
        double x = 3.0;
        double y = Point.square(x);
        System.out.println(y);
    }
}

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

В Java методы — это блоки кода, которые выполняют определенные действия. Методы могут принимать аргументы и возвращать значение. Синтаксис объявления метода в Java следующий:

[модификаторы] тип_возвращаемого_значения имя_метода(формальные_параметры) {
    // тело метода
}

Здесь тип возвращаемого значения — это тип данных, который возвращает метод. Формальные параметры — это переменные, которые используются внутри метода. Аргументы — это значения, которые передаются в метод при его вызове.

39. Методы с пустым списком параметров

В Java методы могут быть объявлены с пустым списком параметров. В этом случае метод может быть вызван без передачи аргументов. Например:

Для объявления метода с пустым списком параметров используется следующий синтаксис:

[модификаторы] тип_возвращаемого_значения имя_метода() {
    // тело метода
}

Если перед вызовом метода передавать аргументы в метод, то компилятор выдаст ошибку.

40. Стандартные методы класса сеттеры и геттеры, синтаксис и их назначение?

Сеттеры и геттеры — это методы класса, которые используются для установки и получения значений полей класса.

Методы обычно используются для обеспечения контроля доступа к полям объекта, поскольку они позволяют указать, как можно получить доступ к полям и изменить их. Они также используются для проверки устанавливаемых или извлекаемых значений и для выполнения любых необходимых действий при изменении значений.

Сеттеры и геттеры обычно имеют следующий синтаксис:

[модификаторы] тип_возвращаемого_значения getИмя_поля() {
    // тело метода
}

[модификаторы] void setИмя_поля(тип_параметра имя_параметра) {
    // тело метода
}

41. Может ли быть поле данных класса объявлено как с модификатором static и final одновременно и что это означает?

Да, это возможно. Статическое поле данных — это поле данных, которое принадлежит классу, а не объекту. Статическое поле данных может быть объявлено как final, что означает, что его значение не может быть изменено после инициализации.

42. Методы класса конструкторы, синтаксис и назначение

Конструкторы — это методы класса, которые используются для инициализации объектов класса. Конструкторы имеют следующий синтаксис:

[модификаторы] Имя_класса([параметры]) {
    // тело метода
}

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

Конструкторы могут быть объявлены как public, private или protected.

Конструктор необязательно должен быть объявлен в классе. Если конструктор не объявлен в классе, то компилятор автоматически создает конструктор по умолчанию, который не имеет параметров и не выполняет никаких действий.

43. Может ли класс иметь в своем составе несколько конструкторов?

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

Пример:

class MyClass {
    int x;
    MyClass() {
        x = 10;
    }
    MyClass(int i) {
        x = i;
    }
}

44. Может ли конструктор класса возвращать значение?

Нет, конструктор класса не может возвращать значение. Конструктор класса используется для инициализации объектов класса. Конструктор класса не может возвращать значение, так как возвращаемое значение должно быть типа void.

Тема 3. Реализация наследования в программах на Джаве

45. Наследование в Джава. Вид наследования и синтаксис Ключевое слово extends

Наследование в Джава — это механизм, который позволяет создавать новые классы на основе уже существующих. Новый класс называется подклассом (дочерним классом, производным классом), а существующий класс называется суперклассом (родительским классом, базовым классом).

Ключевое слово extends используется для наследования класса. Оно указывает, что класс, который объявляется после ключевого слова extends, является суперклассом для класса, который объявляется до ключевого слова extends.

Существует несколько видов наследования:

• Одиночное наследование (single inheritance). При этом класс может наследовать только один суперкласс. Синтаксис:

class SubClass extends SuperClass {
    // тело класса
}

• Множественное наследование. В Java множественное наследование не поддерживается. Однако стоит упомянуть, что класс может реализовывать несколько интерфейсов.

• Иерархическое наследование. При этом класс может наследовать суперкласс, который в свою очередь может наследовать другой суперкласс и т.д. Синтаксис:

class SubClass extends SuperClass {
    // тело класса
}
class SubSubClass extends SubClass {
    // тело класса
}

46. Что означает перегрузка метода в Java (overload)?

Перегрузка метода — это возможность создавать несколько методов с одинаковым именем, но с разными параметрами. При этом каждый метод должен иметь уникальный набор параметров. При вызове метода компилятор выбирает метод, который соответствует переданным параметрам.

Пример:

public class calc {
    public int add(int a, int b) {
        return a + b;
    }
    public int add(int a, int b, int c) {
        return a + b + c;
    }
    public double add(double a, double b) {
        return a + b;
    }
}

Перегрузка методов — полезная возможность, поскольку он позволяет повторно использовать одно и то же имя метода для разных целей.

Однако стоит упомянуть, что перегрузка методов не всегда является хорошей практикой. Например, если методы имеют одинаковые названия, но разные параметры, то это может привести к путанице. Поэтому стоит использовать перегрузку методов только в тех случаях, когда это действительно необходимо.

Также перегрузка не является полной заменой переопределения методов. Перегрузка методов используется для создания различных вариантов одного и того же метода, а переопределение методов используется для изменения поведения метода в подклассе.

47. Что означает переопределение метода в Java (override)?

Переопределение метода — это возможность создавать методы с одинаковым именем и параметрами, но с разным телом. При этом методы должны быть объявлены в одном классе, но в разных подклассах.

Пример:

public class calc {
    public int add(int a, int b) {
        return a + b;
    }
}
public class calc2 extends calc {
    @override
    public int add(int a, int b) {
        return a + b + 1;
    }
}

Строка @override не является обязательной, но ее использование позволяет избежать ошибок при переопределении методов.

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

48. В чем разница между перегрузкой и переопределением методов, поясните

В Java перегрузка методов и переопределение методов — это две разные концепции, связанные со способностью иметь несколько методов с одним и тем же именем.

Перегрузка методов относится к способности класса иметь несколько методов с одним и тем же именем, но с разными списками параметров. Перегрузка метода — это способ предоставления нескольких реализаций метода в зависимости от количества и типа аргументов, переданных методу.

Переопределение метода относится к способности подкласса переопределять или переопределять метод, который он унаследовал от своего суперкласса. Переопределение метода позволяет подклассу предоставлять собственную реализацию метода, унаследованного от суперкласса, а также изменять или расширять поведение метода.

Вот основные различия между перегрузкой и переопределением методов в Java:

• Перегрузка основана на количестве и типе аргументов, переданных методу, а переопределение основано на сигнатуре метода. Сигнатура метода состоит из имени метода, количества и типа аргументов, а также порядка аргументов.
• Перегрузка происходит внутри одного класса, а переопределение происходит между суперклассом и подклассом. Перегрузка методов позволяет классу иметь несколько методов с одинаковыми именами, но с разными списками параметров в одном классе. Переопределение метода позволяет подклассу переопределить или переопределить метод, который он унаследовал от своего суперкласса.
• Перегрузка не связана с наследованием, а переопределение связано с наследованием. Перегрузка методов не требует наследования, так как происходит внутри одного класса. Переопределение метода включает в себя наследование, поскольку позволяет подклассу переопределять или переопределять метод, который он унаследовал от своего суперкласса.
• Перегрузка разрешается во время компиляции, а переопределение разрешается во время выполнения. Перегрузка метода разрешается во время компиляции на основе количества и типа аргументов, переданных методу. Компилятор Java определяет, какую перегруженную версию метода следует вызывать, на основе аргументов, переданных методу.

49. Абстрактные классы в Джава и абстрактные методы класса

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

Абстрактные методы — это методы, объявленные в абстрактном классе, но не имеющие реализации. Абстрактные методы используются для определения сигнатуры метода, но не реализации, и предназначены для реализации подклассами.

Абстрактные методы определяются с помощью ключевого слова abstract и не содержат тела метода. Абстрактные методы должны быть переопределены в подклассах, иначе подкласс должен быть объявлен абстрактным. Также абстрактные методы не могут быть объявлены как final, static или private.

Стоит отметить, что абстрактные классы могут содержать как абстрактные, так и конкретные методы. Конкретные методы — это методы, которые имеют реализацию. Конкретные методы могут быть объявлены как final, static или private, но не могут быть объявлены как abstract.

abstract class Shape {
    abstract void draw();
    void msg() {
        System.out.println("This is a shape");
    }
}

Чтобы использовать абстрактный класс, необходимо создать подкласс, который наследует абстрактный класс и реализует абстрактные методы. В приведенном ниже примере класс Rectangle наследует абстрактный класс Shape и реализует абстрактный метод draw():

class Rectangle extends Shape {
    void draw() {
        System.out.println("drawing rectangle");
    }
}

Абстрактные методы могут быть переопределены в подклассах, но не могут быть переопределены в классах, которые не являются подклассами абстрактного класса.

50. Виды наследования в Джава, использование интерфейсов для реализации наследования

В Джава существует следующие виды наследования:

• Одиночное наследование: при одиночном наследовании подкласс расширяет один суперкласс и наследует все свойства и методы суперкласса. Синтаксис одиночного наследования в Java следующий:

class Subclass-name extends Superclass-name {
   //methods and fields
}

• Множественное наследование: при множественном наследовании подкласс расширяет несколько суперклассов и наследует свойства и методы всех суперклассов. Множественное наследование напрямую не поддерживается в Java, так как это может привести к неоднозначности и сложности.

• Интерфейсное наследование: при интерфейсном наследовании подкласс реализует один или несколько интерфейсов. Синтаксис интерфейсного наследования в Java следующий:

• иерархическое наследование: при иерархическом наследовании подкласс расширяет один суперкласс и наследует все свойства и методы суперкласса. Синтаксис иерархического наследования в Java следующий:

class Subclass-name extends Superclass-name {
   //methods and fields
}

class SubSubclass-name extends Subclass-name {
   //methods and fields
}

• Интерфейсное наследование: при интерфейсном наследовании подкласс реализует один или несколько интерфейсов. Синтаксис интерфейсного наследования в Java следующий:

class Subclass-name implements Interface-name, Interface-name, ... {
   //methods and fields
}

51. Что наследуется при реализации наследования в Джава (какие компоненты класса), а что нет?

При реализации наследования в Java подкласс наследует все поля и методы суперкласса, кроме приватных полей и методов. Подкласс также может расширять суперкласс, добавляя свои собственные поля и методы.

Подкласс не наследует закрытые поля и методы своего суперкласса, поскольку закрытые поля и методы недоступны за пределами класса, в котором они определены. Приватные поля и методы предназначены для использования только внутри класса, в котором они определены, и не предназначены для совместного использования с другими классами.

Подкласс также может определять свои собственные поля и методы, которые не наследуются от суперкласса. Эти поля будут недоступны в суперклассе.

Пример:

class A {
   int i; // this is public
   private int j; // this is private
   A(int i, int j) {
      this.i = i;
      this.j = j;
   }
}

class B extends A {
   int total;
   void sum() {
      this.total = i + j; // ERROR, j is not accessible here
   }
}

Как видно из примера, подкласс не может использовать закрытые поля и методы своего суперкласса. Подкласс может использовать только открытые поля и методы своего суперкласса.

Конструкторы не наследуются. Подкласс не наследует конструкторы своего суперкласса. Подкласс должен явно вызывать конструктор своего суперкласса, используя ключевое слово super, чтобы инициализировать суперкласс.

Пример:

class A {
   int i;
   A(int i) {
      this.i = i;
   }
}
Class B extends A {
   int j;
   B(int i, int j) {
      super(i);
      this.j = j;
   }
}

52. К каким методам и полям базового класса производный класс имеет доступ (даже если базовый класс находится в другом пакете), а каким нет? Область видимости полей и данных из производного класса

В Java существует 4 уровня доступа к полям и методам класса:

• public — доступно всем
• protected — доступно внутри пакета и в подклассах
• default — доступно внутри пакета
• private — доступно только внутри класса

Тема 4. Полиморфизм в Джава. Работа со строками. Интерфейсы

53. Объявление и инициализация переменных типа String

В Java существует 2 способа инициализации переменных типа String:

• прямая инициализация

Синтаксис:

Имя_переменной = "Значение";

• инициализация с помощью конструктора

Синтаксис:

Имя_переменной = new String("Значение");

Литералы хранятся в пуле строк, а переменные типа String — в куче. Поэтому, при присваивании литерала типа String переменной типа String, создается новый объект типа String.

Рассмотрим пример:

String s1 = "hello";
String s2 = "hello";
String s3 = new String("hello");

В данном примере, переменная s1 и литерал «hello» хранятся в пуле строк, а переменная s2 и литерал «hello» хранятся в куче. Поэтому, при сравнении переменных s1 и s2, результатом будет true, а при сравнении переменных s1 и s3, результатом будет false.

Для сравнения строк используется метод equals(), который возвращает true, если строки равны, и false, если строки не равны.

Синтаксис:

Имя_переменной_1.equals(Имя_переменной_2);

54. Операция конкатенации строк и ее использование

В Java вы можете использовать оператор «+» для конкатенации (объединения) двух или более строковых значений. Это называется операцией конкатенации строк.

Синтаксис:

Имя_переменной_1 + Имя_переменной_2;

Это создает новую строку с именем «результат», которая представляет собой конкатенацию строк «строка1» и «строка2».

Вы также можете использовать оператор «+» для объединения строковых значений с другими типами данных. Например, вы можете объединить строку с числом, результатом будет строка. Целое число будет преобразовано в строку, а затем объединено с другой строкой.

Пример:

String result = "строка1" + 2; // результатом будет строка "строка12"

Также можно использовать метод concat() для конкатенации строк. Этот метод возвращает новую строку, которая является результатом конкатенации двух строк. Данный метод не изменяет исходные строки. Он также определен в классе String.

Синтаксис:

Имя_переменной_1.concat(Имя_переменной_2);

Важно отметить, что операция конкатенации строк неэффективна, так как она создает новый строковый объект для каждой конкатенации. Если вам нужно объединить много строк, вместо этого рекомендуется использовать класс StringBuffer или StringBuilder.

55. Что означает утверждение, что объект класса String является неизменяемым

В Java объект класса «String» является неизменяемым, что означает, что его нельзя изменить после создания.

Неизменяемый объект — это объект, состояние которого нельзя изменить после его создания. Это означает, что после создания строкового объекта вы не можете изменить его значение или содержимое.

Например, рассмотрим следующий код:

String str = "строка";
str.toUpperCase();

В этом коде строка str инициализируется значением «Hello». Затем для строки str вызывается метод toUpperCase(), который преобразует строку в верхний регистр. Однако этот метод не изменяет строку str, поскольку она неизменяема.

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

String str = "строка";
String strUpper = str.toUpperCase();

Этот код создает новую строку с именем strUpper, которая является результатом применения метода toUpperCase() к строке str. Строка str остается неизменной.

Неизменяемый объект полезен во многих случаях, так как он гарантирует, что состояние объекта не может быть изменено по ошибке или другой частью кода. Это может помочь избежать ошибок и несоответствий в вашем коде.

Однако важно отметить, что неизменяемый объект — не всегда лучший выбор, поскольку в некоторых случаях он может быть неэффективным. Например, если вам нужно выполнить множество операций над строкой, например конкатенацию, более эффективно использовать изменяемый объект, такой как StringBuilder или StringBuffer, который можно изменить без создания нового объекта для каждой операции.

56. При создании объектов строк с помощью класса StringBuffer, например StringBuffer strBuffer = new StringBuffer(str) можно ли использовать операцию конкатенации строк или необходимо использовать методы класса StringBuffer

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

Класс StringBuffer — это изменяемая (модифицируемая) версия класса String, которая позволяет изменять строку без создания нового объекта для каждой операции.

Чтобы создать строковый объект с помощью класса StringBuffer, используйте следующий синтаксис:

StringBuffer имя_объекта = new StringBuffer(строка);

Чтобы объединить две строки с помощью класса StringBuffer, используйте метод append().

StringBuffer strBuffer = new StringBuffer("Hello");
strBuffer.append(" World");
System.out.println(strBuffer); // Hello World

57. Объявление и инициализация массива строк. Организация просмотра элементов массива

Для объявления массива строк используется следующий синтаксис:

String[] имя_массива = new String[количество_элементов];

Также можно объявить массив строк и сразу инициализировать его значениями:

String[] имя_массива = {"значение1", "значение2", "значение3"};

Для просмотра элементов массива используется цикл for-each (либо цикл for):

for (String str : имя_массива) {
    System.out.println(str);
}

Также можно использовать класс Arrays для просмотра элементов массива:

System.out.println(Arrays.toString(имя_массива));

В данном случае метод toString() возвращает строку, которая содержит все элементы массива, разделенные запятой.

58. Понятие и объявление интерфейсов в Джава

В Джава интерфейс — это абстрактный тип данных, который содержит только объявления методов, но не содержит реализацию этих методов. Интерфейсы используются для описания поведения класса, но не для реализации этого поведения.

Для объявления интерфейса используется следующий синтаксис:

interface Имя_интерфейса {
    // объявление методов
}

Для реализации интерфейса в классе используется следующий синтаксис:

class Имя_класса implements Имя_интерфейса {
    // реализация методов
}

Интерфейсы могут содержать константы, но не могут содержать переменные.

Рассмотрим пример объявления интерфейса и класса, который реализует этот интерфейс:

interface Shape {
    double PI = 3.14;
    void draw();
}

class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("Рисуем круг");
    }
}

public class Main {
    public static void main(String[] args) {
        Shape shape = new Circle();
        shape.draw();
    }
}

В данном примере интерфейс Shape содержит константу PI и метод draw(). Класс Circle реализует интерфейс Shape и реализует метод draw(). Также при создании объекта класса Circle мы можем использовать ссылку на интерфейс Shape, так как класс Circle реализует интерфейс Shape.

Интерфейс полезен во многих случаях, так как он позволяет определить набор поведений или функций, которые должен реализовать класс, не указывая, как эти поведения реализуются. Это позволяет вам создавать гибкий и многоразовый дизайн для вашего кода и применять один и тот же интерфейс к разным классам с разными реализациями.

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

interface Имя_интерфейса {
    static void имя_метода() {
        // тело метода
    }
}

60. Что входит в состав интерфейса. (какие компоненты может содержать интерфейс)?

Интерфейс может содержать следующие компоненты:

• Константы. Поля, объявленные в интерфейсе, должны быть инициализированы и являются константами. Эти константы не могут быть изменены в классе, который реализует интерфейс.

• Абстрактные методы (методы без реализации). Методы, объявленные в интерфейсе, должны быть абстрактными. Эти методы должны быть реализованы в классе, который реализует интерфейс.

• Методы по умолчанию (default methods). Методы, объявленные в интерфейсе, могут быть реализованы в интерфейсе. Эти методы могут быть переопределены в классе, который реализует интерфейс.

• Статические методы (static methods). Методы, объявленные в интерфейсе, могут быть реализованы в интерфейсе. Эти методы не могут быть переопределены в классе, который реализует интерфейс.

• Вложенные типы (nested types). Интерфейс может содержать вложенные типы, такие как классы, интерфейсы, перечисления и аннотации.

61. Может ли интерфейс наследоваться от другого интерфейса?

Да, интерфейс может наследоваться от другого интерфейса. Интерфейс может наследовать только интерфейсы, но не классы.

62. Интерфейс Camparable, назначение, его методы и использование в Джава

В Java интерфейс Comparable — это стандартный интерфейс, который определяет метод, называемый compareTo(), который позволяет сравнивать два объекта. Интерфейс Comparable является частью пакета «java.lang» и реализуется многими классами в библиотеке Java, такими как String, Integer или Double.

Интерфейс Comparable имеет следующий синтаксис:

public interface Comparable<T> {
    public int compareTo(T o);
}

Этот интерфейс объявляет один абстрактный метод с именем compareTo(), который принимает один аргумент типа T и возвращает значение int. Параметр типа T представляет тип сравниваемых объектов.

Чтобы реализовать Comparable интерфейс в классе, необходимо реализовать метод compareTo().

Если метод compareTo() возвращает положительное число, то первый объект больше второго объекта. Если метод compareTo() возвращает отрицательное число, то первый объект меньше второго объекта. Если метод compareTo() возвращает ноль, то объекты равны.

Пример:

public class Student implements Comparable<Student> {
    private String name;
    private int age;
    private int rollNo;
    private String className;
    // getters and setters
    @Override
    public int compareTo(Student student) {
        return (this.rollNo - student.rollNo);
    }
}

63. Какое значение возвращает вызов метода object1.compareTo(object2), который сравнивает 2 объекта obj1 и obj2 в зависимости от объектов?

Если объект obj1 больше объекта obj2, то метод compareTo() возвращает положительное число. Если объект obj1 меньше объекта obj2, то метод compareTo() возвращает отрицательное число. Если объект obj1 равен объекту obj2, то метод compareTo() возвращает ноль.

64. Интерфейсные ссылки и их использование в Джава

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

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

Например, рассмотрим следующее объявление ссылки на интерфейс:

Объявляется ссылочная переменная с именем «shape», которая может содержать ссылку на объект класса, реализующего интерфейс «Shape».

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

Например, рассмотрим следующий код:

Shape shape = new Circle();

Этот код создает новый объект класса Circle, который реализует интерфейс Shape, и присваивает его ссылке интерфейса Shape.

Ссылка на интерфейс полезна во многих случаях, поскольку позволяет получить доступ к методам интерфейса, не зная деталей реализации класса. Это позволяет вам создавать гибкий и многоразовый дизайн для вашего кода и применять один и тот же интерфейс к разным классам с разными реализациями.

Тема 5. Основные принципы и типы исключительных ситуаций

65. Понятие исключительной ситуации и ее обработка

В Java исключительная ситуация представляет собой событие, которое происходит во время выполнения программы и прерывает ее нормальное выполнение. Исключительная ситуация может быть вызвана ошибкой в программе, неправильным вводом данных или другими причинами.

В Java все исключения делятся на два основных типа: Error и Exception. Error используется для ошибок, которые не могут быть обработаны программой. Exception используется для ошибок, которые могут быть обработаны программой.

Чтобы обработать исключительную ситуацию, вы можете использовать оператор try-catch. Оператор try-catch позволяет вам определить блок кода, который может вызвать исключительную ситуацию, и блок кода, который будет выполнен, если исключительная ситуация произойдет.

Оператор try-catch имеет следующий синтаксис:

try {
// code that may throw an exception
} catch (ExceptionType1 ex1) {
// code to handle ExceptionType1
} catch (ExceptionType2 ex2) {
// code to handle ExceptionType2
} catch (ExceptionType3 ex3) {
// code to handle ExceptionType3
} finally {
// code to be executed regardless of whether an exception occurs
}

Блок try содержит код, который может вызвать исключительную ситуацию. Блок catch содержит код, который будет выполнен, если исключительная ситуация произойдет. Блок catch должен указывать тип исключительной ситуации, которую он обрабатывает. Если исключительная ситуация произойдет, то будет выполнен только один блок catch, который соответствует типу исключительной ситуации. finally блок содержит код, который будет выполнен независимо от того, произойдет ли исключительная ситуация или нет. Блок finally не является обязательным.

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

Чтобы обработать исключительную ситуацию, вы можете использовать оператор throw. Оператор throw позволяет вам создать исключительную ситуацию вручную. Оператор throw имеет следующий синтаксис:

throw new ExceptionType("message");

Чтобы обработать исключительную ситуацию, вы можете использовать оператор throws. Оператор throws позволяет вам указать, что метод может вызвать исключительную ситуацию. Оператор throws имеет следующий синтаксис:

public void method() throws ExceptionType1, ExceptionType2, ExceptionType3 {
// code that may throw an exception
}

Оператор throws указывает, что метод может вызвать исключительную ситуацию типа ExceptionType1, ExceptionType2 или ExceptionType3. Если метод вызовет исключительную ситуацию, то она будет передана вызывающему методу, который должен обработать ее.

Чтобы создать собственное исключение, вы можете создать класс, который наследуется от класса Exception. Класс Exception является базовым классом для всех исключений в Java. Класс Exception имеет следующий синтаксис:

public class ExceptionType extends Exception {
    // code
}

66. В каком случае программа должна использовать оператор throw?

В Java оператор throw необходимо использовать, чтобы выбросить исключение «вручную», чтобы сигнализировать об исключительной ситуации. Например, если метод должен вернуть значение, но в какой-то момент он не может вернуть значение, то он должен выбросить исключение, чтобы сигнализировать об этом.

Пример:

public int divide(int a, int b) {
    if (b == 0) {
        throw new ArithmeticException("Cannot divide by zero");
    }
    return a / b;
}

67. В Java все исключения делятся на два основных типа. Что это за типы и какие виды ошибок ни обрабатывают?

В Java исключения делятся на два основных типа: контролируемые и неконтролируемые:

• Контролируемые исключения (checked exceptions) — это исключения, которые должны быть обработаны в коде программы. Они проверяются компилятором или объявлены программистом. Контролируемые исключения наследуются от класса Exception, который наследуется от класса Throwable. Контролируемые исключения обрабатываются с помощью оператора try-catch или с помощью оператора throws в сигнатуре метода.

Синтаксис оператора try-catch:

try {
    // code
} catch (ExceptionType e) {
    // code
}

Cинтаксис оператора throws:

public void method() throws ExceptionType {
    throw new ExceptionType();
}

• Неконтролируемые исключения (unchecked exceptions) — это исключения, которые не проверяются на этапе компиляции и не требуют объявления программистом.

68. Код ниже вызовет ошибку: Exception <…> java. lang.ArrayIndexOutOfBoundsException: 4: Что она означает?

Сообщение об ошибке Exception <...> java.lang.ArrayIndexOutOfBoundsException: 4 означает, что в программе возникло ArrayIndexOutOfBoundsException.

ArrayIndexOutOfBoundsException — это неконтролируемое исключение, которое возникает, когда индекс массива находится вне его границ.

Сообщение об ошибке Exception <...> java.lang.ArrayIndexOutOfBoundsException: 4 указывает на то, что исключение было вызвано при попытке доступа к элементу с индексом 4 массива. Это означает, что в массиве менее 5 элементов или что вы пытаетесь получить доступ к элементу с индексом, который находится за пределами массива.

69. Контролируемые исключения (checked)

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

Контролируемые исключения определяются как подклассы класса Exception или одного из его подклассов и проверяются компилятором Java. Это означает, что если метод генерирует контролируемое исключение, то caller должен либо обработать исключение, либо объявить его в сигнатуре throws метода.

Пример контролируемого исключения:

public void readFile(String fileName) throws IOException {
    if (!fileName.endsWith(".txt")) {
        throw new IOException("Неверное расширение файла");
    }
}

public void readFile(String fileName) {
    try {
        if (!fileName.endsWith(".txt")) {
            throw new IOException("Неверное расширение файла");
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
}

70. Неконтролируемые исключения (unchecked) и ошибки, которые они обрабатывают

В Java неконтролируемые исключения — это исключения, которые не проверяются компилятором и не требуют обработки или объявления программистом. Неконтролируемые исключения представляют собой ошибки, которые не ожидаются и не могут быть предвидены, например ошибки программирования или ошибки времени выполнения.

Неконтролируемые исключения определяются как подклассы класса RuntimeException или одного из его подклассов и не проверяются компилятором Java. Это означает, что если метод выдает неконтролируемое исключение, то caller не должен обрабатывать исключение или объявлять его в сигнатуре throws метода.

Список распространенных неконтролируемых исключений:

• NullPointerException представляет собой ошибку нулевого указателя, например нулевую ссылку или нулевой элемент массива.
• ArrayIndexOutOfBoundsException представляет собой ошибку выхода индекса массива за пределы, например доступ к массиву с недопустимым индексом.
• ArithmeticException представляет собой арифметическую ошибку, такую как деление на ноль или переполнение целого числа.

71. Как реализуется принципы ООП в Java при создании исключений?

При создании исключений в Java используются следующие принципы ООП:

• Наследование. При создании исключений в Java используется наследование, чтобы создать иерархию исключений. Например, класс IOException является подклассом класса Exception, который в свою очередь является подклассом класса Throwable. Это позволяет создавать исключения, которые могут быть обработаны в блоке catch для класса Exception или Throwable.
• Инкапсуляция. Исключения в Java инкапсулируют информацию об ошибке, которая может быть получена с помощью методов getMessage() и printStackTrace().
• Абстракция. Исключения в Java абстрагируют ошибки, которые могут возникнуть во время выполнения программы.
• Полиморфизм. Исключения в Java могут быть обработаны в блоке catch для класса Exception или Throwable, что позволяет обрабатывать исключения различных типов.

Чтобы создать пользовательское исключение в Java, необходимо создать подкласс класса Exception или RuntimeException. Например, чтобы создать исключение, которое может быть обработано в блоке catch для класса Exception, необходимо создать подкласс класса Exception. Например, чтобы создать исключение, которое не может быть обработано в блоке catch для класса Exception, необходимо создать подкласс класса RuntimeException.

Пример создания пользовательского исключения в Java:

public class MyException extends Exception {
    public MyException(String message) {
        super(message);
    }
}

72. Какой оператор позволяет принудительно выбросить исключение?

Чтобы принудительно выбросить исключение в Java, необходимо использовать оператор throw. Например, чтобы выбросить исключение MyException, необходимо написать следующий код:

throw new MyException("MyException");

73. Порядок выполнения операторов при обработке блока блока try…catch

При обработке блока try...catch в Java операторы выполняются в следующем порядке:

1. Выполняется блок try.
2. Выполняется блок catch.
3. Выполняется блок finally.

В блоке try содержится код, который может вызвать исключение. В блоке catch содержится код, который выполняется, если в блоке try возникло исключение. В блоке finally содержится код, который выполняется в любом случае, вне зависимости от того, возникло ли исключение в блоке try или нет.

Использование блока finally в Java не является обязательным. Если блок finally не используется, то после выполнения блока try или catch управление передаётся на следующую строку кода после блока try...catch.

Тема 6. Дженерики и использование контейнерных классов в Джава

74. Абстрактный тип данных Stack (cтек) в Java

Стек — это абстрактный тип данных, который представляет собой список элементов, организованных по принципу LIFO (last in, first out — последним пришёл, первым вышел). Стек можно реализовать с помощью массива или списка. В Java для реализации стека используется класс Stack. Для того, чтобы использовать класс Stack, необходимо импортировать пакет java.util:

import java.util.Stack;

public class StackDemo {
    public static void main(String[] args) {
        Stack<String> stack = new Stack<>();
        stack.push("A"); // pushing element into the stack
        stack.push("B");
        stack.push("C");
        stack.push("D");
        stack.push("E");
        System.out.println(stack); // [A, B, C, D, E]
        System.out.println(stack.pop()); // E
        System.out.println(stack); // [A, B, C, D]
        System.out.println(stack.peek()); // D
        System.out.println(stack); // [A, B, C, D]
        System.out.println(stack.search("B")); // 2
        System.out.println(stack.search("Z")); // -1
    }
}

С помощью метода push() можно добавить элемент в стек. С помощью метода pop() можно извлечь элемент из стека. С помощью метода peek() можно получить элемент из вершины стека, не удаляя его из стека. С помощью метода search() можно получить позицию элемента в стеке. Если элемент не найден, то возвращается значение -1.

Стек наследует от класса Vector, поэтому в классе Stack доступны все методы класса Vector.

75. Универсальные типы или обобщенные типы данных, для чего создаются?

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

Универсальные типы или обобщенные типы данных в Java определяются с помощью параметра типа, который указывается в объявлении класса, интерфейса или метода. Параметр типа указывается в угловых скобках <> после имени класса, интерфейса или метода. Параметр типа может быть любым допустимым идентификатором, но принято использовать одну букву из английского алфавита. Например, T, E, K, V и т.д.

Обозначения стандартных параметров типа:

• T — type. Обозначает тип данных.
• E — element. Обозначает элемент.
• K — key. Обозначает ключ.
• V — value. Обозначает значение.
• N — number. Обозначает число.
• S, U, V — second, third, fourth типы.

Синтаксис объявления универсального типа или обобщенного типа данных в Java:

public class ClassName<T, U> {
    private T t;
    private U u;
    public ClassName(T t, U u) {
        this.t = t;
        this.u = u;
    }
    public T getT() {
        return t;
    }
    public U getU() {
        return u;
    }
}

76. Объявление обобщённого класса коллекции с параметризованным методом для обработки массива элементов коллекции на основе цикла foreach (определение общего метода для отображения элементов массива)

Пример объявления обобщённого класса коллекции с параметризованным методом для обработки массива элементов коллекции на основе цикла foreach в Java:

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

public class GenericClass<T> {
    private List<T> list = new ArrayList<>();

    public void add(T t) {
        list.add(t);
    }

    public void print() {
        for (T t : list) {
            System.out.println(t);
        }
    }
}

Пример использования обобщённого класса коллекции с параметризованным методом для обработки массива элементов коллекции на основе цикла foreach в Java:

public class Main {
    public static void main(String[] args) {
        GenericClass<String> genericClass = new GenericClass<>();
        genericClass.add("Hello");
        genericClass.add("World");
        genericClass.print();
    }
}

77. Что представляет из себя класс ArrayList и в каком случае используется

Класс ArrayList — это класс из Java collections framework, который реализует интерфейс List. Это реализация интерфейса List на основе массива, что означает, что он хранит элементы в массиве и обеспечивает динамическое изменение размера, позволяющее увеличивать или уменьшать список по мере необходимости.

Класс ArrayList используется для создания динамического массива объектов, который может увеличиваться или уменьшаться по мере необходимости. Он предоставляет методы для добавления, удаления и доступа к элементам списка, а также методы для поиска, сортировки и повторения элементов списка.

Пример объявления класса ArrayList в Java:

import java.util.ArrayList;
public class Main {
    public static void main(String[] args) {
        ArrayList<String> arrayList = new ArrayList<>();
        arrayList.add("Hello"); // add element
        arrayList.add("World"); 
        System.out.println(arrayList); // [Hello, World]
        System.out.println(arrayList.get(0)); // Hello
        arrayList.remove(0); // remove element
        System.out.println(arrayList); // [World]
    }
}

ArrayList полезен, когда вы заранее не знаете, сколько элементов будет в списке. Если вы знаете, сколько элементов будет в списке, то лучше использовать массив, так как он быстрее и эффективнее.

Удаление элемента из ArrayList происходит за константное время, т.е. время не зависит от размера списка. Добавление элемента в ArrayList происходит за константное время, если размер списка не превышает емкость. Если размер списка превышает емкость, то время добавления элемента будет линейно зависеть от размера списка.

78. Класс Pattern и его использование

Класс Pattern — это класс стандартной библиотеки Java. Он представляет собой компилированный шаблон регулярного выражения. Этот класс используется для создания объекта Matcher, который выполняет сопоставление с шаблоном регулярного выражения.

Пример использования класса Pattern в Java:

import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Main {
    public static void main(String[] args) {
        Pattern pattern = Pattern.compile("Java");
        Matcher matcher = pattern.matcher("Java is a programming language");
        while (matcher.find()) {
            System.out.println(matcher.start() + " " + matcher.group()); // 0 Java
        }
    }
}

В данном примере используется метод find(), который возвращает true, если в строке найдено совпадение с шаблоном регулярного выражения. Метод start() возвращает индекс начала совпадения, а метод group() возвращает совпадение.

Регулярные выражения используются при работе с текстом. Они позволяют искать и заменять текст в строке.

79. Класс Math и его использование

Класс Math — это класс стандартной библиотеки Java. Он предоставляет методы для выполнения основных математических операций, таких как возведение в степень, вычисление квадратного корня, тригонометрические функции и т.д.

Пример использования класса Math в Java:

import java.lang.Math;
public class Main {
    public static void main(String[] args) {
        System.out.println(Math.abs(-10)); // 10
        System.out.println(Math.pow(2, 3)); // 8.0
        System.out.println(Math.sqrt(9)); // 3.0
        System.out.println(Math.sin(Math.PI / 2)); // 1.0
    }
}

Класс Math содержит множество статических методов, которые можно использовать для выполнения различных математических операций. Например, метод abs() возвращает абсолютное значение числа, метод pow() возвращает значение числа, возведенного в степень, метод sqrt() возвращает квадратный корень числа, а метод sin() возвращает синус угла в радианах.

Конструктор класса Math объявлен как приватный, поэтому его нельзя использовать для создания объектов. Все методы класса Math также объявлены как статические, поэтому они могут быть вызваны без создания объекта класса Math.

80. Как вызываются методы класса Math и что при этом происходит?

Из-за того, что конструктор класса Math объявлен как приватный,создать объект класса Math нельзя. Однако все методы и поля класса Math объявлены как статические, поэтому они могут быть вызваны без создания объекта класса Math.

Тема 7. Java Core. Дженерики (продолжение) и использование контейнерных классов Java Framework Collection

81. Структура коллекций в Java Collection Framework. Иерархия интефейсов

Java Framework Collection — это набор классов, которые предоставляют различные алгоритмы для работы с коллекциями. Классы Java Framework Collection расположены в пакете java.util.

Структура коллекций в Java Framework Collection представлена на рисунке ниже.

Интерфейс Collection является базовым интерфейсом для всех коллекций. Он определяет основные методы для работы с коллекциями, такие как методы add(), remove(), size(), isEmpty(), contains(), toArray(), iterator() и т.д.

Приведем примеры самых частоиспользуемых реализаций.

Интерфейс List расширяет интерфейс Collection и определяет методы для работы с элементами коллекции по индексу. Интерфейс List реализуют классы ArrayList, LinkedList, Vector и Stack. Данный интерфейс используется для хранения элементов в виде списка. Stack — это класс, который наследуется от класса Vector и реализует интерфейс List. Stack используется для хранения элементов в виде стека.

Интерфейс Set расширяет интерфейс Collection и определяет методы для работы с множествами. Интерфейс Set реализуют классы HashSet, LinkedHashSet и TreeSet. Данный интерфейс используется для хранения элементов в виде множества. Интерфейс SortedSet расширяет интерфейс Set и определяет методы для работы с отсортированными множествами. Интерфейс SortedSet реализуют интерфейс NavigableSet. Интерфейс NavigableSet расширяет интерфейс SortedSet и определяет методы для работы с навигацией по множеству. Интерфейс NavigableSet реализуют классы TreeSet и ConcurrentSkipListSet. Данный интерфейс используется для хранения элементов в виде отсортированного множества.

Интерфейс Queue расширяет интерфейс Collection и определяет методы для работы с очередями. Интерфейс Queue реализуют классы LinkedList, PriorityQueue и ArrayDeque. Данный интерфейс используется для хранения элементов в виде очереди.

Интерфейс Deque расширяет интерфейс Queue и определяет методы для работы с двусторонними очередями. Интерфейс Deque реализуют классы LinkedList и ArrayDeque. Данный интерфейс используется для хранения элементов в виде двусторонней очереди.

Интерфейс Map определяет методы для работы с отображениями. Интерфейс Map реализуют классы HashMap, LinkedHashMap и TreeMap. Данный интерфейс используется для хранения элементов в виде отображения. Следует отметить, что интерфейс Map не расширяет интерфейс Collection. Интерфейс SortedMap расширяет интерфейс Map и определяет методы для работы с отсортированными отображениями. Интерфейс SortedMap реализует интерфейс NavigableMap. Интерфейс NavigableMap реализуют классы TreeMap и ConcurrentSkipListMap. Данный интерфейс используется для хранения элементов в виде отсортированного отображения.

82. Коллекция HashMap, создание и методы работы с ней

Коллекция HashMap — это класс в пакете java.util, который реализует интерфейс Map. Коллекция HashMap хранит элементы в виде пар ключ-значение. Ключи должны быть уникальными, а значения могут повторяться. Коллекция HashMap не гарантирует порядок хранения элементов. Коллекция HashMap не является синхронизированной, поэтому не является потокобезопасной. Коллекция HashMap позволяет хранить null в качестве ключа и значения.

Пример создания коллекции HashMap:

import java.util.HashMap;

public class Main {
    public static void main(String[] args) {
        HashMap<Integer, String> map = new HashMap<>();
    }
}

Основные методы работы с HashMap:

• put(K key, V value) — добавляет элемент в коллекцию. Возвращает null, если элемент добавлен, иначе возвращает предыдущее значение элемента с таким ключом.
• get(Object key) — возвращает значение элемента с указанным ключом.
• remove(Object key) — удаляет элемент с указанным ключом. Возвращает null, если элемент не найден.
• containsKey(Object key) — проверяет, содержит ли коллекция элемент с указанным ключом.
• containsValue(Object value) — проверяет, содержит ли коллекция элемент с указанным значением.
• size() — возвращает количество элементов в коллекции.
• isEmpty() — проверяет, пуста ли коллекция.
• clear() — удаляет все элементы из коллекции.

83. Чем является класс LinkedList<Е>

Класс LinkedList<Е> является классом коллекции, который реализует интерфейс List<Е> и представляет собой связный список. Связный список — это структура данных, которая состоит из узлов, каждый из которых содержит ссылку на следующий узел. Первый узел называется головой, а последний — хвостом. Каждый узел содержит ссылку на предыдущий узел. Связный список позволяет быстро добавлять и удалять элементы в любом месте списка.

Класс LinkedList<Е> является универсальным, поэтому в качестве параметра типа можно указать любой ссылочный тип.

Пример использования класса LinkedList<Е>:

import java.util.LinkedList;

public class Main {
    public static void main(String[] args) {
        LinkedList<String> list = new LinkedList<>();
    }
}

Основные методы класса LinkedList<Е>:

• add(E element) — добавляет элемент в конец списка.
• addFirst(E element) — добавляет элемент в начало списка.
• addLast(E element) — добавляет элемент в конец списка.
• removeFirst() — удаляет первый элемент из списка.
• removeLast() — удаляет последний элемент из списка.
• remove(int index) — удаляет элемент по индексу.
• get(int index) — возвращает элемент по индексу.
• set(int index, E element) — заменяет элемент по индексу.
• size() — возвращает размер списка.

84. Одним из ключевых методов интерфейса Collection является метод Iterator<Е> iterator(). Что возвращает это метод?

Метод iterator() возвращает объект типа Iterator<Е>, который позволяет перебирать элементы коллекции. Для перебора элементов коллекции используется следующий цикл:

import java.util.ArrayList;
import java.util.Iterator;

public class Main {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("Java");
        list.add("Kotlin");
        list.add("C++");
        list.add("C#");
        list.add("Python");

        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            String element = iterator.next();
            System.out.println(element);
        }
    }
}

85. Что возвращает метод next()

Метод next() возвращает следующий элемент коллекции. Если элементов больше нет, то метод next() выбрасывает исключение NoSuchElementException. Поэтому перед вызовом метода next() следует проверить, есть ли еще элементы в коллекции, вызвав метод hasNext().

86. Что возвращает метод hasNext()

Метод hasNext() возвращает true, если в коллекции есть еще элементы, и false в противном случае.

Данный метод может быть использован, например, для проверки, есть ли еще элементы в коллекции, перед вызовом метода next().

87. Обобщенный класс HashSet класс коллекция, наследует свой функционал от класса AbstractSet, а также реализует интерфейс Set. Что он себя представляет?

Класс HashSet представляет собой коллекцию, которая хранит элементы в виде хэш-таблицы. Элементы в коллекции не упорядочены. Класс HashSet не позволяет хранить дубликаты элементов. Класс HashSet не является потокобезопасным, поэтому при работе с ним необходимо использовать синхронизацию.

Коасс HashSet реализует интерфейс Set, который является наследником интерфейса Collection. Поэтому класс HashSet наследует все методы, которые определены в интерфейсе Collection.

Пример использования класса HashSet:

import java.util.HashSet;

public class Main {
    public static void main(String[] args) {
        HashSet<String> set = new HashSet<>();
    }
}

Основные методы класса HashSet:

• add(E e) — добавляет элемент в коллекцию
• clear() — удаляет все элементы из коллекции
• contains(Object o) — возвращает true, если коллекция содержит элемент o
• isEmpty() — возвращает true, если коллекция пуста
• remove(Object o) — удаляет элемент o из коллекции
• size() — возвращает количество элементов в коллекции

88. Обобщенный класс HashMap класс коллекция, которая реализует интерфейс Map для хранения пар ключ-значение. Что он себя представляет?

Класс HashMap представляет собой коллекцию, которая хранит элементы в виде хэш-таблицы.

Класс HashMap реализует интерфейс Map, который является наследником интерфейса Collection. Поэтому класс HashMap наследует все методы, которые определены в интерфейсе Collection.

Пример использования класса HashMap:

import java.util.HashMap;

public class Main {
    public static void main(String[] args) {
        HashMap<String, Integer> map = new HashMap<>();
    }
}

Основные методы работы с HashMap:

• put(K key, V value) — добавляет элемент в коллекцию. Возвращает null, если элемент добавлен, иначе возвращает предыдущее значение элемента с таким ключом.
• get(Object key) — возвращает значение элемента с указанным ключом.
• remove(Object key) — удаляет элемент с указанным ключом. Возвращает null, если элемент не найден.
• containsKey(Object key) — проверяет, содержит ли коллекция элемент с указанным ключом.
• containsValue(Object value) — проверяет, содержит ли коллекция элемент с указанным значением.
• size() — возвращает количество элементов в коллекции.
• isEmpty() — проверяет, пуста ли коллекция.
• clear() — удаляет все элементы из коллекции.

Тема 8. Стандартные потоки ввода-вывода. Сериализация

89. Стандартные поток ввода-вывода, предоставляемые Java

Java предоставляет ряд стандартных классов ввода-вывода (I/O) в пакете java.io стандартной библиотеки Java, которые позволяют читать и записывать данные из различных источников и назначений.

Данные классы:

• InputStream и OutputStream — это абстрактные классы, определяющие основные методы чтения и записи байтов данных. Они являются суперклассами всех других классов потоков ввода и вывода в стандартной библиотеке Java.
• Reader и Writer — это абстрактные классы, которые определяют основные методы чтения и записи символов данных. Они являются надклассами всех других классов символьных потоков ввода и вывода в стандартной библиотеке Java.
• FileInputStream и FileOutputStream — это классы, которые позволяют читать и записывать данные в файлы.
• ByteArrayInputStream и ByteArrayOutputStream — это классы, которые позволяют читать и записывать данные в массив байтов.
• BufferedInputStream и BufferedOutputStream — это классы, которые позволяют буферизировать данные, прежде чем они будут записаны в файл или прочитаны из файла.
• StringReader и StringWriter — это классы, которые позволяют читать и записывать данные в строку.
• DataInputStream и DataOutputStream — это классы, которые позволяют читать и записывать данные в бинарном формате.

Пример использования потоков:

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

public class Main {
    public static void main(String[] args) {
        try (FileInputStream inputStream = new FileInputStream("file.txt")) { // Open the file
        int data;
        while ((data = inputStream.read()) != -1) {
            System.out.print((char) data);
        }
        } catch (IOException e) {
            e.printStackTrace();
        }
        }
}

90. Понятие сериализации, интерфейс Serializable

Сериализация — это процесс преобразования объекта в последовательность байтов, которая может быть записана в файл или передана по сети.

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

91. Какие объекты можно сериализовать?

В Java можно сериализовать только объекты, которые реализуют интерфейс Serializable. Если класс не реализует этот интерфейс, то при попытке сериализовать объект этого класса будет выброшено исключение NotSerializableException.

Все поля класса должны быть сериализуемыми. Если поле не сериализуемое, то при сериализации объекта будет выброшено исключение NotSerializableException.

92. Какие методы определяет интерфейс Serializable?

Интерфейс Serializable не содержит никаких методов, он просто помечает классы, которые могут быть сериализованы.

93. Что означает понятие десериализация?

Десериализация — это процесс преобразования последовательности байтов в объект. Это обратный процесс сериализации.

В Java десериализация объектов реализуется с классом ObjectInputStream.

Пример десериализации объекта:

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

public class Main {
    public static void main(String[] args) {
        try (ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("file.txt"))) {
            Person person = (Person) objectInputStream.readObject();
            System.out.println(person);
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

Для десериализации объекта необходимо, чтобы класс, объект которого был сериализован, был доступен во время десериализации. Если класс не будет найден, то будет выброшено исключение ClassNotFoundException.

94. Класс File, определенный в пакете java.io, не работает напрямую с потоками. В чем состоит его задача?

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

Основные методы класса File:

• createNewFile() — создает новый файл, если файл с таким именем уже существует, то метод вернет false;
• delete() — удаляет файл;
• exists() — проверяет существует ли файл;
• isDirectory() — проверяет является ли файл каталогом;
• isFile() — проверяет является ли файл обычным файлом;
• isHidden() — проверяет является ли файл скрытым;
• length() — возвращает размер файла в байтах;
• list() — возвращает массив строк, содержащий имена файлов и каталогов, которые находятся в каталоге;
• mkdir() — создает каталог;
• renameTo(File dest) — переименовывает файл.
• toPath() — возвращает объект типа Path, который представляет собой путь к файлу.

95. При работе с объектом класса FileOutputStream происходит вызов метода FileOutputStream.write(), что в результате этого происходит

При вызове метода FileOutputStream.write() происходит запись данных в файл. Если файл не существует, то он будет создан. Если файл существует, то его содержимое будет перезаписано.