2018.6.20 Java考试试题总结（Java语言基础与面向对象编程）最新版

时间 2020-07-09

标签 2018.6.20 java 考试试题总结语言基础面向对象编程最新版栏目 Java 繁體版

原文原文链接

Java考试试题总结

##1、单选题（每题1分 * 50 = 50分） ###1．java程序的执行过程当中用到一套JDK工具，其中javac.exe指（ B ）java

A．java语言解释器
B．java字节码编译器
C．java文档生成器
D．java类分解器

###2．在Java语言中，不容许使用指针体现出的Java特性是（ D ）程序员

A．可移植
B．解释执行
C．健壮性
D．安全性

###3． 00101010(&)00010111语句的执行结果是( C )编程

###4．在Java中语句：37.2%10的运算结果为( A )数组

A．7.2
B．7
C．3
D．0.2

###5．0.6332 的数据类型是（ B ）浏览器

A．float
B．double
C．Float
D．Double

###6．System.out.println(“5” + 2);的输出结果应该是（ A ）安全

A．52
B．7
C．2
D．5

 System.out.println("5"+2+1);//521

###7．下面的方法，当输入为 2 的时候返回值是多少（ D ）多线程

public static int getValue(int i) {
        int result = 0;
        switch (i) {
        case 1:
            result = result + i;
        case 2:    //从这里进去    result=0+2*2  =4
            result = result + i * 2;
        case 3:     //由于没有break结束   因此直接进入   result= 4+2*3  =10
            result = result + i * 3;
        }
        return result;
}


A．0
B．2
C．4
D．10

###8．下列语句中，属于多分支语句的是（ B ）并发

A．if语句
B．switch语句
C．do while语句
D．for语句

###9．下列程序执行的结果是（ C ）。app

public class Ex6 {
    public static void main(String[] args) {
        char ch='8';
        int r=10;
        switch(ch+1) {  //第一次 9     第二次  15+1
            case '7': r=r+3;
            case '8': r=r+5;
            case '9': r=r+6;//9+6=15
                break;
            default: ;
        }
    System.out.print(r);
    }
}


A．14
B．13
C．16
D．10

###10．执行以下程序代码后，a的值是多少（ C ）编程语言

public class Ex10 {
    public static void main(String[] args) {
       int a=0;
       int c=0;
        do{
        --c;
        a=a-1;
        }while(a>0);
        System.out.println("aa"+a);
    }    
}

A．0       B．1       C．-1      D．死循环

do while的特色:
	当不知足循环条件就退出,这种循环的特色是至少会执行循环一次，先执行循环后判断

###11．下面程序代码执行的结果为：（ B ）

public class Ex11 {
    public static void main(String[] args) {
      for(int i = 0;i<5;i++){
        System.out.println(i++);
        if(i%3==0)
        break;
        }   
    }
}

A．0   1   2
B．0   2
C．0   2   4
D．0   1   3


使用break语句是跳出循环执行循环以后的语句，而continue语句是停止本次循环继续执行下一次循环。

###12．下列数组声明中错误的是（ D ）

A．int[] a         B．int a[]
C．int[][] a       D．int a[10]

###13．执行完代码”int[] x=new int[25];”后，如下( A )说明正确的

A．x[24]为0
B．x[24]未定义
C．x[25]为0
D．x[0]为空

###14.应用程序的main方法中有如下语句，则输出的结果是（ A ）

public class Ex14 {
    public static void main(String[] args) {
       int[]  x= {122,33,55,678,-987};
        int  y= x[0];
        for(int i=1;i<x.length;i++){
            if(x[i]>y)
                y =x[i];
            }
            System.out.println(y);
    }
}

A．678   B．122   C．-987   D．33

##15．方法methodA返回类型是（ A ）

public class ReturnIt{
     return Type methodA(byte x, double y) {
       return (short) x/y * 2;
   }
}

A．int    B．byte    C．long  D．double

###16．下面程序运行的结果是（ A ）

public class X {
    private static int a;
    public static void main(String [] args) {
        modify(a);
        System.out.println(a);
    }

    public static void modify(int a) {
        a++;
    }
}

A．0       B．1       C．程序编译失败       D．程序抛出异常

