Java 匿名内部类、Java 中 == 与 equals 的区别

原创已于 2022-03-30 17:09:14 修改 · 1.1k 阅读

3 ·

CC 4.0 BY-SA版权

文章标签：

#java

于 2019-04-20 21:23:37 首次发布

Java_SE 专栏收录该内容

25 篇文章

订阅专栏

本文深入探讨Java中匿名内部类的使用与限制，以及equals方法的重写原则。了解如何利用匿名内部类简化代码，并掌握equals方法的正确实现，确保对象比较的准确性。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

匿名内部类 Anonymous Inner Class

匿名内部类 Anonymous Inner Class

1、匿名内部类也就是没有名字的内部类。

2、使用匿名内部类还有个前提条件：必须继承一个父类或实现一个接口。创建格式：

new 父类构造器（参数列表）|实现接口（）  {  
     //匿名内部类的类体部分  
}

3、创建匿名内部类时它会立即创建一个该类的实例，该类的定义会立即消失，所以匿名内部类是不能够被重复使用的，适用于单次使用的场景。

import java.util.logging.Logger;
public class HelloWorld {
    public static void main(String[] args) throws InterruptedException {
        Person person = new YellowPerson();
        person.show();
    }
}
abstract class Person {
    public abstract void show();
}
class YellowPerson extends Person {
    @Override
    public void show() {
        Logger logger = Logger.getAnonymousLogger();
        logger.info("我们是黄种人");
    }
}

new YellowPerson(); 假如只需要使用一次，其实也没必要继承 Person 抽象类。可以使用匿名内部类如下。

import java.util.logging.Logger;
public class HelloWorld {
    public static void main(String[] args) throws InterruptedException {
        Person person = new Person() {
            @Override
            public void show() {
                Logger logger = Logger.getAnonymousLogger();
                logger.info("我们是黄种人");
            }
        };
        person.show();
    }
}
abstract class Person {
    public abstract void show();
}

new Person(){...} 中的 {} 就是匿名内部类，相当于继承了 Perser 抽象类。
对于只需要使用一次时，这样的确更方便，因为没必要专门去写一个类继承 Person 了，但是如果希望以后多次使用的，则可以使用具体类来继承。

4、接口也是同理：

import java.util.logging.Logger;
public class HelloWorld {
    public static void main(String[] args) throws InterruptedException {
        //直接使用匿名内部类来新建任务。
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                Logger logger = Logger.getAnonymousLogger();
                logger.info("我是线程：" + Thread.currentThread().getName());
            }
        };
        new Thread(runnable).start();
    }
}

{ }：相当匿名内部类，实现了 Runable 接口。

匿名内部类注意事项

1、使用匿名内部类时，必须是继承一个类或者实现一个接口（两者不可兼得）。

2、匿名内部类中是不能定义构造函数的。因为匿名内部类没有名称，所以也就没有构造器。

3、匿名内部类中不能存在任何的静态成员变量和静态方法。因为创建匿名内部类时它会立即创建一个该类的实例，该类的定义会立即消失，所以匿名内部类是不能够被重复使用的。

4、匿名内部类为局部内部类，所以局部内部类的所有限制同样对匿名内部类生效。

5、匿名内部类不能是抽象的，它必须要实现继承的类或者实现的接口的所有抽象方法。

== 运算符

1、如果作用于基本数据类型的变量，则直接比较其存储的 “值”是否相等；

2、如果作用于引用类型的变量，则比较的是所指向的对象的地址。

    public static void main(String[] args) {
        int n = 10;
        int m = 10;
        System.out.println(n == m);//true。基本类型直接比较值

        String str1 = "hello";
        String str2 = "hello";
        String str3 = new String("hello");
        String str4 = new String("hello");

        //str1 的值存放在字符串常量池中，创建str2时，因为 hello 已经存在，所以会直接返回对象的引用地址
        System.out.println(str1 == str2);//true。
        System.out.println(str3 == str4);//false。引用类型，比较的是对象的地址
        System.out.println(str2 == str3);//false。str2 指向的字符串常量池中的对象，str3 指向堆内存中的对象

        str1 = str3;
        str2 = str3;
        System.out.println(str1 == str2);//true。此时 str1 、str2 都指向同一个对象
    }

    public static void main(String[] args) {
        int n = 1000;
        int m = 1000;
        System.out.println(n == m);//true。基本类型直接比较值

        Integer i1 = 1000;
        Integer i2 = 1000;
        System.out.println(i1 == i2);//false
    }

1、int 是基本类型，所以可以直接使用 == 判断，但是 Integer 是引用类型，这里和 Integer 本身的处理方式有关。Integer i1 = 1000; 其实它默认使用 valueOf 方法进行装箱操作。

