java笔试练习题笔记 （6）

下列说法正确的有：（）

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

答案解析：在Java中，如果一个类没有显式地定义构造器（constructor），编译器会提供一个默认的无参数构造器。因此，构造器是可以省略的。构造器的名称必须与类名完全相同，而方法可以与类同名但不推荐（很奇怪竟然可以同名）。构造器是在创建类的新实例时，使用new关键字调用的。每次创建新对象时，都会执行构造器。一个类可以定义多个构造器，只要它们的参数列表不同（即参数的数量或类型不同）。这称为构造器重载。

下面有关List接口、Set接口和Map接口的描述，错误的是？
A.他们都继承自Collection接口
B.List是有序的Collection，使用此接口能够精确的控制每个元素插入的位置
C.Set是一种不包含重复的元素的Collection
D.Map提供key到value的映射。一个Map中不能包含相同的key，每个key只能映射一个value

答案解析：Map接口和Collection接口是同一等级的。

关于Java中的数组，下面的一些描述，哪些描述是准确的：（    ）
A.数组是一个对象，不同类型的数组具有不同的类
B.数组长度是可以动态调整的
C.数组是一个连续的存储结构
D.一个固定长度的数组可类似这样定义: int array[100]
E.两个数组用equals方法比较时，会逐个遍历其中的元素，对每个元素进行比较
F.可以二维数组，且可以有多维数组，都是在Java中合法的

 答案解析：

BD错：数组的长度是固定的，int[] array =new array[10]

E错：数组是一种引用数据类型  那么他肯定是继承Object类的  所以里面有equals() 方法 但是肯定没有重写过 因为他并不是比较数组内的内容  ，使用Arrays.equals()  是比较两个数组中的内容。

下面哪些赋值语句是正确的（）

A.long test=012
B.float f=-412
C.int other =(int)true
D.double d=0x12345678
E.byte b=128

答案解析：A和B中long和float，正常定义需要加l和f，但是long和float属于基本类型，会进行转化，所以不会报出异常。AB正确 boolean类型不能和任何类型进行转换，会报出类型异常错误。所以C错。 D选项可以这样定义，D正确。 E选项中，byte的取值范围是-128—127。报出异常： cannot convert from int to byte.所以E选项错误。

根据以下代码段,执行new Child("John", 10); 要使数据域data得到10，则子类空白处应该填写(    )。

class Parent {

    private int data;

    public Parent(int d){ data = d; }

}

class Child extends Parent{

    String name;

    public Child(String s, int d){

        ___________________

        name = s;

    }

}

答案解析：1.子父类存在同名成员时，子类中默认访问子类的成员，可通过super指定访问父类的成员，格式：super.xx  (注：xx是成员名)； 2.创建子类对象时，默认会调用父类的无参构造方法，可通过super指定调用父类其他构造方法，格式：s uper(yy) (注：yy是父类构造方法需要传递的参数)。

以下声明合法的是
A.default String s
B.public final static native int w( )
C.abstract double d
D.abstract final double hyperbolicCosine( )

答案解析:A：java的访问权限有public、protected、private和default的，default不能修饰变量 C：普通变量不能用abstract修饰，abstract一般修饰方法和类 D：被定义为abstract的类需要被子类继承，但是被修饰为final的类是不能被继承和改写的矛盾。

下列哪个说法是正确的（）
A.ConcurrentHashMap使用synchronized关键字保证线程安全
B.HashMap实现了Collction接口
C.Array.asList方法返回java.util.ArrayList对象
D.SimpleDateFormat是线程不安全的

答案解析：

A:早期的ConcurrentHashMap是通过分段锁Segment来实现的。java1.8以后是通过CAS+synchronized使锁更细化。

B: HashMap在java的集合框架中实现了Map接口，而Collection接口常见的实现类是LIst，Set,Queue等接口的实现类。

C:Arrays.asList方法返回的是java.util.Arrays.ArrayList.ArrayList<T>。

下列关于序列化和反序列化描述正确的是：
A.序列化是将数据转为n个 byte序列的过程
B.反序列化是将n个 byte转换为数据的过程
C.将类型int转换为4 byte是反序列化过程
D.将8个字节转换为long类型的数据为序列化过程

答案解析：

序列化：将数据结构转换称为二进制数据流或者文本流的过程。序列化后的数据方便在网络上传输和在硬盘上存储（看的懂的转为看不懂的数字）。

反序列化：与序列化相反，是将二进制数据流或者文本流转换称为易于处理和阅读的数据结构的过程。

