Java基础笔试练习（四）

时间  2019-11-09
标签 java 基础 笔试 练习 栏目 Java 繁體版
原文   原文链接

Java基础笔试练习（四）

1.编译Java Application 源程序文件将产生相应的字节码文件，这些字节码文件的扩展名为( )。

A.java
B.class
C.html
D.exehtml

答案：
Bjava

解析：
Java源程序的后缀名为“.java”,通过编译以后生成的字节码文件后缀名为“.class”git

2. 问如下哪一个说法是正确的？（）

A 派生出子类 B, B 派生出子类 C,而且在 java 源代码有以下声明：程序员

  1. A a0=new A();
  2. A a1=new B();
  3. A a2=new C();

A.只有第一行能经过编译
B.第一、2行能经过编译，但第3行编译出错
C.第一、二、3行能经过编译，但第二、3行运行时出错
D.第1行，第2行和第3行的声明都是正确的github

答案：
D面试

解析：
这个题考了两个点：算法

  1. 继承的传递性。
  2. 多态，父类引用指向子类对象。

3.如下哪一个接口的定义是正确的？（ ）

A.interface B{ void print() { } ;}
B.interface B{ static void print() ;}
C.abstract interface B extends A1, A2 //A一、A2为已定义的接口{ abstract void print(){ };}
D.interface B{ void print();}编程

答案：
D数组

解析：
A，接口中方法的默认修饰符时public abstract，抽象方法但是没有方法体的，没有大括号{}
B，JDK8中，接口中的方法能够被default和static修饰，可是！！！被修饰的方法必须有方法体。
C，注意一下，接口是能够多继承的。整个没毛病，和A选项同样，抽象方法不能有方法体安全

