Java: почему мой список содержит разные типы? (Списки фильтрации)

Вам следует избегать instanceof check в дополнительном примере вопроса. При работе с элементами списка должно быть достаточно наличия доступных методов интерфейса. Если вам нужно что-то сделать только с ObjectA или ObjectB, я предлагаю использовать другой список только с ObjectA или ObjectB. Например, вы можете определить разные методы для выполнения конкретной работы Thing и конкретной задачи ObjectB:

public void processThings(List<Thing> things) {

        for(final Thing thing : things) {

            // we work only with methods that provided by interface Thing
            System.out.println(thing.getType());
            System.out.println(thing.getName());

        }
    }

public void processObjectsB(List<ObjectB> objectsB) {

        // here we do some specific things with only B objects, 
        // assuming class ObjectB has an additional method doSomeSpecificB()
        for(final ObjectB objectB : objectsB) {

            objectB.doSomeSpecificB();

        }
    }

Can someone provide a link (or some keywords which can be used for searching), which explain this behavior, or can explain it to me?

Такое поведение называется «полиморфизмом». По сути, поскольку ObjectA и ObjectB реализуют Thing, экземпляры ObjectA и ObjectB могут использоваться как объект Thing. В вашем коде вы добавили их в список, который может содержать объекты Thing.

Обратите внимание, что даже если эти объекты теперь относятся к (во время компиляции) типу Thing, во время выполнения они все равно знают, что они собой представляют. Когда вы вызываете для них toString, будут вызываться соответствующие переопределенные методы toString в ObjectA и ObjectB. Это как если бы Thing «трансформируется» в ObjectA или ObjectB.

Is the are "good" way to filter this List for all Types of ObjectA to perform only on these objects some operations?

Причина, по которой люди говорят, что это плохая практика, заключается в том, что если вы хотите делать разные вещи в зависимости от того, является ли объект ObjectA или ObjectB, почему вы заставили их реализовать Thing и составить список Thing для их хранения? Вы могли просто использовать List<Object>. Реальным преимуществом использования List<Thing> является то, что вы избегать знаете, какие фактические объекты там находятся, когда вы работаете со списком. Все, что вам известно, это то, что элементы внутри списка реализуют Thing, и вы можете вызывать методы, объявленные в Thing.

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

things - это List<Thing>. Это означает, что во время компиляции Java гарантирует, что любой объект, который вы записываете в thingsявляется, будет Thing. Поскольку ObjectA и ObjectB реализуют Thing, фактический выполнение любого члена things может быть ObjectA или ObjectB. Это по дизайну, и эта функция называется полиморфизм: объекты разных классов имеют общий интерфейс и могут быть доступны через этот интерфейс независимо от их фактического типа. Например, вы можете использовать:

for(final Thing thing : things) {
    System.stdout.println("Found a " + thing.getType() + " named " + thing.getName());
}

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

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

У меня есть огород, в котором выращивают картофель, морковь и брокколи. У меня очень строгое правило - я не буду сажать в саду ничего, что нельзя есть. Так что никакого ядовитого плюща здесь!

Итак, это Garden<Edible> - все, что я сажаю в саду, должно быть съедобным.

Теперь class Potato implements Edible означает, что каждый картофель съедобен. Но это также означает, что я могу посадить картофель в своем саду. Точно так же class Carrot implements Edible - вся морковь съедобна, и мне разрешено сажать морковь.

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

Потому что это Garden<Edible>. Он может содержать или не содержать объекты Potato. Он может содержать или не содержать объекты Broccoli. Он не содержит объектов PoisonIvy.

Теперь переведите все это на свой пример. У вас есть class ObjectA implements Thing - это означает, что каждый ObjectA является Thing. У вас есть class ObjectB implements Thing - это означает, что каждый ObjectB является Thing. И у вас есть List<Thing> - List, который может содержать объекты ObjectA, объекты ObjectB и любой другой объект любого класса, кроме implements Thing. То, что вы не можете поместить в него, - это объект любого класса, который не реализует Thing.