下面有关Java的说法正确的是（    ）
A.一个类可以实现多个接口
B.抽象类必须有抽象方法
C.protected成员在子类可见性可以修改
D.通过super可以调用父类构造函数
E.final的成员方法实现中只能读取类的成员变量
F.String是不可修改的，且java运行环境中对string对象有一个对象池保存

答案解析：抽象类中不一定包含抽象方法，但包含抽象方法的类一定是抽象类。父类中的protected方法子类在重写的时候访问权限可以修改，其实就是重写的要素之一，换了个说法而已。final 的成员方法除了能读取类的成员变量，还能读取类变量。

覆盖（重写）与重载的关系是（）。

A.覆盖（重写）只有出现在父类与子类之间，而重载可以出现在同一个类中
B.覆盖（重写）方法可以有不同的方法名，而重载方法必须是相同的方法名
C.final修饰的方法可以被覆盖（重写），但不能被重载
D.覆盖（重写）与重载是同一回事

答案解析：final修饰的方法可以被重载，但不可以被重写。

列表(List)和集合(Set)下面说法正确的是？  ( )


A.Set中至多只能有一个空元素
B.List中至多只能有一个空元素
C.List和Set都可以包含重复元素的有序集合
D.List和Set都是有序集合

答案解析：list有序有重；set无序无重。

如果int x=20, y=5，则语句System.out.println(x+y +""+(x+y)+y);  的输出结果是（）

A.2530
B.55
C.2052055
D.25255

答案解析：

1）不论有什么运算，小括号的优先级都是最高的，先计算小括号中的运算，得到x+y +""+25+y

2）任何字符与字符串相加都是字符串，但是是有顺序的，字符串前面的按原来的格式相加，字符串后面的都按字符串相加，得到25+“”+25+5。（后面不是30千万别加起来，从左到右计算）

Which statement declares a variable a which is suitable for referring to an array of 50 string objects?
下面哪个Java语句声明了一个适合于创建50个字符串对象数组的变量？
A.char a[][];
B.String a[];
C.String[] a;
D.Object a[50];
E.String a[50];
F.Object a[];

答案解析：

A：char[][] 定义了二位字符数组。在Java中，使用字符串对char数组赋值，必须使用toCharArray()方法进行转换。所以A错误。

B、C：在Java中定义String数组，有两种定义方式：String a[]和String[] a。所以B、C正确。

D、E：数组是一个引用类型变量 ，因此使用它定义一个变量时，仅仅定义了一个变量，这个引用变量还未指向任何有效的内存，因此定义数组不能指定数组的长度。所以D、E错误。

F：Object类是所有类的父类。子类其实是一种特殊的父类，因此子类对象可以直接赋值给父类引用变量，无须强制转换，这也被称为向上转型。这体现了多态的思想。所以F正确。

注意：声明和创建的区别。在java中，声明一个数组时，不能直接限定数组长度，只有在创建实例化对象时，才能给定数组长度。

下面哪项技术可以用在WEB开发中实现会话跟踪实现？
A.session
B.Cookie
C.地址重写
D.隐藏域

答案解析：有四种方法可以实现会话跟踪技术：URL重写、隐藏表单域、Cookie、Session。

1）.隐藏表单域：，非常适合步需要大量数据存储的会话应用。

2）.URL 重写:URL 可以在后面附加参数，和服务器的请求一起发送，这些参数为名字/值对。 3）.Cookie:一个 Cookie 是一个小的，已命名数据元素。服务器使用 SET-Cookie 头标将它作为 HTTP 响应的一部分传送到客户端，客户端被请求保存 Cookie 值，在对同一服务器的后续请求使用一个 Cookie 头标将之返回到服务器。与其它技术比较，Cookie 的一个优点是在浏览器会话结束后，甚至 在客户端计算机重启后它仍可以保留其值

4）.Session：使用 setAttribute(String str,Object obj)方法将对象捆绑到一个会话。

在异常处理中，以下描述不正确的有

A.try块不可以省略
B.可以使用多重catch块
C.finally块可以省略
D.catch块和finally块可以同时省略

答案解析：如try中有异常抛出，则会去执行catch块，再去执行finally块；假如没有catch 块，可以直接执行finally 块，方法就以抛出异常的方式结束，而finally 后的内容也不会被执行，所以catch 和 finally 不能同时省略。

