JAVA考试相关

淡淡的烟草味﹌ 2022-12-10 14:59 182阅读 0赞

1.  **语法基础（）**
    
    1.  **Java简介**

1．java语言是1995年由（A）公司发布的。

A.Sun

B.Microsoft

C.Borland

D.Fox Software

2．Sun公司针对应用领域不同，提供了三个Java版本，其中对于个人计算机程序开发的是 **j2se** ，对于企业开发应用的是** j2ee** ，对于嵌入式设备应用开发的是** j2me **。

3.java是一个网络编程语言，简单易学，利用了面向对象的技术基础，但又独立于硬件结构，具有（ABCD）。

A.可移植性  B.健壮性  C.安全性  D.高性能

4.java语言的执行模式是：（C）

A 全编译型

B 全解释型

C 半编译和半解释型

D 同脚本语言的解释模式

5.下列关于虚拟机说法错误的是：（B）

A 虚拟机可以用软件实现

B 虚拟机部可以用硬件实现

C 字节码是虚拟机的机器码

D 虚拟机把代码程序与各操作系统和硬件分开

6.下列不是虚拟机执行过程特点的是（A）

A 双线程

B 多线程

C 动态链接

D异常处理

7.java程序的执行过程中用到一套JDK工具，其中javac.exe指（A）

A  java语言编译器

B  java字节码解释器

C  java文档生成器

D  java类分解器

8.java的API结构中，不属于类库主要包括的核心包的是（C）

A  java包

B  javax

C  javadoc包

D  org扩展包

9.在当前的java实现中，每个编译单元就是一个以（A）为后缀的文件

A  java

B  class

C  doc

D  exe

10．java可以跨平台的原因是\_**java****虚拟机**\_\_\_。

11. JAVA语言的执行模式是**半编译和\_\_\_半解释型\_\_**\_。

12. Java Application应用程序的编写和执行分3步进行：**编写源代码、编译源代码、\_\_解释执行\_\_\_。**

13.JAVA系统运行时，通过\_\_**垃圾回收**\_\_\_机制周期性的释放无用对象所使用的内存，完成对象的清除。

1.  1.  **Java开发环境配置**

1.  1.  **Java基础语法**

1.main()方法的返回类型是什么？(B)  
A. int  
B. void  
C. boolean  
D. static

2．每个java的编译单元可包含多个类或界面，但是每个编译单元最多只能有（A）类或者界面是公共的。

A一个

B两个

C四个

D任意多个

3. 哪些是将一个十六进制值赋值给一个long型变量? (D)

A. long number = 345L;

B. long number = 0345;

C. long number = 0345L;

D. long number = 0x345L

4．下列不属于Java基本数据类型的是（B）

A int

B String

C float

D boolean

5．下列不属于整型变量的类型是（C）

A byte

B short

C float

D long

6. int类型整型变量在内存中的位数为（C）

A 8

B 16

C 32

D 64

7．下面选项声明正确的是（AC）

A.float f = 1F;

B.float f = 1.0;

C.float f = '1';

D.float f = "1";

E.float f = 1.0d;

8．下面哪个选项合法的声明了boolean类型(B)

A:boolean b = 0;

B:boolean b = true;

C:boolean b = "true";

D:boolean b = 'true';

9．下面哪能个选项是byte类型的取值范围(C)

A: 0 ... 255

B: 0 ... 65535

C: -128 ... 127

D: -32768 ... 32767

10．下列声明和赋值语句错误的是（C）

A double w=3.1415;

B String strl=”bye”;

C float z=6.74567

D boolean truth=true;

11.下面哪些是合法的标识符? （ABE）

A. $persons  
B. TwoUsers  
C. \*point  
D. this  
E. \_endline

12.程序最后的结果是:（b）

int i = 0, j = 1;

if ((i++ == 1) && (j++ == 2))

i = 42;

System.out.println("i = " + i + ", j = " + j);

A: i = 1, j = 2

B: i = 1, j = 1

C: i = 42, j = 2

D: i = 42, j = 1

13.程序最后的结果是:（d）

int i = 1;

int j = i++;