// 这是 Integer 中的静态内部类，用于缓存 [-128,127] 之间的 Integer 对象
    private static class IntegerCache {
        static final int low = -128;
        static final int high;
        static final Integer cache[];

        static {
            // high value may be configured by property
            int h = 127;
            String integerCacheHighPropValue =
                sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
            if (integerCacheHighPropValue != null) {
                try {
                    int i = parseInt(integerCacheHighPropValue);
                    i = Math.max(i, 127);
                    // Maximum array size is Integer.MAX_VALUE
                    h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
                } catch( NumberFormatException nfe) {
                    // If the property cannot be parsed into an int, ignore it.
                }
            }
            high = h;

            cache = new Integer[(high - low) + 1];
            int j = low;
            for(int k = 0; k < cache.length; k++)
                cache[k] = new Integer(j++);

            // range [-128, 127] must be interned (JLS7 5.1.7)
            assert IntegerCache.high >= 127;
        }

        private IntegerCache() {}
    }

//所以当 valueOf 的时候，如果值在 [-128,127]直接，则直接存从缓存的常量中返回对象
//如果再范围外，则重新创建对象。
    public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }

其余的包装类型也是同理。

equals 方法

1、equals 是 Object 基类定义的方法，不能作用于基本数据类型的变量

2、如果子类没有对 equals 方法进行重写，则比较的是引用类型的变量所指向的对象的地址；

3、如 String、Date 、Integer 等类对 equals 方法进行了重写，比较的是所指向的对象的内容。

//Object 中定义的 equals 方法
    public boolean equals(Object obj) {
        return (this == obj);
    }

1、显然 Object 中的 equals 方法比较的仍然是两个对象的地址是否一致。所以很多时候如果想要比较对象表示的值是否相等，则需要自己重写 equals 方法。

2、比如常见的 String 可以比较两个字符串的值是否相等，Date 可以比较两个日期是否相等，都是因为他们重写了 equals 方法。

    public static void main(String[] args) {
        String str1 = "hello";
        String str2 = "hello";
        String str3 = new String("hello");
        String str4 = new String("hello");

        System.out.println(str1.equals(str2));//true。
        System.out.println(str3.equals(str4));//true。
        System.out.println(str2.equals(str3));//true。

        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date date1 = dateFormat.parse("2019-04-23 08:00:00");
        Date date2 = dateFormat.parse("2019-04-23 08:00:00");
        System.out.println(date1==date2);//false
        System.out.println(date1.equals(date2));//true
    }

3、String 中重写 equals 方法如下：

public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;//如果两个对象地址一样，则显然值也会相等
        }
        if (anObject instanceof String) {//判断是否为 String 类型
            String anotherString = (String)anObject;
            int n = value.length;
            if (n == anotherString.value.length) {//接着开始逐个字符的进行对比
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                        return false;//只要有一个位置的字符不相等，则都是不相等
                    i++;
                }
                return true;//否则表示两个字符串对象表示的值相等
            }
        }
        return false;
    }

4、Date 中重写 equals 方法如下：

    public boolean equals(Object obj) {
        return obj instanceof Date && getTime() == ((Date) obj).getTime();
    }

5、再比如 Integer ：

    public static void main(String[] args) throws ParseException {
        Integer i1 = 1000;
        Integer i2 = 1000;
        System.out.println(i1==i2);//false
        System.out.println(i1.equals(i2));//true
    }

Integer 重写 equals 如下：

    public boolean equals(Object obj) {
        if (obj instanceof Integer) {
            return value == ((Integer)obj).intValue();//先拆箱，然后对比基本类型的值
        }
        return false;
    }

重写 equals

1、上面 String 、Date、Integer 都自己重写 equals 方法，所以有自己的比较规则。对于其它没有重写 equals 方法的类，则使用时仍然是调用的 Object 的 equals 方法，比较的是对象的地址。

public class HelloWorld {
    public static void main(String[] args) throws ParseException {
        User user1 = new User();
        User user2 = new User();
        user1.setName("zhangSan");
        user2.setName("zhangSan");

        System.out.println(user1==user2);//false
        System.out.println(user1.equals(user2));//false。此时 equals 与 == 无异
    }
}
class User{
    private String name;

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                '}';
    }
}

2、修改成如下所示即可：

import java.text.ParseException;
public class HelloWorld {
    public static void main(String[] args) throws ParseException {
        User user1 = new User();
        User user2 = new User();
        user1.setName("zhangSan");
        user2.setName("zhangSan");

        System.out.println(user1==user2);//false
        System.out.println(user1.equals(user2));//true
    }
}
class User{
    private String name;

    public void setName(String name) {
        this.name = name;
    }

    //IDEA 中可以使用快捷键自动生成，就像生成 getter 、setter 方法一样。Alt + Insert
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        User user = (User) o;

        return !(name != null ? !name.equals(user.name) : user.name != null);

    }

    @Override
    public int hashCode() {
        return name != null ? name.hashCode() : 0;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                '}';
    }
}

如果两个对象相同，即obj1.equals(obj2)=true，则它们的hashCode必须相同，但如果两个对象不同，则它们的hashCode不一定不同，如果两个不同对象的hashCode相同，这种现象称为冲突，冲突会导致操作哈希表的时间开销增大，所以尽量定义好的hashCode()方法，能加快哈希表的操作。

如果相同的对象有不同的hashCode，对哈希表的操作会出现意想不到的结果（期待的get方法返回null），要避免这种问题，只需要牢记一条：要同时复写equals方法和hashCode方法，而不要只写其中一个。