Рекомендации к применению:

• Cтатический: если вложенный класс должен быть виден за пределами одного метода или он слишком длинный для того, чтобы его можно было удобно разместить в границах одного метода и если каждому экземпляру такого класса необходима ссылка на включающий его экземпляр.
• Нестатический: если ссылка на обрамляющий класс не требуется. Доступ к полям стат. и нестат. класса.
• Локальный: если класс необходим только внутри какого-то метода и требуется создавать экземпляры этого класса только в этом методе.
• Анонимный: если к тому же применение класса сводится к использованию лишь в одном месте и уже существует тип, характеризующий этот класс.

Лапша на тему использования:

Вложенные классы используются для различных целей:

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

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

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

Локальные классы имеют следующие особенности:

• Видны только в пределах блока, в котором объявлены;
• Не могут быть объявлены как private/public/protected или static;
• Не могут иметь внутри себя статических объявлений (полей, методов, классов);
• Имеют доступ к полям и методам обрамляющего класса;
• Могут обращаться к локальным переменным и параметрам метода, если они объявлены с модификатором final или effectively final.

Локальные классы обычно используются в следующих случаях:

1. Когда класс связан с одним методом:
   Если класс нужен только в одном методе, его можно объявить внутри этого метода. Это делает код более читаемым и поддерживаемым.
2. Когда класс необходим для поддержки операций, специфичных для метода:
   Если вам нужно выполнить сложную операцию, которая лучше всего реализуется с использованием класса, но эта операция не имеет отношения к остальной части программы, тогда локальный класс может быть подходящим решением.
3. Когда требуется скрыть класс от остальной части программы:
   Поскольку локальные классы не видны за пределами метода, в котором они объявлены, они являются полезным инструментом инкапсуляции.

Если речь об объектах разных классов - сколько позволяет память вашей системы.

Если об экземплярах конкретного класса, то каждое объявление анонимного класса ведет к созданию нового класса во время компиляции. т.е. один.

Абстрактные классы в Java - это классы, которые не могут быть инстанцированы.

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

Создавать экземпляры самого абстрактного класса не разрешается.

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

Для обозначения используется модификатор abstract.

Абстрактные классы могут содержать как абстрактные методы, так и не абстрактные методы.

При этом наследниками абстрактного класса могут быть как другие абстрактные классы, так и классы, допускающие создание объектов, т.е. классы в которых реализованы все методы.

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

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

Особенности абстрактных классов:

• Может быть конструктор (для вызовов по цепочке из наследников)
• Имплементят интерфейсы, но не обязаны реализовывать их методы
• Не могут быть final
• Могут содержать static методы
• Нельзя создать объект
• Абстрактные методы могут отсутствовать
• Может содержать метод main()
• Классы-наследники не обязаны реализовывать все абстрактные методы

Абстрактный класс в Java может содержать от нуля и более абстрактных методов.

Однако, даже если абстрактный класс не содержит ни одного абстрактного метода, он все равно не может быть инстанциирован.

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

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

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

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

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

Обычные методы в абстрактном классе - это методы, которые имеют реализацию (т.е. они не являются абстрактными).
Эти методы могут быть вызваны напрямую из любого наследника этого абстрактного класса.
Это позволяет разработчикам предоставить общую функциональность для всех наследников, которую можно переопределить при необходимости.

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

Ни одного. Невозможно создать объект абстрактного класса в Java.

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

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

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

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

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

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

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

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

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

1. Методы: Интерфейс может объявлять любое количество методов.

   Все методы в интерфейсе по умолчанию являются публичными и абстрактными.

   Т.е. определяются имена методов, списки аргументов и типы возвращаемых значений, но не реализуется их поведение. Все методы неявно объявляются как public.

2. Константы: Интерфейс может содержать переменные, которые по умолчанию являются public, static и final.

   Т.е. по факту это константы.

3. Вложенные типы: Интерфейс может содержать вложенные интерфейсы, классы и перечисления.

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

5. Статические методы: Также, начиная с Java 8, интерфейс может содержать статические методы.

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

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

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

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

Объявляем переменную, пишем new ИмяИнтрефейса{и тут же реализацию методов}

Поля автоматически являются публичными public, статическими static и неизменяемыми final.

Все методы неявно объявляются как public.

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

Статические методы в интерфейсе являются частью интерфейса без возможности использовать их для объектов класса реализации;

Методы класса java.lang.Object нельзя переопределить как статические;

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

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

Дефолтные методы можно переопределить.

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

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

Метод по умолчанию не может переопределить метод класса java.lang.Object.

Для чего они нужны?

Помогают реализовывать интерфейсы без страха нарушить работу других классов.

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

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

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

Методы по умолчанию, Статические методы и Частные (приватные) методы.

