[Java笔试系列]1 40题Java笔试汇总

1 下面描述函数重写错误的是

A: 要有子类继承或实现
B:子类方法的权限必须大于等于父类的权限

C:父类中被private权限修饰的方法可以被子类重写

D:子类重写接口中的抽象方法,子类的方法权限必须是public的

private只能在类内访问

2 关于封装下面介绍错误的是

A：封装将变化隔离
B：封装提高重用性
C：封装安全性

D：只有被private修饰才叫做封装

封装 跟 private权限是两个不同的概念，前者表示一种思想，后者表示访问权限

3 试图编译运行下面的代码会发生什么情况

public class MyClass{
  static int i;
  public static void main(String[] args){
    System.out.println(i);
  }
}

A: 错误，变量i没有被初始化
B:输出null
C:输出1

D:输出0

静态变量会进行默认初始化，静态整型默认初始化为0，静态类默认初始化为null

4 在Java中，下面对于构造函数的描述正确的是

A: 类必须显式定义构造函数
B:构造函数的返回类型是void
C:构造函数和类有相同的名称，并且不能带任何参数

D:一个类可以定义多个构造函数

构造函数可以重载

5 下面对this的作用描述错误的是

A: 当成员变量和局部变量重名的时候可以用this区分
B:this() 语句必须放在构造函数的第一行,根据this后面括号中的参数调用本类其他的构造函数
C:this 可以调用本类的一般函数

D:this 可以调用父类的一般函数

调用父类的一般函数应使用 super

6 面向对象与面向过程的区别？

面向过程--针对某一个问题单独提出解决方案和代码开发
面向对象--组件化的代码设计

7 在Java中，以下程序编译运行后的输出结果为

public class Test {
     int x, y;
     Test(int x, int y) {
      this.x = x;
      this.y = y;
     }

public static void main(String[] args) {
      Test pt1, pt2;
      pt1 = new Test(3, 3);
      pt2 = new Test(4, 4);
      System.out.print(pt1.x + pt2.x);
     }
}

A: 6
B: 3 4
C:8

D:7

8 给定一个Java程序Test.java的代码如下所示，编译时，会出现以下（ ）情况

class Parent {
  public int count() {              // 第1行
     return 0;
  }
}

public  class Test  extends Parent {
   public float count() {              // 第2行
     return 9;                // 第3行
   }
}

A: 编译通过
B:在第1行引发编译错误

C:在第2行引发编译错误

D:在第3行引发编译错误

重写父类方法不可修改其返回类型

9 在Java语言中，下列关于类的继承的描述，正确的是

A一个类可以继承多个父类

B一个类可以具有多个子类

C子类可以使用父类的所有方法
D子类一定比父类有更多的成员方法

10 Java中，如果类C是类B的子类，类B是类A的子类，那么下面描述正确的是

A: C可以继承B中的公有成员，同样也可以继承A中的公有成员

B:C只继承了B中的成员
C:C只继承了A中的成员
D:C不能继承A或B中的成员

11 是一组有相同属性、共同行为和共同关系的对象的抽象

A: 类

B:方法
C:属性
D:以上都不对

12 下列关于Object类中定义的方法描述正确的是

A: 其他类不能调用
B:其他类部分能调用
C:其他类大部分不能调用

D:其他类全部能调用

13 下列程序运行的结果是

public Class Test{
   public static void main(String[] args){
     int persent=10;
     tripleValue(persent);
      System.out.println(persent);
 }
 public static void tripleValue(int x){
     x=3*x;
 }
}

A:40
B:30
C:20
D:10

14 下面关于接口的特性，哪些描述正确？

A: 接口可以实例化
B:可以声明接口的变量C:接口变量必须引用实现了的类对象D:接口可以被继承

15 关于java接口的说法错误的是

A:一个java接口是一些方法特征的集合，但没有方法的实现
B:Java接口中定义的方法可以在不同的地方被实现，可以具有完全不同的行为
C: Java接口中可以声明私有成员

D:Java接口不能被实例化

说出下面程序的执行结果
interface InterfaceA{
  String S = “good”;
  Void f();
}
abstract class ClassA{
abstract void g();
}

class ClassB extends ClassA implements InterfaceA{
void g(){
System.out.print(S);
}
public void f(){
System.out.print(“”+S);
}

}

public class Test{
public static void main(String[] args){
    ClassA a = new ClassB();
    InterfaceA b = new ClassB();
    a.g();
      b.f();
  }
}

A:good good

