Всё ок, но вале как всегда не нравится

В условии не сказано что я должен вызвать метод у переданного объекта. В условии сказано что я должен вызвать необходимый метод, если переданный объект является экземпляром этого класса. Запрета на создание новых объектов в условии нет. Оператор instanceof - проверяет соответствие объекта классу и его родителям, поэтому это не совсем точный способ проверки. А метод getSimpleName - проверяет только имя класса этого объекта и всё. А теперь вернемся к вопросу: 1. Условие - Проверить что переданный объект соответствует необходимому классу:

if (person.getClass().getSimpleName().equals("Player"))
// Проверил.

2. Условие - вызвать метод класса, которому соответствует этот объект:

new Player().play();
// Вызвал

Вопрос: что не так? Вариант ответа: "Условие - гавно. и они хотят совершенно другого" - тоже принимается.

У тебя методы нестатические, ты их можешь вызывать у объектов. " вызвать метод класса, которому соответствует этот объект" - это абсурд, тут важен именно объект. Со временем поймешь, и даже вопроса такого бы не возникло. Представь, что у тебя есть объект мяч, и ты умеешь делать две функции: если мяч футбольный, то ударить по воротам, если баскетбольный, то кинуть в корзину. Тебе дают мяч, говорят проверить, что это за мяч и выполнить соответствующее действие. Ты же проверяешь, что за мяч тебе дали, запоминаешь, какого он типа и выкидываешь в мусорку. И если этот мяч был футбольным, то ты берешь новый футбольный мяч и пинаешь его, ну или создаешь новый баскетбольный и кидаешь в корзину, если переданный тебе мяч был баскетбольным. Это совсем другая работа. Метод должен работать именно с переданным объектом, и дело здесь не в том, что и в том и в другом случае выведется одно и то же слово "play" или "dance". Под каждый объект выделена отдельная память, у каждого из них есть свои состояния, которые могут изменяться переданными методами. Поэтому работать с person тут ключевое. А чтобы вызвать метод у person, нужно выполнить приведение типа. А чтобы выполнить приведение типа, надо выполнить проверку instanceof, чтобы не поймать ошибку, т.к. легко могут быть разные классы в разных пакетах с одинаковыми именами, и по имени никто не сверяет, сверяют по сути, и именно через instanceof. Этот оператор не проверяет соответствие родителям, он проверяет только соответствие классу или его наследникам. У классов Dancer и Player наследников нет, а даже если бы и были, они бы не перестали являться от этого Dancer и Player. В общем, я тебе все решение уже расписал, осталось только реализовать.

Да я решил уже давно задачу. Это меня просто бомбануло от корявых требований. Я работаю бизнес-аналитиком в IT. И пишу требования разработчикам на реализацию тех или иных фич. В бизнес-анализе есть целые дисциплины которые описывают какие должны быть требования и один из атрибутов хороших требований - это недвусмысленность. То есть требование "Копать отсюда и до рассвета" - это тоже требование, но весьма хреновое. Кто-то может его трактовать одним образом, кто-то другим. Твоя трактовка с мячом верна относительно этих требований так же как и моя. В системе же нет ограничений что нельзя создавать новый объект. Там сказано просто "Вызови метод класса" и пофиг как его вызвать. Если ты протестишь мой код, то увидишь что он работает ровно так как описано в требованиях. Никто же не запрещает нам делать пустые объекты, которые потом соберет мусоросборщик 🙂. А по поводу instanceof не соглашусь с тобой. Он реально проверяет принадлежность как к классу, так и к его родителям, вот тебе задачка для теста этой гипотезы:

public class Test {
public static void main(String[] args) {
          MedicalStaff medic = new HeadDoctor ();
            if (medic instanceof Nurse) {
               System.out.println ("Nurse");
           } else if (medic instanceof Doctor) {
              System.out.println ("Doctor");
          } else if (medic instanceof HeadDoctor) {
             System.out.println ("HeadDoctor");
         }
      }
  }
class MedicalStaff {}
class Doctor extends MedicalStaff {}
class Nurse extends MedicalStaff {}
class HeadDoctor extends Doctor {}

Спорим что в консоль пойдет Doctor, а не HeadDoctor ?🙂

Раз уж мы тут за недвусмысленность, то через getClass() тоже надо проверять правильно.

public class Test {
    public static void main(String[] args) {
        Doctor doctor1 = new Doctor();
        MedicalStaff.Doctor doctor2 = new MedicalStaff.Doctor();
        System.out.println(doctor1.getClass().getSimpleName());
        System.out.println(doctor2.getClass().getSimpleName());
    }
}
class MedicalStaff {
    static class Doctor {}
}
class Doctor {}

Спорим, что в консоль выведет две одинаковые строчки? А ведь эти классы даже не состоят в отношениях наследования.

Твой пример ничего не доказывает. Как я и говорил выше, instanceof не проверяет родительские классы, он проверяет дочерние. Запись if (medic instanceof Doctor) дословно означает следующее: "является ли объект [ссылка на который хранится в переменной] medic объектом класса Doctor [или любого из наследников этого класса]". То есть выведется "Doctor" не потому что Doctor - это MedicalStaff, а потому что HeadDoctor - это частный случай доктора. Как вообще можно проверять принадлежность объекта к родителям указанного класса? К родителям какого уровня? У всех классов вообще единый родитель, Object. И я еще раз говорю, что никакой двусмысленности и повода для бугурта в задаче нет. Тебе дан объект, надо вызвать его метод, что еще непонятно? Такого юзкейса, как "надо вызвать этот метод у любого объекта такого же класса", вообще нет.

Ну правда, я же не голословлю😄 Вот код, который доказывает что instanceof проверяет как класс, так и его родителей:

public class Test {

    public static void main(String[] args) {
        Doctor medic = new Doctor();

        // Если instanceof не проверяет родителя, то первый if будет false
        if (medic instanceof Object){
            System.out.println("Объект Doctor является объектом Object ");
        }
        else if (medic instanceof Doctor){
            System.out.println("Объект Doctor является объектом Doctor ");
        }

    }

    public static class Doctor{
    }
}

А вот результат выполнение кода:

Объект Doctor является объектом Object

Ни в коем случае не спорю 🙂 Методом

getSimpleName()

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

А я лишь хочу сказать, что когда нам нужно проверить, является ли какой-то объект экземпляром какого-то класса - метод getSimpleName() вообще использовать не нужно. Если уж нас интересует класс - то и проверять надо класс, а не его название.

А какая тут разница? Если объект является экземпляром Player или любого его наследника (т.е. instanceOf Player возвращает true - значит, мы можем привести этот объект к типу Player и вызвать метод play. А какой именно у него класс при этом - нас волновать не должно. И это правильно, это как раз соответсвует принципам ООП (почитай, например, про SOLID).

Разница в том что Java дает возможность решать задачи, используя разные подходы и инструменты. И когда мне заявляют что мое решение не правильное, потому что надо использовать только insyanceof, это вызывает ровно такое же недоумение, как когда мне говорят что зубы надо чистить только пастой белого цвета. Да, instanceof может быть удобнее в некоторых случаях, а в некоторых нет. И если нет ограничений по использованию операторов и методов, то разработчик вправе сам выбрать как реализовывать функционал, ИМХО

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