см. содержимое интерфейса

Да.

От двух других?

И снова да.

Зачем нужен equals().
Чем он отличается от операции ==?

Базовая реализация:

equals в классе Object проверяет только равенство ссылок:

public boolean equals(Object obj) {
    return (this == obj);
}

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

Основные принципы:

1. Рефлексивность

   x.equals(x) = true

2. Симметричность

   x.equals(y) = true

   y.equals(x) = true

3. Транзитивность

   x.equals(y) = true

   y.equals(z) = true

   x.equals(z) = true

4. Постоянство или Непротиворечивость

   Результат одно и то же число пока объект не изменится

   Для любых ссылок на значения х и у, если несколько раз вызвать х.equals(y), постоянно будет возвращаться значение true либо постоянно будет возвращаться значение false при условии, что никакая информация, используемая при сравнении объектов, не поменялась.

5. Если объекта нет - ложь

   x.equals(null) = false

   Для любой ненулевой ссылки на значение х выражение х.equals(null) должно возвращать false.

Правила переопределения equals():

• Использование оператора == для проверки, является ли аргумент ссылкой на указанный объект. Если является, возвращается true. Если сравниваемый объект == null, должно вернуться false.
• Использование оператор instanceof и вызова метода getClass() для проверки, имеет ли аргумент правильный тип. Если не имеет, возвращается false.
• Приведение аргумента к правильному типу. Поскольку эта операция следует за проверкой instanceof она гарантированно будет выполнена.

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

  Если проверки для всех полей прошли успешно, возвращается результат true, в противном случае - false.

• По окончанию переопределения метода equals() следует проверить: является ли порождаемое отношение эквивалентности рефлексивным, симметричным, транзитивным и непротиворечивым? Если ответ отрицательный, метод подлежит соответствующей правке.

@Override
public boolean equals(Object obj) {
    if (this == obj) //равен сам себе
    return true;
    if (obj == null) //не равен нулю
    return false;
    if (getClass() != obj.getClass()) //объекты одного класса
    return false;
    BlackBox other = (BlackBox) obj; //приведение
    if (varA != other.varA) //для конкретных переменных класса
    return false;
    if (varB != other.varB)
    return false;
    return true;
}

Когда уместно не переопределять equals()

Чем a.getClass().equals(A.class) отличается от a instanceOf A.class

Для equals всегда нужно сравнивать типы объектов через getClass.

instanceof не соблюдает правило симметрии в наследниках.

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

Метод hashCode() необходим для вычисления хэш кода объекта, переданного в качестве входного параметра.

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

Почему нельзя реализовать hashcode() который будет гарантированно уникальным для каждого объекта?

Следует понимать, что в Java множество возможных хэш кодов ограничено типом int, а множество объектов ничем не ограничено.

Из-за этого, вполне возможна ситуация, что хэш коды разных объектов могут совпасть:

• если хэш коды разные, то и объекты гарантированно разные;
• если хэш коды равны, то объекты могут необязательно равны.
• для одного и того-же объекта, хеш-код всегда будет одинаковым;
• если объекты одинаковые, то и хеш-коды одинаковые (но не наоборот).

Каким образом реализованы методы hashCode() и equals() в классе Object?

native означает, что реализация данного метода выполнена на другом языке (здесь на C++) и обычно возвращает адрес объекта в памяти.

Есть ли какие-либо рекомендации о том, какие поля следует использовать при подсчете hashCode()?

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

Для этого необходимо использовать уникальные, лучше всего примитивные поля, например такие как id, uuid.
При этом нужно следовать правилу, если поля задействованы при вычислении hashCode(), то они должны быть задействованы и при выполнении equals().

Что будет, если переопределить equals() не переопределяя hashCode()?
Какие могут возникнуть проблемы?

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

Так для HashMap это может привести к тому, что пара «ключ-значение», которая была в нее помещена при использовании нового экземпляра ключа не будет в ней найдена.

В HashSet при добавлении объект сначала сравнивается хэш добавляемого и существующие (быстрая проверка очень экономит время), если хэш разный – то дальше сравнивается по equals.

Есть класс Point{int x, y;}.
Почему хэш-код в виде 31 * x + y предпочтительнее чем x + y?

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

Lombok аннотация @EqualsAndHashCode

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

Статические методы объявляются с помощью ключевого слова static.

Основные характеристики статических методов:

1. Статический метод может быть вызван прямо из класса и не требует создания экземпляра класса.
2. Статический метод может прямо обращаться только к статическим переменным и статическим методам. Он не может прямо обращаться к нестатическим членам (переменным и методам).
3. Не могут быть переопределены (в прямом смысле это слова, см. сокрытие), но могут быть перегружены.

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