###17．给定以下Java程序的方法结构，则方法体实现语句正确的是（ C ）

public String change(int i){ //方法体 }

A．return 100;
B．return ‘a’;
C．return i+””;
D．return i;

###18．下列语句正确的是（ A ）

A．形式参数能够被视为local variable （局部变量）
B．形式参数可被字段修饰符修饰
C．形式参数为方法被调用时，真正被传递的参数
D．形式参数不能够是对象

A：形式参数和局部变量同样，生命周期随着方法的结束而终结，离不开方法。在Java中形式参数都是值传递的，因此能够视为一个局部变量。

B：Java中字段修饰符有：public、protected、default、private、final、static。在形式参数中，若是要使用字段修饰符，只能使用final修饰符。其余任何修饰符都能引发编译器错误。

C：java中方法没有引用调用，调用的形参都是拷贝的。 
D：形式参数能够是值或者对象。

###19．在某个类中存在一个方法：void getSort(int x),如下能做为这个方法的重载声明的是（ C ）

A．public getSort(float x)   没有返回类型 必定是构造函数 不能重载
B．int getSort(int y)   参数同样不是重载
C．double getSort(int x,int y)
D．void get(int x, int y)

重载断定就是方法名相同传入的参数不一样  参数列表不一样

###20．given the following

public class X {
    public static void main(String [] args) {
       String d="bookkeeper";
	    d.substring(2,9);//这里须要从新接收字符串  含义是重第二个开始到第九个位置结束 okkeepe
	    d = "u"+d; //仍是用最开始的d字符串
	    System.out.println(d);
    }
}
What is the result （  B ）

A．uookkeewoo
B．ubookkeeper
C．ubookkeepertoo
D．An exception is thrown at runtime

总结：substring(x)是从字符串的的第x个字符截取
     substring(x,y）是从x到y前的位置中止

###21．下面程序运行的结果是（ A ）

public class Test1{
    public static void main(String args[]){
        String a="1234";
        String b="1234";
        String c = new String("1234");
        System.out.println(a==b);//True  比较的是地址
        System.out.println(a==c);//false 比较的是地址
        System.out.println(a.equals(c));//true  比较的是内容
	}
}

A．true false true
B．true true  false
C．true false false
D．true true  true

####22．给定以下Java代码，编译运行后，输出的结果将是（ B ）

public class Test {
    public static void main(String args[]) {
        String s1 = new String("Test");
        String s2 = new String("Test");
        if (s1 == s2)
            System.out.println("Same");//比较的是地址   new出来是开辟新的空间
        if (s1.equals(s2))
            System.out.println("Equals");//比较的是内容
    }
}

A．Same
B．Equals
C．SameEquals
D．什么都不输出

###23．下面的代码执行结果是（ A ）

public class TT{
    public static void main(String[]args){
        String a = "A";
        StringBuffer b = new StringBuffer("B");
        StringBuffer c = new StringBuffer("C");//初始化出的StringBuffer对象的内容就是字符串”C”
        change(a,b,c);
            System.out.println(a+","+b+","+c);//A,B1,C
}
static void change(String s,StringBuffer s1,StringBuffer s2){
    s=s+"1";
    s1.append("1");
        System.out.println("1"+s2);// C
    s2=new StringBuffer("C1");C  //初始化出的StringBuffer对象的内容就是字符串”C1”
        System.out.println("2"+s2);// C1
    }
}

A．A,B1,C
B．A1,B1,C1
C．A,B,C
D. A1,B,C

注意：String类是final变量不能够修改，stringbuffer 是new出来的，生成的对象根据括号里面的内容来生成

###24．下列说法正确的有（ C ）

A．class中的constructor不可省略
B．constructor必须与class同名，但方法不能与class同名
C．constructor在一个对象被new时执行
D．一个class只能定义一个constructor

方法能够和类名同名的，和构造方法惟一的区别就是，构造方法没有返回值。

###25．关于对象的删除，下列说法正确的是（ B ）

A．必须由程序员完成对象的清除
B．Java把没有引用的对象做为垃圾收集起来并释放
C．只有当程序中调用System.gc()方法时才能进行垃圾收集
D．Java中的对象都很小，通常不进行删除操做

解释：在Java中定义对象时每每经过new运算符为其分配内存空间，因而当再也不但愿使用这个对象时须要释放掉它所占用的内存。在Java中，释放内存的工做是由系统自动隐含的进行，编程人员无须关心。

###26．下列描述中，错误的是（ A ）

A．Java要求编程者管理内存
B．Java的安全性体如今多个层次上
C．Applet要求在支持Java的浏览器上运行
D．Java有多线程机制

在编译层、解释层、平台层分别做不一样的安全检查
Applet自己不能运行，但可以嵌入到Web浏览器中运行
多线程是Java程序的并发机制，它能同步共享数、处理不一样的事件

###27．在以下所示的类Test中，共有（ C ）个构造方法

public class Test{
private int x;
public Test(){  //1
	x = 35;
}

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

public Test(double f){  //2
	this.x = (int)f;
}

public Test(String s) { }  //3
}

A．1
B．2
C．3
D．4

构造方法是与clss同名可是无返回值参数能够不一样

###28．设 A为已定义的类名，下列声明A类的对象a的语句中正确的是（ A ）

A．public  A  a=new  A( );
B．public  A  a=A( );
C．A  a=new  class( );
D．a  A

###29．关于类的静态成员的不正确描述是（）

A．静态成员不属于对象，是类的共享成员
B．静态数据成员初始化的时机要优先于实例成员
C．静态成员函数不拥有this指针，须要经过类参数访问对象成员
D．只有静态成员函数能够操做静态数据成员

###30．下列说法正确的是（ C ）

A．Java中包的主要做用是实现跨平台功能
B．package语句只能放在import语句后面
C．包(package)由一组类(class)和界面(interface)组成
D．能够用#include关键词来标明来自其余包中的类

###31．关于继承的说法正确的是（ B ）

A．子类将继承父类全部的属性和方法
B．子类将继承父类的非私有属性和方法
C．子类只继承父类public方法和属性
D．子类只继承父类的方法，而不继承属性

###32．下列修饰符中与访问控制无关的是（ D ）

A．private
B．public
C．protected
D．final

###33．关于被私有访问控制符private修饰的成员变量，如下说法正确的是（）

A．能够被三种类所引用：该类自身、与它在同一个包中的其余类、在其余包中的该类的子类
B．能够被两种类访问和引用：该类自己、该类的全部子类
C．只能被该类自身所访问和修改
D．只能被同一个包中的类访问

###34．关于对象成员占用内存的说法哪一个正确（ B ）

A．同一个类的对象共用同一段内存
B．同一个类的对象使用不一样的内存段，但静态成员共享相同的内存空间
C．对象的方法不占用内存
D．以上都不对

###35．下列哪一个类的声明是正确的（ D ）

A．abstract final class HI{}
B．abstract private move(){}
C．protected private number;
D．public abstract class Car{}

类声明的格式为： [修饰符]class类名[extends父类名][implements类实现的接口列表]{...} 修饰符指明类的访问控制符和类型说明符。修饰符包括：public、默认(也称friendly)、 abstract、final。public和默认(也称friendly)为访问控制符，abstract和final是类型说明符。访问控制符能够和类型说明符搭配使用.

####36．如下程序的输出结果为（ D ）

class Base {
    public Base(String s) {
        System.out.println("B");
    }
}


class Derived extends Base {
    public Derived(String s) {
        System.out.println("D");
    }
}

public class Test{
    public static void main(String[] args) {
        new Derived("C");
    }
}

A．BD
B．DB
C．C
D．编译错误

###37．在使用super 和this关键字时，如下描述正确的是（ A ）

A．在子类构造方法中使用super（）显示调用父类的构造方法，super（）必须写在子类构造方法的第一行，不然编译不经过
B．super（）和this（）不必定要放在构造方法内第一行
C．this（）和super（）能够同时出如今一个构造函数中
D．this（）和super（）能够在static环境中使用，包括static方法和static语句块

解释：
	super()和this()相似,区别是，super从子类中调用父类的构造方法，this()在同一类内调用其它方法。
	3）super()和this()均需放在构造方法内第一行。
	4）尽管能够用this调用一个构造器，但却不能调用两个。
	5）this和super不能同时出如今一个构造函数里面，由于this必然会调用其它的构造函数，其它的构造函数必然也会有super语句的存在，因此在同一个构造函数里面有相同的语句，就失去了语句的意义，编译器也不会经过。
	6）this()和super()都指的是对象，因此，均不能够在static环境中使用。包括：static变量,static方法，static语句块。
	7）从本质上讲，this是一个指向本对象的指针, 然而super是一个Java关键字。

###38．当编译并运行如下程序列会出现什么结果（ A ）

class A{
public int getNumber(int a){
return a+1;
   }
}

class B extends A{
   public int getNumber(int a, char c){
      return a+2;
}
public static void main(String[] args){
	B b=new B();
	System.out.println(b.getNumber(0));
   }
}

A．编译错误
B．运行错误
C．1
D．2

###39．阅读下列程序，选择哪个是正确的输出结果（）没有图片

A．static A I’m A class static B I’m B class
B．I’m A class I’m B class static A static B
C．static A static B I’m A class I’m B class
D．I’m A class static A I’m B class static B

注释：静态成员是累的共享成员
	 静态变量要在定义时就初始化
	 调用静态方法时经过类或对象激活

###40．以下题：在子类Child2的方法f()中不能够操做的变量是（ A ）

package a;
class Parent{
private int i=20;
protected int j=30;
public int k=40;
int h=50;
}

class Child1 extends Parent {    }

class Child2 extends Child1{

void f(){   }

}

A．i            B．j          C．k          D．h

###41．下列程序的运行结果是（）。

class Parent{
	int i=20;
	int j=30;
	void f(){
	System.out.print(” “+i);
   }
}

class Child extends Parent {
	int i=30;
	int k=40;
	void f(){
	System.out.print(” “+i);
}
	void g(){
		System.out.print(” “+k);
}

public static void main(String args[]){
Parent x=new Child();
System.out.print(x.i);
	x.f();
Child x1=(Child)x;
System.out.print(” “+x1.i);
x1.f();
   }
}

A．30 30 30 30       B．20 20 20 20     C．20 30 30 30     D．都不对

###42．在JAVA 中（ C ）。

A．一个子类能够有多个父类，一个父类也能够有多个子类
B．一个子类能够有多个父类，但一个父类只能够有一个子类
C．一个子类只能够有一个父类，但一个父类能够有多个子类
D．上述说法都不对

###43．下列哪种叙述是正确的（ D ）

A． abstract修饰符可修饰字段、方法和类
B． 抽象方法的body部分必须用一对大括号{ }包住
C． 声明抽象方法，大括号无关紧要
D． 声明抽象方法不可写出大括号

###44．设int a=-2，则表达式a>>3的值为（ D ）。

A．8
B．0
C．3
D．-1

1000 0010    右移以后 1000  0001

###45．看下面的程序,请给出结果：（ B ）

public class TestObj{
    public static void main(String[] args){
        Object o=new Object(){
            public boolean equals(Object obj){
                return true;
    }
};
    System.out.println(o.equals("Fred"));
    }
}

A．运行时抛出异常
B．true
C．Fred
D．第三行编译错误

###46．下面程序问题（ C ）

interface C {
   name = “”;
   void f();
   abstract void g();
   void h(){};
}

A．第2行编译错误
B．第4行编译错误
C．第5行编译错误
D．没有错误,正确

###47．如下对抽象类的描述正确的是（ D ）

A.抽象类没有构造方法
B.抽象类必须提供抽象方法
C.抽象类能够经过new关键字直接实例化
D.有抽象方法的类必定是抽象类

###48．如下描述错误的有（ C ）

A.abstract 能够修饰类、接口、方法
B.abstract修饰的类主要用于被继承
C.abstract 能够修饰变量
D.abstract修饰的类，其子类也能够是abstract修饰的
E.final能够用来修饰类、方法、变量

###49．关于String，StringBuilder以及StringBuffer，描述错误的是（ B ）

A.对String对象的任何改变都不影响到原对象，相关的任何change操做都会生成新的对象
B.StringBuilder是线程安全
C.StringBuffer是线程安全
D.能够修改StringBuilder和StringBuffer的内容

String 
final 修饰，不可变

StringBuilder  非线程安全、不使用多线程的状况下，效率高

StringBuffer 
线程安全

###50．在类的定义中能够有两个同名函数，这种现象称为函数（ C ）。

A.封装
B.重写
C.重载
D.继承

##2、多选题（每题2分 * 10 = 20分） ###1．关于final的说法正确的是（ C D）

A．final通常修饰静态变量，静态变量不会发生变化
B．final不能修饰抽象类，抽象类是用来继承的
C．final修饰的方法，不能被重写，可是能够重载
D．final修饰类，类不能被继承， String就是final类

###2．下列标识符不合法的有（ ACD ）

A．new    B．$Usdollars    C．1234    D．car．taxi

###3．下面错误的初始化语句是（ CD ）

A．char str[]=”hello”;
B．char str[100]=”hello”;
C．char str[]={‘h’,’e’,’l’,’l’,’o’};
D．char str[]={‘hello’};

###4．在Java中，下面关于包的陈述中正确的是（ A D ）

A．包的声明必须是源文件的第一句代码。
B．包的声明必须紧跟在import语句的后面。
C．只有公共类才能放在包中。
D．能够将多个源文件中的类放在同一个包中。

###5．关于数组的描述正确的是（ ACD ）

A． 数组有一个属性是length
B． 数组有一个方法是length()
C． 数组是固定长度，相同类型，连续的物理存储空间
D． 数组的声明能够是基本数据类型，也能够是对象类型数组，可是数组自己是引用类型

###6．对于二分搜索法，下面描述正确的是（A C）

A．可用于数组
B．可用于单链表
C．只能在已排序的数据上进行
D．最坏状况下时间复杂度是O（N*LogN）  

二分查找须要在已排序的数组上进行，须要可以经过下标直接索引到值，所以没法在链表上进行
二分查找首先要求数据是有序的,同时要求能随机访问数据元素, 有序数组能够, 链表不行,
二分查找由于每次都是从中间点开始查找，因此最坏状况是目标元素存在于最边缘的状况。最坏为O（LogN）

###7．下列关于类的继承的描述，正确的有？（B ）

A．一个类能够直接继承多个父类
B．一个类能够具备多个子类
C．子类会自动拥有父类定义的有效访问权限的方法以及成员变量
D．一个类继承另外一个类必须重写父类的方法

###8．下列描述错误的是？（B D）

A．类只能继承一个父类，可是能够实现多个接口
B．抽象类自身能够定义成员而接口不能够
C．抽象类和接口都不能被实例化
D．一个类能够有多个基类和多个基接口

Java不支持多继承，只能有一个基类
接口中定义的成员变量默认为public static final，只可以有静态的不能被修改的数据成员；并且，必须给你赋初值，其全部成员方法都是public、abstract的，并且只能被这两个关键字修饰。

###9．数据的存储结构包括？（ A B）

A．顺序存储
B．链式存储
C．图存储
D．二叉存储

###10．关于下面的代码说法正确的是（ A C）

final class D{
final int no=1;
final void f(){
final String s=””;
s = “some thing”;
    }
}

A．该类不可被继承
B．第2行可不对no赋值
C．f方法不可被重写
D．没有编译错误

##3、填空题（每题2分 * 5 = 10分） ###一、若是一个 Java 源程序文件中定义了4个类，则使用编译命令 javac 编译该源程序文件，将生成 4 个扩展名为class 的字节码文件。

###二、设 x = 2 则表达式 (x++)*3 的值是 6 。

###三、Java 语言的各类数据类型之间提供了两种转换：自动转换、强制转换。

###四、Java 设计有 gc 关键字，这不只防止了内存地址计算错误的问题，也省去了编程时对内存进行分配的烦恼。

###五、咱们在Java 程序中把关键字 super 加到方法名称的面前，来实现子类调用父类的方法。

##4、简答题（每题5分 * 4 = 20分） ###一、抽象类（abstract class）和接口（interface）有什么异同？

抽象类：包含抽象方法的类就是抽象类 
接口：指抽象方法的集合，方法不包含方法体

相同点：
    都不能被实例化
    接口的实现类或者抽象类的子类都必须实现了接口或抽象类中的方法后才能够被实例化

不一样点:
	接口只有定义，方法不能在接口中实现，实现接口的类要实现接口中全部的方法；抽象类能够有定义与实现，方法能够在抽象类中实现
接口要实现，抽象类要继承，一个类能够实现多个接口，但只能继承一个抽象类 接口强调设计理念为“has -a”的关系，抽象类强调“is -a”关系
	接口中定义变量默认为public static final,且要赋初值，方法必须是public,static，且只能是这两个；抽象类中能够有本身的数据成员变量，也能够有非抽象的成员方法，并且成员变量默认为default。这些成员变量能够在子类中被从新定义，也能够从新赋值，抽象方法（有abstract修饰）不能用peivate,static,synchronized,native等访问修饰符修饰，同时方法以分号结尾，而且不带花括号
接口被运用于比较经常使用的功能，便于往后的维护或者添加删除方法；而抽象类更倾向于充当公共类的角色，不适用于对里面的代码进行修改

　　接口是一种特殊形式的抽象类，使用接口彻底有可能实现与抽象类相同的操做。当子类和父类之间存在有逻辑上的层次结构时，推荐使用抽象类；当用于不一样类之间，定义不一样类之间的通讯规则，但愿支持差异较大的两个或者更多对象之间的特定交互行为时，应该使用接口。 
此外，接口能够继承接口，抽象类能够实现接口，抽象类也能够继承具体类。抽象类也能够有静态的main方法。

###二、什么是Java虚拟机？为何Java被称做是“平台无关的编程语言”？

Java虚拟机是执行字节码文件（.class）的虚拟机进程。
java源程序（.java）被编译器编译成字节码文件（.class）。而后字节码文件，将由java虚拟机，解释成机器码（不一样平台的机器码不一样）。利用机器码操做硬件和操做系统

由于不一样的平台装有不一样的JVM，它们可以将相同的.class文件，解释成不一样平台所须要的机器码。正是由于有JVM的存在，java被称为平台无关的编程语言

###三、说明overload和override的区别。

override（重写，覆盖） 
	一、方法名、参数、返回值相同。 
	二、子类方法不能缩小父类方法的访问权限。 
	三、子类方法不能抛出比父类方法更多的异常(但子类方法能够不抛出异常)。 
	四、存在于父类和子类之间。 
	五、方法被定义为final不能被重写。 

overload（重载，过载） 
	一、参数类型、个数、顺序至少有一个不相同。   
	二、不能重载只有返回值不一样的方法名。 
	三、存在于父类和子类、同类中。 

方法的重写(Overriding)和重载(Overloading)是Java多态性的不一样表现。 
重写(Overriding)是父类与子类之间多态性的一种表现，而重载(Overloading)是一个类中多态性的一种表现。

###四、&和&&的区别？

&和&&都是逻辑运算符号，&&又叫短路运算符
&是位运算，返回结果是int型
&&是逻辑运算，返回结果是bool型

##5、编程题（每题10分 * 2 = 20分） ###一、求100以内的素数（能被1和自己整除）。

public class test {
 public static void main(String[] args) {
  int i,n,k=0;
     for (n = 3; n<=100; n++) {     //3~100的全部数
         i=2;
         while (i<n) {
             if (n%i==0)  break;  //若能整除说明n不是素数，跳出当前循环
             i++;    
      if (i==n) {     //若是i==n则说明n不能被2~n-1整除，是素数
             k++;             //统计输出数的个数
             System.out.print(i+ "\t ");
             if (k %6==0)    //每输出5个则换行
              System.out.println();
         }
     }
 }
}

###二、请使用Java编写程序对数组进行冒泡排序。

public class X{
    public static void main(String[] args){
        int[] arr = {34,2,6,4,23};
        for(int i =0;i<arr.length;i++){
            for(int j = 0;j<i;j++){
                if(arr[i]>arr[j]){
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        for(int i = 0;i<arr.length;i++){
            System.out.println(arr[i]);
        }
    }
}