问题：Anonymous Inner Class (匿名内部类) 是否可以extends(继承)其它类，是否可以implements(实现)interface(接口)，并说明原因
解答：不能通过extends或implement关键词来继承类或实现接口，而是直接实现抽象类或接口中的方法
匿名内部类的作用：
1.通常用来简化代码编写，单次实现接口中全部的抽象方法，Anonymous Inner Class 没有名字，每次调用才会重新创建，用完即会回收
- 最常用的情况就是在多线程的实现上，因为要实现多线程必须继承Thread类或是继承Runnable接口。如例子：Runnable接口的匿名内部类实现
public class Demo {
public static void main(String[] args) {
Runnable r = new Runnable() {
public void run() {
for (int i = 1; i <= 10; i++) {
System.out.print(i + " ");
}
}
};
Thread t = new Thread(r);
t.start();
}
}
问题：多重继承的概念在Java中实现是通过如下哪些？
A. 扩展两个或多个类
B. 扩展一个类并实现一个或多个接口
C. 实现两个或更多接
解答：B，java仅支持单个继承，可以实现多个接口，接口可以继承多个
问题：根据下面的程序代码，哪些选项的值返回true？
public class Square {
long width;
public Square(long l) {
width = l;
}
public static void main(String arg[]) {
Square a, b, c;
a = new Square(42L);
b = new Square(42L);
c = b;
long s = 42L;
}
}
A、a == b
B、s == a
C、b == c
D、a.equals(s)
解答：C
A：a和b都是分别new的对象，所占堆内存处于不同的位置，应该是false
B：对象和基本数据类型不能比较
C: c直接就赋值给b了，所以他们两个在堆内存对应的是一块地址，应该是true
D：equals，会进行封箱操作，他们的地址也是不一样的，false
问题：在jdk1.5的环境下，有如下4条语句：
1、 Integer i01 = 59;
2 、int i02 = 59;
3 、Integer i03 =Integer.valueOf(59);
4 、Integer i04 = new Integer(59);
以下输出结果为false的是：
A、System.out.println(i01 == i02);
B、System.out.println(i01 == i03);
C、System.out.println(i03 == i04);
D、System.out.println(i02 == i04);
解答：C
包装类 与 基本类型比较时会自动使用值比较，A、D为true ，
jvm 中会缓存1-1024的Integer，i01 与 i03 使用相同地址的类，i03创建是通过IntegerCache创建，在-128到127之间。而i04创建是通过Integer中的value
问题：大小为MAX的循环队列中，f为当前对头元素位置，r为当前队尾元素位置(最后一个元素的位置)，则任意时刻，队列中的元素个数为：
A、r-f
B、(r-f+MAX+1)%MAX
C、r-f+1
D、(r-f+MAX)%MAX
解答：B
f为当前对头元素位置，r为当前队尾元素位置(最后一个元素的位置)，则任意时刻，队列中的元素个数为:(r-f+MAX+1)%MAX
问题：如下Java语句
double x= 3.0;
int y=5;
x/=–y;
执行后，x的值是()
A 、3
B、-0.6
C、0.4
D、0.75
解答：B
x /= -y表示为：x = x / -y = 3.0 / -5 = -0.6,由于x为double类型，所有结果也是double类型
问题：n个数值选出最大m个数（3<m<n）的最小算法复杂度是：
A、O(n)
B、O(nlogn)
C、O(logn)
D、O(mlogn)
E、O(nlogm)
F、O(mn)
解答：A
1.最简单的方法：将n个数排序，排序后的前k个数就是最大的k个数，这种算法的复杂度是O(nlogn)
2.O(n)的方法：利用快排的patition思想，基于数组的第k个数来调整，将比第k个数小的都位于数据的左边，比第k个数大的都调整到数组的右边，这样调整后，位于数组右边的k个数最大的k个数（这k个数不一定是排序好的）
3.O(nlogk)的方法：先创建一个大小为k的最小堆，接下来我们每次从输入的n个整数中读入一个数，如果这个数比最小堆的堆顶元素还要大，那么替换这个最小堆的堆顶并调整
问题：有一个文件ip.txt，每行一条ip记录，共若干行，下面哪个命令可以实现“统计出现次数最多的前3个ip及其次数”？
A、uniq -c ip.txt | sort -nr | head -n 3
B、sort ip.txt | uniq -c | sort -rn | head -n 3
C、cat ip.txt | count -n | sort -rn | head -n 3
D、cat ip.txt | sort | uniq -c | sort -rn | top -n 3
解答：B
第一次排序，把ip按顺序排列，因为第二个uniq只会合并相邻项
第二次排序，才是把ip按出现次序大小从大到小排列，最后取前三项结果
问题：设有两个事务T1,T2,其并发操作如下所示,下面评价正确的是()
步骤 T1 T2
1 读A=100
2 读A=100
3. A=A+10写回
4. A=A-10写回
A、该操作不能重复读
B、该操作不存在问题
C、该操作读"脏"数据
D、该操作丢失修改
解答：D
当两个或多个事务读取同一数据并做修改时，会发生丢失更新问题，即后一事务更新的结果会被前一事务更新的结果所覆盖。
比如：当事务A和事务B同时进行，事务A对数据做了修改，但还未提交，此时，事务B又对同一数据做了修改（注意：此时事务A还未提交修改过的数据），等事务A做事务提交时，会发生数据改动丢失
问题：CPU和两台输入/输出设备(I1,I2)多道程序设计环境下,同时有三个作业J1,J2,J3进行,这三个作业使用CPU和输入/输出设备的顺序和时间如下所示:
J1:I2(35ms); CPU(15ms); I1(35ms);CPU(15ms); I2(25ms)
J2:I1(25ms); CPU(30ms); I2(35ms)
J3:CPU(30ms); I1(25ms);CPU(15ms);I1(15ms);
假定CPU,I1,I2都能并行工作,J1的优先级最高,J2次之,J3优先级最低,优先级高的作业可以抢占优先级低的作业的CPU,但不能抢占I1,I2,作业从J3开始到完成需要多少时间?
A、130
B、85
C、140
D、115
解答：B
问题：在jdk1.5之后，下列 java 程序输出结果为()
1 int i=0;
2 Integer j = new Integer(0);
3 System.out.println(i==j);
4 System.out.println(j.equals(i));
A、true,false
B、true,true
C、false,true
D、false,false
E、对于不同的环境结果不同
F、程序无法执行
解答：B
第①种i==j =>true：基本类型和它包装型进行“”运算符的比较，基本型封装型将会自动拆箱变为基本型后再进行比较，因此Integer(0)会自动拆箱为int类型再进行比较，显然返回true；
第②中(j.equals(i)) ==>true：基本型封装类型调用equals(),但是参数是基本类型，这时候，先会进行自动装箱，基本型转换为其封装类型
== 比较的是变量(栈)内存中存放的对象的(堆)内存地址，用来判断两个对象的地址是否相同，即是否是指相同一个对象。比较的是真正意义上的指针操作。
1、比较的是操作符两端的操作数是否是同一个对象。
2、两边的操作数必须是同一类型的（可以是父子类之间）才能编译通过。
3、比较的是地址，如果是具体的阿拉伯数字的比较，值相等则为true，如：int a=10 与 long b=10L 与 double c=10.0都是相同的（为true），因为他们都指向地址为10的堆
equals
1.equals用来比较的是两个对象的内容是否相等，由于所有的类都是继承自java.lang.Object类的，所以适用于所有对象，如果没有对该方法进行覆盖的话，调用的仍然是Object类中的方法，而Object中的equals方法返回的却是==的判断
2.String s="abce"是一种非常特殊的形式,和new 有本质的区别。它是java中唯一不需要new 就可以产生对象的途径。以String s="abce";形式赋值在java中叫直接量,它是在常量池中而不是象new一样放在压缩堆中。这种形式的字符串，在JVM内部发生字符串拘留，即当声明这样的一个字符串后，JVM会在常量池中先查找有有没有一个值为"abcd"的对象,如果有,就会把它赋给当前引用.即原来那个引用和现在这个引用指点向了同一对象,如果没有,则在常量池中新创建一个"abcd",下一次如果有String s1 = "abcd";又会将s1指向"abcd"这个对象,即以这形式声明的字符串,只要值相等,任何多个引用都指向同一对象，而String s = new String("abcd");和其它任何对象一样.每调用一次就产生一个对象，只要它们调用
3.也可以这么理解: String str = "hello"; 先在内存中找是不是有"hello"这个对象,如果有，就让str指向那个"hello".如果内存里没有"hello"，就创建一个新的对象保存"hello". String str=new String ("hello") 就是不管内存里是不是已经有"hello"这个对象，都新建一个对象保存"hello"
// equals方法最初是在所有类的基类Object中进行定义的，源码是
public boolean equals(Object obj) {
return (this == obj);
}
//由equals的源码可以看出这里定义的equals与==是等效的（Object类中的equals没什么区别），不同的原因就在于有些类（像String、Integer等类）对equals进行了重写，但是没有对equals进行重写的类（比如我们自己写的类）就只能从Object类中继承equals方法，其equals方法与==就也是等效的，除非我们在此类中重写equals。
public class test1 {
public static void main(String[] args) {
String a = new String("ab"); // a 为一个引用
String b = new String("ab"); // b为另一个引用,对象的内容一样
String aa = "ab"; // 放在常量池中
String bb = "ab"; // 从常量池中查找
if (aa == bb) // true
System.out.println("aa==bb");
if (a == b) // false，非同一对象
System.out.println("a==b");
if (a.equals(b)) // true
System.out.println("aEQb");
if (42 == 42.0) { // true
System.out.println("true");
}
}
}
问题：下列java程序的输出结果为()
1 public class Example{
2 String str=new String(“hello”);
3 char[] ch={‘a’,‘b’};
4 public static void main(String args[]){
5 Example ex=new Example();
6 ex.change(ex.str,ex.ch);
7 System.out.print(ex.str+" and ");
8 System.out.print(ex.ch);
9 }
10 public void change(String str,char ch[]){
11 str=“test ok”;
12 ch[0]=‘c’;
13 }
14 }
A、hello and ab
B、hello and cb
C、hello and a
D、test ok and ab
E、test ok and cb
解答： B
Java方法传参是将变量复制一份传进去的，基本类型复制的就是变量值本身，成为值传递，数组类型复制的变量的值的引用，方法change里拿到的str和ch都是外部变量引用的复制'str'和'ch’，'ch[0]'可以直接修改外部变量的值，而str = “test ok”， 在方法内部会重新为"test ok"分配内存空间，并把引用赋值内'str',并不会改变外部变量的值
问题：有关下述Java代码描述正确的选项是()
1 public class TestClass {
2 private static void testMethod(){
3 System.out.println(“testMethod”);
4 }
5 public static void main(String[] args) {
6 ((TestClass)null).testMethod();
7 }
8 }
A、编译不通过
B、编译通过，运行异常，报NullPointerException
C、编译通过，运行异常，报IllegalArgumentException
D、编译通过，运行异常，报NoSuchMethodException
E、编译通过，运行异常，报Exception
F、运行正常，输出testMethod
解答：F
思路
1.将null强制类型转换后得到的是一个空的该类型的引用变量，(Object) null 同等于 Object obj = null
2.使用对象调用静态方法时，与该对象是否为空没有关系
3.private控制修饰符，表示只在本类中使用，包括内部类
还有一个调用静态方法容易搞错的例子，Thread的静态方法interrupted()与实例方法interrupt()
public class Do {
public static void main(String[] args ) {
MyThread thread=new MyThread();
thread.start();
thread.interrupt();
System.out.println("第一次调用thread.interrupted()："+thread.interrupted());
System.out.println("第二次调用thread.interrupted()："+thread.interrupted());
System.out.println("thread是否存活："+thread.isAlive());
}
}
输出结果为：
第一次调用thread.interrupted()：false
第二次调用thread.interrupted()：false
thread是否存活：true
为什么第一次调用thread.interrupted()的结果不是true？
因为interrupted()是静态方法，与该对象是具体哪个实例无关，它执行的是Thread.currentThread().isInterrupted(true);在当前对应的是main线程，而被中断的是MyThread实例
问题：将整数数组（7-6-3-5-4-1-2）按照堆排序的方式原地进行升序排列，请问在整个排序过程中，元素3的数组下标发生过()次改变？
A、0
B、1
C、2
D、3
E、4
F、5
解答：C
问题：对文件名为Test.java的java代码描述正确的是()
1 class Person {
2 String name = "No name";
3 public Person(String nm) {
4 name = nm;
5 }
6 }
7 class Employee extends Person {
8 String empID = "0000";
9 public Employee(String id) {
10 empID = id;
11 }
12 }
13 public class Test {
14 public static void main(String args[]) {
15 Employee e = new Employee("123");
16 System.out.println(e.empID);
17 }
18 }
A、输出：0000
B、输出：123
C、编译报错
D、输出：No name
解答：C
每个类的创建都依赖构造函数，子类的创建依赖子类的构造函数，子类继承父类的字段和方法，那么父类的字段和方法就需要父类来完成初始化操作，所以子类需要实现父类的构造方法
解决方法：在子类构造方法中调用super("")或者在父类添加无参构造函数
问题：若k为整形,下述while循环的次数为:()
1 k=1000;
2 while (k>1)
3 { print k;
4 k=k/2;
5 }
A、1000
B、10
C、11
D、9
解答：D
整数除以2，其实就是整数向右移1位，右移比符号运算效率更高，把1000转化为二进制是0011 1110 1000，当右移直到只剩下一个1时（也就是将最高位的1移动到最低位，0000 0000 0001），共需要移动9次
问题：以下程序的输出结果是()？
1 int x = 1;
2 do{
3 printf("%2d\n",x++);
4 }while(x--);
A、1
B、无任何输出
C、2
D、陷入死循环
解答：D
初始条件: x=1
第一次循环:输出1, x=2
x--=2>0, x=1,进入第二次循环
- 第二次循环:输出1,x=2
x--=2>0, x=1,进入第三次循环
...
依此规律,该行代码会无限输出1
问题：对于JVM内存配置参数：
-Xmx10240m -Xms10240m -Xmn5120m -XXSurvivorRatio=3,其最小内存值和Survivor区总大小分别是（）
A、5120m，1024m
B、5120m，2048m
C、10240m，1024m
D、10240m，2048m
解答：D
-Xms:初始堆大小，表示java虚拟机堆区内存初始内存分配的大小，通常为操作系统可用内存的1/64大小即可
-Xmx:最大堆大小，表示java虚拟机堆区内存可被分配的最大上限，通常为操作系统可用内存的1/4大小。但是开发过程中，通常会将 -Xms 与 -Xmx两个参数的配置相同的值，其目的是为了能够在java垃圾回收机制清理完堆区后不需要重新分隔计算堆区的大小而浪费资源
-Xmn:年轻代大小
-XX:NewSize=n:设置年轻代大小
-XX:NewRatio=n:设置年轻代和年老代的比值。如:为3，表示年轻代与年老代比值为1：3，年轻代占整个年轻代年老代和的1/4
-XX:SurvivorRatio=n:年轻代中Eden区与两个Survivor区的比值。注意Survivor区有两个。如：3，表示Eden：Survivor=3：2，一个Survivor区占整个年轻代的1/5
我们可以知道，最小内存值是10240m，排除A,B选项
根据Generation-Collection算法(目前大部分JVM采用的算法)，一般根据对象的生存周期将堆内存分为若干不同的区域，一般情况将新生代分为Eden ，两块Survivor：
计算Survivor大小， Eden:Survivor = 3，总大小5120,3x+x+x=5120 x=1024（Survivor区有两个，即将年轻代分为5份，每个Survivor区占一份），所以得出答案：总大小为2048m
问题：执行下列代码的输出结果是( )
1 public class Demo{
2 public static void main(String args[]){
3 int num = 10;
4 System.out.println(test(num));
5 }
6 public static int test(int b){
7 try{
9 b += 10; //1
10 return b; //2
11 }catch(RuntimeException e){
14 }
15 catch(Exception e2){
17 }
18 finally{
20 b += 10;//3
21 return b;//4
22 }
23 }
24}
A、10
B、20
C、30
D、40
解答：C
1、不管有没有出现异常，finally 块中代码都会执行;
2、当尝试和捕获中有返回时，finally 仍然会执行;
3、finally 是在返回后面的表达式运算后执行的（此时并没有返回运算后的值，而是先把要返回的值保存起来，不管最后中的代码怎么样，返回的值都不会改变，任然是之前保存的值），所以函数返回值是在finally执行前确定的;
4、finally中如果包含return，那么程序将在这里返回，而不是try或catch中的return返回，返回值就不是try或catch中保存的返回值了
问题：给定某Java程序的main方法如下，该程序编译运行后的结果是（ ）
1 public class Test {
2 int count = 21;
3 public void count() {
4 System.out.println(++count);
5 }
6 public static void main(String args[]) {
7 new Test().count();
8 new Test().count();
9 }
10 }
A、22 23
B、21 22
C、22 22
D、21 23
解答：C
同个对象的两个不同实例，执行相同的方法，输出自己的成员变量，结果肯定是一样的，int count 并没有被static修饰，这个变量并不是共享变量，不存在指向同一个对象
问题：以下JAVA程序的输出是什么（）
public class HelloSogou{
public static synchronized void main(String[] a){
Thread t = new Thread(){
public void run(){
Sogou();
}
};
t.run();
System.out.print("Hello");
}
static synchronized void Sogou(){
System.out.print("Sogou");
}
}
A、HelloSogou
B、SogouHello
C、Hello
D、结果不确定
解答：B
线程的start与run方法的区别：
1.先来看下start()的源码，start()启动线程其实是通过start0()启动的
public synchronized void start() {
/**
* This method is not invoked for the main method thread or "system"
* group threads created/set up by the VM. Any new functionality added
* to this method in the future may have to also be added to the VM.
*
* A zero status value corresponds to state "NEW".
*/
if (threadStatus != 0)
throw new IllegalThreadStateException();
/* Notify the group that this thread is about to be started
* so that it can be added to the group's list of threads
* and the group's unstarted count can be decremented. */
group.add(this); //添加到线程组
boolean started = false;
try {
start0(); //调用本地方法start0()来启动新的线程
started = true;
} finally {
try {
if (!started) {
group.threadStartFailed(this);
}
} catch (Throwable ignore) {
/* do nothing. If start0 threw a Throwable then
it will be passed up the call stack */
}
}
}
private native void start0(); //本地方法start0()
2.run()源码
public void run() {
if (target != null) {
target.run();
}
}
只是调用了runnable里面的run方法，并没有创建新的线程
run方法启动，走的线程是main线程，不会启动新线程
如果是start()方法启动，则会new一个新的线程去thread-0去跑，
先运行run方法运行Sogou，再打印hello
问题：Java类Demo中存在方法func0、func1、func2、func3和func4，请问该方法中，哪些是不合法的定义？(不定项选择题)
1 public class Demo{
2 float func0()
3 {
4 byte i=1;
5 return i;
6 }
7 float func1()
8 {
9 int i=1;
10 return;
11 }
12 float func2()
13 {
14 short i=2;
15 return i;
16 }
17 float func3()
18 {
19 long i=3;
20 return i;
21 }
22 float func4()
23 {
24 double i=4;
25 return i;
26 }
27}
A、func1
B、func2
C、func3
D、func4
E、func0
解答： A D
Java类型转换分为自动转换和强制转换两种
基本类型间的自动类型转换需要满足以下条件:
(1).转换双方的类型必须兼容，例如int和long类型就是兼容的，而int和boolean就是不兼容的。
(2).只能是"窄类型"向"宽类型"转换,也就是目标类型的数据表示范围要比源类型的数据表示范围要大
byte–>short–>int–>long->float–>double
Double源码：
public static final double MIN_VALUE = 0x0.0000000000001P-1022; // 4.9e-324
public static final double MAX_VALUE = 0x1.fffffffffffffP+1023;//1.7976931348623157e+308
Float源码：
// 2<sup>-149</sup> 2的负149次方
public static final float MIN_VALUE = 0x0.000002P-126f; // 1.4e-45f
public static final float MAX_VALUE = 0x1.fffffeP+127f; // 3.4028235e+38f
Long源码：
/**
* A constant holding the minimum value a {@code long} can
* have, -2<sup>63</sup>.
*/
@Native public static final long MIN_VALUE = 0x8000000000000000L;
/**
* A constant holding the maximum value a {@code long} can
* have, 2<sup>63</sup>-1.
*/
@Native public static final long MAX_VALUE = 0x7fffffffffffffffL;
float的范围为-2^128 ~ +2^128，也即-3.40E+38 ~ +3.40E+38；
double的范围为-2^1024 ~ +2^1024，也即-1.79E+308 ~ +1.79E+308
即，double类型的范围大于float类型，所以，D选项错误
从double转成float时会存在无法转换的情况，因为double表示的数据范围大于float表示的数据范围，所以从double到float要明确使用强制类型转换
func3() long型的范围小于float，所以，自动数据类型转换都是由精度低的往精度高的转换，正确；
func2(),func0()正确；
func1() 方法没有返回值，错误；
E 是什么？
这是科学计数法，表示的是 eg:1.810524e10 则是18105240000,小数点往后10位表示的是1.810524乘以10的十次方
有效位：
float:浮点型，含字节数为4，32bit，数值范围为-3.4E38~3.4E38（7个有效位）
double:双精度实型，含字节数为8，64bit数值范围-1.7E308~1.7E308（15个有效位）
decimal:数字型，128bit，不存在精度损失（相对不存在，28个有效位后会报错），常用于银行帐目计算。（28个有效位）
float f = 345.98756f;//结果显示为345.9876，只显示7个有效位，对最后一位数四舍五入。
double d=345.975423578631442d;//结果显示为345.975423578631，只显示15个有效位，对最后一位四舍五入
注：float和double的相乘操作，数字溢出不会报错，会有精度的损失
问题：对于满足SQL92标准的SQL语句:
select foo,count(foo) from pokes where foo>10 group by foo having count (*)>5 order by foo
其执行顺序应该是?
A、FROM->WHERE->GROUP BY->HAVING->SELECT->ORDER BY
B、FROM->GROUP BY->WHERE->HAVING->SELECT->ORDER BY
C、FROM->WHERE->GROUP BY->HAVING->ORDER BY->SELECT
D、FROM->WHERE->ORDER BY->GROUP BY->HAVING->SELECT
解答：A
问题：在Java中，包com中定义了类TestUtil，在com的子包util中定义了同名类TestUtil，给定如下Java代码，编译运行时，将发生（ ）
1 package test;
2 import com.util.TestUtil;
3 import com.TestUtil;
4 public class Test {
5 public static void main(String[] args) {
6 TestUtil testutil = new TestUtil();
7 }
8 }
A、创建了一个com.TestUtil对象
B、创建了一个com.util.TestUtil对象
C、运行时出现异常
D、编译无法通过
解答：D
根据JDK中ClassLoader类加载器知道，因为在JVM编译的时候,因为创建完源文件之后，程序先要被JVM中的java编译器进行编译为.class文件，他自下而上去找架包搜索需要的引用的类，当他发现同名的类的架包有两个，他就不知道使用哪个架包了,需要指定是那个包下面的类才可以编译通过
问题：如下代码，执行test()函数后，屏幕打印结果为（）
1 public class Test2
2{
3 public void add(Byte b)
4 {
5 b = b++;
6 }
7 public void test()
8 {
9 Byte a = 127;
10 Byte b = 127;
11 add(++a);
12 System.out.print(a + " ");
13 add(b);
14 System.out.print(b + "");
15 }
16}
A、127 127
B、128 127
C、129 128
D、以上都不对
解答：D
应该是：-128 127
b++ 是先赋值再计算
++a 是先计算再赋值
add(a); 先执行a = a + 1 （127 + 1） = 128，再执行add里面的运算 b = b ++ ,前面说到 b 是先赋值再计算，所以此次结果不会改变。最终结果为128，但是Byte 最大为127，超过了最大值，所以变成了最小值-128
add(b); 同上，b的结果不会改变所以为127.
问题：以下程序运行的结果为（）
1 public class Example extends Thread{
2 @Override
3 public void run(){
4 try{
5 Thread.sleep(1000);
6 }catch (InterruptedException e){
7 e.printStackTrace();
8 }
9 System.out.print("run");
10 }
11 public static void main(String[] args){
12 Example example=new Example();
13 example.run();
14 System.out.print("main");
15 }
16}
A、runmain
B、mainrun
C、main
D、run
E、不能确定
解答：A
1、run() 和 start() 的区别：
run() 方法和线程没有关系
Thread 的 run方法如下：
public void run() {
if (target != null) {
target.run();
}
}
target 就是实现了Thread的子类。这里就是Example。
其实可以看出就是调用了Example 的run方法。就相当于普通方法调用
start() 方法才是启动一个线程了，通过查看源码 方法上有个synchronized 修饰。
2、线程的执行流程
如题，程序运行到example.run(); 会执行这个方法，最后再执行System.out.print(“main”);所以这个结果是：runmain
要是改成example.start(); 就是有两个线程，一个是main主线程，一个是example线程，这时候两个线程抢占锁，谁先抢到，谁执行，所以最后结果是：无法确定
问题：以下JAVA程序的输出是什么（）
1 public class HelloSogou{
2 public static synchronized void main(String[] a){
3 Thread t=new Thread(){
4 public void run(){Sogou();}
5 };
6 t.run();
7 System.out.print("Hello");
8 }
9 static synchronized void Sogou(){
10 System.out.print("Sogou");
11 }
12 }
A、HelloSogou
B、SogouHello
C、Hello
D、结果不确定
解答：B
如果是 t.start();使用start()方法区启动线程，答案则是E.不确定，因为有可能是A
这是因为：这一点应该至今没有解决。这因为从操作系统之间调用的问题
因为java线程源码看是，start最终他执行的是本地方法start0，是直接调用操系统的线程的一个方法，而这个start0 他会调用一个native文件，也就是我们的c文件。但是这个c文件他并没有直接去调用os（操作系统）函数
他的实现是：start0会去调用操作系统函数的pthread_create创建线程的方法。这个创建方法会有一个传回调方法的参数然后再由操作系统去掉用java的run方法。这一系列的调用。导致主线程main已经执行了
问题：下面哪段程序能够正确的实现了GBK编码字节流到UTF-8编码字节流的转换：byte[] src,dst;
A、dst=String.fromBytes(src，“GBK”).getBytes(“UTF-8”)
B、dst=new String(src，“GBK”).getBytes(“UTF-8”)
C、dst=new String(“GBK”，src).getBytes()
D、dst=String.encode(String.decode(src，“GBK”))，“UTF-8” )
解答：B
String#getBytes(charset) 是将字符串以指定字符集进行编码成字节流
String(bytes,charset) 则是将字节流以指定字符集解码成字符串
问题：关于代码中的变量在内存中的存储位置描述正确的是()
1 int a=0;
2 class someClass{
3 int b;
4 static int c;
5 };
6 int main(){
7 int d=0;
8 someClass *p=new someClass();
9 return 0;
10 }
A、堆、栈、全局区均有变量
B、不存在堆区的变量
C、不存在栈区的变量
D、不存在全局变量区的变量
解答：A
问题：假设MySQL数据库表:
create table T{
k int unsigned not null auto_increment,
a date,
b varchar(24),
c int,d varchar(24),
primary key(k),unique key a_index (a DESC,b DESC),
key k1(b),key k2©,key k3(d));
如下哪些sql语句查询能较好的利用索引?()
A、select b from WHERE b like ‘aaa%’;
B、select a,b from T WHERE a=‘2015-10-25’ ORDER BY b ASC,c ASC;
C、select a,b,c from T WHERE a=‘2015-10-25’ ORDER BY b ASC;
D、select a,b,c from T WHERE a=‘2015-10-25’ ORDER BY a,b;
解答：AD
问题：已知a为不为空的数组，且变量b===a. 以下哪些方式可以清空数组, 使得a.length 与 b.length 都为 0;
A、b.len(0)
B、a = []
C、a.splice(0, a.length)
D、a = a.slice(a.length)
解答：C
java中没有len()方法，故A不对
B选项：相当于a指向了一个新的数组，新数组为空数组
C选项：数组的splice(0，a.length)方法执行后返回的是被删除的项，执行后删除了数组的每一项，原数组发生改变
D选项：数组的slice(a.length)方法执行后返回空数组，赋值给a,但是这个方法对原数组不会产生影响，所以b.length不为0
问题：计算f(10)时，f()被调用了多少次？
1 int f(int x) {
2 if(x <= 2)
3 return 1;
4 return f(x - 2) + f(x - 4) + 1;
5}
A、14
B、18
C、20
D、24
E、以上都不是
解答：E
基于偶数递归树，应该是15次
问题：以下计算斐波那契数列的函数时间复杂度为()
1 int Fibonacci(int n)
2 {
3 if(n==0)
4 return 0;
5 else if(n==1)
6 return 1;
7 else
8 return Fibonacci(n-1)+Fibonacci(n-2)
9 }
A、O(nlogn)
B、O(n^2)
C、O(n)
D、O(2^n)
解答：D
问题：有以下程序段,下面正确的选项是（）
1 class DemoThread extends Thread {
2 public static void main(String args[]) {
3 DemoThread threadOne = new DemoThread();
4 DemoThread threadTwo = new DemoThread();
5 threadOne.start();
6 System.out.print("thread one.");
7 threadTwo.start();
8 System.out.print("thread two.");
9 }
10 public void run() {
11 System.out.print("Thread.");
12 }
13 }
A、编译失败
B、程序运行结果为：thread one.Thread.thread two.Thread.
C、程序运行结果是：thread one.thread two.Thread.Thread.
D、程序运行结果不确定
解答：D
因为java线程源码看是，start最终他执行的是本地方法start0，是直接调用操系统的线程的一个方法
而这个start0 他会调用一个native文件，也就是我们的c文件。但是这个c文件他并没有直接去调用os（操作系统）函数
他的实现是：start0会去调用操作系统函数的pthread_create创建线程的方法，这个创建方法会有一个传回调方法的参数然后再由操作系统去掉用java的run方法，这一系列的调用，导致主线程main已经执行了，所以这里最终那个线程先执行run方法并不确定
问题：下面java程序的运行结果是()
1 class A {
2 static {
3 System.out.print("A");
4 }
5 public A() {
6 System.out.print("a");
7 }
8 void say() {
9 System.out.print("1");
10 }
11 }
12 class B extends A {
13 static {
14 System.out.print("B");
15 }
16 public B() {
17 System.out.print("b");
18 }
19 void say() {
20 System.out.print("2");
21 }
22 }
23 public class Hello {
24 public static void main(String[] args) {
25 A ab = new B();
26 ab.say();
27 ab = new B();
28 ab.say();
29 }
30 }
A、ABab2ABab2
B、AaBb1AaBb2
C、ABab1ab2
D、ABab2ab2
解答：D
这题考的是static 和 构造函数的执行顺序
先执行父类static块，在执行子类static块，static块只执行一次。 所以只有一个AB，然后就是构造方法，先执行父类的，在执行子类的，因为new了两次，所以有两个ab，紧接着调用了两次say方法，所以有两个2
问题：Linux进程内存空间有以下几个部分：
1.stack
2.heap
3.bss segment
4.code segment/text segment
5.data segment
它们从高地址到低地址的分布顺序为()
A、45321
B、12354
C、45312
D、21354
解答：B
1、栈(Stack): 由编译器自动分配释放管理. 用于函数调用,保存函数的返回地址,函数的参数,函数内部定义的局部变量
2、堆(heap) : 需要由程序员分配释放管理，若程序员不释放，程序结束时可能由OS回收。通常在堆中进行动态存储分配。(建议一定要手动释放,不然会造成内存泄漏)
3、未被初始化数据段(bbs):它属于静态存储区,但是该段中的数据没有经过初始化.即存放未初始化的静态变量或全局变量
4、数据段(data):数据段分为读写数据段和只读数据段
读写数据段：已初始化的全局变量或者已初始化的静态变量
只读数据段：只读全局量和只读局部量(使用const); 程序中使用的常量
5、代码段(text)：即二进制代码,代码段是只读的,可被多个进程共享
问题：假定x=500，求下面函数的返回值（）
1 int fun(int x)
2{
3 int countx = 0;
4 while (x)
5 {
6 countx++;
7 x = x & (x – 1);
8 }
9 return countx;
10｝
A、2
B、3
C、5
D、6
解答：D
x = x & x-1 # 将x的二进制表示最后一位1变成0，那么整段代码的目的就是求x二进制表示1的个数
500 -> 111110100，有6个1
问题：其中 alert 两次输出结果为（）
1 var foo=”hello”;
2(function(){
3 var bar=”world”;
4 alert(foo+bar);
5})();
6alert(foo+bar);
A、hello world报错
B、hello world hello world
C、hello world hello
D、hello world
解答：A
外面的 alert 找不到变量 bar 的定义
问题：设有一个递归算法如下
1 int f(int n) {
2 if(n<=3) return 1;
3 else return f(n-2)+f(n-6)+1;
4}
试问计算f(f(9))时需要计算（）次f函数。
A、10
B、11
C、12
D、14
解答：C
一、先算内层f(9)
[1] 计算 f(9) = f(7) + f(3) + 1;
[2] 计算[1]中 f(7) = f(5) + f(1) + 1;
[3] 计算[2]中 f(5) = f(3) + f(-1) + 1;
[4] 计算[3]中 f(3) = 1;
[5] 计算[3]中 f(-1) = 1;
{至此f(5)可计算得： f(5) = 1 + 1 + 1 = 3}
[6] 计算(1)中f(1) = 1;
{至此f(7)可计算得 ：f(7) = 3 + 1 + 1 = 5}
[7] 计算[1]中f(3) = 1;
{至此f(9)可计算得：f(9) = 5 + 1 + 1 = 7}
计算f(9)一共调用了7次函数
二、计算外层f(7) 由上面步骤可知，计算f(7)调用了5次函数 所以一共调用了函数7+5=12次
问题：下面函数的时间复杂度是（）
1 long foo(long x){
2 if(x<2) return 1;
3 return x*x*foo(x-1);
4}
A、O(N)
B、O(N^2)
C、O(N^3)
D、o(N!)
解答：A
这是一个递归算法，如:n表示递归次数
foo(2)=22foo(1) n=2
foo(3)=33foo(2) n=3
foo(4)=44foo(3) n=4
………………
依次类推：
foo(N)=NNfoo(N-1) n= (N)
当n>=2时
foo(n)=n2foo(n-1)=n2(n-1)2foo(n-2)=…=n2(n-1)^2*…2foo(1);
递归n-1步，时间复杂度为O(n)
因此时间复杂度为：O(N)
问题：运行以下程序
1 <script>
2 var m= 1, j = k = 0;
3 function add(n) {
4 return n = n+1;
5 }
6 y = add(m);
7 function add(n) {
8 return n = n + 3;
9 }
10z = add(m);
11</script>
y和z的最终结果为:
A、2,4
B、4,4
C、2,2
D、报异常
解答：B
javascript里没有函数重载，如果存在两个同名函数，后一个函数会覆盖前一个函数；解析器在读取、加载数据时会先读取函数声明再读取函数表达式，综上，y和z的值都为4
问题：下面的输出结果()
(function() {
2 var a = b = 5;
3 })();
4console.log(b);
5console.log(a);
A 、5，5
B、undefined，undefined
C、5，undefined
D、5，Uncaught ReferenceError: a is not defined
解答：D
由于 a 和 b 都定义在函数的封闭范围内，并且都始于 var关键字，大多数JavaScript开发人员期望 typeof a 和 typeof b 在上面的例子中都是undefined
然而，事实并非如此。这里的问题是，大多数开发人员将语句 var a = b = 5; 错误地理解为是以下声明的简写：
var b = 5;
var a = b;
但事实上，var a = b = 5; 实际是以下声明的简写：
b = 5;
var a = b;
既然语句 var a = b = 3; 是语句 b = 3; 和 var a = b;的简写， b 最终成为了一个全局变量（因为它没有前缀 var 关键字），因此仍然在范围内甚至封闭函数之外
在严格模式下（即使用 use strict），语句var a = b = 3; 将生成ReferenceError: a is not defined的运行时错误，从而避免任何否则可能会导致的headfakes /bug
问题：NumberList是一个顺序容器，以下代码执行后，NumberList里的元素依次为
1 List<int> NumberList = new List<int>(){2,4,1,3,5};
2 for(int i = 0;i<NumberList.Count;++i)
3{
4 int v = NumberList[i];
5 if(v%2 = = 0)
6 {
7 NumberList.Remove(v);//删除的是元素，而非下标
8 }
9}
A、2,4,1,3,5
B、2,1,3,5
C、4,1,3,5
D、1,3,5
解答：C
类似于Java中的ArrayList，初始时Arraylist为{2,4,1,3,5}
第一次循环 i=0;v=2;2是偶数，所以把2从ArrayList中移除，这时ArrayList变为{4,1,3,5}
第二次循环i=1;v=1(因为新的ArrayList中4的索引是0),1不是偶数，
依次 3和 5都不是偶数，所以只删除了元素2，那么剩下的就是{4,1,3,5}
问题：执行某操作，前50次成功，第51次失败a全部回滚b前50次提交第51次抛异常，ab场景分别如何设置Spring（传播性）？
解答：
a、全部回滚 父类方法加事务PROPAGATION_REQUIRED
b、第51次抛异常 父类方法加事务PROPAGATION_REQUIRED ，子类方法加事务PROPAGATION_REQUIRES_NEW
问题：检查程序，是否存在问题，如果存在指出问题所在，如果不存在，说明输出结果
1 public class HelloB extends HelloA
2{
3 public HelloB()
4 {
5 }
6 {
7 System.out.println("I’m B class");
8 }
9 static
10{
11 System.out.println("static B");
12 }
13 public static void main(String[] args)
14 {
15 new HelloB();
16 }
17}
18class HelloA
19{
20 public HelloA()
21 {
22 }
23 {
24 System.out.println("I’m A class");
25 }
26 static
27 {
28 System.out.println("static A");
29 }
30}
A、static A
I’m A class
static B
I’m B class
B、I’m A class
I’m B class
static A
static B
C、static A
static B
I’m A class
I’m B class
D、I’m A class
static A
I’m B class
static B
解答：C
构造方法是只有你在new对象的时候才会执行,
静态语句块和静态方法在类加载到内存的时候就已经执行了
静态语句块只能给静态变量赋值,里面不能出现方法,同样,静态方法里面也不能出现静态语句块
所以先是静态语句块执行,然后静态方法加载到内存，静态语句块你不管它它自动会执行，而静态方法它一直存在于内存中，只有你用类名点方法名的时候才会执行
{
System.out.println("I’m A class");
}
他是非静态代码块，如果都是静态代码，一个类里面，按照先后顺序执行，父子之间，父类静态代码块先执行
正确顺序是：
父类A静态代码块->子类B静态代码块->父类A非静态代码块->父类A构造函数->子类B非静态代码块->子类B构造函数
问题：检查程序，是否存在问题，如果存在指出问题所在，如果不存在，说明输出结果
1package algorithms.com.guan.javajicu;
2public class Example {
3 String str = new String("good");
4 char[] ch = {'a','b','c'};
5 public static void main(String[] args) {
6 Example ex = new Example();
7 ex.change(ex.str, ex.ch);
8 System.out.print(ex.str +"and");
9 System.out.print(ex.ch);
10 }
11
12 public void change(String str, char ch[]){ 12
13 str= "test ok";
14 ch[0]= 'g';
15 }
16}
A、test okandabc
B、test okandgbc
C、goodandabc
D、goodandgbc
解答：D
数组：
使用一个"new"创建一个对象时，在堆中会分配一段内存空间，并返回一个引用。这一点对于数组也适用，因为在java中，数组也是对象
字符串：
1、显式的String常量
str= “test ok”;
代码执行后就在常量池中创建了一个值为test ok的String对象；
此时该字符串的引用在虚拟机栈里面
2、String对象
String str = new String(“good”);
Class被加载时就在常量池中创建了一个值为good的String对象，执行时会在堆里创建new String(“good”)对象
问题：下面代码运行后,变量 total 的结果是?
1 int total = 0;
2 for (int i = 0, j = 5; total < 10 || j > 3; ++i, --j) {
3 total += (i + j);
4 }
A、5
B、10
C、无法通过编译
D、运行时出错
E、运行时死循环
解答：B
for循环的表达式一般如下：
for(表达式1;表达式2;表达式3){
表达式4;
}
执行的顺序为：
1）第一次循环，即初始化循环。
首先执行表达式1（一般为初始化语句），再执行表达式2（一般为条件判断语句），判断表达式1是否符合表达式2的条件，如果符合，则执行表达式4，否则，停止执行，最后执行表达式3
2）下次的循环：
首先执行表达式2，判断表达式3是否符合表达式2的条件；如果符合，继续执行表达式4，否则停止执行，最后执行表达式3.如果往复，直到表达式3不再满足表达式2的条件。
总的来说，执行顺序是一致的，先进行条件判断（表达式2），再执行函数体（表达式4），最后执行表达式3，如此往复，区别在于，条件判断的对象，在第一次判断时，是执行表达式1，初始化对象，后续的判断对象是执行后的结果（表达式3）
本题执行顺序为：
total += (i + j); => i=0,j=5 , total=5
++i, --j ; => i=1,j=4 , total=5
total += (i + j); => i=1,j=4 , total=10
++i, --j ; => i=2,j=3 , total=10
问题：执行以下程序后的输出结果是（）
1public class Test {
2public static void main(String[] args) {
3 StringBuffer a = new StringBuffer("A");
4 StringBuffer b = new StringBuffer("B");
5 operator(a, b);
6 System.out.println(a + "," + b);
7}
8public static void operator(StringBuffer x, StringBuffer y) {
9 x.append(y); y = x;
10}
11}
A、A,A
B、A,B
C、B,B
D、AB,B
解答：D
a和x是同个地址，b和y是同个地址，然后执行x.append(y)就把y的值放在x的地址里面此时a地址和x是同一个所以a就是AB了，接着执行y=x是把x的地址给y，这时候axy属于同一个地址，所以y=x 只是改变了y的地址没改变b的地址，所以b还是B
问题：以下java程序代码，执行后的结果是（）
1 public class Test {
2 public static void main(String[] args) {
3 Object o = new Object() {
4 public boolean equals(Object obj) {
5 return true;
6 }
7 };
8 System.out.println(o.equals("Fred"));
9 }
10}
A、Fred
B、true
C、编译错误
D、运行时抛出异常
解答：B
重写了object 的equals 的方法，使他怎么输出都是tue
相当于创建了一个方法无论传入什么对象返回都是true
问题：下面代码运行结果是（）
1 public class Test{
2 public int add(int a,int b){
3 try {
4 return a+b;
5 }
6 catch (Exception e) {
7 System.out.println("catch语句块");
8 }
9 finally{
10 System.out.println("finally语句块");
11 }
12 return 0;
13 }
14 public static void main(String argv[]){
15 Test test =new Test();
16 System.out.println("和是："+test.add(9, 34));
17 }
18}
A、catch语句块
和是：43
B、编译异常
C、finally语句块
和是：43
D、和是：43
finally语句块
解答：C
try、catch、finally 这个过程也就是这样，如果try catch finally 都有return：
1、在没有异常的情况下，try 中的返回值先保存到临时区域里在去执行finally ，这个finally 有返回值，这个返回值将之前try中的保存到临时区域的值用返回的这个值替换，再将这个临时区域中的值返回给上一级方法。
2、如果有异常，则执行catch中的代码，这里的return 将返回一个返回值放到临时区域，再去执行finally ，这个finally有返回值，这样就将catch中存在临时区域中的值用这个finally 返回的值替换掉，在将这个临时区域的值返回给上一级方法。
System.out.println(“和是：”+test.add(9, 34)); 这是进行字符串拼接是一个整体，所以首先是进入add方法中，进去之后先把先不运算result，而是输出finally块。注意：此时finally块输出结果是：finally语句块，这句话首先打印到控制台中。打印完后返回来执行try中的return得到43，所以此时再将结果与"和是："进行拼接–>输出：和是 43。所以此时控制台又多了一句话：和是 43。加上之前finally先在控制台上的输出，所以结果为：finally语句块 和是 43
问题：关于下面代码片段叙述正确的是（）
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
被final修饰的变量不会自动转换类型
b4,b5被final修饰，所以不会转成int类型
b1,b2没有被final修饰，会转成int类型相加，得到的结果也是int，从大的范围变成小的范围需要强转，同时需要注意不要超出小的范围，不然计算结果不正确
问题：现有二叉搜索树（BST）前序遍历结果序列为abdefgc，中序遍历结果序列为debgfac，请问后序遍历结果序列?
A、debgfac
B、edgfbca
C、edgbfca
D、degbfac
解答：B
前序遍历：
1.访问根节点
2.前序遍历左子树
3.前序遍历右子树
中序遍历：
1.中序遍历左子树
2.访问根节点
3.中序遍历右子树
后序遍历：
1.后序遍历左子树
2.后序遍历右子树
3.访问根节点
问题：下面代码输出的结果是？
public class NULL {
public static void print(){
System.out.println(“MTDP”);
}
public static void main(String[] args) {
try{
((NULL)null).print();
}catch(NullPointerException e){
System.out.println("NullPointerException");
}
}
}
A、NullPointerException
B、MTDP
C、都不输出
D、无法正常编译
解答：B
因为null值可以强制转换为任何java类类型，(String)null也是合法的。但null强制转换后是无效对象，其返回值还是为null，而static方法的调用是和类名绑定的，不借助对象进行访问所以能正确输出。反过来，没有static修饰就只能用对象进行访问，使用null调用对象肯定会报空指针错了
问题：以下JSP代码定义了一个变量，如何输出这个变量的值？
<bean:define id=“stringBean” value=“helloWorld”/>
A、<bean:write name=“helloWorld”/>
B、<%=stringBean%>
C、<bean:write name=“stringBean”/>
D、<%String myBean=(String)pageContext.getAttribute(“stringBean”,PageContext.PAGE_SCOPE);%><%=myBean%>
解答：BCD
用Struts 的bean:define 标签定义了一个字符串变量 stringBean ,它的值为 helloworld
A：bean:write相当于 <%=request.getAttribute(“something”)%> 其中 something 是属性的名字。所以 A 错，C对
B：通过Jsp 表达式 获取变量 stringBean 的值
D：通过 pageContext（PageContext类的实例，提供对JSP页面所有对象以及命名空间的访问） 获取stringBean 的值，赋给 String 类型的变量 myBean，然后通过 Jsp 表达式 处理该值
问题：下面函数将返回？
1 public static int func (){
2 try{
3 return 1;
4 }catch (Exception e){
5 return 2;
6 }finally{
7 return 3;
8 }
9}
A、1
B、2
C、3
D、编译错误
解答：C
try{
return 1; // 这里会执行，但是不会立刻return，return之前会继续执行finally代码
}catch (Exception e){
return 2; // 异常才会执行
}finally{
return 3; // 无论如何这里都会执行，如果finally有return会立刻返回
}
问题：设 m 和 n 都是 int 类型，那么以下 for 循环语句，___
for(m=0,n=-1;n=0;m++,n++)
n++;
A、循环体一次也不执行
B、循环体执行一次
C、是无限循环
D、有限次循环
E、循环结束判断条件不合法
F、运行出错
解答：A
执行顺序：
（1）初始化m=0,n=-1
（2）循环条件n=0，为假，所以循环体一次也不执行
问题：下面程序运行的结果是？
public static void main(String args[]) {
Thread t = new Thread() {
public void run() {
pong();
}
};
t.run();
System.out.print("ping");
}
static void pong() {
System.out.print("pong");
}
A、pingpong
B、pongping
C、pingpong和pongping都有可能
D、都不输出
解答：B
t.run();直接执行java线程,主线被抢占
@FunctionalInterface
public interface Runnable {
/**
* When an object implementing interface <code>Runnable</code> is used
* to create a thread, starting the thread causes the object's
* <code>run</code> method to be called in that separately executing
* thread.
* <p>
* The general contract of the method <code>run</code> is that it may
* take any action whatsoever.
*
* @see java.lang.Thread#run()
*/
public abstract void run();
}
如果t.start();则答案是C
因为java线程源码看是，start最终他执行的是本地方法start0，是直接调用操系统的线程的一个方法。
而这个start0 他会调用一个native文件，也就是我们的c文件。但是这个c文件他并没有直接去调用os（操作系统）函数。他的实现是：start0会去调用操作系统函数的pthread_create创建线程的方法。这个创建方法会有一个传回调方法的参数然后再由操作系统去掉用java的run方法。这一系列的调用。可能导致主线程main已经执行了。
问题：阅读以下JAVA程序段，执行结果正确的是（ ）
public class Test
{
public static void main (String[] args)
{
Byte var1 = 126;
Byte var2 = 127;
Byte var3 = var1 + var2; //第7行
}
}
A、编译成功并且变量var3的值为253
B、第7行有错误导致编译不成功
C、第7行有“溢出”导致执行失败
D、编译成功并且变量var3的值为1
解答：B
byte类型进行运算时会自动转化为int类型，需要强转
问题：下面代码的运行结果是（ ）
public class Arraytest
{
int a[] = new int[6];
public static void main ( String arg[] ) {
System.out.println ( a[0] );
}
}
A、null
B、0
C、编译出错
D、运行出错
解答：C
类的静态成员(变量和方法)属于类本身，在类加载的时候就会分配内存；
非静态成员（变量和方法）属于类的对象，所以只有在类的对象产生（创建类的实例）时才会分配内存，然后通过类的对象（实例）去访问
因为a是非静态变量；
在一个类的静态成员中去访问其非静态成员之所以会出错是因为在类的非静态成员不存在的时候类的静态成员就已经存在了，访问一个内存中不存在的东西就会出错
问题：执行如下程序，输出结果是（ ）
class MyTest {
public static void main(String[] args) {
Integer first = new Integer(3);
Integer second = 3;
int three = 3;
System.out.println(first==second);
System.out.println(first==three);
}
}
A、falsetrue
B、falsefalse
C、truetrue
D、truefalse
解答：A
1、int 和Integer在进行比较的时候，Integer会进行拆箱，转为int值与int进行比较
2、Integer与Integer比较的时候，由于直接赋值的时候会进行自动的装箱，那么这里就需要注意两个问题，一个是-128<= x<=127的整数，将会直接缓存在IntegerCache中，那么当赋值在这个区间的时候，不会创建新的Integer对象，而是从缓存中获取已经创建好的Integer对象。二：当大于这个范围的时候，直接new Integer来创建Integer对象
3、new Integer(1) 和Integer a = 1不同，前者会创建对象，存储在堆中，而后者因为在-128到127的范围内，不会创建新的对象，而是从IntegerCache中获取的。那么Integer a = 128, 大于该范围的话才会直接通过new Integer（128）创建对象，进行装箱
下面的程序将来打印什么?（）
1 public class TestIncr {
2 public static void main(String args[]) {
3 int i = 0;
4 i = i++ + i;
5 System.out.println("I = "a + i);
6 }
7}
A、I = 1
B、I = 2
C、I = 3
D、编译出错
解答：D
问题：以下类定义中的错误是什么？（）
1 abstract class xy
2{
3 abstract sum (int x, int y) { }
4}
A、没有错误
B、类标题未正确定义
C、方法没有正确定义
D、没有定义构造函数
解答：C
有两个问题1：不应该有{ }，2：没有返回值
问题：针对下面的代码块,哪个equal为true:（）
String s1 = "xiaopeng" ;
String s2 = "xiaopeng" ;
String s3 =new String;
A、s1 == s2
B、s1 = s2
C、s2 == s3
D、都不正确
解答：A
== 用法：
如果作用于基本数据类型的变量，则直接比较其存储的 “值”是否相等
如果作用于引用类型的变量，则比较的是所指向的对象的地址， 比较的是两个变量是否指向同一个对象
使用字符串常量给String变量赋值，s1和s2字符串常量会被存进内存的常量池里面，供整个程序使用，所以s1和s2实际是引用了同一个字符串对象，地址相同，而new出来的是在存在堆内存中，单独的一份，所以s3和另外两个地址不同
问题：尝试编译以下程序会产生怎么样的结果？（）
1 public class MyClass {
2 long var;
3 public void MyClass(long param) { var = param; }//(1)
4 public static void main(String[] args) {
5 MyClass a, b;
6 a =new MyClass();//(2)
7 b =new MyClass(5);//(3)
8 }
9 }
A、编译错误将发生在（1），因为构造函数不能指定返回值
B、编译错误将发生在（2），因为该类没有默认构造函数
C、编译错误将在（3）处发生，因为该类没有构造函数，该构造函数接受一个int类型的参数
D、该程序将正确编译和执行
解答：C
因为MyClass不是构造函数，而是一个普通的方法。又因为一个类，如果不自定义构造方法，会有个缺省的构造方法，所有(2)处是不会报错误的。而缺省的构造方法是无参的。所以在(3)处会报错
问题：已知如下类定义：
1 class Base {
2 public Base (){
3 //...
4 }
5 public Base ( int m ){
6 //...
7 }
8 public void fun( int n ){
9 //...
10 }
11}
12public class Child extends Base{
13 // member methods
14}
如下哪句可以正确地加入子类中？
A、private void fun( int n ){ //…}
B、void fun ( int n ){ //… }
C、protected void fun ( int n ) { //… }
D、public void fun ( int n ) { //… }
解答：D
方法的重写（override）两同两小一大原则：
方法名相同，参数类型相同
子类返回类型小于等于父类方法返回类型，
子类抛出异常小于等于父类方法抛出异常，
子类访问权限大于等于父类方法访问权限。
问题：以下语句的执行结果是什么？
1+”10”+3+”2”
A、”11032”
B、“16”
C、16
D、“32101”
解答：A
当一个整形类型数值加上“”，会转化为字符串类型，这也是整形转化为字符串的一种方式。这种会产生两个String对象，所以整形加上字符串时，此时+就变成了了连接符
问题：
1 public class IfTest{
2 public static void main(string[]args){
3 int x=3;
4 int y=1;
5 if(x=y)
6 System.out.println(“Not equal”);
7 else
8 System.out.println(“Equal”);
9 }
10 }
结果是?
A、The output is “Equal”
B、The output in “Not Equal”
C、An error at line 5 causes compilation to fall.
D、The program executes but does not print a message.
解答：C
在 Java 中 if 只能匹配 ture、false，赋值语句没有返回结果，无法使用在 if 句式中，会语法报错
问题：输出的是？
1 class Foo {
2 final int i;
3 int j;
4 public void doSomething() {
5 System.out.println(++j + i);
6 }
7}
A、0
B、1
C、2
D、不能执行，因为编译有错
解答：D
final必须进行初始化赋值，编译报错
问题：下列哪些针对代码运行结果的描述是正确的？
1 class Car extends Vehicle
2{
4 public static void main (String[] args)
5 {
6 new Car(). run();
7 }
8 private final void run()
9 {
10 System. out. println ("Car");
11 }
12}
13class Vehicle
14{
15 private final void run()
16 {
17 System. out. println("Vehicle");
18 }
19}
A、Car
B、Vehicle
C、Compiler error at line 6
D、Compiler error at line 8
E、Exception thrown at runtime
解答：A
父类用final修饰的方法 无法被子类重写 所以调用本身方法
问题：经过强制类型转换以后，变量a，b的值分别为多少？
short a =128；
byte b =(byte) a；
A、128 127
B、128 - 128
C、128 128
D、编译错误
解答：B
## int占4个字节，32位
byte占1个字节，8位
所以强转时会截断。前24位
## 在内存中表示形式（ 注意java中是以补码表示一个数，所以表示形式是补码，不是原码！ ）：
int a = 3 00000000 00000000 00000000 00000011 （强转byte时前面24个0被截断）
byte b = 3 00000011
int a = -3 11111111 11111111 11111111 11111101 （强转byte时前面24个1被截断）
byte b = -3 11111101
## 1、Java中用补码形式表示
2、第一位正负位，1表示负，0表示正。
3、原码：一个数的二进制表示。
3的原码00000011 -3的 原码 10000011
4、反码：负数原码按位取反（符号位不变）。正数原码本身。
3的反码00000011 -3的反码11111100
5、补码：正数是原码本身。负数反码加1。
3的补码是00000011 -3的补码是11111101
## 已知负数的补码，求负数：
补码-1=反码，反码按位取反=该负数绝对值
已知负数，求负数的补码：
1、负数原码除了符号位，按位取反（不含符号位），加1。
2、负数绝对值的补码（也就是原码），按位取反（含符号位），加1
java int 128转为byte，值：
128为正数，补码为10000000（前面24个0省略），变成byte，只剩下10000000（byte为1个字节），因为开头是1，所以为负数。即1个负数的补码是10000000。反码是01111111，原码是1000000。是128.因为是负数，所以是-128。
问题：假设如下代码中，若t1线程在t2线程启动之前已经完成启动。代码的输出是（）
1 public static void main(String[]args)throws Exception {
2 final Object obj = new Object();
3 Thread t1 = new Thread() {
4 public void run() {
5 synchronized (obj) {
6 try {
7 obj.wait();
8 System.out.println("Thread 1 wake up.");
9 } catch (InterruptedException e) {
10 }
11 }
12 }
13 };
14 t1.start();
15 Thread.sleep(1000);//We assume thread 1 must start up within 1 sec.
16 Thread t2 = new Thread() {
17 public void run() {
18 synchronized (obj) {
19 obj.notifyAll();
20 System.out.println("Thread 2 sent notify.");
21 }
22 }
23 };
24 t2.start();
25 }
A、Thread 1 wake up
Thread 2 sent notify.
B、Thread 2 sent notify.
Thread 1 wake up
C、A、B皆有可能
D、程序无输出卡死
解答：B
t1 启动后执行 obj.wait() 时，进入阻塞状态，让出时间片并释放锁，等待其他线程的唤醒。然后 t2 获取到 obj，并唤醒 t1，待 t2 执行完毕，释放锁后，t1 再继续执行
问题：下列代码的执行结果是：（ ）
1 public class Test3{
2 public static void main(String args[]){
3 System.out.println(100%3);
4 System.out.println(100%3.0);
5}
6}
A、1和1
B、1和1.0
C、1.0和1
D、1.0和1.0
解答：B
大数据类型与小数据类型做数值运算时：
小的数据类型会自动转为大数据类型，无无需强转。 （小转大——类型声明）
大的数据类型转为小的数据类型，必须强转，但是可能会丢失内容 （大转小——强转）
第一个，没有牵扯到不同类型之间的运算，所以还是 1
第二个，int对double取余，自动会转换为double类型，所以是 1.0
问题：运行下面代码，输出的结果是（）
1 class A {
2 public A() {
3 System.out.println("class A");
4 }
5 { System.out.println("I'm A class"); }
6 static { System.out.println("class A static"); }
7}
8public class B extends A {
9 public B() {
10 System.out.println("class B");
11 }
12 { System.out.println("I'm B class"); }
13 static { System.out.println("class B static"); }
14
15 public static void main(String[] args) {
16 new B();
17 }
18}
A、class A static
class B static
I’m A class
class A
I’m B class
class B
B、class A static
I’m A class
class A
class B static
I’m B class
class B
C、class A static
class B static
class A
I’m A class
class B
I’m B class
D、class A static
class A
I’m A class
class B static
class B
I’m B class
解答：A
执行顺序优先级：静态块>构造块>构造方法
当涉及到继承时，按照如下顺序执行：
1、执行父类的静态代码块，并初始化父类静态成员变量
2、执行子类的静态代码块，并初始化子类静态成员变量
3、执行父类的构造代码块，执行父类的构造函数，并初始化父类普通成员变量
4、执行子类的构造代码块， 执行子类的构造函数，并初始化子类普通成员变量
问题：当你编译和运行下面的代码时，会出现下面选项中的哪种情况？
1 public class Pvf{
2 static boolean Paddy;
3 public static void main(String args[]){
4 System.out.println(Paddy);
5 }
6}
A、编译时错误
B、编译通过并输出结果false
C、编译通过并输出结果true
D、编译通过并输出结果null
解答：B
类中声明的变量有默认初始值；方法中声明的变量没有默认初始值，必须在定义时初始化，否则在访问该变量时会出错。boolean类型默认值是false
问题：如下的Java程序
public class Test {
public static void main(String[] args) {
System.out.println(args[0]);
}
}
若采用命令行“java Test one two three”调用，则程序输出的结果为：
A、Test
B、one
C、two
D、java
解答：B
题目少了public class Test {
采用命令行“java Test one two three”调用
其中Test为调用的方法，而one two three则为Test方法里面main函数的参数；System.out.println(args[0]);表示输出第一个元素，故为one；
问题：执行如下程序，输出结果是（ ）
1 class Test
2{
3 private int data;
4 int result = 0;
5 public void m()
6 {
7 result += 2;
8 data += 2;
9 System.out.print(result + " " + data);
10 }
11 }
12 class ThreadExample extends Thread
13 {
14 private Test mv;
15 public ThreadExample(Test mv)
16 {
17 this.mv = mv;
18 }
19 public void run()
20 {
21 synchronized(mv)
22 {
23 mv.m();
24 }
25 }
26 }
27 class ThreadTest
28 {
29 public static void main(String args[])
30 {
31 Test mv = new Test();
32 Thread t1 = new ThreadExample(mv);
33 Thread t2 = new ThreadExample(mv);
34 Thread t3 = new ThreadExample(mv);
35 t1.start();
36 t2.start();
37 t3.start();
38 }
39 }
A、0 22 44 6
B、2 42 42 4
C、2 24 46 6
D、4 44 46 6
解答：C
Test mv =newTest()声明并初始化对data赋默认值
使用synchronized关键字加同步锁线程依次操作m()
t1.start();使得result=2,data=2,输出即为2 2
t2.start();使得result=4,data=4,输出即为4 4
t3.start();使得result=6,data=6,输出即为6 6
System.out.print(result +" "+ data);是print()方法不会换行,输出结果为2 24 46 6
问题：以下代码执行的结果显示是多少（ ）？
1 public class Demo { class Super{ int flag=1;
2 Super(){
3 test();
4 } void test(){
5 System.out.println("Super.test() flag="+flag);
6 }
7 } class Sub extends Super{
8 Sub(int i){ flag=i;
9 System.out.println("Sub.Sub()flag="+flag);
10 } void test(){
11 System.out.println("Sub.test()flag="+flag);
12 }
13 } public static void main(String[] args) { new Demo().new Sub(5);
14 }
15}
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
问题：对下面Spring声明式事务的配置含义的说明错误的是()
1 <bean id="txProxyTemplate" abstract="true"
2class=
3"org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
4 <property name="transactionManager" ref="myTransactionManager" />
5<property name="transactionAttributes">
6<props>
7 <prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>
8 <prop key="*">PROPAGATION_REQUIRED</prop>
9 </props>
10</property>
11</bean>
A、定义了声明式事务的配置模板
B、对get方法采用只读事务
C、缺少sessionFactory属性的注入
D、配置需要事务管理的bean的代理时，通过parent引用这个配置模板
解答：C
TransactionProxyFactoryBean 类没有 sessionFactory 属性，不需要注入；直接用 parent 引用配置模板 Bean，关联目标 DAO 对象即可
<bean id="myProxy" parent="txProxyTemplate">
<property name="target" ref="myTarget">;
</bean>
问题：有这么一段程序
1 public class Test{
2 public String name="abc";
3 public static void main(String[] args){
4 Test test=new Test();
5 Test testB=new Test();
6 System.out.println(test.equals(testB)+","+test.name.equals(testB.name));
7 }
8}
请问以上程序执行的结果是（）
A、true,true
B、true,false
C、false,true
D、false,false
解答：C
Test未重写equals,则使用Object的equals方法：
public boolean equals(Object obj) {
return (this == obj);
}
String 则使用String重写的equals方法：
public boolean equals(Object anObject) {
if (this == anObject) {
return true;
}
if (anObject instanceof String) {
String anotherString = (String)anObject;
int n = value.length;
if (n == anotherString.value.length) {
char v1[] = value;
char v2[] = anotherString.value;
int i = 0;
while (n-- != 0) {
if (v1[i] != v2[i])
return false;
i++;
}
return true;
}
}
return false;
}
问题：现有如下代码段：
1 x = 2;
2 while(x<n/2)
3 x = 2*x;
假设n>=0，则其时间复杂度应为（ ）
A、O(log2(n))
B、O(nlog2(n))
C、O(n)
D、O(n^2)```language
解答：A
可以看到2*x为基本操作，基本操作的执行的次数即为程序的时间复杂度；
x=1 x=2x2=4
x=2 x=4x2=8
…
执行到n次
x=2(n+1)
即2（n+1）<n/2结束
