Можно ли так решать и в чем отличие?

И если так проверить все поля по очереди, то получишь одинаковые объекты. А цена сравнивается через ==, потому что она типа int, примитив. Числа можно сравнивать между собой прямо так.

По поводу Object не совсем понял, у нас ведь idea выдает то, что мы передаем в метод equals объект класса Object, я не до конца понимаю почему пишем, что наш объект будет именно этого класса, а не нашего класса для которого мы делаем метод. public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; Car car = (Car) o; return year == car.year && Objects.equals(model, car.model); } Почему бы просто не написать, public boolean equals(Car car) , по сути проверки на ссылки, на null объекты так же пройдут, сравнить поля так же можно через Objects.equals, разницы все никак не могу найти. + я правильно понимаю, что стандартные equals которая формирует idea не совсем корректные, тк там нет никаких проверок на "null" ? Просто опять же если опираться на решение, которое предлагают нам ребята из джавараша, то там так таковых проверок на null для каждого поля не предусмотрено, что странно. Ведь эта проверка " o == null " все же относится к проверке объекта на null который мы будем сравнивать, а не его какого-то поля.

А, я твой вопрос про Object изначально не так понял. Да, дело не в идее, а дело в том, что в классе Object есть метод equals(), аргументом у которого является другой объект типа Object. Этот метод позволяет нам сравнить два любых объекта и сказать, являются ли они одинаковыми между собой или нет. Этот метод сначала проверяет, что объекты между собой одного класса, и если это действительно так, то имеет смысл сравнивать между собой поля этих объектов, а в противном случае, если это объекты равных классов, то и сравнивать между собой дальше их не имеет смысла, объекты точно разные. И поскольку у нас любой класс является наследником класса Object, то этот метод можно вызвать у объекта вообще любого класса. То есть в любом классе, описано это или нет можно вызвать метод equals и передать параметром любой другой объект. Ты конечно можешь в своём классе Iphone описать метод equals, у которого параметром будет другой объект Iphone, но проблема в том, что этот метод не будет переопределять поведение оригинального метода equals: чтобы сработало переопределение, нужно чтобы у двух методов совпадала сигнатура, включающая в себя название методов, количество, порядок и типы параметров, а у тебя типы будут разными. Метод equals много где используется, даже когда ты этого не замечаешь. Например, когда ты добавляешь объекты в набор (Set), в нём могут содержаться только уникальные элементы. Для проверки уникальности будет вызываться метод equals (ведь ты помнишь, его можно вызвать у любого объекта). Коллекция понятия не будет иметь о том, что в твоём классе описан другой метод equals с параметром типа Iphone, она про твой класс ничего не знает. Зато знает, что у объекта любого класса можно вызвать метод equals(Object obj), потому что это задано самой спецификацией джавы и описано в её библиотеке. Мысль закончу ниже.

И именно поэтому тебе нужно переопределить именно метод с параметром типа Object. Переопределяя метод, ты как бы говоришь: другие объекты вы можете сравнивать как хотите, а вот чтобы сравнить сказать, что айфон был тождественен другому объекту, нужно, чтобы выполнялись следующие условия: - если айфон сравнивать с самим собой, то они одинаковые; - другой объект не должен быть null; - другой объект тоже должен быть айфоном; - цена другого айфона должна быть такой же, как у моего; - модели этих айфонов должны совпадать; - цвет этих айфонов должен совпадать. То есть ты сам определяешь, какие два айфона будут считаться одинаковыми и заменяешь стандартное поведение из метода equals своим. Именно это и требуется реализовать в задаче. На первых двух пунктах останавливаться подробнее не буду, думаю они вопросов не вызывают.