Основные характеристики нестатических методов:

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

Переопределение метода (Method Overriding) в Java - это механизм, который позволяет дочернему классу предоставить свою собственную реализацию метода, уже определенного в родительском классе.

Это важный аспект объектно-ориентированного программирования, так как он поддерживает принцип полиморфизма.

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

Аннотация @Override не является обязательной, но это хорошая практика использовать её при переопределении методов, так как это помогает быстрее выявить ошибки во время компиляции, если метод родительского класса не существует или имеет другую сигнатуру.

Перегрузка метода (Method Overloading) - это возможность в языке программирования Java, которая позволяет классу иметь два или более метода с одинаковым именем, но разными параметрами.

Важно помнить:

1. Методы должны иметь одинаковое имя, но разные параметры (как по типу, так и по количеству).
2. Перегруженные методы могут иметь разные модификаторы доступа (private, public, protected).
3. Перегруженный метод может выбросить любое количество исключений, независимо от того, выбрасывают ли исключения оригинальные методы.
4. Перегруженный метод может иметь разные возвращаемые типы.*

*Можно ли изменить тип возвращаемых данных при перегрузке метода?

Нет, однако...

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

Однако, статический метод может сокрыт в подклассе.

Сокрытие метода в Java (Method Hiding) - это механизм, позволяющий подклассу предоставить свою собственную реализацию статического метода, уже определенного в родительском классе.

Сокрытие метода в Java применяется только к статическим методам. Нестатические методы поддерживают переопределение, но не сокрытие.

Затенение метода (method overriding) и сокрытие метода (method hiding) - это разные понятия в Java.

Затенение метода (Method Overriding): Это механизм, который позволяет подклассу предоставить реализацию метода, уже предоставленного в его суперклассе.

Этот механизм используется для достижения полиморфизма времени выполнения.

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

Сокрытие метода (Method Hiding): Если суперкласс и подкласс имеют статические методы с одинаковым именем и параметрами, то метод в подклассе скрывает метод в суперклассе.

Это известно как сокрытие метода.

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

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

Статические методы не могут быть переопределены в точном смысле слова, но они могут скрыть родительские статические методы (затирать).

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

Да, могут.

При переопределении метода сужать модификатор доступа нельзя, т.к. это приведет к нарушению принципа подстановки Барбары Лисков. Расширение уровня доступа возможно.

Изменять тип возвращаемого значения при переопределении метода разрешено только в сторону сужения типа (вместо родительского класса - наследника).

При изменении типа, количества, порядка следования аргументов вместо переопределения будет происходить overloading (перегрузка) метода.

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

Также, возможно добавлять новые исключения, являющиеся наследниками от уже объявленных или исключения RuntimeException.

Порядок следования таких элементов при переопределении значения не имеет.

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

В C++, например, виртуальные функции позволяют достичь "позднего связывания" или "динамического связывания", что является ключевой составляющей полиморфизма.

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

Таким образом, в Java нет необходимости (и даже возможности) явно обозначать методы как "виртуальные" - это поведение является стандартным.

Varargs (Variable-Length Arguments) - это возможность в Java, которая позволяет методу принимать нуль или более аргументов одного типа.
Это очень удобно, когда вы не знаете, сколько аргументов нужно передать методу.

Вы можете определить varargs в методе, указав тип аргумента, за которым следуют три точки (...).

Например:

public void printNumbers(int... numbers) {
    for (int number : numbers) {
        System.out.println(number);
    }
}

Теперь вы можете вызвать этот метод с любым количеством аргументов типа int (включая ноль аргументов):

printNumbers();        // No arguments
printNumbers(1);       // One argument
printNumbers(1, 2, 3); // Three arguments

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

Varargs должен быть последним в списке аргументов метода.

Неоднозначность при работе с varargs в Java может возникнуть в следующих случаях:

1. Перегрузка методов с varargs и без.
   Если у вас есть перегруженные методы, один из которых принимает varargs, а другой - фиксированное количество аргументов, компилятор может не определить, какой метод вызвать.

   Например, если у вас есть методы foo(int a, int b) и foo(int... a), вызов foo(1, 2) может быть неоднозначным.

2. Перегрузка методов с разными типами varargs.
   Если у вас есть два метода, оба с varargs, но с разными типами, и вы пытаетесь вызвать метод с аргументами, которые могут быть приведены к обоим типам, это может привести к неоднозначности.

   Например, есть методы foo(Integer... a) и foo(String... a),, вызов foo(null) может вызвать неоднозначность.

3. Неоднозначность с передачей null.
   Если метод принимает varargs и вы передаете null, это может привести к исключению NullPointerException, если метод пытается обработать varargs как массив (что он и есть), так как null не может быть обработан как массив.

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