Java基础选择题——2

第1章 Java程序设计概述

1.1单项选择题

1．编译Java Application源文件将产生相应的字节码文件，扩展名是什么

   A. .java          B. .class

   C. .html        D. .exe

解答：B

2．Java语言具有许多优点和特点，下列选项中，哪个反映了Java中“一次编译，随处运行”的特点。

   A. 简单性                   B. 平台无关性

   C. 面向对象性           D. 安全性

解答：B

3．Java语言具有许多优点和特点，下列选项中，哪个反映了Java中并行机制的特点。

   A. 多线程               B. 平台无关性

   C. 面向对象性             D. 安全性

解答：A

4．在Java语言中，下列哪些语句关于内存回收的说明是正确的?

   A．程序员必须创建一个线程来释放内存；

   B．内存回收程序负责释放无用内存 ；

   C．内存回收程序允许程序员直接释放内存 ；

   D．内存回收程序可以在指定的时间释放内存对象

解答：B

A．，程序员通常不需要（也不能）直接控制内存的分配和释放。Java有一个自动的内存管理系统，包括内存分配和垃圾回收，这些都是由Java虚拟机（JVM）自动处理的。

B．这个选项是正确的。Java的垃圾回收器（Garbage Collector）会自动跟踪哪些对象是不再被引用的（即“无用的”），并在适当的时候回收这些对象的内存。

C．这个选项是不正确的。Java的内存回收器是自动运行的，并且它不允许程序员直接控制内存的释放。程序员只能控制对象的引用，当没有引用指向某个对象时，垃圾回收器就会认为这个对象是无用的，并可能回收它的内存。

D．
这个选项也是不正确的。虽然现代的垃圾回收器提供了很多配置选项，但程序员通常不能指定垃圾回收器在何时运行。垃圾回收器的运行是由JVM根据内部算法和策略自动触发的，这些策略和算法的目标是最大化程序的吞吐量和/或最小化程序的延迟。

因此，正确的选项是B。

5．一个Java源文件中最多只能有多少个public类。

   A. 1个      B. 2个

   C. 3个     D. 任意多个

解答：A

一个Java源文件中最多只能有1个public类。这是Java语言规范所规定的。

6．下面哪一个不是Java语言所具有的特点。

   A. 没有全局变量，在类的定义外部没有任何的变量定义；

   B. 不直接支持指针操作，而使用更安全的引用类型
（这个描述是正确的。Java不直接支持指针操作，而是使用引用类型来访问对象。这是为了内存安全和简化内存管理。）

   C. 支持子类对父类的多继承；//单继承的

   D. 具有自动垃圾收集功能；

解答：C

7．下面哪一个不是Java开发工具包JDK的组成部分。

   A. Java的编译器；

   B. Java的解释器；

   C. Java的API继承类库；

   D. Eclipse开发工具；

解答：C  （感觉选D）

8．JDK提供的编译器是（   ）。

   A. java.exe        B. javac.exe

   C. javap.exe     D. javaw.exe

解答：B

在JDK中，提供的编译器是javac.exe。这个工具用于将Java源代码（.java文件）编译成字节码（.class文件），这些字节码可以被Java虚拟机（JVM）执行。

因此，正确的选项是：

B. javac.exe

A. java.exe - 这是Java运行时环境（JRE）中的Java应用程序启动器，用于运行Java程序。
C. javap.exe - 这是一个Java类文件反汇编器，它接受编译过的类文件并打印出可供人类阅读的输出，以显示编译后代码的结构。
D. javaw.exe - 类似于java.exe，但它不打开控制台窗口来运行Java程序。通常用于图形用户界面（GUI）应用程序。

9．作为Java应用程序入口的main方法，其声明格式可以是（ ）

   A. public void main(String [] args)

   B. public static void main(String [] args)

   C. public static void Main(String * args)

   D. public int main(String [] args)

解答：B

10．下列说法正确的是（ A ）  

A、 JAVA程序的main方法必须写在类里面

B、 JAVA程序中可以有多个main方法

C、 JAVA程序中类名必须与文件名一样  

D、 JAVA程序的main方法中如果只有一条语句，可以不用{}(大括号)括起来

A、
这是正确的。在Java中，main方法是程序的入口点，但它必须是一个类的成员方法，并且这个类通常被命名为包含main方法的公共类。

B、
这是不正确的。在Java中，虽然可以在不同的类中定义多个main方法，但程序启动时只能调用一个main方法，即包含public static void main(String[] args)签名的那个。因此，从程序运行的角度来看，你不能“拥有”多个main方法。