B:good good
C:goodgood
D:goodgood
ClassB 继承了抽象类 ClassA 并实现了接口 InterfaceA，在 main 函数中，向上实例化一个抽象类的实例 a，一个接口 A 的实例 b，通过 a,b 调用他们各自的方法，则输出一个来自 a.g() 的 good，一个来自 b.f() 的 good。

16 如果类中的成员变量可以被同一包访问，使用如下哪个修饰符

A:public
B:private

C:default

D:protected
public 共有的 都能访问
private 私有的 类内防问
default 包内可以访问
protected 保内 继承关系的 可以访问

17 简述java访问权限

public 共有的，任何类都可以访问
protected 受保护的，同一包的类可以访问，不同包的子类可以访问
default同一包的类可以访问
private 私有的 类内防问

18 Java访问权限修饰符的区别

Java有四种访问权限，其中三种有访问权限修饰符，分别为private，public和protected，还有一种不带任何修饰符：
private: Java语言中对访问权限限制的最窄的修饰符，一般称之为“私有的”。被其修饰的类、属性以及方法只能被该类的对象访问，其子类不能访问，更不能允许跨包访问。
default：即不加任何访问修饰符，通常称为“默认访问模式“。该模式下，只允许在同一个包中进行访问。
protect: 介于public 和 private 之间的一种访问修饰符，一般称之为“保护形”。被其修饰的类、属性以及方法只能被类本身的方法及子类访问，即使子类在不同的包中也可以访问。
public： Java语言中访问限制最宽的修饰符，一般称之为“公共的”。被其修饰的类、属性以及方法不仅可以跨类访问，而且允许跨包（package）访问。

19 被（）修饰的类、属性以及方法不仅可以跨类访问，而且允许跨包访问

A:public

B:private
C:default
D:protected

20 java里有哪几种权限修饰符？

A:publicB:private

C:default

D:protected

public 共有的 都能访问
private 私有的 类内防问
default 包内可以访问
protected 保内 继承关系的 可以访问

21java中可以导入多个不同包的同名类

对
java 中可以导入多个不同包同名类，使用多个同名类时非第一个同名类需要加上包名

22 有一个源代码，只包含import java.util.* ; 这一个import语句，下面叙述正确的是

A:只能写在源代码的第一句
B:可以访问 java/util 目录下及其子目录下的所有类

C:能访问java/util目录下的所有类，不能访问java/util子目录下的所有类

D:编译错误
导入 java.util.* 不能读取其子目录的类，因为如果 java.util 里面有个 a 类，java.util.regex 里面也有个a类，我们若是要调用a类的方法或属性时，不知道使用哪个a类，所以选C。

23 java中关于import，class和package的声明顺序正确的是

A:import,class,package
B:package,class,import

C:import,package,class

D:class,import,package
java中导入一个类使用关键字import,然后是类所在包名称，最后是类名称

24 在java中，用package语句说明一个包时，该包的层次结构必须是

A:与文件的结构相同
B:与文件目录的层次相同

C:与文件类型相同

D:与文件大小相同
定义一个包要用package关键字，用package语句说明一个包时，该包的层次结构必须与文件目录的层次相同。否则，在编译时可能出现查找不到的问题，所以选项B正确。

25 如果包名包含多个层次，每个层次应该使用什么符号分割

A:\
B:/
C:\*

D:.

26 java中导入包的关键字是

A:package

B:import

C:extends
D:implements

27JAVA中以下那个包是自动导入的

A: java.lang

B:java.io
C:java.util
D:java .net
java.lang包是java语言的核心包，它提供了java中的基础类，java自动导入

28 位于同一个包中的类，不需要导入就可以直接访问

对
类隐含当前包地址

29 请指出下题的执行结果：

class SuperClass
{
   SuperClass(){}
   SuperClass(String str){
   System.out.prinln("Super with a String");
   }
}

public class SubClass extends SuperClass{
  SubClass(String str){
     System.out.prinln("Sub with a String");
   }
  public static void main(String[] args){
    SubClass sub = new SubClass("sub");
   }
}

先调用父类的无参构造器，
Sub with a String
创建一个子类的对象实例的时候，必先调用父类的无参数的构造函数（默认构造函数）

30 请指出下题的执行结果：

class SuperClass
{
   SuperClass(String str){
   System.out.prinln("Super with a String");
  }
}

public class SubClass extends SuperClass{
   SubClass(String str){
   super(str);
   System.out.prinln("Sub with a String");
   }
   public static void main(String[] args){
   SubClass sub = new SubClass("sub");
   }
}

