JavaSE基础测试03及答案

旧城等待， 2024-03-17 12:46 39阅读 0赞

## Javase 基础测试03 ##

### 一、选择题 ###

1、使用Java 语言编写的源程序保存时的文件扩展名是（）

a) .class

b) .java

c) .cpp

d) .txt

2、设有数组的定义int\[\] a = new int\[3\]，则下面对数组元素的引用错误的是（）

a) a\[0\]

b) a\[a.length-1\]

c) a\[3\]

d) int i=1; a\[i\]

3、在类的定义中可以有两个同名方法，这种现象称为方法（）

a) 封装

b) 继承

c) 覆盖

d) 重载

4、设有说明语句int\[\] a = new int\[6\],则数组a包括了\_\_\_ 个元素（）

a)0

b)5

c)6

d)7

5、下列类定义中，不正确的是()

a)class x \{ .... \}

b)class x extends y \{ .... \}

c)class x implements y1,y2 \{ .... \}

d)public class x extends String \{ .... \}

6、下列哪个声明是错误的：（）

a) int i = 10;

b) float f = 1.1;

c) double d = 32.2;

d) byte b = 127;

7、有关于抽象方法的说法正确的是()

a) 可以有方法体

b) 可以出现在非抽象类中

c) 是没有方法体的方法

d) 抽象类中的方法都是抽象方法

8、下列哪个不是java的关键字：（）

a) public

b) extends

c) main

d) class

9)、在java中，定义接口的关键是（）

a) abstract

b) interface

c) class

d) extends

10、在java中，类可派生自一个父类，并实现（）个接口

a) 1

b) 2

c) 3

d) 任意多

**答案：1.b 2.c 3.d 4.c 5.d 6.b 7.c 8.c 9.b 10.d**

### 二、判断题 ###

1、java抽象类是声明时必须使用abstract关键。（）

2、java程序中，java.lang.Object是基类（）

3、java中数组对象的长度是固定长度（）

4、java程序类声明可以是多继承的（）

5、程序代码int\[\] a = new int\[3\];int b = a\[3\];是可以编译的，但不可以执行。（）

6、类中声明的方法可以定义在类体外（）

7、在类体内声明成员变量时不允许赋值（）

8、抽象方法是一种只有说明而无具体实现的方法（）

9、抽象方法一定出现在抽象类中（）

10、最终类，最终方法和最终变量的修饰符都用final（）

###### **答案：1.T 2.T 3.T 4.F 5.T 6.F 7.F 8.T 9.F 10.T**  ######

### 三、简答题 ###

1、简述方法的重载和方法的重写？

override（重写）

1、方法名、参数、返回值相同。

2、子类方法不能缩小父类方法的访问权限。

3、子类方法不能抛出比父类方法更多的异常(但子类方法可以不抛出异常)

4、存在于父类和子类之间。

5、方法被定义为final不能被重写。

overload（重载）

1、参数类型、个数、顺序至少有一个不相同。

2、不能重载只有返回值不同的方法名。

3、存在于同类中。

2、java中实现多态的机制是什么？

Java实现多态有三个必要条件：继承、重写、向上转型。

继承：在多态中必须存在有继承关系的子类和父类。

重写：子类对父类中某些方法进行重新定义，在调用这些方法时就会调用子类的方法。

向上转型：在多态中需要将子类的引用赋给父类对象，只有这样该引用才能够具备技能调用父类的方法和子类的方法。

java中实现多态的机制是依靠父类或接口的引用指向子类。从而实现了一个对象多种形态的特性。其中父类的引用是在程序运行时动态的指向具体的实例，调用该引用的方法时，不是根据引用变量的类型中定义的方法来运行，而是根据具体的实例的方法。

3、什么是抽象类？什么是抽象方法？有什么特点？

抽象类就是不能使用new方法进行实例化的类，即没有具体实例对象的类。

对象不能由抽象类直接创建，只可以通过抽象类派生出新的子类，再由其子类来创建对象。