if ((i == ++j) || (i++ == j)) \{

i += j;

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

A: i = 1   B: i = 2   C: i = 3   D: i = 4

14.下面哪个结果是正确的(C)

boolean bool = true;

if (bool = false) \{

System.out.println("a");

\} else if (bool) \{

System.out.println("b");

\} else if (!bool) \{

System.out.println("c");

\} else \{

System.out.println("d");

A: a B: b C: c D: d

15．下列语句序列执行后，m 的值是(C)。

int  a=10, b=3, m=5;

if( a==b )

m+=a;

else

m=++a\*m;

A) 15     B) 50     C) 55     D) 5

16．下列语句序列执行后，k 的值是(B)。

int  i=4,j=5,k=9,m=5;

if(i>j||m<k)\{

k++;

else \{

k--;

A) 5     B) 10     C) 8     D) 9

17．下列语句序列执行后，i 的值是(D)。

int s=0,i=1;

while( i<=4 ) \{

s\*=i;

i++;

A) 6     B) 4     C) 24     D) 5

18．下列语句序列执行后，k 的值是(D)。

int  x=6, y=10, k=5;

switch( x%y )

case 0:  k=x\*y;

case 6:  k=x/y;

case 12:  k=x-y;

default:  k=x\*y-x;

A) 60     B) 5     C) 0     D) 54

19.下列语句序列执行后，i 的值是(d)。

int s=0,i=1;

while( i<=4 ) \{

s\*=i;

i++;

A) 6     B) 4     C) 24     D) 5

20.下面哪个结果是正确的\_\_B\_\_\_

for (int i = 0; i < 3; i++) \{

switch(i) \{

case 0: System.out.print("zero");

case 1: System.out.print("one ");

break;

case 2: System.out.print("two ");

case 3: System.out.print("three ");

A: zero one two three

B: zero one one two three

C: one two three

D: one two three two three one

21.下面结果哪个是正确的\_\_B\_\_\_

int i = 4, j = 3;

do \{

if (i > j) \{

continue;

j--;

\} while (++i < 6);

System.out.println("i = " + i + " and j = " + j);

A: i = 6 and j = 5

B: i = 6 and j = 3

C: i = 6 and j = 4

D: i = 5 and j = 6

22.若有循环：A

int x=5,y=20;

do \{

y-=x;

x+=2;

\}while(x<y);

则循环体将被执行( )。

A) 2次     B) 1次   3  C) 0次     D) 3次

23.以下由do-while语句构成的循环执行的次数是(B)。

int  m = 8;

do \{

\++m;

\} while ( m < 8 );

A)一次也不执行    B)执行1次

C)8次             D)有语法错，不能执行

24. 下列语句序列执行后，i的值是(A)。

int  i=10;

do \{

i/=2;

\} while( i>1 );

A) 1      B) 5      C) 2     D) 0

25.下列语句序列执行后，i的值是(D)。

int  i=10;

do \{

i/=2;

\} while( i-- > 1 );

A) 1      B) 5      C) 2     D) –1

1.  1.  **java基本数据类型、变量类型**

8种基本数据类型：byte、short、int、long、float、double、char、boolean

1.下面代码的运行结果为：（）

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异常

答案：C

2.以下哪些选项是Java中的基本数据类型

A、byte

B、char

C、long

D、Integer

E、String

答案：ABC

3.Java 语言用以下哪个类来把基本类型数据封装为对象（）

A、包装类

B、Class

C、Math

D、Object

答案：A

4.在Java语言中，String类型的成员变量，其默认初识值是（）

A、false

B、“”

C、0

D、null

答案：D

5.Java语言里，byte类型的取值范围是（）

A、\-128 ~ 127

B、-228 ~128

C、-255 ~ 256

D、-255 ~ 255

答案：A

6.Java中主要有如下几种类型的变量()

A、局部变量

B、类变量（静态变量）

C、成员变量（非静态变量）

D、方法变量

答案：ABC

7.对于java类型变量char c,short s,float f,double d,表达式c\*s+f+d的结果类型为（）

A、float

B、char

C、short

D、double

答案：D

8.下列关于成员变量默认值的描述中，错误的是（）

A、byte类型数据的默认值是0

B、int类型数据的默认值是0

C、long类型数据的默认值是0

