1.编译Java Application 源程序文件将产生相应的字节码文件，这些字节码文件的扩展名为( )。
A.java
B.class
C.html
D.exe
答案：
B
解析：
Java源程序的后缀名为“.java”,经由编译之后天生的字节码文件后缀名为“.class”
2. 问以下哪个说法是精确的？（）
A 派生出子类 B, B 派生出子类 C,并且在 java 源代码有如下声明：
A a0=new A();A a1=new B();A a2=new C();A.只有第一行能通过编译
B.第1、2行能通过编译，但第3行编译出错
C.第1、2、3行能通过编译，但第2、3走运行时出错
D.第1行，第2行和第3行的声明都是精确的
答案：
D
解析：
这个题考了两个点：
继续的通报性。多态，父类引用指向子类工具。3.以下哪个接口的定义是精确的？（ ）
A.interface B{ void print() { } ;}
B.interface B{ static void print() ;}
C.abstract interface B extends A1, A2 //A1、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
解析：
1、abstract不能与final并列润色同一个类 对的。
2、abstract类中不应该有private的成员 对的 ：abstract类中可以有private 但是不应该有。
3、abstract方法必须在abstract类或接口中 对的 ： 若类中方法有abstract润色的，该类必须abstract修正。接口方法默认public abstract。
4、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
解析：
1、count()得到总记录数
2、打算总页数
3、获取所有记录(个人觉得这一步不须要，可以直接获取指定页数数据)
4、过滤显示本页数据
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
解析：
总结一下
一个子类只能继续一个抽象类,但能实现多个接口抽象类可以有布局方法,接口没有布局方法抽象类可以有普通成员变量,接口没有普通成员变量抽象类和接口都可有静态成员变量,抽象类中静态成员变量访问类型任意,接口只能public static final(默认)抽象类可以没有抽象方法,抽象类可以有普通方法,接口中都是抽象方法抽象类可以有静态方法,接口不能有静态方法抽象类中的方法可以是public、protected;接口方法只有public17.根据下面这个程序的内容，判断哪些描述是精确的：（ ）
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润色的变量只有赋值，线程安全； 欢迎示正。
推举
Java笔试内容凑集 持续更新中….
文末
欢迎关注个人微信公众号：Coder编程
获取最新原创技能文章和免费学习资料，更有大量佳构思维导图、口试资料、PMP备考资料等你来领，方便你随时随地学习技能知识！
