牛客网错题总结（6）

我自己运营的一个公众号-----IT资源君
我每天都会分享java全套教程，python爬虫，python数据分析，各类IT资源等1000G资源，大家可以去免费无套路领取

---

1.Servlet的生命周期可以分为初始化阶段，运行阶段和销毁阶段三个阶段，以下过程属于初始化阶段是（）。
A.加载Servlet类及.class对应的数据
B.创建servletRequest和servletResponse对象
C.创建ServletConfig对象
D.创建Servlet对象

---

2.JAVA反射机制主要提供了以下哪些功能？
A.在运行时判断一个对象所属的类
B.在运行时构造一个类的对象
C.在运行时判断一个类所具有的成员变量和方法
D.在运行时调用一个对象的方法

解析： Java反射机制主要提供了以下功能：

• 在运行时判断任意一个对象所属的类；
• 在运行时构造任意一个类的对象；
• 在运行时判断任意一个类所具有的成员变量和方法；
• 在运行时调用任意一个对象的方法；
• 生成动态代理。
  因此，答案为：ABCD

---

3.以下代码执行的结果显示是多少（ ）？

public class Demo { class Super{  int flag=1;
         Super(){
             test();
         }  void test(){
            System.out.println("Super.test() flag="+flag);
         }
    } class Sub extends Super{
        Sub(int i){  flag=i;
            System.out.println("Sub.Sub()flag="+flag);
        }  void test(){
            System.out.println("Sub.test()flag="+flag);
        }
    }  public static void main(String[] args) {  new Demo().new Sub(5);
     }
}

A. Sub.test() flag=1
Sub.Sub() flag=5
B. Sub.Sub() flag=5
Sub.test() flag=5
C. Sub.test() flag=0
Sub.Sub() flag=5
D. Super.test() flag=1
Sub.Sub() flag=5

解析：

在继承中代码的执行顺序为：1.父类静态对象，父类静态代码块
2.子类静态对象，子类静态代码块
3.父类非静态对象，父类非静态代码块
4.父类构造函数
5.子类非静态对象，子类非静态代码块
6.子类构造函数
对于本题来说：在只想new Sub(5)的时候，父类先初始化了 int flag = 1，然后执行父类的构造函数Super（），父类构造函数中执行的test（）方法，因子类是重写了test（）方法的，因此父类构造函数中的test（）方法实际执行的是子类的test（）方法，所以输出为Sub.test() flag=1，接着执行子类构造函数Sub(5) 将flag赋值为5，因此输出结果Sub.Sub() flag=5。最终选择了A

---

4.类Parent和Child定义如下：

1 ．class  Parent{

2. public  float  aFun(float a, float b) { }

3 ．}

4 ．class  Child  extends  Parent{

5 ．

6 ．}

将以下哪种方法插入行5是不合法的。（ ）

A. float aFun(float a, float b){ }
B. public int aFun(int a, int b) { }
C. public float aFun(float p, float q){ }
D. private int aFun(int a, int b){ }

解析

方法重写应遵循“三同一小一大”原则：
“三同”：即方法名相同，形参列表相同，返回值类型相同；
“一小”：子类方法声明抛出的异常比父类方法声明抛出的异常更小或者相等；
“一大”:子类方法的访问修饰符应比父类方法更大或相等。

A选项是重写，但是默认访问修饰符比父类小，插入第五行编辑器会报错。
B、D不是重写。因为形参列表和返回值类型不同，不满足“三同”。所以写在第五行以普通方法对待，插入第五行没有错误。
C选项满足重写的各项条件，是正确的重写，所以插入第五行没有错误。

---

5.运行下面代码，输出的结果是（）

class A {
    public A() {
        System.out.println("class A");
    }
    { System.out.println("I'm A class"); } 
    static { System.out.println("class A static"); }
}
public class B extends A {
    public B() {
        System.out.println("class B");
    }
    { System.out.println("I'm B class"); }
    static { System.out.println("class B static"); }
     
    public static void main(String[] args) { 
 new B(); 
 }
}

A. class A static
class B static
I’m A class
class A
I’m B class
class B
B. class A static
I’m A class
class A
class B static
I’m B class
class B
C. class A static
class B static
class A
I’m A class
class B
I’m B class
D. class A static
class A
I’m A class
class B static
class B
I’m B class

解析：

要理解Java程序初始化顺序，就得理解虚拟机从加载、编译、运行一个类的过程：
静态代码域：包括静态变量、静态代码块，这些是随着虚拟机加载得时候就要执行得，且只会执行一次，它们之间得优先级是同等的，根据出现的先后来决定次序。

当运行一个子类程序时，JVM首先会先完成加载：
先父类再子类，所以会先执行父类和子类的静态代码域。
加载完成后，开始编译执行（走main方法入口）：
main方法的代码是要new一个子类，所以首先会去初始化父类再去构造子类。而初始化父类的操作是，先是非静态代码块/变量，最后是构造函数。完成了父类的创建后，按照相同的规则去构造子类。

所以题目答案很明了、。A

---

选项中哪一行代码可以添加 到题目中而不产生编译错误？

public abstract class MyClass {
     public int constInt = 5;
     //add code here
     public void method() {
     }
}

A. public abstract void method(int a);
B. constInt = constInt + 5;
C. public int method();
D. public abstract void anotherMethod() {}
解析
答案是A

A是抽象方法，抽象类可以包含抽象方法，也可以不包含，虽然A 方法名是method，与题目中的方法同名，但是参数不同，是重载方法
B 在类中不能constInt = constInt + 5; 方法中可以
C 的方法名与题目中的方法名相同，返回值不能作为重载的依据
D 抽象方法没有方法体