D、float类型数据的默认值是0.0f

答案：C

1.  1.  **java修饰符**

1.编译并运行下面代码，请选择形貌精确的项

public class XiuShiFu\{

int i =10;

private static float pi=3.0f;//(1)

public static void main(string \[\] args) \{

public inti= 20;//(2)

final doubled= 4.0d;//(3)

System.out.println(i+d +pi) ;\} \}

A、编译精确，输出效果28.0数据类型

B、 编译错误，(1) 处有错误

C、 编译错误，(2) 处有错误

D、 编译错误，(3) 处有错误

E、 编译精确，输出效果18.0

答案：C

2.Java接口的修饰符可以为（）

(a)private

(b)protected

(c)final

(d)abstract

答案：CD

3.下列可作为java语言修饰符的是（）

A、a1

B、$1

C、\_1

D、11

答案：ABC

4.关于Java访问权限修饰符，以下描述正确的有（）

A、包访问权限。声明关键字为“default”，具有包可见性。

B、public权限。声明关键字为“public”，具有最大的访问权限，任何类都可以访问。

C、protected权限。声明关键字为“protected”，具有包可见性和子类可见性。

D、private权限。声明关键字为“private”，除类自身外，对外不可见。

E、以上描述全部是错误的。

答案：BCD

1.  1.  **java运算符**

1.Java 程序中使用赋值运算符进行对象赋值时，可以得到两个完全相同的对象。

A、正确

B、错误

答案：B

2)假定+，\*和&分别表示加法、乘法和指数运算，且计算符优先级顺序从高到低依次为：+，\*和&，运算符运算时遵循左结合率，则：2+1\*2&1\*2&2的值为：

A、10

B、18

C、324

D、1296

答案：D

1.  1.  **java对象和类简介**
2.  下面属于JAVA的Object类方法有（ABCD）

1.  hashCode()
2.  clone()
3.  equals()
4.  finalize()

1.  在创建对象时，必须（C）

1.  先声明对象，然后才能使用对象
2.  先声明对象，为对象分配内存空间，然后才能使用对象
3.  先声明对象，为对象分配内存空间，对对象初始化，然后才能使用对象
4.  对象可以直接使用

1.  在JAVA中，”123”属于（B）类对象

1.  Int
2.  String
3.  Integer
4.  Number

1.  下面关于类和对象之间的关系的描述，正确的时（C）

1.  联接关系
2.  包含关系
3.  抽象和具体的关系
4.  类时对象的具体化

1.  类时具有相同（A）的集合

1.  属性和方法
2.  变量和方法
3.  变量和数据
4.  对象和属性

1.  实例变量的作用域是整个（C）

1.  语句块
2.  方法
3.  类
4.  以上都不对

1.  A派生出子类B，B派生出子类C，并且在Java源代码中有如下声明：

1. A a0=new A();

2. A a1 =new B();

3. A a2=new C();

问以下哪个说法是正确的？（D）

1.  只有第1行能通过编译
2.  第1、2行能通过编译，但第3行编译出错
3.  第1、2、3行能通过编译，但第2、3行运行时出错
4.  第1行、第2行和第3行的声明都是正确的

1.  **语法基础（）**

1.  1.  **Java流程结构**
2.  Java流程控制结构不包括（D）

1.  选择结构
2.  循环结构
3.  顺序结构
4.  return 0;

1.  基本for循环需要哪些组成部分（D）

1.  初始部分
2.  条件表达式
3.  增量部分语句
4.  contonue，break

1.  下面关于while和do-while循环的说法中，正确的是(D )。  
        A．与do-while语句不同的是，while语句的循环体至少执行一次  
        B．do-while语句首先计算终止条件，当条件满足时，才去执行循环体中的语句  
        C．两种循环除了格式不同外，功能完全相同  
        D．以上答案都不正确

1.  1.  **Java数组**
2.  下面错误的初始化语句是（ABD）

1.  char str\[\]=”hello”
2.  char str\[100\]=”hello”
3.  char str\[\]=\{‘h’,’e’,’l’,’l’,’o’\}
4.  char str\[\]=\{‘hello’\}

