Решение о написании данной статьи пришло из-за недостаточной информации её на каком-либо одном ресурсе. И вот пришлось всё собирать по кусочкам. Здесь не будет какой-то углублённой информации. Здесь будет только поверхностная и лёгкая к восприятию, чтобы вам было с чего начать и чтобы в дальнейшем вы уже сами решили, что вам нужно узнать получше.
Надеюсь вам будет всё интуитивно понятно и вы закроете пробелы в недостающих знаниях. А теперь вперёд за дело!
Метод equals в Java используется для проверки, равен ли объект другому объекту. В данном случае метод переопределяет реализацию метода equals, который наследуется от класса Object.
В этом коде:
public boolean equals(Object obj) {
return (this == obj); }
Метод equals принимает один параметр типа Object и возвращает значение типа boolean. Внутри метода происходит сравнение текущего объекта (this) с переданным объектом (obj) с помощью оператора ==. Этот оператор проверяет, ссылаются ли две переменные на один и тот же объект в памяти.
Пример 1:
Предположим, у нас есть класс Person:
class Person {
private String name;
public Person(String name) {
this.name = name;
}
// Другие методы...
}
И мы хотим сравнить два объекта Person на равенство. Если мы используем метод equals, как показано выше, то он всегда будет возвращать false, потому что метод сравнивает ссылки на объекты, а не их содержимое. Чтобы исправить это, нам нужно переопределить метод equals таким образом, чтобы он сравнивал значения свойств объектов. Например:
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
} else if (obj instanceof Person) {
Person other = (Person) obj;
return this.name.equals(other.name);
} else {
return false;
}
}
Теперь метод equals корректно сравнивает два объекта Person по их имени.
Пример 2:
Если мы хотим использовать метод equals для сравнения двух строк, мы можем просто использовать его напрямую, так как в классе String уже есть переопределённый метод equals. Например:
String str1 = "Hello";
String str2 = "Hello";
boolean areEqual = str1.equals(str2); // true
Этот код вернёт true, потому что строки содержат одинаковые символы.
А теперь рассмотрим фрагмент кода, приведенного в примере выше:
else if (obj instanceof Person) {
Person other = (Person) obj;
return this.name.equals(other.name);
, чтобы проверить, является ли объект obj экземпляром класса Person.
1. else if (obj instanceof Person) — это условие проверяет, принадлежит ли объект obj классу Person или его подклассу. Если это так, то выполняется блок кода внутри фигурных скобок {...}.
Конструкция obj instanceof Person в Java используется для проверки, является ли объект obj экземпляром класса Person или его подкласса.
Оператор instanceof проверяет, принадлежит ли объект указанному классу или одному из его суперклассов. Если объект действительно является экземпляром указанного класса или одного из его подклассов, результатом будет true, иначе — false.
Эта конструкция часто используется в условных выражениях для выполнения определённых действий в зависимости от типа объекта.
2. Person other = (Person) obj; — здесь происходит приведение типа объекта obj к типу Person. Это позволяет обращаться к методам и свойствам класса Person для объекта obj. Переменная other теперь ссылается на объект типа Person, который был передан в качестве параметра obj.
3. return this.name.equals(other.name); — этот код сравнивает два значения свойства name у объектов this и other. Метод equals() используется для сравнения строк. Если значения совпадают, метод возвращает true, иначе — false. Результат этого сравнения возвращается из метода, в котором содержится этот фрагмент кода.
Таким образом, если объект obj является экземпляром класса Person, код сравнивает значения их свойств name и возвращает результат сравнения.
=================================================================================================
Дополнительно:
Оператор *instanceof* в Java используется для проверки, является ли объект экземпляром определённого класса или его подкласса. Вот несколько примеров использования этого оператора с пояснениями:
1. Пример проверки типа объекта:
class Vehicle {
}
class Car extends Vehicle {
}
public class Main {
public static void main(String[] args) {
Vehicle vehicle = new Car();
if (vehicle instanceof Car) {
System.out.println("Это автомобиль");
} else {
System.out.println("Это не автомобиль");
}
}
}
В этом примере мы создаём класс Vehicle и его подкласс Car. Затем мы проверяем, является ли переданный объект vehicle экземпляром класса Car, используя оператор instanceof. Если объект является экземпляром Car, выводится сообщение «Это автомобиль», иначе — «Это не автомобиль».
2. Пример приведения типа с использованием instanceof:
interface Animal {
}
class Dog implements Animal {
}
public class Main {
public static void main(String[] args) {
Animal animal = new Dog();
if (animal instanceof Dog) {
Dog dog = (Dog) animal;
// Теперь можно использовать методы класса Dog
}
}
}
Здесь мы используем интерфейс Animal и класс Dog, который его реализует. Мы проверяем, является ли объект animal экземпляром класса Dog, используя instanceof, и если это так, приводим тип объекта к Dog с помощью приведения типов. Это позволяет нам использовать методы и свойства класса Dog.
3. Пример использования instanceof в условных выражениях:
enum Color {
RED, BLUE, GREEN
}
public class Main {
public static void main(String[] args) {
Color color = Color.RED;
if (color instanceof Color.RED) {
System.out.println("Цвет красный");
} else if (color instanceof Color.BLUE) {
System.out.println("Цвет синий");
} else {
System.out.println("Другой цвет");
}
}
}
Этот пример демонстрирует использование оператора instanceof с перечислением (enum) Color. Мы проверяем, равен ли объект color значению Color.RED, Color.BLUE или другому значению перечисления. В зависимости от результата проверки выполняется соответствующий блок кода.
=================================================================================================
**Послесловие.**
*Экземпляр класса в Java* — это **объект**, который создаётся на основе определённого пользователем или встроенного класса. Класс определяет структуру и поведение объекта, а __экземпляр представляет собой конкретную реализацию этой структуры с собственными значениями атрибутов.__
Пример:
Допустим, у нас есть класс Person, который описывает человека:
class Person {
String name;
int age;
// Конструктор
public Person(String name, int age) {
this.name = name;
this.age = age;
}
}
Чтобы создать экземпляр этого класса, мы можем написать:
Person person1 = new Person("Иван", 25);
Здесь person1 — это экземпляр класса Person. Он имеет собственные значения атрибутов (name и age), которые можно использовать и изменять в коде.
Если вам что-то ещё осталось не понятным, возможно пример ниже даст вам уже окончательную ясность в вопросе:
Итак, мне задали вопрос в комментарии:
В метод мы передаём тип Object и проверяем является ли он экземпляром типа Person, тогда как может получиться тру если это разные типы, а потом ещё и приводим их к одному типу, если до этого проверяли являются ли они экземпляры одного и тогоже типа
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
} else if (obj instanceof Person) {
Person other = (Person) obj;
return this.name.equals(other.name);
} else {
return false;
}
}
Давайте попробуем разобраться ещё раз:
1. Это может может получится true, если передаваемый объект-экземпляр(obj) ссылается на ту же ссылку, что и созданный(this).
Vehicle vehicle2toCar = new Car();
Car carReturnVehicle = (Car) vehicle2toCar;
Наши объекты ссылаются на один тот же адрес объекта в памяти.
У наших объектов одинаковые ссылки, поэтому при их сравнении мы получим true.
Пример будет ниже.
2. Если это разные типы, то мы идём в следующее условие, где проверяем их принадлежность друг к другу. И если оно true, тогда мы их приводим к одному типу.
3. Если это разные типы, тогда false.
Для того чтобы прояснить для себя некоторые моменты с экземплярами, делал проверку в idea.
class Vehicle { }
class Car extends Vehicle { }
public class Main {
public static void main(String[] args) {
Vehicle vehicleCarCar = new Car();
Car car = new Car();
Vehicle vehicle = new Vehicle();
Vehicle vehicle2toCar = new Car();
Car carReturnVehicle = (Car) vehicle2toCar;
if (vehicleCarCar instanceof Car) {
System.out.println("Это автомобиль");
} else {
System.out.println("Это не автомобиль");
}
if (car instanceof Vehicle) {
System.out.println("Это автомобиль");
} else {
System.out.println("Это не автомобиль");
}
if (vehicle instanceof Car) {
System.out.println("Это автомобиль");
} else {
System.out.println("Это не автомобиль");
}
if (vehicle2toCar instanceof Car) {
System.out.println("Это автомобиль");
} else {
System.out.println("Это не автомобиль");
}
System.out.println(vehicle2toCar.equals(carReturnVehicle));
}
}
Вывод:
Это автомобиль
Это автомобиль
Это не автомобиль
Это автомобиль
true
===============================================================================================
Давайте теперь объединим и закрепим все знания по equls на 11 уровне 5 лекции:
class Person extends Human{
String name;
int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public boolean equals(Object obj) {
/* Сценарий 1: в метод equals передали тот же самый объект, у которого вызвали метод equals.
Если ссылки у текущего и переданного объектов равны, нужно вернуть true.
Объект совпадает сам с собой: */
if (this == obj) return true;
/*Сценарий 2: в метод equals передали ссылку null — сравнивать не с чем.
Объект, у которого вызвали метод equals, точно не null, значит,
в этом случае нужно вернуть false: */
if (obj == null) return false;
/* Сценарий 3: Проверяем в методе equals передали ли ссылку на объект класса Person.
Все же объекты считаются равными, если это объекты одного класса: */
if (!(obj instanceof Person)) return false;
// Для сравнение объектов двух одинаковых классов вместо instanceof можете использовать
// if (getClass() != obj.getClass()) return false;
/* Сценарий 4: Сравнение двух объектов Person */
// 4.1. Приведение к одному типу
Person person = (Person) obj;
// 4.2. Сравнение параметров двух объектов типа int и String:
// Эти поля могут в себе ничего не содержать изначально и быть 0 или null.
// Нужно выполнить проверку.
// 2 варианта написания:
// Первый с учётом разницы полей в содержании через if
if (this.age != person.age) return false;
if (this.name == null) return person.name == null;
/*Тогда последней строчкой будет */
/** return this.name.equals(person.name); */
// Или сразу учитываем все параметры в операторе return:
return this.name != null && this.name.equals(person.name) && this.age == person.age;
}
}
class Human {
Human type;
}
public class javaRushEquals {
public static void main(String[] args) {
Person person1 = new Person("Dave", 25);
Person person2 = new Person("Dave", 25);
Human human = new Person("Dave", 25);
System.out.println(person1.equals(person2));
System.out.println(person2.equals(human));
}
}
Вывод:
true
true
Методы instanceof и getClass() используются для проверки типа объекта в Java, но они работают по-разному и применяются в разных контекстах.
instanceof — это оператор, который проверяет, является ли объект экземпляром определённого класса или его подкласса. Он возвращает true, если объект принадлежит указанному классу или одному из его подклассов, и false, если нет.
getClass() — это метод, который возвращает класс объекта. Он используется для получения информации о классе объекта во время выполнения программы.
public class GetClassOrInstanceof {
public static void main(String[] args) {
Object obj1 = new Object();
Object obj2 = new String();
String str = new String();
boolean result1 = obj1 instanceof Object; // true
boolean result2 = obj2 instanceof String; // true
boolean result3 = obj1.getClass() == obj2.getClass(); // false
boolean result4 = str.getClass() == obj2.getClass(); // true
}
}
Разница между instanceof и getClass() != obj.getClass() заключается в том, что первый оператор проверяет принадлежность объекта к определённому классу или подклассу, а второй оператор сравнивает классы двух объектов на предмет их идентичности.
Надеюсь эта статья была полезна для вас и ответила минимально на все интересующие вопросы в начале изучения метода equals.
Хорошего времени суток! И успехов!
Если вам понравилась статья, нажмите лайк! ❤️ Вам не сложно, а мне приятно 🙂
ПЕРЕЙДИТЕ В ПОЛНУЮ ВЕРСИЮ