对于构造方法，下列叙述正确的是（ ）。
A.构造方法的优先级一般比代码块低。
B.构造方法的返回类型只能是void型。
C.构造方法的主要作用是完成对类的对象的初始化工作。
D.一般在创建新对象时，系统会自动调用构造方法。

答案解析：：静态成员变量或静态代码块>main方法>非静态成员变量或非静态代码块>构造方法。

继承时：执行父类的静态块>执行子类的静态块>执行父类的构造块，然后执行父类的构造方法>执行子类的构造块，然后执行子类的构造方法。

构造方法没有返回值类型，也不写void。

String s=null;

下面哪个代码片段可能会抛出NullPointerException？
A.if((s!=null)&(s.length()>0))
B.if((s!=null)&&(s.length()>0))
C.if((s==null)|(s.length()==0))
D.if((s==null)||(s.length()==0))

答案解析：

String为引用类型，如果对象为null,也就是说这个对象都不存在了，再去调用对象的相关方法，肯定会报空指针异常。这里调用了String类的length()方法。

&&和||具有短路的效果，在进行&&时，如果&&前的是false，那么&&后的不再执行，直接返回false，同理||也一样。所以BD的s.length()不会被执行，AC会抛出空指针异常.

Java的集合框架中重要的接口java.util.Collection定义了许多方法。选项中哪个方法是Collection接口所定义的（       ）
A.int size()
B.boolean containsAll(Collection c)
C.compareTo(Object obj)
D.boolean remove(Object obj)

答案解析：

1. size()：返回集合中元素的个数。
2. add(Object obj)：向集合中添加一个元素。
3. addAll(Collection coll)：将参数coll包含的所有元素添加到当前集合中。
4. isEmpty()：判断这个集合是否为空。
5. clear()：清空集合元素。
6. contains(Object obj)：判断集合中是否包含指定的obj元素。
   • 判断的依据：根据元素所在类的equals()方法进行判断。
   • 明确：如果存入集合中的元素是自定义的类对象，需要自定义类重写equals()方法。
7. containsAll(Collection coll)：判断当前集合中是否包含coll的所有元素。
8. retainAll(Collection coll)：求当前集合与coll的交集，返回给当前集合。
9. remove(Object obj)：删除集合中obj元素，若删除成功，返回true；否则返回false。
10. removeAll(Collection coll)：从当前集合中删除coll中包含的所有元素。
11. equals(Object obj)：判断当前集合与参数obj是否相等，即集合中的所有元素是否相同。
12. hashCode()：返回集合的哈希值。
13. toArray()：将集合转化为数组。
    • 如无参数，返回的是Object[]类型的数组。
    • 如有参数，返回数组的运行时类型与指定数组的运行时类型相同。
14. iterator()：返回一个Iterator接口实现类的对象，进而实现集合的遍历。
15. 数组转换为集合：使用Arrays.asList(数组)。

    下面哪个语句是创建数组的正确语句？( )
    A.float f[][] = new float[6][6];
    B.float []f[] = new float[6][6];
    C.float f[][] = new float[][6];
    D.float [][]f = new float[6][6];
    E.float [][]f = new float[6][];

    答案解析：数组命名时名称与[]可以随意排列，但声明的二维数组中第一个中括号中必须要有值，它代表的是在该二维数组中有多少个一维数组。float f[][] = new float[][6]; 是不正确的，因为它试图创建一个第二维大小为6的二维数组，但没有指定第一维的大小。（不知道这种题有什么意义）

下面代码的输出结果是什么？
public class ZeroTest {
    public static void main(String[] args) {
     try{
       int i = 100 / 0;
       System.out.print(i);
      }catch(Exception e){
       System.out.print(1);
       throw new RuntimeException();
      }finally{
       System.out.print(2);
      }
      System.out.print(3);
     }
 }
A.3
B.123
C.1
D.12

 答案解析：1、inti = 100/ 0; 会出现异常，会抛出异常，System.out.print(i)不会执行， 2、catch捕捉异常，继续执行System.out.print(1); 3、当执行 thrownewRuntimeException();  又会抛出异常，这时，除了会执行finally中的代码，其他地方的代码都不会执行。

Java 的屏幕坐标是以像素为单位，容器的左下角被确定为坐标的起点。
A.正确
B.错误

答案解析：左上角（这还是java吗给我干哪来了。javaGUI内容）。

java 接口的修饰符可以为（）

A.private
B.protected
C.final
D.abstract

答案解析：接口是通用的，用来描述方法是干什么用的，方法的默认修饰符为public abstract.不可以为final 是因为方法要被重写， 描述符如果为private或者protected，那么子类重写的方法的描述符也可以为private或者protected，这样就是有了访问显示，不符合接口所要达到的的任何人都可以使用了。