解析：A选项定义的是char类型数组，赋值是String类型，所以会报错。  
B同上，C选项正确，D选项'hello'不是char类型，char类型只有一个字符，也不是String类型，String类型使用“hello”。

1.  Java中数组存储在（C）

1.  栈
2.  队列
3.  堆
4.  链表

1.  下面不是数组复制方法的是（C）

1.  用循环语句逐个复制数组
2.  用arraycopy方法
3.  用“=”进行复制
4.  用clone方法

1.  当访问无效数组下标时，会发生（B）

1.  中止程序
2.  抛出异常
3.  系统崩溃
4.  越界访问

1.  关于数组作为方法的参数时，向方法传递的时（A）

1.  数组的引用
2.  数组的栈地址
3.  数组自身
4.  数组的元素

1.  下列语句会造成数组int a\[\]=new int\[10\]越界的是（C）

1. a\[0\]+=9;
2. A\[9\]=10;
3. for(int i=0;i<10;i++) a\[++i\]=i;
4. for(int i=0;i<10;i++) a\[i++\]=i;

7、关于java数组，下面说法错误的是（C）

A. 定义数组的方式可以为int \[\]a;或int a\[\];

B．数组的初始化分为静态初始化和动态初始化两种

C. 数组在动态初始化完成后，可以再次动态修改长度

D. 数组里的元素类型必须相同

1.  1.  **枚举**

代码示例

**enum** Day \{  
    MONDAY, TUESDAY, WEDNESDAY,  
    THURSDAY, FRIDAY, SATURDAY, SUNDAY;  
\}

使用方式

Day day = Day.MONDAY;  
System.out.println(day);  
System.out.println(Day.MONDAY);  
  
*//* *输出结果都是 MONDAY*

1.枚举是什么？

答案：使用enum定义的枚举类是一种引用类型，但是不能使用new，是一种特殊的类，用于固定多个常量对象。

2.枚举的特点？

答案：

1)使用enum修饰，枚举的直接父类为java.lang.Enum ，但是不显示继承自Enum

2)枚举是一种类（class）类型, 枚举相当于类，可以定义构造方法、成员变量、方法。

3)默认私有的构造方法，默认访问权限private

4)不能使用new关键字创建新对象

5)枚举实例必须位于最开始部分

6)enum变量本身带有类型信息，编译器会自动检查出错误

int day = 1;  
day == Day.MONDAY; *//* *这种会出现编译错误*  
  
Day a = Day.MONDAY;  
a == Day.MONDAY; *//* *正常*

3.枚举的实现原理

使用关键字enum定义的枚举类型，在编译过后，编译器会生成对应的7个Day类型的实例对象，分别对

应7个星期，会变成真正的Day类供调用。

MONDAY枚举 对应 public static final Day MONDAY;

反编译Day.class

final **class** Day **extends** Enum \{  
    **public** static Day\[\] values () \{  
        **return** (Day\[\])$VALUES.clone();  
    \}  
     
    **public** static Day valueOf(String s) \{  
        **return** (Day)Enum.valueOf(com/demo/Day, s);  
    \}  
     
    **private** Day(String s, int i)\{  
        **super**(s, i);  
    \}  
     
    **public** static final Day MONDAY;  
    **public** static final Day TUESDAY;  
    **public** static final Day WEDNESDAY;  
    **public** static final Day THURSDAY;  
    **public** static final Day FRIDAY;  
    **public** static final Day SATURDAY;  
    **public** static final Day SUNDAY;  
     
    static \{  
        MONDAY = **new** Day("MONDAY", 0);  
        TUESDAY = **new** Day("TUESDAY", 0);  
        WEDNESDAY = **new** Day("WEDNESDAY", 0);  
        THURSDAY = **new** Day("THURSDAY", 0);  
        FRIDAY = **new** Day("FRIDAY", 0);  
        SATURDAY = **new** Day("SATURDAY", 0);  
        SUNDAY = **new** Day("SUNDAY", 0);  
    \}  
\}

1.  **面向对象**
    
    1.  **理解面向对象**

1. 三个基本特征

答案：封装、继承、多态

2.三个基本特征的含义

答案：

封装：就是把客观事物封装成抽象的类, 并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行隐藏。

