2021Java期末考选择判断题复习

目录

Java编程基础

单选题

多选题

判断题

面向对象

单选题

多选题

判断题

JavaAPI与集合

单选题

多选题

判断题

---

Java编程基础

单选题

1. 下列关于Java语言的描述中，错误的是（ ）

   A、Java是一种高级计算机语言

   B、Java是一门与平台无关的编程语言

   C、Java具有JavaSE、JavaME和JavaEE三大平台

   D、Java是一门介于汇编和高级之间的语言

    答案：D
    说明：java是一种高级计算机语言，与平台无关，因为java的虚拟机会基于用户的代码生成java的中间语言，再将中间语言翻译成机器语言运行

2. 下列关于JDK和JRE的说法中，错误的是（ ）

   A、JDK是java开发核心组件，是用来编译解释java程序的核心组件

   B、JDK包括Java编译器、Java文档生成工具、Java打包工具等

   C、JRE是个单独的软件，所以安装JDK后，还需要单独安装JRE

   D、JRE是java运行环境,用来支持java程序的运行

    答案：C
    说明：JDK自带一个JRE

3. 下面命令中，可以用来正确运行HelloWorld案例的是（ ）

   A、java HelloWorld B、java HelloWorld.java C、javac HelloWorld D、javac HelloWorld.java

    答案：A
    说明：java命令负责运行编译后的class文件，不需要文件后缀名
    而javac命令负责将java文件编译成class文件，所以需要文件后缀名

4. 以下标识符中，不合法的是（ ）

   A、user B、$inner C、class D、login_1

    答案：C
    说明：java中的标识符不能是关键字，不能以数字开头，而class为关键字

5. 以下关于变量的定义，正确的是 （ ） A、int a=10; B、b=2； C、int =20； D、int a；b=a+10；

    答案：A
    说明：变量定义的基本格式 数据类型 变量名=值;变量一定要先初始化后才可以使用。
    其中B没有给b声明数据类型；C没有声明变量名，D没有给a变量初始化

6. 下列数据类型进行运算时，哪一个会发生自动类型提升（） A、int+int B、long+long C、byte+byte D、double+double

    答案：C
    说明：当加法运算的操作数是byte,short,char时，会自动转化为int类型；返回结果为int。

7. 下列关于变量作用域的说法中，正确的是（） A、在main()方法中任何位置定义的变量，其作用域为整个main()方法。 B、代码块中定义的变量，在代码块外也是可以使用的。 C、变量的作用域为：从定义处开始，到变量所在代码块结束的位置。 D、变量的作用域不受代码块的限制。

    答案：C
    说明：变量的作用域为：从定义处开始，到变量所在代码块结束位置。

8. 若int a = 7;a %= 2;则执行后，变量a的值是（） A、7 B、1 C、2 D、 3

    答案：B
    说明：“a %= 2;”运算相当于“a = a % 2;”，因此a的值为7模于2后的结果，因此答案为B。

9. 下列关于条件语句的描述中，错误的是（ ） A、if语句中的条件表达式是一个布尔值。 B、选择语句分为if条件语句和switch条件语句。 C、switch语句中的表达式只能是布尔类型的值。 D、 switch语句只能针对某个表达式的值作出判断。

    答案：C
    说明：if-else条件语句中的条件表达式必须返回一个布尔值，但switch语句中是针对某个表达式的不同值做出不同回应，所以可以是各种类型的值

10. 请阅读下面的程序

     public class SwitchDemo3 {
      public static void main(String[] args) {
       char c = ‘B’;
       switch(c) {
       case ‘A’:
        System.out.println(“优”);
        break;
       case ‘B’:
        System.out.println(“良”);
        break;
       case ‘C’:
        System.out.println(“差”);
        break;
       }
      }
     }

    下列选项中，哪一个才是程序的运行结果（ ） A、优 B、良 C、差 D、 编译失败

     答案：B
     说明：程序中对c的值执行switch语句，而c的值为B，所以走case'B'得到结果“良”