抽象方法就是以abstract修饰的方法，这种方法只声明返回的数据类型、方法名称和所需的参数，没有方法体

4、简述final、finally、finalize特点及用法？

final是java关键字，用于声明属性，方法和类，分别表示属性不可交变，方法不可覆盖，类不可继承。

finally是java中异常处理语句结构的一部分，表示总是执行。

finalize是Object类的一个方法，如果子类中重写了该方法，在垃圾收集器执行的时候会调用被回收对象的此方法。

5、是否可以从一个static方法内部发出对非static方法的调用？

不可以。因为非static方法是要与对象关联在一起的，必须创建一个对象后，才可以在该对象上进行方法调用，而static方法调用时不需要创建对象，可以直接调用。

6、简述this，super关键字用法

(1)this调用本类中的属性，也就是类中的成员变量；

(2)this调用本类中的其他方法；

(3)this调用本类中的其他构造方法，调用时要放在构造方法的首行。

(4)this 也可以调用你类的方法（本类没有的方法）

(5)super()调用父类无参构造方法，必须在子类的构造方法的第一行上，默认是可以不显示写super();

(6)super(参数列表)，调用父类的指定的构造方法。

### 三、程序题 ###

1、编程实现猜数游戏案例。

package doy20;
    
    import java.util.Random;
    import java.util.Scanner;
    
    /**
     * @author phus [495748247@qq.com]
     * @Author: phus
     * @Date: 2023-06-29-14:29
     * @Description:
     */
    
    public class While1 {
         public static void main(String[] args) {
              // 编程实现猜数游戏案例
              Random rand = new Random();
              int start = 0;
              int end = 100;
              int num = rand.nextInt(end - start + 1) + start;
              Scanner sc = new Scanner(System.in);
              int i = 0;
              while ( true ) {
                   ++ i;
                   System.out.printf("请输入数字[%d - %d]：%n", start, end);
                   int t = sc.nextInt();
                   if ( t < start || t > end ) {
                        System.err.printf("输入有误，必须在%d - %d 范围内%n", start, end);
                        continue;
                   }
                   if ( t > num ) {
                        System.err.printf("%d、太大了%n", i);
                   } else if ( t < num ) {
                        System.err.printf("%d、太小了%n", i);
                   } else {
                        System.out.println();
                        System.out.printf("恭喜，你猜对了，你的游戏分数：%d分。", (100 - -- i * 10));
                        break;
                   }
                   if ( i >= 10 ) {
                        System.out.println("游戏结束");
                   }
              }
         }
    }

2、编程实现对一个int\[\] a = new int\[10\]数组排序（排序方式没有要求，顺序没有要求）。

package doy20;
    
    import java.util.Arrays;
    import java.util.Random;
    
    /**
     * @author phus [495748247@qq.com]
     * @Author: phus
     * @Date: 2023-06-29-14:39
     * @Description:
     */
    public class While2 {
         public static void main(String[] args) {
              // 编程实现对一个int[] a = new int[10]数组排序（排序方式没有要求，顺序没有要求）
              var rand = new Random();
              var nums = new int[10];
              for ( int i = 0; i < nums.length; i++ ) {
                   nums[i] = rand.nextInt(100) + 1;
              }
              System.out.printf("排序前：%s%n", Arrays.toString(nums));
              boolean f = rand.nextBoolean();
              for ( int i = 0; i < nums.length; i++ ) {
                   for ( int j = 0; j < nums.length - 1 - i; j++ ) {
                        if ( f ) {
                             if ( nums[j] < nums[j + 1] ) {
                                  int t = nums[j];
                                  nums[j] = nums[j + 1];
                                  nums[j + 1] = t;
                             }
                        } else {
                             if ( nums[j] > nums[j + 1] ) {
                                  int t = nums[j];
                                  nums[j] = nums[j + 1];
                                  nums[j + 1] = t;
                             }
                        }
                   }
              }
              System.out.printf("排序后(%s)：%s%n", f ? "降序" : "升序", Arrays.toString(nums));
         }
    }