javase

原创已于 2022-09-11 19:57:37 修改 · 288 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java #前端 #c++

于 2022-09-11 19:56:28 首次发布

静态内部类不可以直接访问外围类的非静态数据，而非静态内部类可以直接访问外围类的数据，包括私有数据。（）

在这里插入图片描述

假定Base b = new Derived（）; 调用执行b.methodOne（）后，输出结果是什么？

public class Base
{
   public void methodOne()
   {
      System.out.print("A");
      methodTwo();
   }

   public void methodTwo()
   {
      System.out.print("B");
   }
}

public class Derived extends Base
{
   public void methodOne()
   {
      super.methodOne();
      System.out.print("C");
   }

   public void methodTwo()
   {
      super.methodTwo();
      System.out.print("D");
   }
}

ABDC 子类重写了父类的方法会进行覆盖

如果Child extends Parent，那么正确的有（）？

如果Child是class，且只有一个有参数的构造函数，那么必然会调用Parent中相同参数的构造函数

如果Child是interface，那么Parent必然是interface

如果Child是interface，那么Child可以同时extends Parent1，Parent2等多个interface

如果Child是class，并且没有显示声明任何构造函数，那么此时仍然会调用Parent的构造函数

A 可以调用父类无参的构造函数，子类的有参构造函数和是否调用父类的有参数的构造函数无必然联系。

B 接口继承的时候只能继承接口不能继承类，因为如果类可以存在非抽象的成员，如果接口继承了该类，那么接口必定从类中也继承了这些非抽象成员，这就和接口的定义相互矛盾，所以接口继承时只能继承接口。

C 接口可以多继承可以被多实现，因为接口中的方法都是抽象的，这些方法都被实现的类所实现，即使多个父接口中有同名的方法，在调用这些方法时调用的时子类的中被实现的方法，不存在歧义；同时，接口的中只有静态的常量，但是由于静态变量是在编译期决定调用关系的，即使存在一定的冲突也会在编译时提示出错；而引用静态变量一般直接使用类名或接口名，从而避免产生歧义，因此也不存在多继承的第一个缺点。对于一个接口继承多个父接口的情况也一样不存在这些缺点。所以接口可以多继承。

D 子类即使没有显示构造函数，也会有个无参数的默认构造函数，仍然会调用父类的构造函数。

4.Arrays.asList方法返回java.util.ArrayList对象正确吗？

Arrays.asList()

将一个数组转化为一个List对象，这个方***返回一个ArrayList类型的对象，这个ArrayList类并非java.util.ArrayList类，**而是Arrays类的静态内部类！**用这个对象对列表进行添加删除更新操作，就会报UnsupportedOperationException异常。

下面代码的运行结果是（）

public static void main(String[] args){
    String s;
    System.out.println("s="+s);
}

编译失败局部变量必须赋默认值

说明输出结果。

import java.util.Date;  
public class SuperTest extends Date{  
    private static final long serialVersionUID = 1L;  
    private void test(){  
       System.out.println(super.getClass().getName());  
    }  
     
    public static void main(String[]args){  
       new SuperTest().test();  
    }  
}

super.getClass().getName()由于没有重写（getclass是），所以用的还是Object中的getClass().getName()方法：返回当前运行类的名字。所以其实用super和用this都一样。但如果要返回父类的名字就应该使用getClass().getSuperclass()。

注意：如果没有packge这一行结果就不包含"test."

代码如下：

package test;

import java.util.Date;

public class SuperTest extends Date{

    private static final long serialVersionUID = 1l;
    private void test() {
        System.out.println(this.getClass().getName());
        System.out.println(this.getClass().getSuperclass());
        System.out.println(super.getClass().getName());
        System.out.println(super.getClass().getSuperclass());
    }

    public static void main(String[] args) {
        new SuperTest().test();
    }

}

在这里插入图片描述

7.类的加载顺序

在这里插入图片描述

类的加载顺序：

(1) 父类静态对象和静态代码块

(2) 子类静态对象和静态代码块

(3) 父类非静态对象和非静态代码块

(4) 父类构造函数

(5) 子类非静态对象和非静态代码块

(6) 子类构造函数

8.关于下面的程序Test.java说法正确的是( )。

public class Test {
    static String x="1";
    static int y=1;
    public static void main(String args[]) {
        static int z=2;
        System.out.println(x+y+z);
    }
}

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

3
112
13
程序有编译错误

被static修饰的变量称为静态变量，静态变量属于整个类，而局部变量属于方法，只在该方法内有效，所以static不能修饰局部变量

9.以下程序的执行结果是：

static boolean foo(char c){
     System.out.print(c);
     return true;
 }
 public static void main(String[] args) {
     int i =0;
     for(foo('A');foo('B')&&(i<2);foo('C')){
         i++;
         foo('D');
     }
 }

ABDCBDCB
ABCDABCD
编译时出错
运行时抛出异常

1.其实foo(‘A’);就是初始化条件，只会执行一次，所以第一个打印的肯定是A
2.因为i=0;循环条件是i<2 （由此可知循环i等于2的时候就会停止循环，)所有0<2满足条件，接着会输出B，然后执行i++；i就变成1了，再输出D，再最后输出C，一次循环后的结果是：ABDC
3.第二次循环的开始是foo(‘A’);是初始条件所以不会执行，直接从foo(‘B’)开始，输出B，然后i为1，且小于2，此时循环体内再次执行i++；i的值为2了，再次输出D，最后输出C
第二次循环输出：BDC
4.*然后循环再次执行for(foo(‘A’);foo(‘B’)&&(i<2);foo(‘C’))
直接输出B，***i的值在第二轮循环后的值变成了2，2<2不成立，终止循环，输出B

10.@SuppressWarnings(“deprecation”)的功能是什么？

屏蔽不赞同使用的类和方法的警告
屏蔽在强制类型转换的时候编译器给出的警告
关闭所有警告信息
当在可序列化的类上缺少serialVersionUID定义的警告

解析： deprecation: 反对

没学过但是看英文也知道意思了

仔细看看大佬的解析才知道这个考察的是：Java自带的三大注解：

@Override 需要覆盖超类中的方法

@SuppressWarnings() 表示不赞成以后再使用此类方法。题目中其属性是deprecation: 表示禁止了此警示 @Deprecated 表示以后可能会被删除，不建议后来者使用此类或者方法。

11.list是一个ArrayList的对象，哪个选项的代码填到//todo delete处，可以在Iterator遍历的过程中正确并安全的删除一个list中保存的对象？（）

Iterator it = list.iterator();
int index = 0;
while (it.hasNext())
{
    Object obj = it.next();
    if (needDelete(obj))  //needDelete返回boolean，决定是否要删除
    {
        //todo delete
    }
    index ++;
}

it.remove();
list.remove(obj);
list.remove(index);
list.remove(obj,index);

解析：Iterator 支持从源集合中安全地删除对象，只需在 Iterator 上调用 remove() 即可。这样做的好处是可以避免 ConcurrentModifiedException ，当打开 Iterator 迭代集合时，同时又在对集合进行修改。有些集合不允许在迭代时删除或添加元素，但是调用 Iterator 的remove() 方法是个安全的做法。

选择A
);
list.remove(obj);
list.remove(index);
list.remove(obj,index);


解析：Iterator   支持从源集合中安全地删除对象，只需在 Iterator 上调用 remove() 即可。这样做的好处是可以避免 ConcurrentModifiedException ，当打开 Iterator 迭代集合时，同时又在对集合进行修改。有些集合不允许在迭代时删除或添加元素，但是调用 Iterator 的remove() 方法是个安全的做法。

 选择A