java基础知识练习题

Posted 2020-11-20 一直都是瑾凉

前段时间学习Java，做了几道基础题。题都还是面向基础的一些题。分享给大家一起学习

#答案在底部

选择题(共50题，每题2分，满分100分)
1)    在Java类中，使用以下（ ）声明语句来定义公有的int型常量MAX。
    A.    public int MAX = 100;
    B.    final int MAX = 100;
    C.    public static int MAX = 100;
    D.    public static final int MAX = 100;

2)    在Java中，下列关于方法重载的说法中错误的是（ ）（多选）。
    A.    方法重载要求方法名称必须相同
    B.    重载方法的参数列表必须不一致
    C.    重载方法的返回类型必须一致
    D.    一个方法在所属的类中只能被重载一次

3)    给定Java代码如下所示，在横线处新增下列（ ）方法，是对cal方法的重载。（多选）
public class Test{
  public void cal(int x, int y, int z) {}
  ________________                                                            
}
    A.    public int cal(int x, int y, float z){ return 0; }
    B.    public int cal(int x, int y, int z){ return 0; }
    C.    public void cal(int x, int z){ }
    D.    public void cal(int z, int y, int x){ }

4)    在Java中，下面对于构造函数的描述正确的是（ ）。
    A.    类必须显式定义构造函数
    B.    构造函数的返回类型是void
    C.    构造函数和类有相同的名称，并且不能带任何参数
    D.    一个类可以定义多个构造函数

5)    下面Java代码的运行结果是（  ）。
class Penguin {
    private String name=null; // 名字
    private int health=0; // 健康值
    private String sex=null; // 性别
    public void Penguin() {
        health = 10;
        sex = "雄";
        System.out.println("执行构造方法。");
    }
    public void print() {
        System.out.println("企鹅的名字是" + name +
                "，健康值是" + health + "，性别是" + sex+ "。");
    }
    public static void main(String[] args) {
        Penguin pgn = new Penguin();
        pgn.print();
    }
}
    A.    企鹅的名字是null，健康值是10，性别是雄。
    B.    执行构造方法。
        企鹅的名字是null，健康值是0，性别是null。
    C.    企鹅的名字是null，健康值是0，性别是null。
    D.    执行构造方法。
        企鹅的名字是null，健康值是10，性别是雄。

6)    下列选项中关于Java中封装的说法错误的是（ ）。
    A.    封装就是将属性私有化，提供公有的方法访问私有属性
    B.    属性的访问方法包括setter方法和getter方法
    C.    setter方法用于赋值、getter方法用于取值
    D.    类的属性必须进行封装，否则无法通过编译

7)    使用Java实现封装，第一步是修改属性可见性来限制对属性的访问，第二步是创建赋值和取值方法，用于对属性的访问，第三步应该是（ ）。
    A.    使用赋值和取值方法访问属性
    B.    编写常规方法访问属性
    C.    在赋值和取值方法中，加入对属性的存取限制
    D.    编写main方法创建对象，调用赋值和取值方法访问属性

8)    分析如下所示的Java代码，其中this关键字的意思是（ ）。
public class Test {
    private String name;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;            //this关键字所在的行
    }
}
    A.    name属性
    B.    Test类的内部指代自身的引用
    C.    Test类的对象引用Test类的其他对象
    D.    指所在的方法

9)    在Java中，以下程序编译运行后的输出结果为（ ）。
public class Test {
    int x, y;
    Test(int x, int y) {
        this.x = x;
        this.y = y;
    }
    public static void main(String[] args) {
        Test pt1, pt2;
        pt1 = new Test(3, 3);
        pt2 = new Test(4, 4);
        System.out.print(pt1.x + pt2.x);
    }
}
    A.    6
    B.    3 4
    C.    8
    D.    7

10)    在Java语言中，下列关于类的继承的描述，正确的是（ ）。
    A.    一个类可以继承多个父类
    B.    一个类可以具有多个子类
    C.    子类可以使用父类的所有方法
    D.    子类一定比父类有更多的成员方法