11. 请阅读下面的程序

     public class Example  {                                                            
       public static void main(String[] args) {                                      
        int x = 1;                                                                            
        do {                                                                                   
         x++;                                                                        
        } while (x <= 4);                                                                            
       System.out.println("x = " + x);                                                               
       }                                                                                                          
     } 

    程序的运行结果是（） A、3 B、4 C、5 D、 6

     答案：C
     说明：看判断条件，在x<=4时会一直循环，在x>4时会退出循环，结合循环体内的x自加可得退出循环后x的值应为5

12. 在for循环中，分别用①表示初始化表达式，②表示循环条件，③表示操作表达式，④表示循环体，通过序号分析for循环的执行流程。在循环条件的结果为true时，下列执行步骤正确的是（ ）

    A、①②④③ B、①②③④ C、④③②① D、④②③①

     答案：A
     说明：for循环的模板：for(循环变量的类型 循环变量名;循环条件;循环变量的变化方式（即操作表达式）){循环体}
     在执行for循环时，会先初始化表达式，然后看循环条件是否为真，接着执行循环体，执行完毕后再去动循环变量的值

13. 请阅读下面的程序。

     public class Test {
      public static void main(String[] args) { 
          int a = 0;
       int b = 0;
       for (int i = 1; i <= 5; i++) {
        a = i% 2;
        while (a-- >= 0) {
         b++;
        }
       }
       System.out.println("a=" + a + ",b=" + b);
     }
     }

    下列选项中，哪一个是正确的运行结果（ ） A、a=8,b=-2 B、a=-2,b=8 C、a=3,b=0 D、a=0,b=3

     答案：B
     说明：直接看循环条件来判断值，最后的结果来自于for循环里的内层while循环执行完毕以后的值，则while的循环条件决定了a的值，由于循环条件为a-- >= 0,可知先判断a>=0，再在判断后执行一次a的自减，所以当a=0时会继续循环并让a-1，a=-1时会结束循环，同时还会再让a-1，所以最终a的值会为-2

14. 请阅读下面的程序

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

    运行结果正确的是（） A、12345 B、024 C、13 D、不输出任何内容

     答案：D
     说明：break会提前中止并结束循环，在第一次循环中，x=0；则x%2 == 0的判断表达式为真，执行if中的break语句中止循环，所以什么都没有输出

15. 关于continue语句的使用范围，下列说法正确的是（） A、continue语句可以在选择语句中使用 B、continue语句可以在条件语句中使用 C、continue语句可以在循环语句中使用 D、不输出任何内容

     答案：C
     说明：continue语句是循环中使用的跳过该次循环的语句，不能用于其他地方

16. 下面关于方法定义的描述中，正确的是（） A、方法是对功能代码块的封装 B、当方法没有返回值时，返回值类型可以不写 C、当方法没有返回值时，不能有return语句 D、方法是不可以没有参数的

     答案：A
     说明：方法没有返回值时，应声明方法返回值类型为void
     方法没有返回值时，可以写一个没有返回值的return语句：return;
     方法可以没有参数

17. int a[]={45,4,67,23,65,87,34,52,56}；数组中a[5]的值为（ ） 3分 A、23 B、45 C、65 D、87

     答案：D
     说明：数组的索引(下标)从0开始

18. 下面代码中，哪一项是正确定义了一个3*4的二维数组（） A、int[][]arr=new int[3][4] B、int[][]arr=new int[3][] C、int[][]arr=new int[][4] D、int[][]arr={{1,2},{3,4,5},{6}}

     答案：A
     说明：B没有声明列数，列数可变，不一定是一个3*4的二维数组
     C没有声明行数，在java中该声明方法不合法
     D为3行3列的二维数组

19. 下列选项中关于二维数组的定义，格式错误的是（ ） A、int[][]arr=new int[3][4] B、int[][]arr=new int[3][] C、int[][]arr=newint[][4] D、int[][]arr={{1,2},{3,4,5},{6}}

     答案：C
     说明：C没有声明行数，在java中该声明方法不合法