继承：可以使用现有类的所有功能，并在无需编写原来类的情况下对这些功能进行扩展。通过继承创建的类成为“子类”或”派生类“，被继承的称为”基类“或”父类“。

多态性：允许你将子类类型的指针赋值给父类类型的指针

3.实现多态的两种方式？以及区别？

答案：

a. 覆盖

b. 重载

区别：覆盖是在运行时决定，重载是在编译时决定

4.五大设计原则

1)单一职责原则：对一个类而言，应该仅有一个引起它变化的原因。一个职责的变化不能影响另一个的履行。

2)开放封闭原则：软件实体应该是可以扩展的，但是不可修改

3)Liskov替换原则：子类型必须能够替换掉他们的基类型。

4)依赖倒置原则：抽象不应依赖于细节，细节应该依赖于抽象。

5)良性依赖原则：不会在实际中造成危险的以来关系，都是良性依赖。

1.  1.  **类与对象**

1.类与对象的区别

答案：

对象：对象是类的一个实例，有状态和行为。

类：类是一个模板，它表示一类对象的行为和状态。

2.堆内存和栈内存的区别

答案：

堆内存：保存对象的属性内容，堆内存需要用new关键字来分配空间。

栈内存：保存的是堆内存的地址，即一些基本类型的变量和对象的引用变量。

3.下面两种有什么区别

Person person = **null**;  
person = **new** Person();  
  
Person person = **new** Person();

答案：

1) 任何情况下出现关键字 new ，都要分配新的堆内存空间，一旦堆内存分配了，里面就会有类中定义的属性，并且属性内容都是其对应数据类型的默认值。  
2) 第一种：会在堆内存创建一个person并指向null，然后在new的时候会在栈内存中创建Person对象的默认值区域，然后person会指向Persion对象的地址。  
3) 第二种：会同时分配堆内存和栈内存的空间，然后将person实例指向栈内存的Person对象空间。

1.  1.  **构造方法**

1.下列关于Java中类的构造方法的描述，正确的是（）

A、构造方法的返回类型为void

B、可以定义一个类而在代码中不写构造方法

C、在同一个类中定义的重载构造方法不可以相互调用

D、子类不允许调用父类的构造方法

答案：B

2.java中的每个类都至少有一个构造方法，一个类中如果没有定义构造方法，系统会自动为这个类创建一个默认的构造方法。这句话是否正确？

答案：正确

3.在JAVA中，假设A有构造方法A(int a)，则在类A的其他构造方法中调用该构造方法和语句格式应该为（）

A、this.A(x)

B、this(x)

C、super(x)

D、A(x)

答案：B

4.Java中，什么是构造方法？什么是构造方法重载？

答案：构造函数就是生成一个实例对象的方法，也就是我们常说的new；

构造函数重载的意思是存在多个生成一个实例对象的方法，但是方法的参数列表不相同；

1.  **封装**
    
    1.  **包**

1.java语言中，在同一包下，以下说法正确的是（）

A、super.方法（）可以调用父类的所有非私有方法

B、super（）可以调用父类的所有非私有构造函数

C、super.属性可以调用父类的所有非私有属性

D、this和super关键字可以出现在同一个构造函数中

答案：ABCD

2.基本的Java语言函数存储在以下哪个java包中？（）

1.  java.lang

B、java.io

C、java.net

D、java.util

答案：A

3.在Java中，包com中定义了类TestUtil，在com的子包util中定义了同名类TestUtil，给定如下Java代码，编译运行时，将发生（ ）。

package test;

import com.util.TestUtil;

import com.TestUtil;