11)    Java中，如果类C是类B的子类，类B是类A的子类，那么下面描述正确的是（ ）。
    A.    C不仅继承了B中的公有成员，同样也继承了A中的公有成员
    B.    C只继承了B中的成员
    C.    C只继承了A中的成员
    D.    C不能继承A或B中的成员

12)    给定一个Java程序Test.java的代码如下所示，编译时，会出现以下（ ）情况。
class Parent {
    public int count() {               // 第1行
        return 0;
    }
}
public class Test  extends Parent {
    private int i;
    public int count() {               // 第2行
        return i % 9;                // 第3行
    }
}
    A.    编译通过
    B.    在第1行引发编译错误
    C.    在第2行引发编译错误
    D.    在第3行引发编译错误

13)    给定如下一个Java源文件Child.java，编译并运行Child.java，以下结果正确的是（ ）。
class Parent1 {
    Parent1(String s){
        System.out.println(s);
    }
}
class Parent2  extends Parent1{
    Parent2(){
        System.out.println("parent2");
    }
}
public class Child extends Parent2 {
    public static void main(String[] args) {
        Child child = new Child();
    }
}
    A.    编译错误：没有找到构造器Child()
    B.    编译错误：没有找到构造器Parent1()
    C.    正确运行，没有输出值
    D.    正确运行，输出结果为：parent2

14)    给定Java程序Child.java的代码如下所示，则编译运行该类的结果是（ ）。
class Parent {
    Parent() {
        System.out.println("parent");
    }
}
public class Child extends Parent {
    Child(String s) {
        System.out.println(s);
    }
    public static void main(String[] args) {
        Child child = new Child("child");
    }
}
    A.    输出：child
    B.    输出：child
        parent
    C.    输出：parent
        child
    D.    编译错误

15)    下列选项中关于Java中super关键字的说法错误的是（ ）。
    A.    super关键字是在子类对象内部指代其父类对象的引用
    B.    super关键字不仅可以指代子类的直接父类，还可以指代父类的父类
    C.    子类可以通过super关键字调用父类的方法
    D.    子类可以通过super关键字调用父类的属性

16)    分析如下所示的Java代码，则选项中的说法正确的是（ ）（多选）。
class Parent{
    public String name;
    public Parent(String pName){
        this.name = pName;
    }
}
public class Test  extends Parent {  //1
    public Test(String Name){               //2
        name="hello";          //3
        super("kitty");          //4
    }    
}
    A.    第2行错误，Test类的构造函数中参数名称应与其父类构造函数中的参数名相同
    B.    第3行错误，应使用super关键字调用父类的name属性，改为super.name="hello";
    C.    第4行错误，调用父类构造方法的语句必须放在子类构造方法中的第一行
    D.    程序编译通过，无错误

17)    以下关于Object类说法错误的是（ ）。
    A.    一切类都直接或间接继承自Object类
    B.    接口亦继承Object类
    C.    Object类中定义了toString()方法
    D.    Object类在java.lang包中

18)    在Java中，多态的实现不仅能减少编码的工作量，还能大大提高程序的可维护性及可扩展性，那么实现多态的步骤包括以下几个方面除了（ ）。
    A.    子类重写父类的方法
    B.    子类重载同一个方法
    C.    定义方法时，把父类类型作为参数类型；调用方法时，把父类或子类的对象作为参数传入方法
    D.    运行时，根据实际创建的对象类型动态决定使用哪个方法

19)    给定Java代码如下所示，则编译运行后，输出结果是（ ）。
class Parent {
  public void count() {
    System.out.println(10%3);
  }
}
public class Child  extends Parent{
  public void count() {
    System.out.println(10/3);
  }
  public static void main(String args[]) {
    Parent p = new Child();
    p.count();
  }
}

    A.    1
    B.    1.0
    C.    3
    D.    3.3333333333333335