20. 下面关于Java语言的描述中，哪些是正确的（ ） A、Java程序运行时，需要先将后缀名为.java的源文件进行编译。

    B、Java虚拟器不可以解释执行.class文件。 C、Java程序是由操作系统负责解释执行的。 D、Java程序运行时，必须经过编译和解析两个步骤。

     答案：A
     说明：Java程序运行时，必须先把java文件编译成class中间语言(字节码)文件，接下来由JVM（java虚拟机）来翻译字节码文件，只要没有被改动，接下来的运行都可以直接翻译class文件而不需要重新编译

多选题

1. 下列关于main方法的描述中，正确的是（ ） A、在Java程序中，必须要有main方法 B、main方法可以保证Java程序独立运行 C、一个Java程序的主方法是main方法 D、一个Java程序不一定要有main方法

    答案：BCD
    说明：一个Java程序不一定要有main方法，需要独立运行的程序才要有main方法。

2. 下列选项中，属于常量的是（） A、’ ’ B、"intx" C、false D、null

    答案：ABCD
    说明：A：字符常量；B：字符串常量；C和D都是java定义的常量关键字

3. 下列关于方法重载的说法中，正确的是（ ） A、形式参数的个数不同。 B、形式参数的个数不同，数据类型不同。 C、形式参数的个数相同，数据类型不同。 D、形式参数的个数相同，数据类型顺序不同。

    答案：ABCD
    说明：参数里只要有一个地方不一样就都算重载

4. 下列结构语句中，可以用来遍历数组的是（ ） A、if B、while C、switch D、for

    答案：BD
    说明：if和switch是判断语句，循环才是用来遍历数组的

5. 下列选项中关于二维数组的定义，格式正确的是（ ） A、int[][]arr=new int[3][4] B、int[][]arr=new int[3][] C、int[][]arr=new int[][4] D、int[][]arr={{1,2},{3,4,5},{6}}

    答案：ABD
    说明：C没有声明行数，在java中该声明方法不合法，注意是在java里，在c里是反过来的

判断题

1. JavaSE平台中包括了Java最核心的类库，如集合、IO、数据库连接以及网络编程等。

    答案：对
    没啥好说明的我感觉

2. 在不同的操作系统中可以使用同一个JDK。

    答案：错
    说明：不同操作系统环境配置肯定要不一样啊

3. 使用javac命令，可以将Hello.java文件编译成Hello.class文件。

    答案：对
    说明：javac是用来编译java文件的，java是用来翻译class文件的

4. Java语言在定义类时，可以将class写成Class。

    答案：错
    说明：严格区分大小写，小写是一个东西，大写是另一个东西，不区分大小写JVM头给你打烂

5. 在Java中，小数会被默认是double类型的值。

    答案：对
    说明：小数默认都是double型，有需要用float的话在后面加一个F

6. 在Java中，通过强制类型转换可以将int类型的数据转换为boolean类型。

    答案：错
    说明：哥啊你没事闲着把一个整数类型变成真假类型干嘛啊，这里是java不是c

7. 在switch语句中，每个case关键字后面必须有break。

    答案：错
    说明：不break的话只会按顺序一直执行所有case到switch结束，这个特性好用的很

8. while语句必须要有循环条件。

    答案：对
    说明：没有循环条件你怎么判断什么时候开始循环和结束循环

9. 定义一个方法时，其访问修饰符、返回值类型、方法名的顺序可以互换。

    答案：错
    说明：在定义方法时，必须要遵循以下格式：
    修饰符 返回值类型 方法名([参数类型 参数名1,参数类型 参数名2,……]){ 
     执行语句
     …… 
     return 返回值;
    }

10. Java允许在一个程序中定义多个同名的方法，但是参数的类型或个数必须不同，这就是方法的重载

     答案：对
     说明：啊对对对，同名参数不一样就是重载