C、JAVA程序中类名必须与文件名一样
这个选项部分正确但表述不完整。在Java中，如果一个类被声明为public，那么它的名字必须与包含它的源文件的名称相同（不包括.java扩展名）。但如果类不是public的，那么它的名字就不需要与文件名相同。

D、JAVA程序的main方法中如果只有一条语句，可以不用{}(大括号)括起来
这是不正确的。在Java中，即使main方法只有一条语句，你也需要使用花括号{}来定义方法体。花括号是必需的，即使它们内部只包含一条语句。不使用花括号会导致编译错误。

因此，正确的选项是A。

11．下列哪些语句关于Java内存回收的说明是正确的? （  B  ）

 A、程序员必须创建一个线程来释放内存

 B、内存回收程序负责释放无用内存

 C、内存回收程序允许程序员直接释放内存

 D、内存回收程序可以在指定的时间释放内存对象

1、 开发与运行Java程序需要经过的三个主要步骤为____________、____________和____________。

解答：编辑源程序 、编译生成字节码和解释运行字节码

2、使用Java编译器___ javac____.exe编译源文件得到字节码文件。

3、Java应用程序必须通过Java解释器__JAVA__.exe来解释执行其字节码文件。

4、如果Java源文件中有一个类是public类，那么源文件的名字必须与这个类的名字完全_相同______，扩展名是.java 。

5、Java应用程序总是从主类的____main___方法开始执行．

第2章 Java基本的程序设计结构

2.1单项选择题

1、 下面哪一项在java中是非法的标识符？（     ）

A. $user

B. point

C. You&me

D. _endline

解答：Ｃ

在Java中，标识符是用于为变量、方法、类、接口等命名的。它们必须遵循一定的规则：

标识符必须以字母、下划线（_）、美元符号（$）或数字字符开头，但后续字符可以是字母、下划线、美元符号或数字的任意组合。
标识符是大小写敏感的。
标识符不能是Java的关键字或保留字。

A. $user - 这是合法的标识符，因为它以美元符号开头，后续跟着字母。

B. point - 这是合法的标识符，因为它以字母开头。

C. You&me - 这是非法的标识符，因为它包含了非法字符&。在Java中，标识符不能包含&这样的特殊字符（除非它们是有效的操作符或作为字符串字面量的一部分）。

D. _endline - 这是合法的标识符，因为它以下划线开头，后续跟着字母和数字。

2、 若有定义 int a=9,b=6; 那么a>b的值是：（     ）

A. 0    B. 1

C. false D. true

解答：D

3、执行完以下代码int[ ] x = new int[25];后，以下说明正确的是：（      ）

A. x[24]为0                             B. x[24]未定义

C. x[25]为0      //为数组下标越界                      D. x[0]为空             //为0

解答：A

在Java中，当你使用new关键字为一个整数数组分配内存时，数组中的所有元素都会被自动初始化为默认值。对于int类型的数组，这个默认值是0。

对于给定的代码int[] x = new int[25];，你创建了一个长度为25的整数数组x。这个数组有索引从0到24的元素。

4、Java应用程序的main方法中有以下语句，则输出的结果是（     ）。

int[] x={2,3,-8,7,9};

int max=x[0];

for(int i=1;i<x.length;i++){

if(x[i]>max)

max=x[i];

}

System.out.println(max);

A. 2 B. -8

C. 7 D. 9

解答：Ｄ

5、设 x = 1 , y = 2 , z = 3，则表达式  y＋＝z－－/＋＋x  的值是（     ）

 y＋＝z－－/＋＋x  =》y = y + (z－－) 

A. 3          B. 3.5

C. 4          D. 5

解答：A

在解析这个表达式 y += z-- / ++x 之前，我们需要了解Java（以及许多其他C风格的编程语言）中的运算符优先级和顺序点（sequence points）规则。

首先，运算符的优先级从高到低是：

