【equals比较方法 和 内部类】

简介: 【equals比较方法 和 内部类】

前言

对象比较equals方法

三种比较相等方法:

第一种,如果==两侧是基本数据类型,则比较变量的值是否相等

第二种,如果 == 两侧是引用数据类型,则比较引用变量的地址是否相等

第三种,如果要比较引用对象的值是否相等,则要重写Object中的equals方法

class Student{
    public String name;
    public int age;
    //构造方法初始化成员变量
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    //重写toString方法
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    //重写equals方法
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age && Objects.equals(name, student.name);
    }
    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}
public class Test {
    public static void main(String[] args) {
        Student student = new Student("藏三",6);
        Student student2 = new Student("藏三",6);
        //只是比较地址一样不一样
        System.out.println(student==student2);
        //这才是比较对象一样不一样
        System.out.println(student.equals(student2));
    }
}

结论:比较对象中内容是否相同的时候,一定要重写equals方法。

内部类

可以将一个类定义在另一个类或者一个方法的内部,

前者称为内部类,后者称为外部类

【注意事项】

  1. 定义在class 类名{}花括号外部的,即使是在一个文件里,都不能称为内部类
  2. 内部类和外部类共用同一个java源文件,但是经过编译之后,内部类会形成单独的字节码文件

实例内部类

即未被static修饰的成员内部类

// OutClass是外部类
// InnerClass是内部类
class OutterClass{
    public int date1 = 9;
    public static int date2 = 77;
    private  int date3 =66 ;
    public void test(){
       InnerClass innerClass = new InnerClass();//在外部类实例化实例内部类
        System.out.println("OutterClass:test()");
    }
    //实例内部类:即未被static修饰的成员内部类。
    class InnerClass{
        public int date1 = 111;
        public int date4 = 44;
        public static final int date5 = 10;
        private int date6 = 7;
        public void test(){
            System.out.println("InnerClass:test()");
            System.out.println(date1);//实例内部类有date1,外部类也有date1,优先访问实例内部类的
            System.out.println(OutterClass.this.date1);//访问外部类,用外部类类名点this点变量名
            System.out.println(date2);
            System.out.println(date3);
            System.out.println(date4);
            System.out.println(date5);
            System.out.println(date6);
        }
    }
}
public class Test {
    public static void main(String[] args) {
        OutterClass outterClass = new OutterClass();
        //实例化实例内部类对象
        //要先实例化外部类对象,
        // 然后在实例化内部类的=号左边加大驼峰外部类类名和.  右边加小驼峰外部类类名和.
        OutterClass.InnerClass innerClass = outterClass.new InnerClass();
        innerClass.test();
    }
}

静态内部类

class OuterClass{
    public int date1 = 1;
    private int date2 = 2;
    public static int date3 = 3;
    //静态内部类
    static class InterClass{
        public int  date4 = 4;
        public static int date5 = 5;
        private  int date6 = 6;
        public void test(){
            System.out.println("InterClass:test()");
//            System.out.println(date1);//不能调用非静态的成员变量
//            System.out.println(date2);
            //可以用外部类间接访问
            OuterClass outerClass = new OuterClass();
            System.out.println(outerClass.date1);
            System.out.println(outerClass.date2);
            System.out.println(date3);
            System.out.println(date4);
            System.out.println(date5);
            System.out.println(date6);
        }
    }
    public void test(){
        System.out.println("OuterClass:test()");
    }
}
public class Test {
    public static void main(String[] args) {
        //静态内部类的实例化
        OuterClass.InterClass interClass = new OuterClass.InterClass();
        interClass.test();
    }
}

匿名内部类

(多线程常用)

//匿名内部类
interface IA{
    void teat();
}
public class Test {
    public static void main(String[] args) {
        IA a = new IA() {
            @Override
            public void teat() {
                System.out.println("重写了接口方法");
            }
        };
        a.teat();
    }
}

总结

equals比较方法最核心是要重写Object中的equals方法,还有明白什么是外部类,内部类,以及实例内部类,静态内部类。

相关文章
|
6月前
|
存储 算法 Java
为什么要重写 hashcode 和 equals 方法
为什么要重写 hashcode 和 equals 方法
54 0
|
29天前
|
存储 算法 Java
为什么重写 equals 方法时必须同时重写 hashCode 方法?
本文探讨了 Java 中 `hashCode` 方法的作用及其与 `equals` 方法的关系,解释了为什么重写 `equals` 方法时必须同时重写 `hashCode` 方法,并提供了如何正确重写 `hashCode` 方法的示例。
|
11月前
|
存储
重写equals后为什么要重写hashcode方法
重写equals后为什么要重写hashcode方法
66 0
|
6月前
|
存储 IDE Java
为什么重写 equals() 时必须重写 hashCode() 方法?(简单易理解)
为什么重写 equals() 时必须重写 hashCode() 方法?(简单易理解)
47 1
|
Java
Java面向对象中 Object类的详解和其中的equals()和toString()方法的详解
Java面向对象中 Object类的详解和其中的equals()和toString()方法的详解
73 0
|
存储
为什么重写 equals 方法就必须重写 hashCode 方法?
为什么重写 equals 方法就必须重写 hashCode 方法?
79 0
|
存储 Java
重写equals方法
我们在java程序中调用自带的equals方法时,你是否会有这样的疑问:明明我比较的数据都一样啊,为什么会返回false呢?有些人可能还会疑问,怎么有时候返回true?有时候返回false呢?这是为什么呢?其实是和Java底层人家写的equals方法逻辑有关系
为什么要重写 hashcode 和 equals 方法?
为什么要重写 hashcode 和 equals 方法?
82 0
|
存储 Java 对象存储
JavaSE——为什么重写equals的同时一定要重写hashCode?
JavaSE——为什么重写equals的同时一定要重写hashCode?
JavaSE——为什么重写equals的同时一定要重写hashCode?
|
存储 算法 Java
(强制)要求覆写equals必须覆写hashCode(原理分析)
hashCode和equals hashCode和equals用来标识对象,两个方法协同工作可用来判断两个对象是否相等。众所周知,根据生成的哈希将数据散列开来,可以使存取元素更快。对象通过调用Object.hashCode()生成哈希值;由于不可避免会存在哈希值冲突 的情况,因此当hashCode相同时,还需要再调用equals进行一次值的比较;但是若hashCode不同,将直接判定Object不同,跳过equals,这加快了冲突处理效率。Object类定义中对hashCode和equals要求如下:
238 0