面向对象

单选题

1. 在类的继承关系中，需要遵循以下哪个继承原则（） A、多重 B、单一 C、双重 D、不能继承

    答案：B
    说明：子类只允许有一个直接父类，但是接口可以继承多个接口

2. 在Java中，要想让一个类继承另一个类，可以使用以下哪个关键字（） A、inherits B、extends C、implements D、modifies

    答案：B
    说明：没啥好说的，蛮记一下接口的继承用的是C

3. 阅读下面代码：

    public interface Face{
      int counter = 40;   
     }     
     public class Test implements Face{
      private static int counter;   
      public static void main(String[]args){
       System.out.println(++counter);       
      }   
     }  

   Test.java 的编译运行结果是（）。 A、40 B、41 C、0 D、1

    答案：D
    说明：有同名的static静态变量默认用的是静态变量

4. 阅读下面代码：

    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

    答案：C
    说明：在使用多态后的父类引用变量调用方法时，会调用子类重写后的方法。

5. 阅读下面代码：

    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、编译错误

    答案：D
    说明：当需要用多态的方式使用子类特有功能时，应进行向下的类型转换，否则会报错显示父类中没有该方法
    向下类型转换：((子类类型)(父类类型的变量)).子类成员方法

6. 下面对this的作用描述错误的是（ ） A、当成员变量和局部变量重名的时候可以用this区分 B、this()语句必须放在构造函数的第一行,根据this后面括号中的参数调用本类其他的构造函数 C、this可以调用本类的一般函数 D、this可以调用父类的一般函数

    答案：D
    说明：this调用的是当前类的成员，super才能用于调用父类成员

7. 在Java中，如果父类中的某些方法不包含任何逻辑，并且需要有子类重写，应该使用（）关键字来声明父类的这些方法 A、final B、static C、abstract D、void

    答案：C
    说明：题目中的类属于抽象类，则需要abstract抽象修饰符来修饰

8. 阅读下面代码：

     public class Test{
      private static final int counter=10;       
      public static void main(String [] args){          
       System.out.println(++counter);        
      }    
     }

   编译运行Test.java，结果是 （） A、10 B、11 C、编译错误 D、运行时出现异常

    答案：C
    说明：final修饰的变量属于常量，常量不可被改变

9. 阅读下面代码：

    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、程序编译通过，无错误

    答案：C
    说明：A：可以不同；B：子类继承父类后也继承了父类的name成员，不需要多此一举；C的说明就是c的选项本身，D：第四行错误

10. 在Java中，提供了4种访问级别，以下访问控制级别由小到大顺序排列正确的是（） A、private、default、protected、public B、default、public、protected、private C、private、default、public、protected D、protected、public、private、default

     答案：A
     说明：没啥好说的，它就这样规定的，好记一点的话记 私有，默认，受保护，公开

11. 下面描述方法重写错误的是（） A、要有子类继承或实现 B、子类方法的权限必须大于等于父类的权限 C、父类中被private权限修饰的方法可以被子类重写 D、子类重写接口中的抽象方法,子类的方法权限必须是public的

     答案：C
     说明：子类只能重写公开方法，A：本身重写就是一个子类的继承和实现，B和D:子类重写后的方法权限不得小于父类

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

     答案：D
     说明：A：不定义的话JVM会帮你定义一个无参构造，B：没有返回类型，C：礼貌有参构造：你吗

13. 阅读以下代码：

     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; C、Parent p = new Parent(); D、Test p = new Parent();

     答案：A
     说明：一种猜想，不一定对，有没有一种可能，这个应该是填空题
     首先一个新声明一个对象，所以AD二选一，因为Parent是接口，必须由子类继承来实现，所以选A

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

     答案：A
     说明：子类可以继承一切它父类的父类的父类的父类，把它看成遗传吧，你身体里现在指不定还有河姆渡人的DNA（雾

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

     答案：B
     说明：A：类只能单继承，你只有一个爸爸，B：一个爸爸可以子孙满堂，C：私有方法不能用，D：太绝对了，谁说一定要有更多的