public boolean equals(Object object) {
    if(this == object) {
        return true;
    }
    if(object == null || getClass() != object.getClass()) {
        return false;
    }

Если в первых двух ифах мы не вышли из метода, значит ни одно из условий выше не выполнилось. Это означает, что во-первых мы не сравниваем объект сам с собой, а во-вторых классы наших объектов совпадают, то есть в Object object хранится объект типа Iphone. Значит можно выполнить явное приведение типа:

Iphone another = (Iphone) object

Остаётся сравнить между собой три пары полей. Первое поле - это цена (price). Она является примитивом, типа int. Поэтому цены можно сравнить между собой через "==". Сравнили и посмотрели. Если цены разные, то остальное можно не сравнивать, айфоны точно разные.

if (this.price != another.price) {
    return false;
}

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

Итого, мы знаем, что оба объекта - это айфоны, и у них одинаковые цены. Осталось сравнить между собой модели и цвета. Начнём с моделей. Каждая из моделей может быть null, мы от этого не застрахованы. А может быть не null. Поэтому возможны 4 варианта: - обе null; - первая null, вторая не null; - первая не null, вторая null; - обе не null. Если this.model==null, а мы вдруг вызовем у неё метод equals, то возникнет исключение. Поэтому перед тем, как вызывать, надо проверить, что там не null:

if (this.model == null) {
    if (another.model != null) { // если у одного налл, а у другого нет, значит айфоны разные
        return false;
    }
} else { // если this.model != null, то можно вызвать метод equals у самой модели
    if (!this.model.equals(another.model)) {
        return false; // если обе модели разные, то айфоны разные
    }
}
// если мы дошли до этой строчки, значит модели совпадают:
// либо они обе null, либо обе одинаковые

Таким образом мы сравнили между собой две модели. Если обе проверки прошли мимо, значит модели совпадают, и осталось проверить цвета. С ними абсолютно аналогично, выполняются те же самые проверки. Если и цвета совпали, то можно в конце написать return true; потому что если бы было не тру, то сработала бы какая-то их проверок, и false бы вернулось раньше. А чтобы каждый раз руками не писать такую длинную колбасу, а если оно налл, а если вдруг не налл, то тогда сравниваем, и т.д., просто для удобства, все это запихнули внутрь утилитного метода equals класса Objects, он внутри уже содержит проверку на null и на равенство, поэтому весь последний блок кода тождественен написи:

Objects.equals(this.model, another.model)

Если этот метод вернул true, значит либо обе модели null, либо обе не null, но тогда при этом одинаковые. Поэтому идея тебе предлагает просто лаконичную запись вместо того, чтобы объяснять тебе по шагам, как я :)

Простой класс у которого создали метод как вы предложили с параметром Iphone, а не Object. У нас есть 3 телефона и метод который всегда возвращает true, подумайте какой должен быть вывод, а потом можете проверить себя запустив код.

class Iphone{

  public static void main(String[] args)throws IOException {
    Object iphone1 = new Iphone();
    Iphone iphone2 = new Iphone();
    Iphone iphone3 = new Iphone();
    System.out.println(iphone1.equals(iphone2));
    System.out.println(iphone2.equals(iphone1));
    System.out.println(iphone2.equals(iphone3));
  }

  public boolean equals(Iphone iphone) {
    return true;
  }
}

В целом все что я и хотел понять, а именно : "Ты конечно можешь в своём классе Iphone описать метод equals, у которого параметром будет другой объект Iphone, но проблема в том, что этот метод не будет переопределять поведение оригинального метода equals: чтобы сработало переопределение, нужно чтобы у двух методов совпадала сигнатура, включающая в себя название методов, количество, порядок и типы параметров, а у тебя типы будут разными." и второй момент, что в Objects.equals уже заложена проверка на null (время начинать учиться читать документацию оракл) Огромное спасибо за разъяснение.

Если я все правильно понимаю, то : System.out.println(iphone1.equals(iphone2)); // здесь мы вызываем equals Object`a потому и вернется false System.out.println(iphone2.equals(iphone1)); // вот тут конечно вопрос, почему не используется переопределенный метод equals, но возможно из-за того, что объекты различаются классом. System.out.println(iphone2.equals(iphone3)); // здесь используется наш equals который вернет true.

System.out.println(iphone2.equals(iphone1)); Объекты одинаковые, тип ссылки разный. Из за того что мы передаем ссылку типа Object, а в классе Iphone нет метода который принимает Object, вызывается метод родителя и сравниваются ссылки возвращая false

Спасибо