后缀/前缀自增/自减（++/--）
乘法、除法、取模（*///%）
加法、减法（+/-）
赋值（+=/-=/*=//=/%=）

5、执行System.out.println(5/4)，这条代码的输出结果是（     ）

A. 1                       B. 1.25 

C. 1.5                       D. 0

解答：A

在Java中，当你执行 System.out.println(5/4);，这是一个整数除法。因为5和4都是整数（在Java中是int类型），所以结果也是一个整数。整数除法会丢弃小数部分，只保留整数部分。

因此，5除以4的结果是1.25，但因为我们是在做整数除法，所以结果会被截断为1。

 

6、下列语句有错误的是：（     ）

A. int []a;     B. int []b=new int[10];    

C. int c[]=new int[];     D. int d[]=null;

A. int []a; - 这是一个整型数组的声明，但没有初始化，所以它是合法的。

B. int []b=new int[10]; - 这是一个整型数组的声明和初始化，分配了一个大小为10的数组空间，所以它也是合法的。

C. int c[]=new int[]; - 这里尝试创建一个整型数组，但没有指定数组的大小。在Java中，当你使用new关键字来创建数组时，你必须指定数组的大小。因此，这个语句是错误的。

D. int d[]=null; - 这里声明了一个整型数组d并将其初始化为null，表示它不引用任何数组对象。这也是合法的。

所以，错误的选项是 C

解答：C

7、下列语句有错误的是：（     ）

A. int a[][]=new int[5][5];   B. int [][]b=new int[5][5];

C. int []c[]=new int[5][5];   D. int [][]d=new int[5,5];

解答：D

A. int a[][]=new int[5][5]; - 这是合法的二维数组声明和初始化，尽管其声明风格（使用两个方括号放在变量名后）不如B选项常见，但它仍然是有效的。

B. int [][]b=new int[5][5]; - 这是常见的二维数组声明和初始化方式，每个内部数组都是默认初始化为null的。

C. int []c[]=new int[5][5]; - 这与A选项类似，只是将方括号的位置与变量名分开了，它同样是合法的。

D. int [][]d=new int[5,5]; - 在Java中，你不能使用逗号,来指定二维数组的大小。应该使用两个方括号，每个方括号内指定一个维度的大小。因此，这个语句是错误的。

8、下列哪一个不属于Java中的8种基本数据类型（     ）

A. double;   B.char;

C. int;   D. String;

解答：D

9、以下数据类型存储空间最大的是（    ）。

（A）byte  （B）long   （C）float    （D）char

解答：B

（A）byte：1字节（8位）
（B）long：8字节（64位）
（C）float：4字节（32位）（注意：尽管它表示的是浮点数，但其存储空间大小与int相同）
（D）char：2字节（16位）（在Java中，char类型用于存储Unicode字符）

10、System.out.println("5" + 2);的输出结果应该是（）。

A 52                   B7       

C2                     D5

答案：A

11．在类的定义中可以有两个同名方法，每个方法的参数不同，这种现象称为方法（D ）。

（A）封装 （B）继承 （C）覆盖 （D）重载

12．java中定义字符串String s=”pzhu”,下面操作可以取得字符串长度的是（   ）。

   A.  s.length()    B.  s.length    C.  s.size()     D.  length(s)

解答：A

13．指出下列程序运行的结果 （B）(很难)

public class Example {

    String str = new String("good");

    char[] ch = { 'a', 'b', 'c' };

    public static void main(String args[]) {

        Example ex = new Example();

        ex.change(ex.str, ex.ch);

        System.out.print(ex.str + " and ");

        System.out.print(ex.ch);

    }

    public void change(String str, char ch[]) {

        str = "test ok";

        ch[0] = 'g';

    }

}

A、 good and abc

B、 good and gbc

C、 test ok and abc

D、 test ok and gbc

调用 ex.change(ex.str, ex.ch); 方法。这里我们传递了 str 的引用和 ch 的引用到 change 方法中。
在 change 方法中，str = "test ok"; 这行代码改变了局部变量 str 的引用，使其指向一个新的字符串对象 "test ok"。但是，它并没有改变 ex.str 的引用，因为 Java 是按值传递的（对于对象，传递的是引用的值，而不是引用本身）。所以 ex.str 仍然指向原来的 "good" 字符串对象。
另一方面，ch[0] = 'g'; 这行代码改变了 ch 数组的第一个元素的值。因为 ch 是按引用传递的，所以 ex.ch 数组的第一个元素也被改变了。
在 main 方法中，我们打印 ex.str 和 ex.ch。ex.str 仍然是 "good"，而 ex.ch 现在是 {'g', 'b', 'c'}。
因此，输出是 "good and gbc"。

14．下面代码的运行结果为：（C）(较难)     (我选B)

import java.io.*;

import java.util.*;

public class foo{

    public static void main (String[] args){

        String s;

        System.out.println("s=" + s);

    }

}

A 代码得到编译，并输出“s=”

B 代码得到编译，并输出“s=null”

C 由于String s没有初始化，代码不能编译通过

D 代码得到编译，但捕获到 NullPointException异常

在Java中，当你声明一个类的引用变量但没有初始化它时，该变量的值默认是null（对于对象引用类型），但尝试使用未初始化的对象引用进行任何操作（如访问其方法或成员）将会导致NullPointerException。然而，在这个特定的情况下，我们只是在尝试打印出该变量的字符串表示（即调用toString()方法），但由于System.out.println()的特殊处理，它不会调用null的toString()方法，而是直接打印出"null"字符串。

public class foo{

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

String s; 声明了一个名为s的String类型变量，但没有初始化它，所以它的值是null。
System.out.println("s=" + s); 这里，由于+操作符的字符串连接功能，s的值（即null）会被自动转换为字符串"null"，然后与"s="连接，最终输出的是"s=null"。

因此，这段代码会编译通过，并输出"s=null"，而不是抛出NullPointerException。

所以正确答案是：

B 代码得到编译，并输出“s=null”

15．关于以下程序段，正确的说法是（   C   ）

 1．  String  s1=”abc”+”def”;

 2．  String  s2=new  String（s1）；

 3．  if（s1= =s2）  

 4．     System.out.println(“= = succeeded”);  

 5．  if (s1.equals(s2))  

 6．     System.out.println(“.equals()  succeeded”);

A、行4与行6都将执行        

B、行4执行，行6不执行

C、行6执行，行4不执行        

D、行4、行6都不执行

首先，我们逐行分析代码：

String s1 = "abc" + "def";
这行代码创建了一个字符串对象s1，其值为"abcdef"。由于"abc"和"def"都是字符串常量，编译器在编译时会对它们进行优化，将它们连接成一个新的字符串常量"abcdef"。

String s2 = new String(s1);
这行代码创建了一个新的String对象s2，它是s1的一个拷贝。尽管s2的内容与s1相同，但它们是两个不同的对象，分别位于不同的内存位置。

if (s1 == s2)
这里使用了==操作符来比较s1和s2。在Java中，==用于比较两个对象是否引用同一个对象（即比较它们的内存地址）。由于s1和s2是不同的对象，因此这个条件为false。

System.out.println("== succeeded");
由于上面的条件为false，这行代码不会被执行。

if (s1.equals(s2))
这里使用了equals()方法来比较s1和s2的内容是否相同。equals()方法用于比较两个对象的内容是否相等，而不是它们的内存地址。对于String类，equals()方法会比较两个字符串的内容是否相同。因此，s1.equals(s2)的结果为true。

System.out.println(".equals() succeeded");
由于上面的条件为true，这行代码会被执行。

综上所述，行4的代码不会执行，而行6的代码会执行。因此，正确答案是 C：行6执行，行4不执行。

16．Java application中的主类需包含main方法，main方法的返回类型是什么？（ D ）

A、int                  B、float           

C、double             D、void

17．为一个boolean类型变量赋值时，可以使用(B  )方式  

A、 boolean = 1;  //因为你在尝试给boolean类型赋值一个整数1，而不是true或false

B、 boolean a = (9 >= 10);

C、 boolean a="真";   //在尝试将一个字符串"真"赋值给一个boolean类型的变量。在Java中，你不能直接将字符串转换为boolean值。

D、 boolean a = = false;  //使用了两个等号= =，这在Java中是一个比较操作符，用于比较两个值是否相等

18．表达式(11+3*8)/4%3的值是( D  )   

A、 31 B、 0 C、 1 D、 2

35 /4 => 商8  余数为3

在这个表达式中，我们只关心整数除法的结果，即8。

最后，我们进行取模运算：

8 % 3 = 2
%3` 的值是 2。

19．运算符优先级别排序正确的是（ A） （太难）

A、 由高向低分别是：()、!、算术运算符、关系运算符、逻辑运算符、赋值运算符；

B、 由高向低分别是：()、关系运算符、算术运算符、赋值运算符、!、逻辑运算符；

C、 由高向低分别是：()、算术运算符、逻辑运算符、关系运算符、!、赋值运算符；

D、 由高向低分别是：()、!、关系运算符、赋值运算符、算术运算符、逻辑运算符；

20．下列值不为true的表达式有（C ）。

A、 "john" = = "john"

B、 "john".equals("john")

C、 "john" = "john"  

D、 "john".equals(new String("john"))

A、"john" == "john"

在Java中，使用==比较两个字符串对象实际上是比较它们的内存地址（即引用），而不是它们的内容。但由于字符串常量池的存在，对于相同的字符串字面量，Java会尝试重用它们，所以这里"john" == "john"通常是true。

B、"john".equals("john")

这是比较两个字符串内容的正确方法。equals方法会检查两个字符串对象的内容是否相同，因此这里的结果是true。

C、"john" = "john"

这是语法错误。在Java中，你不能使用=来比较两个值是否相等；=是赋值操作符。你应该使用==或equals来比较。因此，这个表达式在编译时就会出错，而不是在运行时返回false。但根据问题的描述，

D、"john".equals(new String("john"))

这里创建了一个新的String对象，其内容与"john"相同。然后，使用equals方法比较这两个字符串的内容。由于它们的内容相同，所以这个表达式的结果是true。

21、下面的方法，当输入为2的时候返回值是多少?（D）(很难)

    public static int getValue(int i) {

        int result = 0;

        switch (i) {

        case 1:

            result = result + i;

        case 2:

            result = result + i * 2;

        case 3:

            result = result + i * 3;

        }

        return result;

    }

A0                    B2                    C4                     D10

答案：D

解析：注意这里case后面没有加break，所以从case 2开始一直往下运行。

22、下面有关for循环的描述正确的是（ A ）  

A、 for循环体语句中，可以包含多条语句，但要用大括号括起来

B、 for循环只能用于循环次数已经确定的情况

C、 在for循环中，不能使用break语句跳出循环

D、 for循环是先执行循环体语句，后进行条件判断     //这是不正确的。for循环首先进行条件判断（即检查是否满足循环的初始条件），如果满足，则执行循环体。然后执行循环的增量部分（通常在for循环的末尾定义），接着再次进行条件判断，如此循环直到条件不满足为止。

23、score是一个整数数组，有五个元素，已经正确初始化并赋值，仔细阅读下面代码，程序运行结果是（ B ）

temp = score[0];  

for (int index = 1;index < 5;index++) {

     if (score[index] < temp) {

         temp = score[index];

     }

}  

A. 求最大数 B. 求最小数  C. 找到数组最后一个元素  D. 编译出错

2.2填空题

1、Java语言是一种完全的_面向对象   _程序设计语言

2、String s1=“China”; int n=s1.length( ); n的值为_5__

3、在Java语言中，基本数据类型包括：____整数类型、____浮点类型、____字符类型_和____布尔类型

17、在Java的基本数据类型中，char型采用Unicode编码方案，每个Unicode码占用__2___字节内存空间，这样，无论是中文字符还是英文字符，都是占用__2___字节内存空间。

首先，我们需要明确题目中的表达式 (x++) / 3 的含义和运算顺序。

在C语言或类似的编程语言中，x++ 是一个后置递增运算符，它的意思是先返回 x 的当前值，然后再将 x 的值增加1。

因此，当 x = 2 时，表达式 (x++) / 3 的计算过程如下：

首先，x 的当前值是 2，所以 (x++) 返回 2。
然后，x 的值增加1，变为 3（但这一步是在计算 (x++) / 3 的结果之后发生的）。
最后，计算 2 / 3，由于这是整数除法，结果会被截断为0。

所以，表达式 (x++) / 3 的值是 0。

注意：如果题目中的表达式是 (++x) / 3，那么结果就会是 1，因为 ++x 是一个前置递增运算符，它会先将 x 的值增加1，然后再返回新的 x 值。

18、设 x = 2 ，则表达式 ( x + + )／3 的值是__0___。

20、设有数组定义：

int MyIntArray[] = { 10, 20, 30, 40, 50, 60, 70 };

则执行以下几个语句后的输出结果是：   120      。

int MyIntArray[] = { 10, 20, 30, 40, 50, 60, 70 };

int s = 0;

for (int i = 0; i < MyIntArray.length; i++)

if (i % 2 == 1)

s += MyIntArray[i];

System.out.println(s);

由于 i % 2 == 1 检查 i 是否是奇数，因此这个条件会在 i 为1、3、5时成立（即索引为1、3、5的元素，对应于数组中的20、40、60）。

将这些元素相加，我们得到 20 + 40 + 60 = 120

21、数组对象的长度在数组对象创建之后，就__不会____改变。数组元素的下标总是从___0___开始。

22、对于数组int[][]t={{1,2,3},{4,5,6}}来说，t.length等于__2___，t[0].length等于__3____。

第3章 类和对象

3.1单项选择题

1、 下列关于变量的叙述哪个是错的？（     ）

A. 实例变量是类的成员变量。

B. 在方法中定义的局部变量在该方法被执行时创建。

C. 实例变量用关键字static声明。

D. 局部变量在使用前必须被初始化。

关于这四个关于变量的叙述，我们可以逐一分析它们：

A. 
这是正确的。实例变量（也称为非静态变量）是定义在类内部但在任何方法、构造器或初始化块之外的变量。它们属于类的实例（对象），而不是类本身。

B. 
这也是正确的。局部变量是定义在方法或代码块中的变量，它们的生命周期是从定义它们的方法或代码块开始执行时开始，到该方法或代码块执行完毕时结束。

C. 
这是错误的。实例变量是类的实例（对象）的属性，而static关键字用于声明类变量（也称为静态变量），这些变量属于类本身，而不是类的实例。实例变量不应该使用static关键字来声明。

D. 
这是正确的。在Java中，局部变量在使用前必须被明确初始化，否则编译器会报错。这是因为局部变量没有默认值，它们的值是不确定的，除非在使用前被显式地赋予一个值。

因此，错误的叙述是C。

解答：C

2、 在Java语言中，下列哪个包是编译器自动导入的？（     ）

A. java.applet B. java.lang

C. java.io D. java.awt

解答：Ｂ

在Java语言中，编译器会自动导入java.lang包中的类，这意味着你不需要使用import语句来导入这个包中的任何类。这是因为java.lang包是所有Java程序的核心，并且包含了Java语言的基础类，如Object、String、Math等。

6、 不允许作为类及类成员的访问控制符的是（     ）。

A. public B. private

C. static D. protected

解答：C

7、 为AB类的一个无形式参数无返回值的方法method书写方法头，使得使用类名AB作为前缀就可以调用它，该方法头的形式为（     ）。

A、 static  void  method( ) B、 public  void  method( )

C、 final  void  method( ) D、 abstract  void  method( )

解答：A

A、static void method( )
这是正确的，因为static修饰符允许我们直接通过类名调用该方法，而无需创建类的实例。

B、public void method( )
这是非静态方法，所以需要通过类的实例来调用。

C、final void method( )
final修饰符用于表示该方法不能被重写，但它并不决定方法是否是静态的。因此，这个方法仍然需要通过类的实例来调用。

D、abstract void method( )
abstract修饰符用于声明抽象方法，抽象方法没有实现，并且包含它的类也必须是抽象的。因此，这个方法不能直接在类上被调用。

8、 可以在下面代码段point x处写入的是？（     ）？？？？不确定

//point x

public class Interesting{

//do something

}

A. String str;

B. static int PI=3.14;

C. public class MyClass{//do other thing…}

D. import java.awt.*;

解答：D

9、Java提供的许多类在不同的包中，使用下面哪个语句可以引入包中的类。

A. package B. include 

C. import     D. add 

解答：C

11、已知A类被打包在packageA , B类被打包在packageB ，且B类被声明为public ，且有一个成员变量x被声明为protected控制方式 。C类也位于packageA包，且继承了B类 。则以下说法正确的是：（      ）

A、A类的实例不能访问到B类的实例

B、A类的实例能够访问到B类一个实例的x成员

C、C类的实例可以访问到B类一个实例的x成员

D、C类的实例不能访问到B类的实例

解答：C（太难）

13、在Java中，关于final关键字的说法正确的是（      ）

A、如果修饰变量，则一旦赋了值，就等同一个常量。

B、如果修饰类，则该类只能被一个子类继承。

C、如果修饰方法，则该方法不能在子类中被覆盖。

D、如果修饰方法，则该方法所在的类不能被继承。

解答：A,C

14、关于构造方法以下说法错误的是 (   D   )。

 （Ａ）构造方法名必须与类名一致  

 （Ｂ）构造方法可以重载   //在Java中，你可以在一个类中定义多个构造方法，只要它们的参数列表不同（即重载）。

 （Ｃ）构造方法是通过new来调用   //在Java中，我们使用new关键字和类的名称（以及可能的参数）来调用构造方法，从而创建类的新实例。

 （Ｄ）每个类都必须编写构造方法代码   //在Java中，如果你没有为类编写任何构造方法，编译器会为你提供一个默认的无参数构造方法。但是，如果你已经定义了一个或多个构造方法，那么编译器就不会再为你提供默认构造方法。所以，你不需要（但可以选择）为每个类编写构造方法代码。

15、关于类的定义以下说法错误（ B ）。  

（A）类定义使用class关键字

（B）每个类中必须有一个main方法

// 这是错误的。main方法是Java应用程序的入口点，但它并不需要定义在每个类中。它只需要定义在包含程序执行起点的类中，通常是一个公共类，并且这个main方法必须是public static void类型，并且接受一个String[]类型的参数。

（C）一个包可以包含多个类

（D）java中所有类都是Object类的子类

16、在创建对象时必须（C） 

A) 先声明对象，然后才能使用对象 

B) 先声明对象，为对象分配内存空间，然后才能使用对象 

C) 先声明对象，为对象分配内存空间，对对象初始化，然后才能使用对象 

D) 上述说法都对

17、在调用方法时，若要使方法改变实参的值，可以（B）

 A) 用基本数据类型作为参数    B) 用对象作为参数

C) A和B都对                 D) A和B都不对

18、关于以下程序代码的说明正确的是（   D   ）??

1class  HasStatic{

private  static  int  x=100;

public  static  void  main(String  args[  ]){

HasStatic  hs1=new  HasStatic(  );

 hs1.x++;

 HasStatic  hs2=new  HasStatic(  );

 hs2.x++;

 hs1=new  HasStatic( );

 hs1.x++;

 HasStatic.x- -;

 System.out.println(“x=”+x);

}

}

A、 5行不能通过编译，因为引用了私有静态变量

B、 10行不能通过编译，因为x是私有静态变量

C、 程序通过编译，输出结果为：x=103

D、 程序通过编译，输出结果为：x=102

19、以下关于构造函数的描述错误的是（  A  ）。

A、构造函数的返回类型只能是void型。

B、构造函数是类的一种特殊函数，它的方法名必须与类名相同。

C、构造函数的主要作用是完成对类的对象的初始化工作。

D、一般在创建新对象时，系统会自动调用构造函数。

20、Java中，在如下所示的Test类中，共有（C ）个构造方法。  

public class Test{

 private int x;

 public Test(){ x=35; }

 public void Test(double f){  This.x=(int)f; }

 public Test(String s){}

}

  A、 0 B、 1 C、 2 D、 3

。构造方法的名称必须与类名相同，并且没有返回类型（连void也没有）。

对于给定的Test类，我们可以分析以下三个方法来确定哪些是构造方法：

public Test(){ x=35; } - 这是一个构造方法，因为它与类名Test相同，并且没有返回类型。
public void Test(double f){ This.x=(int)f; } - 这不是一个构造方法，因为尽管它的名称与类名相同，但它有一个返回类型void。此外，This应该是this（Java是大小写敏感的）。
public Test(String s){} - 这也是一个构造方法，因为它与类名Test相同，并且没有返回类型。

因此，Test类中共有2个构造方法。

21、在Java中,关于构造方法，下列说法错误的是(  C  )  

A、 构造方法的名称必须与类名相同

B、 构造方法可以带参数

C、 构造方法不可以重载  

D、 构造方法绝对不能有返回值

22、在Java语言中，下列关于类的继承的描述，正确的是（B ）。  

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

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

C、 子类可以使用父类的所有方法

D、 子类一定比父类有更多的成员方法

23、分析选项中关于Java中this关键字的说法正确的是（ A ）  

A、 this关键字是在对象内部指代自身的引用

B、 this关键字可以在类中的任何位置使用

C、 this关键字和类关联，而不是和特定的对象关联

D、 同一个类的不同对象共用一个this

24、在Java接口中，下列选项中有效的方法声明是（ A ）。  

A、 public void aMethod();

B、 public final void aMethod();  

C、 protected void aMethod();

D、 private void aMethod();

在Java接口中，方法默认是public和abstract的。即使你没有显式地添加这些修饰符，它们在接口方法中也是隐含的。让我们来分析这些选项：

A、public void aMethod(); - 这是有效的，因为public是接口方法的有效修饰符。在接口中，你不能直接实现方法（即不能有方法体），但你可以声明它们为public。

B、public final void aMethod(); - 这是无效的，因为final方法意味着它不能被重写，但接口中的方法默认就是抽象的，需要被实现类重写。因此，final和接口方法是矛盾的。

C、protected void aMethod(); - 这是无效的，因为接口方法默认是public的，你不能将它们声明为protected或private。

D、private void aMethod(); - 这也是无效的，和protected一样，你不能在接口中声明方法为private，因为接口方法的目的是要被实现类实现的。

所以，正确的选项是 A。

25、下列选项中关于Java中super关键字的说法正确的是（A ）。  

A、 super关键字是在子类对象内部指代其父类对象的引用

B、 super关键字不仅可以指代子类的直接父类，还可以指代父类的父类

C、 子类通过super关键字只能调用父类的方法，而不能调用父类的属性

D、 子类通过super关键字只能调用父类的属性，而不能调用父类的方法

3.2填空题

1、在Java程序中，通过类的定义只能实现____单重继承____，但通过接口的定义可以实现多____多重继承____。

2、_抽象（abstract）___方法是一种仅有方法头，没有具体方法体和操作实现的方法，该方法必须在抽象类之中定义。__final____方法是不能被当前类的子类重新定义的方法。

3、面向对象程序设计的三个特征是_____封装、____多态、____继承

4、Java是面向对象语言，类是客观事物的_抽象____，而对象是类的_实例____。

5、如果在子类中想使用被子类隐藏的父类成员变量或方法，就可以使用关键字__ super_____。

6、Java中有一种叫作___构造方法__的特殊方法用来对类的对象成员进行初始化。

7、JAVA语言中提供了两种类型的字符串类来处理字符串，它们是___String_和___StringBuffer类

8、Java语言中，所有 的类都是___Object的子类，Java的窗口通常是___JFrame__的子类，___抽象_类只能定义但不能被实例化，_ 最终_类不能被继承

9、一般Java程序的类体由两部分组成：一部分是_属性_，另一部分是_方法_

10、分别用__class_关键字来定义类，用_new__关键字来分配实例存储空间。

11、Java中类成员的限定词有以下几种：__ private_ _, public __ _, protected __ _,  _缺省_ _。其中，_public __的限定的范围最大。类中限定为_ private __的成员，只能被这个类本身内部访问。

12、Java类中，如果类的定义者没有显式的定义任何构造方法，系统将自动提供一个___无参默认_构造方法。

13、在子类中定义与父类的相同的方法,若在多个子类中定义相同的方法,则可以调用不同子类中的相同方法而实现不同的功能,这实现了程序运行时的______  多态 。

3.3简答题

1. 简单阐述方法的重载和方法的重写之间的区别

解答：

重写是子类的方法覆盖父类的方法，要求方法名和参数都相同

重载是在同一个类中的两个或两个以上的方法，拥有相同的方法名，但是参数却不相同

2、 简述实例变量和类变量的区别。

解答：类变量也叫静态变量，也就是在变量前加了static 的变量；实例变量也叫对象变量，即没加static 的变量；

区别在于：类变量是所有对象共有，其中一个对象将它值改变，其他对象得到的就是改变后的结果；而实例变量则属对象私有，某一个对象将其值改变，不影响其他对象；

2、简述实例方法和类方法的区别

解答：实例方法可以对当前对象的实例变量进行操作，也可以对类变量进行操作，实例方法由实例对象调用。但类方法不能访问实例变量，只能访问类变量。类方法可以由类名直接调用，也可由实例对象进行调用。类方法中不能使用this或super关键字。

3、面向对象的三个基本特征是什么，分别简单介绍每个特征。

解答：三大特性是：封装，继承，多态。

封装性就是把对象的属性和服务结合成一个独立的单位，并尽可能隐蔽对象的内部细节。

特殊类的对象拥有其一般类的全部属性与服务，称作特殊类对一般类的继承。

对象的多态性是指在一般类中定义的属性或服务被特殊类继承之后，可以具有不同的数据类型或表现出不同的行为。这使得同一个属性或服务在一般类及其各个特殊类中具有不同的语义。

4、简单阐述成员变量和局部变量的区别。

解答：

1)成员变量在整个类内都有效，局部变量只在定义它的方法内有效。

2)成员变量又分为实例成员变量（简称实例变量）和类变量（也称静态变量），如果成员变量的类型前面加上关键字static，这样的成员变量称为类变量或静态变量。

3)如果局部变量的名字与成员变量的名字相同，则成员变量被隐藏，也就是说，这个成员变量在这个方法内暂时失效。这时如果想在该方法内使用成员变量，必须使用关键字this。

5、 简述对象的引用和实体。

解答：当用类创建一个对象时，类中的成员变量被分配内存空间，这些内存空间称为该对象的实体，而对象中存放着引用，以确保实体由该对象操作使用。没有实体的对象称为空对象，空对象不能使用，即不能让一个空对象去调用方法产生行为。

6、简述this关键字的意义，以及它在成员方法和构造方法中如何使用。

解答：this是Java的一个关键字，表示某个对象。this可以出现在实例方法和构造方法中，但不可以出现在类方法中。this可以出现在实例方法和构造方法中，但不可以出现在类方法中。this关键字出现在类的构造方法中时，代表使用该构造方法所创建的对象。实例方法必须通过对象来调用，当this关键字出现在类的实例方法中时，代表正在调用该方法的当前对象。

成员函数中定义了和成员变量中相同的变量时，引用成员变量要用this;构造函数中调用同一个类的其他构造函数时用this。

7、简单描述Java的参数传值中的两种方式，基本数据类型参数的传值和引用类型参数的传值？

解答：在基本数据类型参数的传值中，基本数据类型的参数向该参数传递的值的级别不可以高于该参数的级别。

在引用类型参数的传值中，Java的引用类型数据包括对象、数组和接口，当参数是引用类型时，“传值”传递的是变量的引用而不是变量所引用的实体。如果改变参数变量所引用的实体，就会导致原变量的实体发生同样的变化，但是如果改变参数的引用不会影响向其传值的变量的引用。

8、基本数据类型和对象作为参数传递的不同？

解答：

（1） 基本数据类型作为参数在方法中传递的是值传递。

（2） 对象是引用传递，当对象作为参数传递时，传递的是对象的地址。