16. 在Java中，多态的实现不仅能减少编码的工作量，还能大大提高程序的可维护性及可扩展性，下面哪一个选项不属于多态的条件（）。 A、子类重写父类的方法 B、子类重载同一个方法 C、要有继承或实现 D、父类引用指向子类对象

     答案：B
     说明：多态的条件：父类引用指向子类对象，要有子类继承，子类要重写至少一个父类的方法，简单点说就是把父类当子类来用

17. 下面选项中，类的声明方式正确的是

    A、public void AA{…} B、public class Move(){…} C、public class void number{…} D、public class Car{…}

     答案：D
     说明：A：void是干嘛的；B：你是想定义一个类还是定义一个方法；C：没事别乱加void
     类的声明模板： 访问权限修饰符 class 类名{...}

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

     答案：A
     说明：接口里只能声明抽象方法，C直接排除，接口的方法必须是public以便继承，BD排除

19. 已知类的继承关系如下： class Employee; class Manager extends Employee; class Director extends Employee; 则以下语句能通过编译的是（） A、Employee e = new Manager(); B、Director d = new Manager(); C、Director d = new Employee (); D、Manager m = new Director();

     答案：A
     说明：考的应该是多态，则应该用父类引用指向子类对象，只有A符合条件

20. 类中的一个成员方法被下面哪个修饰符修饰，该方法只能在本类被访问（） A、public B、private C、protected D、default

     答案：B
     说明：private，私有

多选题

1. 在Java中，下面关于抽象类的描述正确的是（）。 A、抽象类可以被实例化 B、如果一个类中有一个方法被声明为抽象的，那么这个类必须是抽象类 C、抽象类中的方法必须都是抽象的 D、声明抽象类必须带有关键字abstract

    答案：BD
    说明：A抽象类不能被实例化，B只有抽象类配用抽象方法，其他的不配 C抽象类可以有普通方法，接口才必须都是抽象方法

2. 以下关于static关键字的说法正确的是（） A、static关键字可以修饰类 B、static关键字可以修饰成员 C、static关键字可以修饰所有的变量 D、static关键字可以修饰代码块

    答案：BD
    说明：没有静态类，真的没有，局部变量上用static会导致JVM爆炸，因为局部变量应该在出了作用域以后被回收，而static告诉它这个变量是静态的不能被回收，你这么写它会顺着总线爬出来砍你

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

    答案：ABC
    说明：接口中的常量格式：public static final 数据类型 常量名称 = 数据值;
    前面的public static final可以不写，别小气，接口定义常量就是给人用的，别加私有修饰符

4. 关于super关键字以下说法哪些是正确的（） A、super关键字可以调用父类的构造方法 B、super关键字可以调用父类的普通方法 C、super与this不能同时存在于同一个构造方法中 D、super与this可以同时存在于同一个构造方法中

    答案：ABC
    说明：super就是用来调用父类的成员用的，所以AB对，C和D题目应该不严谨，如果super和this指向的不是同一个东西还是可以一起用的，如果指向同一个东西一起用会有错

5. 分析如下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、new B().test();

    答案：AD
    说明：A的用法是个多态，拿父类用子类的方法，而D是直接用子类来做这个方法

6. 下面关于Java接口的说法正确的是（） A、Java接口中定义的是扩展功能 B、Java接口中可以被多个子类实现,一个类也可以同时实现多个接口 C、Java接口中可以声明私有成员 D、Java接口不能被实例化

    答案：ABD
    说明：A：雀食，B：接口可以多继承，抽象类不行，C：要公开，别自私，接口声明东西就是给子类继承用的，D：和抽象类一样，接口必须要有继承才能实例化