下列有关java构造函数叙述正确的是（）
A.构造器的返回值为void类型
B.如果一个源文件中有多个类，那么构造器必须与公共类同名
C.构造器可以有0个，1个或一个以上的参数
D.每个类可以有一个以上的构造器

答案解析：每一个类都可以有构造函数

Java创建对象的说法正确的有（）
A.用new语句创建对象，是最常见的创建对象的方法。
B.运用反射手段,调用java.lang.Class或者java.lang.reflect.Constructor类的newInstance()实例方法。
C.调用对象的clone()方法。
D.运用反序列化手段，调用java.io.ObjectInputStream对象的 readObject()方法。

 答案解析：

• 使用 new 关键字（最常用）： ObjectName obj = new ObjectName();
• 使用反射的Class类的newInstance()方法： ObjectName obj = ObjectName.class.newInstance(); 
• 使用反射的Constructor类的newInstance()方法： ObjectName obj = ObjectName.class.getConstructor.newInstance();
• 使用对象克隆clone()方法： ObjectName obj = obj.clone(); 
• 使用反序列化（ObjectInputStream）的readObject()方法： try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream(FILE_NAME))) { ObjectName obj = ois.readObject(); }

  ---

  以下代码的循环次数是
  public class Test {
      public static void main(String args[]) {
          int i = 7;
          do {
              System.out.println(--i);
              --i;
          } while (i != 0);
              System.out.println(i);
      }
  }
  
  
  A.0
  B.1
  C.7
  D.无限次

  答案解析：每次循环都是减二，i一直不为0，所以循环为无限执行。（答案都有无限次了我还傻乎乎的觉得能循环结束）

  ---

  下面代码的执行结果是 :
  class Chinese{
  private static Chinese objref =new Chinese();
  private Chinese(){}
  public static Chinese getInstance() { return objref; }
  }
  
  public class TestChinese {
  public static void main(String [] args) {
  Chinese obj1 = Chinese.getInstance();
  Chinese obj2 = Chinese.getInstance();
  System.out.println(obj1 == obj2);
  }
  }
  A.true
  B.false
  C.TRUE
  D.FALSE

  答案解析：单例模式: 第一步，不让外部调用创建对象，所以把构造器私有化，用private修饰。 第二步，怎么让外部获取本类的实例对象？通过本类提供一个方法，供外部调用获取实例。由于没有对象调用，所以此方法为类方法，用static修饰。 第三步，通过方法返回实例对象，由于类方法(静态方法)只能调用静态方法，所以存放该实例的变量改为类变量，用static修饰。 最后，类变量，类方法是在类加载时初始化的，只加载一次。所以由于外部不能创建对象，而且本来实例只在类加载时创建一次，所有符号引用都指向了一个实体。

  ---

  如果一个list初始化为{5，3，1}，执行以下代码后，其结果为（）？
  nums.add(6);
  nums.add(0,4);
  nums.remove(1);
  A.[5, 3, 1, 6]
  B.[4, 3, 1, 6]
  C.[4, 3, 6]
  D.[5, 3, 6]

  答案解析：

  nums.add(6); //往后边加一个6，{5，3，1，6}

  nums.add(0,4);//往下标为0的数加一个4，{4，5，3，1，6} nums.remove(1); // 移除下标为1 的元素，{4，3，1，6}

  ---

  在java中重写方法应遵循规则的包括（）
  A.访问修饰符的限制一定要大于被重写方法的访问修饰符
  B.可以有不同的访问修饰符
  C.参数列表必须完全与被重写的方法相同
  D.必须具有不同的参数列表

  答案解析：小心一定等字眼。

• 两同：方法名和参数列表相同
• 两小：返回值或声明异常比父类小（或相同）   
• 一大：访问修饰符比父类的大（或相同）

  ---

  
  final、finally和finalize的区别中，下述说法正确的有？
  A.final用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承。
  B.finally是异常处理语句结构的一部分，表示总是执行。
  C.finalize是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可以覆盖此方法提供垃圾收集时的其他资源的回收，例如关闭文件等。
  D.用变量被final修饰之后，不能再指向其他对象，它指向的对象的内容也是不可变的。

  答案解析：使用 final 关键字修饰一个变量时，是指引用变量不能变，引用变量所指向的对象中的内容还是可以改变的。（常考的三个fin开头的区别）