20)    分析如下Java代码，如果想在控制台上输出“B类的test()方法”，则在横线处应填入（ ）（多选）。
class A {
    public void test() {
        System.out.println("A类的test()方法");
    }
}
class B extends A {
    public void test() {
        System.out.println("B类的test()方法");
    }
    public static void main(String args[]) {
         ________________________                                  
    }
}
    A.    A a = new B();
            a.test();
    B.    A a = new A();
                a.test();
    C.    B b = new A();
                b.test();
    D.    B b = new B();
                b.test();

21)    编译运行如下Java代码，输出结果是（   ）。
class Base {
    public void method(){
        System.out.print ("Base method");
    }
}
class Child extends Base{    
    public void methodB(){
        System.out.print ("Child methodB");
    }
}
class Sample {
    public static void main(String[] args) {
        Base base= new Child();
        base.methodB();
    }
}
    A.    Base method
    B.    Child methodB
    C.    Base method Child MethodB
    D.    编译错误

22)    下面关于Java接口的说法错误的是（ ）。
    A.    一个Java接口是一些方法特征的集合，但没有方法的实现
    B.    Java接口中定义的方法在不同的地方被实现，可以具有完全不同的行为
    C.    Java接口中可以声明私有成员
    D.    Java接口不能被实例化

23)    在Java接口中定义常量，下面语法错误的是（ ）。
    A.    static int MALE = 1;
    B.    final int MALE = 1;
    C.    int MALE = 1;
    D.    private int MALE = 1;

24)    在Java接口中，下列选项中属于有效的方法声明是（ ）（多选）。
    A.    public void aMethod();
    B.    void aMethod();
    C.    void aMethod(){}
    D.    private void aMethod();

25) 给定如下Java程序代码，在横线处加入（ ）语句，可以使这段代码编译通过（多选）。
interface Parent{
    public int count(int i);
}
public class Test implements Parent {
    public int count(int i){
        return i % 9;
}
  public static void main(String[] args){
        ________________
        int i = p.count(20);
    }
}
    A.    Test p = new Test();
    B.    Parent p = new Test();
    C.    Parent p = new Parent();
    D.    Test p = new Parent();

26)    下列选项中关于Java中ArrayList、LinkedList、HashMap三个类的描述错误的是（   ）。
    A.    ArrayList和LinkedList均实现了List接口
    B.    ArrayList的访问速度比LinkedList快
    C.    添加和删除元素时，ArrayList的表现更佳
    D.    HashMap实现Map接口，它允许任何类型的键和值对象，允许将null用作键或值

27)    关于Java中的集合实现类，下列说法描述错误的是（   ）。
    A.    HashMap是Map接口的实现类
    B.    ArrayList对象是长度可变的对象引用数组
    C.    集合框架都包含三大块内容：对外的接口、接口的实现和对集合运算的算法
    D.    Set中存储一组不允许重复、有序的对象

28)    对于Java中的集合类java.util.ArrayList，以下说法正确的是（   ）。
    A.    这个集合中的元素是无序的
    B.    可以通过键来获取这个集合中的元素
    C.    在对这个集合的元素执行遍历操作时，效率比较高
    D.    可以通过addFirst()方法，在列表的首部插入元素

29)    给定如下Java代码，其中第（   ）行代码有错误。
import java.util.*;
public class MapTest {
    public static void main(String[] args) {
        List pList = new ArrayList();
        pList.add("A");                         //第五行
        pList.add("B");                         //第六行
        for (int i = 0; i < pList.size(); i++) {          //第七行
            String str = pList.get(i);               //第八行
            System.out.print(str);         
        }
    }
}

    A.    五
    B.    六
    C.    七
    D.    八

30)    给定如下Java代码，可以填入横线处的代码是（   ）。
import java.util.*;
public class Test {
    public static void main(String[] args) {
        ________
        list.addLast("001");
    }
}
    A.    List list = new ArrayList();
    B.    List list = new List();
    C.    ArrayList list = new ArrayList();
    D.    LinkedList list = new LinkedList();

