Java错题集(二)

目录

 

以下程序的运行结果是：(    )

下面有关java final的基本规则，描述错误的是？

关于equals和hashCode描述正确的是    ()

以下代码执行的结果是多少（）？

---

 

以下程序的运行结果是：(    )

TreeSet<Integer> set = new TreeSet<Integer>();
 TreeSet<Integer> subSet = new TreeSet<Integer>();
 for(int i=606;i<613;i++){
 if(i%2==0){
 set.add(i);
 }
 }
 subSet = (TreeSet)set.subSet(608,true,611,true);
 set.add(629);
 System.out.println(set+" "+subSet);

正确答案: C   你的答案: B (错误)

编译失败

发生运行时异常

[606, 608, 610, 612, 629] [608, 610]

[606, 608, 610, 612, 629] [608, 610,629]

来源：https://www.nowcoder.com/questionTerminal/9643a55b528743f6a68ac7adf9072ea0

subset(form，true，to，true)是Treeset的非静态方法，该方法返回从form元素到to元素的一个set集合，两个boolean类型是确认是否包含边境值用的。

 

下面有关java final的基本规则，描述错误的是？

正确答案: B   你的答案: B (正确)

final修饰的类不能被继承

final修饰的成员变量只允许赋值一次，且只能在类方法赋值

final修饰的局部变量即为常量，只能赋值一次。

final修饰的方法不允许被子类覆盖

来源：https://www.nowcoder.com/questionTerminal/870eeb30a78e4a03b15c6d45e5f16bf9

final修饰的成员变量为基本数据类型时，在赋值之后无法改变。

当final修饰的成员变量为引用数据类型时，在赋值后其指向地址无法改变，但是对象内容还是可以改变的。

final修饰的成员变量在赋值时可以有三种方式。1、在声明时直接赋值。2、在构造器中赋值。3、在初始代码块中进行赋值。

 

关于equals和hashCode描述正确的是    ()

正确答案: A B C   你的答案: B C (错误)

两个obj，如果equals()相等，hashCode()一定相等（符合代码规范的情况下）

两个obj，如果hashCode()相等，equals()不一定相等

两个不同的obj， hashCode()可能相等

其他都不对

来源：https://www.nowcoder.com/questionTerminal/19348388946640c9b2ce962eed10cda1

“==”：作用是判断两个对象的地址是否相等，即，判断两个对象是不是同一个对象，如果是基本数据类型，则比较的是值是否相等。

"equal"：作用是判断两个对象是否相等，但一般有两种使用情况

              1.类没有覆盖equals()方法, 则相当于通过“==”比较

              2.类覆盖equals()方法，一般，我们都通过equals()方法来比较两个对象的内容是否相等，相等则返回true,如String

 

地址比较是通过计算对象的哈希值来比较的，hashcode属于Object的本地方法，对象相等（地址相等），hashcode相等，对象不相等，hashcode()可能相等，哈希冲突

 

以下代码执行的结果是多少（）？

        

import java.util.*;

public class Demo {
    public static void main(String[] args) {
        Collection<?>[] collections = {
                new HashSet<String>(), new ArrayList<String>(), new HashMap<String, String>().values()
        };
        Super subToSuper = new Sub();
        for(Collection<?> collection: collections) {
            System.out.println(subToSuper.getType(collection));
        }
    }
    abstract static class Super {
        public static String getType(Collection<?> collection) {
            return "Super:collection";
        }
        public static String getType(List<?> list) {
            return "Super:list";
        }
        public String getType(ArrayList<?> list) {
            return "Super:arrayList";
        }
        public static String getType(Set<?> set) {
            return "Super:set";
        }
        public String getType(HashSet<?> set) {
            return "Super:hashSet";
        }
    }
    static class Sub extends Super {
        public static String getType(Collection<?> collection) {
            return "Sub";
        }
    }
}

正确答案: C   你的答案: A (错误)

Sub:collection
Sub:collection
Sub:collection

Sub:hashSet
Sub:arrayList
Sub:collection

Super:collection
Super:collection
Super:collection

Super:hashSet
Super:arrayList
Super:collection

来源：https://www.nowcoder.com/questionTerminal/5dbdf7b89d9a4c27908a8c5c1e88c2fe

1.

这是静态分派的过程，在编译时已经决定了使用super的方法，因为subToSuper 是指super对象，可是为什么会选择collection呢，for循环出来他们实际上指的是collection对象表示的，即类似于Collection    col = new  HashSet<>();这样传入方法getType（）中的参数就是col，左边是静态类型，右边是实际类型。由于重载实际上是使用静态分派的，重载时是通过参数的静态类型而不是实际类型作为判定依据的。详细参考深入理解java虚拟机248页解释。

2.

考察点1：重载静态多分派——根据传入重载方法的参数类型，选择更加合适的一个重载方法

考察点2：static方法不能被子类覆写，在子类中定义了和父类完全相同的static方法，则父类的static方法被隐藏，Son.staticmethod()或new Son().staticmethod()都是调用的子类的static方法，如果是Father.staticmethod()或者Father f = new Son(); f.staticmethod()调用的都是父类的static方法。

考察点3：此题如果都不是static方法，则最终的结果是A. 调用子类的getType，输出collection

3

我觉得这个题没理解的好好去看看深入理解JVM虚拟机这本书的第八章的内容。

考了两个知识点：

    1. 静态方法，不存在重写，重写只对可见的实例方法有效。静态方法只有隐藏。

    2. 重载是根据形参的静态类型确定调用的方法版本，重写是根据调用者在运行期的实际类型来确定调用的方法版本。