public class Test \{

public static void main(String\[\] args)  \{

TestUtil testutil = new TestUtil();

A、创建了一个com.TestUtil对象

B、创建了一个com.util.TestUtil对象

C、运行时出现异常

D、编译无法通过

答案：D

4.在java中，用package语句说明一个包时，该包的层次结构必须与\_\_\_\_\_相同。

答案：与文件目录的层次

1.  1.  **访问权限修饰符**

1.关于Java访问权限修饰符，以下描述正确的有

A、包访问权限。声明关键字为“default”，具有包可见性。

B、public权限。声明关键字为“public”，具有最大的访问权限，任何类都可以访问。

C、protected权限。声明关键字为“protected”，具有包可见性和子类可见性。

D、private权限。声明关键字为“private”，除类自身外，对外不可见。

E、以上描述全部是错误的。

答案BCD

2.访问权限关键字以及访问能力的关系列表（填是否）

<table> 
 <tbody> 
 <tr> 
 <td style="vertical-align:top;width:82.95pt;"> 类型 </td> 
 <td style="vertical-align:top;width:82.95pt;"> 无修饰符 </td> 
 <td style="vertical-align:top;width:82.95pt;"> Private </td> 
 <td style="vertical-align:top;width:82.95pt;"> Protected </td> 
 <td style="vertical-align:top;width:83pt;"> Public </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:82.95pt;"> 同一类 </td> 
 <td style="vertical-align:top;width:82.95pt;"> &nbsp; </td> 
 <td style="vertical-align:top;width:82.95pt;"> &nbsp; </td> 
 <td style="vertical-align:top;width:82.95pt;"> &nbsp; </td> 
 <td style="vertical-align:top;width:83pt;"> &nbsp; </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:82.95pt;"> 同一包的之类 </td> 
 <td style="vertical-align:top;width:82.95pt;"> &nbsp; </td> 
 <td style="vertical-align:top;width:82.95pt;"> &nbsp; </td> 
 <td style="vertical-align:top;width:82.95pt;"> &nbsp; </td> 
 <td style="vertical-align:top;width:83pt;"> &nbsp; </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:82.95pt;"> 同一包的非子类 </td> 
 <td style="vertical-align:top;width:82.95pt;"> &nbsp; </td> 
 <td style="vertical-align:top;width:82.95pt;"> &nbsp; </td> 
 <td style="vertical-align:top;width:82.95pt;"> &nbsp; </td> 
 <td style="vertical-align:top;width:83pt;"> &nbsp; </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:82.95pt;"> 不同包的子类 </td> 
 <td style="vertical-align:top;width:82.95pt;"> &nbsp; </td> 
 <td style="vertical-align:top;width:82.95pt;"> &nbsp; </td> 
 <td style="vertical-align:top;width:82.95pt;"> &nbsp; </td> 
 <td style="vertical-align:top;width:83pt;"> &nbsp; </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:82.95pt;"> 不同包的非子类 </td> 
 <td style="vertical-align:top;width:82.95pt;"> &nbsp; </td> 
 <td style="vertical-align:top;width:82.95pt;"> &nbsp; </td> 
 <td style="vertical-align:top;width:82.95pt;"> &nbsp; </td> 
 <td style="vertical-align:top;width:83pt;"> &nbsp; </td> 
 </tr> 
 </tbody> 
</table>

答案：

<table> 
 <tbody> 
 <tr> 
 <td style="vertical-align:top;width:82.95pt;"> 类型 </td> 
 <td style="vertical-align:top;width:82.95pt;"> 无修饰符 </td> 
 <td style="vertical-align:top;width:82.95pt;"> Private </td> 
 <td style="vertical-align:top;width:82.95pt;"> Protected </td> 
 <td style="vertical-align:top;width:83pt;"> Public </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:82.95pt;"> 同一类 </td> 
 <td style="vertical-align:top;width:82.95pt;"> 是 </td> 
 <td style="vertical-align:top;width:82.95pt;"> 是 </td> 
 <td style="vertical-align:top;width:82.95pt;"> 是 </td> 
 <td style="vertical-align:top;width:83pt;"> 是 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:82.95pt;"> 同一包的子类 </td> 
 <td style="vertical-align:top;width:82.95pt;"> 是 </td> 
 <td style="vertical-align:top;width:82.95pt;"> 否 </td> 
 <td style="vertical-align:top;width:82.95pt;"> 是 </td> 
 <td style="vertical-align:top;width:83pt;"> 是 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:82.95pt;"> 同一包的非子类 </td> 
 <td style="vertical-align:top;width:82.95pt;"> 是 </td> 
 <td style="vertical-align:top;width:82.95pt;"> 否 </td> 
 <td style="vertical-align:top;width:82.95pt;"> 是 </td> 
 <td style="vertical-align:top;width:83pt;"> 是 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:82.95pt;"> 不同包的子类 </td> 
 <td style="vertical-align:top;width:82.95pt;"> 否 </td> 
 <td style="vertical-align:top;width:82.95pt;"> 否 </td> 
 <td style="vertical-align:top;width:82.95pt;"> 是 </td> 
 <td style="vertical-align:top;width:83pt;"> 是 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:82.95pt;"> 不同包的非子类 </td> 
 <td style="vertical-align:top;width:82.95pt;"> 否 </td> 
 <td style="vertical-align:top;width:82.95pt;"> 否 </td> 
 <td style="vertical-align:top;width:82.95pt;"> 否 </td> 
 <td style="vertical-align:top;width:83pt;"> 是 </td> 
 </tr> 
 </tbody> 
</table>

1.  1.  **接口与实现**

1.下面能在接口中定义的是(AD)

1.  常量  b.变量  c.构造器  d.抽象方法

2.下面关于接口和类的说法错误的是（C）

1.  一个类可以实现多个接口
2.  接口中不允许有构造器
3.  实现接口的类，没有重写接口的所有方法也可以实例化
4.  接口之间是可以继承的，并且可以多继承

3.请问接口有什么限制？

1)变量会被隐式的指定为public static final变量，并且只能是public static final 变量

2)方法会被隐式的指定为public abstract 方法且只能是public abstract方法

