JavaSE基础测试03及答案

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));
     }
}