Super with a String
Sub with a String
创建一个子类的对象实例的时候，必先调用父类的无参数的构造函数（默认构造函数）

31 请指出下题的执行结果：

class SuperClass
{
 SuperClass(String str){
  System.out.prinln("Super with a String");
 }
}

public class SubClass extends SuperClass{
 SubClass(String str){
  System.out.prinln("Sub with a String");
 }
 public static void main(String[] args){
  SubClass sub = new SubClass("sub");
 }
}

在调用子类构造器之前，会先調用父类构造器，当子类构造器中没有使用"super(参数或无参数)"指定调用父类构造器时，是默认调用父类的无参构造器，如果父类中包含有参构造器，却沒有无参构造器，则在子类构造器中一定要使用“super(参数)”指定调用父类的有参构造器，不然就会报错。

32 Java 构造方法有哪些特点

Java 构造方法有以下特点：

• 方法名必须与类名相同
• 可以有 0 个、1 个或多个参数
• 没有任何返回值，包括 void
• 默认返回类型就是对象类型本身
• 只能与 new 运算符结合使用

33 是否可以用VOID修饰构造方法

实际上，类的构造方法是有返回值的，当使用 new 关键字来调用构造方法时，构造方法返回该类的实例，可以把这个类的实例当成构造器的返回值，因此构造器的返回值类型总是当前类，无须定义返回值类型。但必须注意不要在构造方法里使用 return 来返回当前类的对象，因为构造方法的返回值是隐式的。

34 能否使用 static、final、synchronized、abstract 修饰构造方法？

不可以，构造方法不能被 static、final、synchronized、abstract 和 native（类似于 abstract）修饰。构造方法用于初始化一个新对象，所以用 static 修饰没有意义。构造方法不能被子类继承，所以用 final 和 abstract 修饰没有意义。多个线程不会同时创建内存地址相同的同一个对象，所以用 synchronized 修饰没有必要。

35 简述默认构造方法和Nullary 构造方法的差异

无参数的构造方法也被称为 Nullary 构造方法。只有编译程序自动加入的构造方法，才称为默认构造函数。如果自行编写无参数、没有内容的构造函数，就不称为默认构造函数了（只是 Nullary 构造函数）。虽然只是名词定义，不过认证考试时要区别一下两者的不同。

36 构造方法是用来创建对象的么？

在构造方法执行之前,类的内存空间已经开辟完成了,意思就是说对象已经创建了,这步是由new关键字来完成的,而构造方法的作用是给类中的变量进行初始化赋值

37 构造方法是否可以被重写?

不可以，构造器是不能被继承的，因为每个类的类名都不相同，而构造器名称与类名相同，所以根本谈不上继承。 又由于构造器不能继承，所以就不能被重写

38 下列关于构造方法说法正确的是

A:构造方法的名称可以和类不一样
B:构造方法必须有返回值
C: 只能用运算符new调用构造方法

D:构造方法不可以被重载
本题考查构造方法的概念。构造方法用来初始化类的一个对象，构造方法具有和类一样的名称，选项A说法错误。构造方法没有返回类型还可以重载，选项B说法错误。构造方法只能用运算符new调用构造方法，选项C说法正确。如果没有定义构造方法，在Java运行时，系统会自动提供默认的构造方法，它没有任何参数，选项D说法错误

39 有一个名为MyClass的public类，想要成功编译的条件是（）

A:MyClass类中必须定义一个正确的main()方法

B:MyClass类必须定义在MyClass.java的源文件中

C:MyClass类必须定义在MyClass包中
D:MyClass类必须被导入

40在子类中调用父类的成员方法必须使用super关键字（）

错误，若子类没有重写父类的方法，那么就不需要使用super

41 请说明比较两个对象时，使用“==”比较两个引用变量和使用equals()方法比较两个引用变量的区别

当使用“==”比较两个引用变量时，比较的是两个引用变量存储的表示地址的整型值，当使用equals()比较时，比较的是两个对象的具体内容

42 类的实例变量在什么时候会被分配空间？

类的实例变量属于对象层次，在程序运行且创建对象时分配时分配空间

43 什么是匿名对象？什么是内部类？

创建的对象没有特定的命名的引用变量指向的对象称为匿名对象；在一个类内部定义的类称为内部类

44 抽象类是

不能实例化的类。抽象类没有实现的方法，不能实例化。使用abstract的抽象类只需要声明方法首部，不需要声明方法体，其方法体只能由子类来完成。如果类的某一方法是抽象的，则整个类就必须是抽象的