4.如下会产生信息丢失的类型转换是( ）

A.float a=10
B.int a=（int）8846.0
C.byte a=10； int b=-a
D.double d=100

答案：
B

解析：
会产生信息丢失不如说丢失精度，这样可能更容易明白，而精度丢失只会发生在从大范围到小范围的转换。上面四个选项，只有 B 是从 double 到 int ，也就是从大范围到小范围。

5.如下代码的输出的正确结果是

public class Test {
    public static void main(String args[]) {
        String s = "祝你考出好成绩！";
        System.out.println(s.length());
    }
}

A.24
B.16
C.15
D.8

答案：
D

解析：
java的String底层是char数组，它的length()返回数组大小，而unicode中一个汉字是能够用一个char表示的。 一个汉字等于一个字符字符是char，一个汉字也等于二个字节，字节是byte。

6.java中，StringBuilder和StringBuffer的区别，下面说法错误的是？

A.StringBuffer是线程安全的
B.StringBuilder是非线程安全的
C.StringBuffer对 String 类型进行改变的时候其实都等同于生成了一个新的 String 对象，而后将指针指向新的 String 对象。
D.效率比较String<StringBuffer<StringBuilder，可是在 String S1 = “This is only a” + “ simple” + “ test”时，String效率最高。

答案：
C

解析：
效率：String(大姐，出生于JDK1.0时代) 不可变字符序列<StringBuffer(二姐，出生于JDK1.0时代) 线程安全的可变字符序列<StringBuilder(小妹，出生于JDK1.5时代) 非线程安全的可变字符序列。Java中的String是一个类，而并不是基本数据类型。string是值传入，不是引用传入。StringBuffer和StringBuilder能够算是双胞胎了，这二者的方法没有很大区别。但在线程安全性方面，StringBuffer容许多线程进行字符操做。这是由于在源代码中StringBuffer的不少方法都被关键字synchronized修饰了，而StringBuilder没有。StringBuilder的效率比StringBuffer稍高，若是不考虑线程安全，StringBuilder应该是首选。另外，JVM运行程序主要的时间耗费是在建立对象和回收对象上。
关于D:由于进行字符串加运算时其实是在堆中开辟大量空间，为了不资源耗尽java编译器自动将String变量变为StringBulider然后进行append处理。

7.下列关于修饰符混用的说法，错误的是( )

A.abstract不能与final并列修饰同一个类
B.abstract类中不该该有private的成员
C.abstract方法必须在abstract类或接口中
D.static方法中能直接调用类里的非static的属性

答案：
D

解析：
一、abstract不能与final并列修饰同一个类 对的。
二、abstract类中不该该有private的成员 对的 ：abstract类中能够有private 可是不该该有。
三、abstract方法必须在abstract类或接口中 对的 ： 若类中方法有abstract修饰的，该类必须abstract修改。接口方法默认public abstract。
四、static方法中能处理非static的属性 错误 ：在JVM中static方法在静态区，静态区没法调用非静态区属性。

8.以下语句经过算术运算和逻辑运算以后i和 j的结果是（ ）

int i=0;
int j=0;
if((++i>0)||(++j>0)){
//打印出i和j的值。
}

A.i=0;j=0
B.i=1;j=1
C.i=0;j=1
D.i=1;j=0

答案：
D

解析：
考察的是短路逻辑的用法，即：当第一个逻辑表达式能够肯定结果时，将再也不进行剩余表达式的运算。

9.如下是java concurrent包下的4个类，选出差异最大的一个

A.Semaphore
B.ReentrantLock
C.Future
D.CountDownLatch

答案：
C

解析：
A、Semaphore：类，控制某个资源可被同时访问的个数;
B、ReentrantLock：类，具备与使用synchronized方法和语句所访问的隐式监视器锁相同的一些基本行为和语义，但功能更强大；
C、Future：接口，表示异步计算的结果；
D、CountDownLatch： 类，能够用来在一个线程中等待多个线程完成任务的类。

10.下面有关java实例变量,局部变量,类变量和final变量的说法，错误的是？

A.实例变量指的是类中定义的变量，即成员变量，若是没有初始化，会有默认值。
B.局部变量指的是在方法中定义的变量，若是没有初始化，会有默认值
C.类变量指的是用static修饰的属性
D.final变量指的是用final 修饰的变量

答案：
B

解析：
B.定义在类中的变量是类的成员变量，能够不进行初始化，Java会自动进行初始化，若是是引用类型默认初始化为null,若是是基本类型例如int则会默认初始化为0
局部变量是定义在方法中的变量，必需要进行初始化。
被static关键字修饰的变量是静态的，静态变量随着类的加载而加载，因此也被称为类变量
被final修饰的变量是常量

11.关于JAVA的垃圾回收机制，下面哪些结论是正确？

A.程序能够任意指定释放内存的时间
B.JAVA程序不能依赖于垃圾回收的时间或者顺序
C.程序可明确地标识某个局部变量的引用再也不被使用
D.程序能够显式地当即释放对象占有的内存

答案：
B

解析：
java提供了一个系统级的线程，即垃圾回收器线程。用来对每个分配出去的内存空间进行跟踪。当JVM空闲时，自动回收每块可能被回收的内存，GC是彻底自动的，不能被强制执行。程序员最多只能用System.gc()来建议执行垃圾回收器回收内存，可是具体的回收时间，是不可知的。当对象的引用变量被赋值为null，可能被当成垃圾。

12.JSP分页代码中，哪一个步骤次序是正确的？

A.先取总记录数，获得总页数，最后显示本页的数据。
B.先取全部的记录，获得总页数，再取总记录数，最后显示本页的数据。
C.先取总页数，获得总记录数，再取全部的记录，最后显示本页的数据。
D.先取本页的数据，获得总页数，再取总记录数，最后显示全部的记录。

答案：
A

解析：
一、count(*)获得总记录数
二、计算总页数
三、获取全部记录(我的感受这一步不须要，能够直接获取指定页数数据)
四、过滤显示本页数据

13.关于访问权限说法正确的是 ？ ( )

A.外部类前面能够修饰public,protected和private
B.成员内部类前面能够修饰public,protected和private
C.局部内部类前面能够修饰public,protected和private
D.以上说法都不正确

答案：
B

解析：
(1)对于外部类而言，它也可使用访问控制符修饰，但外部类只能有两种访问控制级别：public和默认。由于外部类没有处于任何类的内部，也就没有其所在类的内部、所在类的子类两个范围，所以 private 和 protected 访问控制符对外部类没有意义。
(2)内部类的上一级程序单元是外部类，它具备 4 个做用域：同一个类（ private ）、同一个包（ protected ）和任何位置（ public ）。
(3)由于局部成员的做用域是所在方法，其余程序单元永远不可能访问另外一个方法中的局部变量，因此全部的局部成员都不能使用访问控制修饰符修饰。

14.如下代码执行的结果显示是多少（ ）？

public class Demo { 
    class Super{  
         int flag=1;
         Super(){
             test();
         }  
         void test(){
            System.out.println("Super.test() flag="+flag);
         }
    } 
    class Sub extends Super{
        Sub(int i){  
            flag=i;
            System.out.println("Sub.Sub()flag="+flag);
        }  
        void test(){
            System.out.println("Sub.test()flag="+flag);
        }
    } 
    public static void main(String[] args) {  
        new Demo().new Sub(5);
    }
}

A.Sub.test() flag=1,Sub.Sub() flag=5
B.Sub.Sub() flag=5,Sub.test() flag=5
C.Sub.test() flag=0,Sub.Sub() flag=5
D.Super.test() flag=1,Sub.Sub() flag=5

答案：
A

解析：

在继承中代码的执行顺序为：
1.父类静态对象，父类静态代码块
2.子类静态对象，子类静态代码块
3.父类非静态对象，父类非静态代码块
4.父类构造函数
5.子类非静态对象，子类非静态代码块
6.子类构造函数
对于本题来讲：在只想new Sub(5)的时候，父类先初始化了int flag=1，而后执行父类的构造函数Super（），父类构造函数中执行的test（）方法，因子类是重写了test（）方法的，所以父类构造函数中的test（）方法实际执行的是子类的test（）方法，因此输出为Sub.test() flag=1，接着执行子类构造函数Sub(5) 将flag赋值为5，所以输出结果Sub.Sub() flag=5。最终选择了A。

15.Java多线程有几种实现方法？

A.继承Thread类
B.实现Runnable接口
C.实现Thread接口
D.以上都不正确

答案：
AB

解析：
AB.
多线程一共有三种实现方式
方式1：继承Thread类，并重写run()方法
方式2：实现Runnable接口，实现run()方法
方式3：实现Callable接口，线程结束后能够有返回值，可是该方式是依赖于线程池的。

16.在Jdk1.7中，下述说法中抽象类与接口的区别与联系正确的有哪些？

A.抽象类中能够有普通成员变量，接口中没有普通成员变量。
B.抽象类和接口中均可以包含静态成员常量。
C.一个类能够实现多个接口，但只能继承一个抽象类
D.抽象类中能够包含非抽象的普通方法，接口中的方法必须是抽象的，不能有非抽象的普通方法。

答案：
A B C D

解析：
总结一下

  1. 一个子类只能继承一个抽象类,但能实现多个接口
  2. 抽象类能够有构造方法,接口没有构造方法
  3. 抽象类能够有普通成员变量,接口没有普通成员变量
  4. 抽象类和接口均可有静态成员变量,抽象类中静态成员变量访问类型任意,接口只能public static final(默认)
  5. 抽象类能够没有抽象方法,抽象类能够有普通方法,接口中都是抽象方法
  6. 抽象类能够有静态方法,接口不能有静态方法
  7. 抽象类中的方法能够是public、protected;接口方法只有public

17.根据下面这个程序的内容，判断哪些描述是正确的：（ ）

public class Test {
    public static void main(String args[]) {
    String s = "tommy";
    Object o = s;
    sayHello(o); //语句1
    sayHello(s); //语句2
    }
    public static void sayHello(String to) {
        System.out.println(String.format("Hello, %s", to));
    }
    public static void sayHello(Object to) {
        System.out.println(String.format("Welcome, %s", to));
    }
}

A.这段程序有编译错误
B.语句1输出为:Hello, tommy
C.语句2输出为:Hello, tommy
D.语句1输出为:Welcome, tommy
E.语句2输出为:Welcome, tommy
F.根据选用的Java编译器不一样，这段程序的输出可能不一样

答案：
CD

解析：
略

18.Java特性中,abstract class和interface有什么区别（）

A.抽象类能够有构造方法，接口中不能有构造方法
B.抽象类中能够有普通成员变量，接口中没有普通成员变量
C.抽象类中不能够包含静态方法，接口中能够包含静态方法
D.一个类能够实现多个接口，但只能继承一个抽象类。

答案：
A B D

解析：
接口中的成员变量被隐式的声明为public static final ，jdk1.8后接口中能够有静态方法并且存在方法体

19.关于下面代码片断叙述正确的是（）

代码片断：

byte b1=1,b2=2,b3,b6; 
final byte b4=4,b5=6; 
b6=b4+b5; 
b3=(b1+b2); 
System.out.println(b3+b6);

A.输出结果：13
B.语句：b6=b4+b5编译出错
C.语句：b3=b1+b2编译出错
D.运行期抛出异常

答案：
C

解析：
C.被final修饰的变量是常量，这里的b6=b4+b5能够当作是b6=10；在编译时就已经变为b6=10了。而b1和b2是byte类型，java中进行计算时候将他们提高为int类型，再进行计算，b1+b2计算后已是int类型，赋值给b3，b3是byte类型，类型不匹配，编译不会经过，须要进行强制转换。Java中的byte，short，char进行计算时都会提高为int类型。

20.下列那些方法是线程安全的(所调用的方法都存在)

A.

public class MyServlet implements Servlet {
public void service (ServletRequest req, ServletResponse resp) {
    BigInteger I = extractFromRequest(req);
    encodeIntoResponse(resp,factors);
}
}

B.

public class MyServlet implements Servlet {
private long count =0;
public long getCount() {
return count;
}
public void service (ServletRequest req, ServletResponse resp) {
BigInteger I = extractFromRequest(req);
BigInteger[] factors = factor(i);
count ++;
encodeIntoResponse(resp,factors);
}
}

C.

public class MyClass {
private int value;
public synchronized int get() {
return value;
}
public synchronized void set (int value) {
this.value = value;
}
}

D.

public class Factorizer implements Servlet {
private volatile MyCache cache = new MyCache(null,null);

public void service(ServletRequest req, ServletResponse resp) {
BigInteger i = extractFromRequest(req);
BigInteger[] factors = cache.getFactors(i);
if (factors == null) {
factors = factor(i);
cache = new MyCache(i,factors);
}
encodeIntoResponse(resp,factors);
}

答案：
A C D

解析：
A：没有成员（没有共享资源），线程安全；
B：假设存在线程1和线程2，count初始值为0，当线程1执行count++中count+1（此时未写回最终计算值），这时线程2执行count++中读取count，发生数据错误，致使线程1线程2的结果都为1，而不是线程1的结果为1，线程2的结果为2，线程不安全；
C：成员私有，对成员的set get方法都加剧量级锁，线程安全； D：volatile有两个做用：可见性（volatile变量的改变能使其余线程当即可见，但它不是线程安全的，参考B）和禁止重排序；这里是可见性的应用，类中方法对volatile修饰的变量只有赋值，线程安全； 欢迎指正。

推荐

大厂笔试内容集合（内有详细解析） 持续更新中....

ProcessOn是一个在线做图工具的聚合平台~

文末

欢迎关注我的微信公众号：Coder编程
欢迎关注Coder编程公众号，主要分享数据结构与算法、Java相关知识体系、框架知识及原理、Spring全家桶、微服务项目实战、DevOps实践之路、每日一篇互联网大厂面试或笔试题以及PMP项目管理知识等。更多精彩内容正在路上~
新建了一个qq群：315211365，欢迎你们进群交流一块儿学习。谢谢了！也能够介绍给身边有须要的朋友。

文章收录至
Github: https://github.com/CoderMerlin/coder-programming
Gitee: https://gitee.com/573059382/coder-programming
欢迎关注并star~
微信公众号

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程