7. 阅读下面代码：

    abstract class Shape     {
      abstract void draw( );     
     }

   要创建Shape类的子类Circle，以下代码正确的是（）。 A、class Circle extends Shape{ int draw( ){} } B、abstract class Circle extends Shape{ } C、class Circle extends Shape{ void draw( ); } D、class Circle extends Shape{ void draw( ){} }

    答案：BD
    说明：A：继承就继承，瞎改什么返回值B抽象类可以继承，嗯C：普通类也配用抽象方法？D：继承的同时要实现抽象方法

8. 阅读下面代码：

    public class Parent{
      int change(){
        …
      }
     }
     Class Child extends Parent{
     _______ (此处可以放入下面哪个选项)
     }

   下面选项中可以加入Child类中的方法是（） A、public int change(){} B、int show(int i){} C、private int change(){} D、abstract int change(){}

    答案：AB
    说明：A：一个中规中矩的重写B:一个自己的方法，不错C：说了多少遍继承重写权限必须不小于父类，D：普通类你也配用抽象方法？

9. 下面选项中不能和abstract关键字共用的是() A、abstract不可以和private共用 B、abstract不可以和static共用 C、abstract不可以和final共用 D、abstract不可以和public共用

    答案：ABC
    说明：啊硬记吧摆烂了
    欸还没呢 抽象方法必须被实现才能用，私有就不能被继承实现了，所以私有不行，静态和终极是一个道理

10. 在java中，已定义了两个接口B和C，下面继承语句正确的是（） A、interface A extends B,C B、interface A implements B,C C、class A implements B,C D、class A implements B,implements C

     答案：AC
     说明：一个接口使用关键字extends来继承自其他接口，一个类用 implements继承接口

判断题

1. 在定义一个类的时候，如果类的成员被private所修饰，该成员不能在类的外部被直接访问。

    答案：对
    说明：嗯私有，别人看不见

2. 声明构造方法时，不能使用private关键字修饰。

    答案：错
    说明：构造函数是用于初始化对象用的，如果一个类只有一个实例（如单例模式），将构造函数私有化了之后，只能由这个类本身来调用，其他类就不能直接调用该类生成新的对象，也就避免了同一个类被反复创建的情况。

3. 静态代码块会随着类对象的创建而创建。

    答案：错
    说明：当类被加载(如第一次创建对象)的时候，静态代码块会执行，由于类只加载一次，所以静态代码块只被执行一次，一次，一次

4. instanceof关键字可以用于判断一个对象是否为某个类(或接口)的实例或者子类实例。

    答案：对
    说明：啊对对对

5. 接口中只能定义常量和抽象方法。

    答案：对
    说明：啊对对对，接口的特性，得记

6. Java中被final关键字修饰的变量，不能被重新赋值。

    答案：对
    说明：final，终极，常用于修饰常量，常量之所以叫常量就是因为它不能变

7. 在静态方法内可以调用非静态方法。

    答案：错
    说明：静态方法不能访问属于某个对象的成员变量，只能处理静态变量，类都还没被创建调用个锤子非静态，调用以后存到谁手里？

8. 类中static修饰的变量或方法，可以使用类名或对象的引用变量访问。

    答案：对
    说明：它本身不依赖对象，只要用类名访问就可以了，当然多此一举也不是不行，注意两种方法访问的是同一个变量

9. 抽象方法必须定义在抽象类中，所以抽象类中的方法都是抽象方法。

    答案：错
    说明：抽象类可以有普通方法，想不到吧

10. Java中的每个类都至少有一个构造方法，一个类中如果没有定义构造方法，系统会自动为这个类创建一个默认的构造方法。

     答案：对
     说明：JVM天天给你擦屁股，快说谢谢JVM

JavaAPI与集合

单选题

1. 下面哪个方法可以实现获取字符在某个字符串中第一次出现的索引？（） A、char charAt(int index)； B、int indexOf(int ch); C、int lastIndexOf(int ch); D、boolean endsWith(String suffix);

    答案：B
    说明：A答案返回字符串中index位置上的字符
    C答案返回指定字符在此字符串中最后一次出现处的索引
    D答案判断此字符串是否以指定的字符串结尾
    API杂项多，实在记不住可以试着翻译一下函数名