31)    在Java中，（   ）类的对象可被用作堆栈或者队列。
    A.    LinkedList
    B.    ArrayList
    C.    Collection
    D.    HashMap

32)    在Java中，关于HashMap类的描述，以下说法错误的是（   ）。
    A.    HashMap使用键/值的形式保存数据
    B.    HashMap能够保证其中元素的顺序
    C.    HashMap的存储方式是哈希表，查询指定元素效率高
    D.    HashMap通过get( key)获取对应的值

33)    阅读下面的Java代码，运行结果描述正确的是（   ）。
import java.util.*;
public class TestMap{
     public static void main(String[] args){
        Map map=new HashMap( );
         map.put(“first”,”football”);
         map.put(“first”,”basketball”);
         System.out.print(map.get(“first”));
    }
}
    A.    编译时发生错误
    B.    编译通过，运行时发生错误
    C.    正确运行，显示basketball
    D.    正确运行，显示football

34)    在Java中，集合框架 API定义了一组用于批量操作数据的接口和类，它们包括在（   ）包中。
    A.    java.lang
    B.    java.sql
    C.    java.util
    D.    java.math

35)    以下选项中关于XML文档的说法正确的是（   ）（多选）。
    A.    XML文档中使用用户自定义标签，标签名不区分大小写
    B.    可以使用DTD或者XSD定义XML文档结构
    C.    XML文档的作用是数据存储、数据交换、数据显示
    D.    XML文档总是以一个XML声明开始

36)    以下选项中关于DOM和SAX的说法错误的是（   ）。
    A.    DOM和SAX都是目前常用的XML解析技术
    B.    DOM把XML文档映射成一个倒挂的树状结构
    C.    DOM模型内存消耗小，DOM解析器能提供更好的性能优势
    D.    SAX读取文档时会激活一系列事件，推给事件处理器，由事件处理器来访问文档

37)    以下选项中关于Java中文件输入输出的说法正确的是（   ）（多选）。
    A.    在Java中，文件的输入输出功能是通过流来实现的
    B.    如果要把数据写入到一个文件中，需要创建一个输入流对象
    C.    字符流在某些方面比如汉字的处理，比字节流更高效
    D.    可以通过Reader r=new Reader("c:\pet.txt")来创建一个输入流对象

38) 给定如下Java代码，实现文件复制功能，其中第（   ）行代码有错误。
public class TestIO {
    public static void main(String[] args) throws Exception {
        Reader fr = new FileReader("c:\source.txt");
        Writer fw = new FileWriter("c:\target.txt");
        char[] ch = new char[1024];
        int length = fr.read(ch);//第六行
        while (length != -1) {
            fw.write(ch);   //第八行
            length = fr.read(ch);
        }
        if (null != fr)
            fr.close(); //第十三行
        if (null != fw)
            fw.close();
    }
}
    A.    没有错误
    B.    六
    C.    八
    D.    十三

39）给定下面的类定义
public class Upton{
public static void main(String argv[]){
}

//Here
}
下面哪一个在替换//Here后是合法的（多选）？
A.    public int amethod(int z){}
B.    public int amethod(int i,int j){return 99;}
C.    protected void amethod(long l){ }
D.    private void anothermethod(){}