3)接口中所有的方法都不能有具体的实现，接口中的方法都必须是抽象方法

4)接口中不允许有构造器

1.  1.  **类访问权限**

1.类成员的访问权限有（ABC）

1.  Public
2.  Private
3.  Protected
4.  static

2.将类的成员的访问权限设置为默认的，则该成员能够被（A）

1.  同一包中的类访问
2.  其它包中的类访问
3.  所有的类访问
4.  所有的类的子类访问

3.java类的修饰符有哪些，在什么情况下使用？

Java类有公共类和非公共类，使用public修饰的类就是公共类，没有public修饰就是非公共类。如果这个类允许在其他包中使用就定义为公共类，如果不允许在其他包中使用就不用public修饰。

1.  **继承**
    
    1.  **继承的语法**

1.下面关于java继承的描述正确的是（B）

A. 一个类只能实现一个接口

B. 继承是通过extends关键字来描述的，而且只允许继承自一个直接父类

C. 一个类不能同时继承一个类和实现一个接口

D. 单一继承使代码不可靠

2.在java中能实现多重继承效果的方式是（C）

1.  内部类
2.  适配器
3.  接口
4.  同步

3.在java中，想要一个类继承另一个类，可以使用以下哪个关键字(C)

1.  inherits
2.  implements
3.  extends
4.  modifies

4.以下可以被继承的类有（AEFG）

1.  Number
2.  String  
3.  Byte
4.  Math
5.  Exception
6.  Thread
7.  ClassLoader

5.下列叙述中，正确的是（D）

1.  子类继承父类的所有属性和方法
2.  子类可以继承父类的私有的属性和方法
3.  子类可以继承父类的公有的属性和方法
4.  创建子类对象时，父类的构造方法都要被执行

6.关于继承下面说法正确的是（C）

A. 子类能够继承父类私有属性

B. 子类可以重写父类夫人final方法

C. 子类能继承不同包父类的projected属性

D. 子类能够继承不同父类的缺省属性

7.Java中内实现多重继承效果的方式是（C）

A. 内部类

B. 适配器

C. 接口

D. 同步

8.Java中关于继承的描述正确的是（ACD）

A. 一个子类只能继承一个父类

B. 子类可以继承父类的构造方法

C. 继承具有传递性

D. 父类一般具有通用性，子类更具体

1.  1.  **向上转型**

1.下面代码的运行结果是（B）