2. 阅读下面的程序：

    class StringDemo{
      public static void main(String[] args){
        String s1 = “a”;
      String s2 = “b”;
      show(s1,s2);
      System.out.println(s1+s2);
    }
     public static void show(String s1,String s2){
         s1 = s1 +”q”;
         s2 = s2 + s1;
    }
    }

   上述程序的运行结果为（ ） A、ab B、 aqb C、 aqbaq D、 aqaqb

    答案：A
    说明：经典，在方法里传参以后对形参做操作，结果并没有返回到外面的实参

3. 已知 String 对象 s="abcdefg"，则 s.substring(2, 5)的返回值为（） A、"bcde" B、 "cde" C、 "cdef" D、"def"

    答案：B
    说明：substring方法的使用：substring(a,b)，取出字符串中从下标a开始到b-1结束，[a,b)半开半闭区间的字符，注意字符串下标从0开始

4. System类的getProperties()方法的作用是（） A、获取当前的操作系统的属性 B、 获取当前JVM的属性 C、 获取指定键指示的操作系统属性 D、 获取指定键指示的JVM的属性

    答案：A
    说明：看不懂就翻译，getProperties，获取属性

5. 阅读下列代码：

    public class Example {
     public static void main(String[] args) {
      int[] srcArray = { 11, 12, 13, 14 };
      int[] destArray = { 21, 22, 23, 24 };
      System.arraycopy(srcArray, 1, destArray, 2, 2);
      for (int i = 0; i < destArray.length; i++) {
       System.out.print(destArray[i] + " ");
      }
     }
    }

   程序的运行结果是（） A、21 22 12 13 B、21 22 11 12 C、 21 11 12 24 D、 发生数组角标越界异常

    答案：A
    说明：arraycopy的运作原理：arraycopy(源数组,源数组的起始下标,目的数组,目的数组的起始下标,复制的元素个数n)，
    从源数组的起始下标开始复制n个元素， 覆盖目的数组起始下标开始的n个元素

6. 下列关于集合的描述中，哪一个是错误的（ ） A、集合按照存储结构可以分为单列集合Collection和双列集合Map。 B、 List集合的特点是元素有序、元素可重复。 C、 Set集合的特点是元素无序并且不可重复。 D、 集合存储的对象必须是基本数据类型。

    答案：D
    说明：其他是特性，没什么好解释的背就完事了，集合存储的可以是用户自定义的数据类型，所以D错

7. 下列关于ArrayList的描述中，错误的是（）。 A、ArrayList集合可以看作一个长度可变的数组。 B、ArrayList集合不适合做大量的增删操作。 C、ArrayList集合查找元素非常便捷。 D、ArrayList集合中的元素索引从1开始。

    答案：D
    说明：都是从0开始的，无论数组，ArrayList，字符串，能用下标访问的都是从0开始的

8. 以下关于foreach的说法中，哪一个是错误的（） A、使用foreach遍历集合时，可以对元素进行修改。 B、foreach可以对数组进行遍历。 C、foreach可以对集合进行遍历。 D、foreach循环是一种更加简洁的for循环，也称增强for循环。

    答案：A
    说明：改不了，因为for-each本质是把元素复制给你的循环变量，任何对变量的操作都影响不到原来的集合或数组，但普通的for可以，因为普通的for是用下标直接读数组本身

9. 下列选项中，不属于HashMap类的方法的是（） A、get(Object key) B、keySet() C、comparator() D、entrySet()

    答案：C
    说明：comparator()方法是TreeMap类中的方法，不常用的函数没人会记的，平时要用也是查手册，我寻思应该也不会考，考这种东西纯恶心人

10. 下列选项中，哪个可以正确地定义一个泛型（） A、ArrayList list = new ArrayList(); B、ArrayList list = new ArrayList (); C、ArrayList list = new ArrayList(); D、ArrayList list = new ArrayList ();

     答案：A
     说明：泛型的定义规范：集合类  对象名 = new 集合类 (构造)