40）给定下面的类定义
class Base{
public void amethod(){
System.out.println("Base");
}
}
public class Hay extends Base{
public static void main(String argv[]){
Hay h = new Hay();
h.amethod();
}
下面在类Hay中的哪一个方法将会编译并使程序打印出字符串"Hay"？
A.    public int amethod(){ System.out.println("Hay");}
B.    public void amethod(long l){ System.out.println("Hay");}
C.    public void amethod(){ System.out.println("Hay");}
D.    public void amethod(void){ System.out.println("Hay");}

41）给定下面的类定义
public class ShrubHill{
    public void foregate(String sName){}
//Here
}
下面的哪一个方法可以合法的直接替换//Here（多选）？
A.    public int foregate(String sName){}
B.    public void foregate(StringBuffer sName){}
C.    public void foreGate(String sName){}
D.    private void foregate(String sType){}

42）  给定下面的类定义
class Base{
Base(int i){}
}
class DefCon extends Base{
DefCon(int i){
//XX
}
}
如果将标记//XX的地方替换为下面的行，哪一行是独立合法的？
A.    super();
B.    this();
C.    this(99);
D.    super(99);

43）给定下面的类
public class Crowle{
public static void main(String argv[]){
Crowle c = new Crowle();
}
Crowle(){
System.out.println("Greetings from Crowle");
}
}
构造方法会返回哪一种数据类型？
A.    null
B.    integer
C.    String
D.    no datatype is returned

44）当你试着编译运行下面的代码的时候，可能会发生什么？
public class Crowle{
public static void main(String argv[]){
Crowle c = new Crowle();
}
void Crowle(){
System.out.println("Greetings from Crowle");
}
}
A.    输出 "Greetings from Crowle"
B.    系统报错
C.    输出 "void"
D.    没有输出

45）当你试着编译运行下面的类的时候，可能会发生什么？
class Base{
Base(int i){
System.out.println("Base");
}
}
class Severn extends Base{
public static void main(String argv[]){
Severn s = new Severn();
}
void Severn(){
System.out.println("Severn");
}
}
A.    编译完成并运行时输出字符串"Severn"
B.    编译错误
C.    编译完成但运行时没有输出
D.    编译完成并运行时输出字符串"Base"

46）怎样通过一个语句改变数组大小同时保持原值不变？
A.    使用Array类的setSize()方法
B.    使用Util.setSize(int iNewSize)
C.    使用 size() 操作
D.    以上没有一个是对的。

47）你想用下面的代码查找数组最后一个元素的值，当你编译并运行它的时候，会发生什么？
  public class MyAr{
      public static void main(String argv[]){
        int[]i = new int[5];
        System.out.println(i[5]);
      }
  }
A.    编译完成并输出 0
B.    编译完成并输出null
C.    编译完成但运行时异常
D.    编译错误

48）作为一个好的Java程序员，你已忘记了曾经在C/C++中知道的关于数组大小信息的知识。如果你想遍历一个数组并停止在最后一个元素处。你会使用下面的哪一个？
A.    myarray.length();
B.    myarray.length;
C.    myarray.size
D.    myarray.size();

49）你的老板为了你写出了HelloWorld而很高兴地为你升职了，现在她给你分配了一个新任务，去做一个踢踏舞游戏（或者我小时候玩的曲棍球游戏）。你认为你需要一个多维数组，下面哪一个能做这个工作？
A.    int i =new int[3][3];
B.    int[] i =new int[3][3];
C.    int[][] i   =new int[3][3];
D.    int i[3][3]=new int[][];

50）你希望找到一个更优雅的方式给你的数组赋值而不使用for 循环语句，下面的哪一个能做到？
A.     myArray{
        [1]="One";
        [2]="Two";
        [3]="Three";
        }
B.    String s[5]=new String[]{"Zero","One","Two","Three","Four"};
C.    String s[]=new String[]{"Zero","One","Two","Three","Four"};
D.    String s[]=new String[]={"Zero","One","Two","Three","Four"};

#答案：
1.D 2.CD 3.AC 4.D 5.C 6.D 7.C 8.B 9.D10.B
11.A 12.A 13.B 14.C 15.B 16.AC 17.B 18.B 19.C 20.AD
21.D 22.C 23.D 24.AB 25.AB 26.C 27.D 28.C 29.D 30.D
31.A 32.B 33.C 34.C 35.BCD 36.C 37.AC 38.A 39.BCD40.C
41.BC 42.D 43.D 44.D 45.B 46.D 47.C 48.B 49.C 50.C