public class Car() \{

public void run() \{

System.out.println(“汽车在跑”);

public class Benz extends Car \{

public void run() \{

System.out.println(“奔驰在跑”);

public static void main(String\[\] args) \{

Car car = (Car)(new Benz());

car.run();

A、汽车在跑

B、奔驰在跑

C、无法编译

D、运行时将抛出异常

class A \{

public void print() \{

System.out.println("A:print");

class B extends A \{

public void print() \{

System.out.println("B:print");

public class Test\{

public static void main(String args\[\])

A a = new B();

a.print();

运行结果是：？

答案：B:print

1.  1.  **final关键字**

1.public class Test \{

public static void main(String\[\] args)  \{

final MyClass myClass = new MyClass();

System.out.println(++myClass.i);

class MyClass \{

public int i = 0;

输出结果是：？

答案：1

2.String、StringBuffer都是（C）类，都不能被继承

A、static

B、abstract

C、final

D、private

3.排除错误

public class Something \{

public int addOne(final int x) \{

return ++x;

答案：错误，调用方法的时候已经对x进行赋值，不能再对其进行++操作。

4.输出结果是：

public class Test

public static void main(String\[\] args)

String str1 = "helloworld";

String str2 = "hello";

final String str3 = "hello";

String str4 = str2 + "world";

String str5 = str3 + "world";

System.out.println(str1 == str4);

System.out.println(str1 == str5);

答案：

False

True

5.下列关键字中可以表示常量的是（A）

A、final

B、default

C、private

D、transient

6.若类申明加上（B）修饰符，则表示该类不能有子类

A、close

B、final

C、down

D、end

7.下面说法正确的是（A）

A、final可修饰类、属性（变量）、方法

B、abstract可修饰类、方法

C、抽象方法只有方法头，没有方法体

D、关键字final和abstarct不能同时

1.  **多态**
    
    1.  **理解多态**

1.  下面针对多态说法正确的是：（）

1.  一个接口，多种实现
2.  同一种事物表现出的多种形态
3.  把一系列具体事务的共同点抽象出来，再通过这个抽象的事物，与不同的具体事物进行对话
4.  允许将子类类型的指针赋值为父类类型的指针。

答案：ABCD

2.下面四个选项中，（ ）是用来形容虚函数的。

A、virtual B、publlic    c、using   D、false

答案：A

3.要实现动态多态性，可以通过（ ）调用虚函数。

A.基类指针

B.成员名限定

C.对象名

D.派生类名

答案：A

1.  1.  **多态的表现形式**

1.多态的三种表现形式（  ）

A、继承       B、重写    C、父类引用指向子类对象     D、封装

答案：ABC

1.  1.  **重载与重写**

1、在类的定义中可以有两个同名函数，这种现象称为函数（   ）。

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

答案：D

2、Java 构造方法能否被重写和重载？

**答：**重写是子类方法重写父类的方法，重写的方法名不变，而类的构造方法名必须与类名一致，假设父类的构造方法如果能够被子类重写则子类类名必须与父类类名一致才行，所以 Java 的构造方法是不能被重写的。而重载是针对同一个的，所以构造方法可以被重载。

3、在java中重写方法应遵循规则的包括（）

1.  访问修饰符的限制一定要大于被重写方法的访问修饰符
2.  可以有不同的访问修饰符
3.  参数列表必须完全与被重写的方法相同

D、必须具有不同的参数列表

答案：BC

4、Java里关于方法的重写(Override)和重载(Overloade),下面说法正确的是（）

1.  方法重写是指父类与子类之间多态性的一种表现

B、方法重载是指同一个类中多态性的一种表现

C、子类中定义的某方法与其父类中的某方法有相同的签名(名称、参数、返回值)，称之为方法重写

D、一个类中定义了多个同名的方法，但方法签名(名称、参数、返回值)不相同，称之为方法重载

答案：ABCD

5、在Java中，以下关于方法重载和方法重写描述正确的是？  
A、方法重载和方法的重写实现的功能相同。  
B、方法重载出现在父子关系中，方法重写是在同一类中。  
C、方法重载的返回值类型必须一致，参数项必须不同。  
D、方法重写的返回值类型必须相同。

答案：D

JAVA考试相关

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关 Java设计考试系统

相关 Java网络考试系统

相关【java】排序相关

相关 Java-锁相关

相关 JAVA考试相关

相关 JAVA基础水平考试

相关计算机考试相关证书（一）

相关计算机考试相关证书（二）

相关 Java Synchronized相关

相关 Java 时间相关