多选题

1. 下面哪些选项可以实现String的初始化？（） A、String str = "abc"; B、String str = new String(); C、String str = new String(“abc”); D、char[] chs = {‘a’,’b’,’c’};String str = new String(chs);

    答案：ABCD
    说明：A，定义同时赋值，B，定义但不赋值，C，走构造方法赋值，D走构造方法用字符数组赋值

2. 下列选项中，属于StringBuffer类特点的是（） A、字符串缓冲区，提高字符串的操作效率 B、StringBuffer类是线程安全的 C、 StringBuffer类的toString()方法，将缓冲区变成字符串 D、 StringBuffer是不可变的对象

    答案：ABC
    说明：StringBuffer是一个字符缓冲区，比String最大的不同就是它可变

3. 下面选项中，对Math类描述正确的是（） A、Math类中所有的方法都是静态的,所以类名.调用即可 B、Math类的构造函数是私有的,所以其他类不能用Math类创建对象 C、 Math类在java.math包中 D、 Math类可以创建对象

    答案：AB
    说明：Math类在java.lang包中；方法声明为静态可以方便用户的调用； Math类不可以创建对象,因为构造方法被私有了，而且方法都是静态的，用它创建对象纯属没事找事

4. 下列选项中，哪些方法是LinkedList类独有的（ ） A、void addFirst(Object o) B、Object getFirst() C、Object removeFirst() D、boolean Remove(Object obj)

    答案：ABC
    说明：蛮记一下，只有LinkedList这种类链表结构才有First这种说法

5. 下列关于HashMap集合的描述中，正确的是（ ） A、HashMap集合是Map接口的一个实现类 B、HashMap集合存储的对象都是键值映射关系 C、HashMap集合存储的对象，必须保证不出现重复的键 D、HashMap集合中，如果存储的键名称相同，那么后存储的值则会覆盖原有的值，简而言之就是，键相同，值覆盖

    答案：ABCD
    说明：HashMap集合是Map接口的一个实现类，它用于存储键值映射关系，但必须保证不出现重复的键。如果存储了相同的键，后存储的值则会覆盖原有的值，简而言之就是，键相同，值覆盖。

判断题

1. 使用字符串常量可以直接初始化一个String对象。

    答案：对
    说明：确实，这是其中一种初始化方法

2. 字符串一旦初始化就不可以被改变。

    答案：对
    说明：记住，字符串是一种常量

3. String类的equals()方法和“= =”的作用是一样的。

    答案：错
    说明：equals方法比较的是两个字符串的值是否相等，==比较的是两个对象的地址值
    很有意思的一点，因为String的实质是引用一个字符串常量，所以equals和==在用户上看起来是完全一样的，但其实底层的实现不一样
    他奶奶的，玩阴的是吧，直接来把

4. StringBuffer类和String类一样，都是不可变对象。

    答案：错
    说明：StringBuffer可变，没什么好说的

5. System类中提供的属性和方法都是静态的。

    答案：对
    说明：雀食

6. Runtime类是用单例设计模式设计的,不能直接创建对象,可以通过Rutime类中的一个静态方法getRuntime()方法获取实例。

    答案：对
    说明：也是特性，记吧

7. 集合是长度可变的数组。

    答案：错
    说明：文字游戏了嗷，长度确实可变，但是数组太菜了不能表示多种类型，高贵的集合怎么能和数组混为一谈呢

8. List集合中不允许出现重复的元素。

    答案：错
    说明：List集合存储不唯一的，有序（插入顺序）的元素

9. Iterator接口是Java集合框架中的成员。

    答案：对
    说明：老朋友迭代器，用来遍历所有集合框架

10. Set接口中的元素是无序，并且都会以某种规则保证存入的元素不出现重复。

     答案：对
     说明：Set存储一组无序，唯一的元素