面试真题
public class Test { //二维数组能够这样定义,数组命名时名称与[]能够随意排列，但声明的二维数组中第一个中括号中必需要有值 float []f1[] = new float[6][]; float []f2[] = new float[6][6]; float [][] f3 = new float[6][]; float f4[][] = new float[6][]; float f5[][] = new float[6][6]; }
/** * 运行下面代码的输出结果： * * @author chenyangkai * * * */ public class Test { public static Test t1 = new Test(); public static Test t2 = new Test(); { System.out.println("构造块"); } static { System.out.println("静态块"); } public static void main(String[] args) { Test t = new Test(); //結果是：构造块 构造块 静态块 构造块 } }
/**
* 执行下面代码输出结果是：
* @author chenyangkai
*
*/
public class Test {
public static void main(String[] args) {
A classa = new A("he");
A classb = new A("he");
//输出false ==判断的是引用地址
System.out.println(classa == classb);
//输出false,没有重写equals方法，使用的Object的equals方法,Object的equals方法用的是 ==
System.out.println(classa.equals(classb));
}
}
class A {
public A(String str) {
}
}
/** * 执行下面代码输出结果是： * @author chenyangkai * */ public class Test { public static void main(String args[]) { int a = 10; int b; int c; if (a > 50) { b = 9; } //变量没有初始化就使用会编译不经过，报错 c = b + a; } }
/** * 执行下面代码输出结果是： A:good and abc B:good and gbc C:test ok and abc D:test ok and gbc * @author chenyangkai * */ public class Test { String str = new String("good"); char[] ch = { 'a', 'b', 'c' }; public static void main(String args[]) { Test t = new Test(); Test.change(t.str, t.ch); System.out.print(t.str + " and "); System.out.print(t.ch); } public static void change(String str, char ch[]) { /** * String是final修饰的，值不能改变 * ch是引用类型，传递过来的是它的引用地址，这个地址指向堆里面的一个对象, 作修改操做会把对象的值改变 * * 答案B */ str = "test ok"; ch[0] = 'g'; } }
/** * 执行下面代码输出结果是： A:出错 B:342 C:34234 D:3423 * @author chenyangkai * */ public class TestDemo { public static String output =""; public static void foo(int i){ try{ if(i == 1){ throw new Exception(); } }catch(Exception e){ output += "2"; return ; }finally{ output += "3"; } output += "4"; } public static void main(String[] args) { foo(0); foo(1); System.out.println(output); } //答案：D }
/*** * 下面的输出语句输出什么 * @author chenyangkai * */ public class Test { public static void main(String[] args) { Integer i01=59; int i02=59; Integer i03=Integer.valueOf(59); Integer i04=new Integer(59); System.out.println(i01==i02);//true System.out.println(i01==i03);//true System.out.println(i03==i04);//false System.out.println(i02==i04);//true System.out.println(i01 == i04);//false } } ①不管如何，Integer与new Integer不会相等。不会经历拆箱过程， ②两个都是非new出来的Integer，若是数在-128到127之间，则是true,不然为false java在编译Integer i2 = 128的时候,被翻译成-> Integer i2 = Integer.valueOf(128);而valueOf()函数会对-128到127之间的数进行缓存 ③两个都是new出来的,都为false ④int和integer(不管new否)比，都为true，由于会把Integer自动拆箱为int再去比
定义有StringBuffer s1=new StringBuffer(10);s1.append(“1234”)则s1.length()和s1.capacity()分别是多少? length 返回当前长度 若是字符串长度没有初始化长度大，capacity返回初始化的长度 若是append后的字符串长度超过初始化长度，capacity返回增加后的长度 答案：4 10
如下关于对象序列化描述正确的是:(CD) A:使用FileOutputStream能够将对象进行传输 B:使用PrintWriter能够将对象进行传输 C:使用transient修饰的变量不会被序列化 D:对象序列化的所属类须要实现Serializable接口 使用ObjectOutputStream和ObjectInputStream能够将对象进行传输. 声明为static和transient类型的成员数据不能被串行化。由于static表明类的状态， transient表明对象的临时数据。
多态的做用（ABC） A:隐藏细节 B:提升可重用性 C:扩展代码模块 D:提升编译可靠性
如下各种中哪几个是线程安全的？(BCD ) A:ArrayList B:Vector C:Hashtable D:Stack
Java程序的种类有（ BCD） A:类（class） B:Applet C:Application D:Servlet Java程序的种类有： （a）内嵌于Web文件中，由浏览器来观看的_Applet （b）可独立运行的 Application （c）服务器端的 Servlets
面向对象程序设计方法的优势包含：(ABC) A:可重用性 B:可扩展性 C:易于管理和维护 D:简单易懂
下列关于JAVA多线程的叙述正确的是（BC） A:调用start()方法和run()均可以启动一个线程 B:CyclicBarrier和CountDownLatch均可以让一组线程等待其余线程 C:Callable类的call()方法能够返回值和抛出异常 D:新建的线程调用start()方法就能当即进行运行状态 1. start()方法来启动线程，真正实现了多线程运行，调用了run()方法；run()方法看成普通方法的方式调用。 2. CyclicBarrier让一组线程等待其余线程；CountDownLatch让一组线程等待某个事件发生。 3. Callable可以抛出checked exception。 4. start()方法让thread进去可运行状态（runnable），等待获取CPU的使用权
/***
* 下面的输出语句输出什么
* @author chenyangkai
*
*/
public class Test {
public static void main(String[] args) {
String classFile = "com.jd.". replaceAll(".", "/") + "MyClass.class";
System.out.println(classFile);
}
}
A:com. jd
B:com/jd/MyClass.class
C:///////MyClass.class
D:com.jd.MyClass
答案：c。因为replaceAll方法的第一个参数是一个正则表达式，而"."在正则表达式中表示任何字符，因此会把前面字符串的全部字符都替换成"/"。若是想替换的只是"."，那么久要写成"\\.".
/*** * 下面的输出语句输出什么 * @author chenyangkai * */ public class Test { public static void main(String[] args) { double d1=-0.5; System.out.println("Ceil d1="+Math.ceil(d1)); System.out.println("floor d1="+Math.floor(d1)); } } 答案：-0.0 -1.0 若是参数小于0且大于-1.0，结果为 -0。若是参数是 NaN、无穷、正 0、负 0，那么结果与参数相同， 若是是 -0.0，那么其结果是 -0.0
/*** * 下面的输出语句输出什么 * A:1true * B:2true * C:1false * D:2false * @author chenyangkai * */ public class Test { public static void main(String[] args) { Integer var1 = new Integer(1); Integer var2 = var1; doSomething(var2); System.out.print(var1.intValue()); System.out.print(var1 == var2); } public static void doSomething(Integer integer) { integer = new Integer(2); } } 答案：A,第一个打印语句打印的是1，第二个打印语句打印的是true.解析：intValue()是把包装类Integer转成int类型。Integer var2 = var1这条语句是把var1的引用地址赋给var2.调用doSomthing方法会把对象的值变成2，可是var1和var2仍是只指向同一个对象的引用地址，使用==比较返回ture,由于他们仍是同一引用地址。
19.https://blog.csdn.net/weixin_45535947/article/details/99999559java
Java 程序中使用赋值运算符进行对象赋值时，能够获得两个彻底相同的对象。
错误。Student s1 = new Student();
Student s2 = s1;
此时是将s1的引用地址赋给s2只有一个对象。
/*** * 下面的输出语句输出什么 * A:510050 * B:0 * C:运行时错误 * D:5050 * @author chenyangkai * */ public class Test { public static void main(String[] args) { int count = 0; int num = 0; for(int i=0;i<=100;i++) { num = num +i; count = count++; } System.out.println(count*num); } } 答案：B.count = count++等价于 int temp = count; count++;count = temp;值就没有改变一直是0.
下面说法正确的是（） A:构造函数先调用本身的构造函数而后初始化成员变量最后调用基类构造函数 B:构造函数先调用基类构造函数而后调用本身的构造函数最后初始化成员变量 C:构造函数先调用基类构造函数而后初始化成员变量最后调用本身的构造函数 D:构造函数先调用本身的构造函数而后调用基类构造函数最后初始化成员变量 答案：C
/*** * 下面的输出语句输出什么 * A：编译错误，指明run方法没有定义 B:运行错误，run方法没有定义 * C:运行错误，只鞥呢run方法没有定义 * D:编译经过，但无输出 * @author chenyangkai * */ public class Test extends Thread { public static void main(String[] args) { Test b = new Test(); b.run(); } public void start() { for (int i = 0; i < 10; i++) { System.out.println("Value of i = " + i); } } } 答案：D,Bground继承了Thread，可是没有重写run方法，run方法是个空方法.那么调用run方法确定是无输出。
/** * 运行下面代码结果是什么 * A:0 * B:1 * C:编译出错 * D:2 * @author chenyangkai * */ public class Test1 { private static int x; public static void main(String[] args) { name(x); System.out.println(x); } public static void name(int x) { x++; } } 答案：A.name()参数列表中的变量与类变量同名，此时x++,操做的是变量，而打印语句打印的是类变量。
/** * 运行下面代码结果是什么 * A:0 * B:1 * C:编译出错 * D:2 * @author chenyangkai * */ public class Test1 { private static int x; public static void main(String[] args) { name(x); System.out.println(x); } public static void name(int y) { x++; } } 答案：B。此时name()方法中的变量与类边量不一样，X++操做的是类变量。
下面关于实例成员的说法，正确的有（） A:实例成员也被称为实例变量 B：实例成员属于类成员 C:实例成员属于实例，单不隶属于整个类 D:实例成员包括实例变量和实例方法 E:实例成员变量就是静态变量 答案：CD。成员分为实例成员和类成员。实例成员属于对象的而类成员属于类的。实例成员包括实例变量和实例方法。类成员包括类变量和类方法。
下面选项中表示是对float类型变量的声明，那些是正确的（） A:float a = -586; B:float b = 3.1456; C:float c = 0xA4E D:float d = 42e1.2L E:float e = 52.08D F:float f = 5.88F 答案：ACF 注意AC的值是整型的，int类型能够赋给float.
下面那些说法是合法的（） A:long a = 12345 B:int i = 6.6L C:float f = 12.56 D:double d = 3.14 E:double d1 = 45.9F 答案：ADE
/** * 运行下面代码结果是什么 * A:x1=1x2=2x3=1 * B:x1=1x2=0x3=2 * C:x1=1x2=1x3=1 * D:不能编译 * @author chenyangkai * */ public class Test1 { public static void main(String[] args) { int x =1; Test1 t = new Test1(); System.out.print("x1="+x); t.setValue(x); System.out.println("x3="+x); } public void setValue(int x) { x = x+1; System.out.print("X2="+x); } } 答案：A.setValue的方法参数传递是值传递，此时调用setValue()方法实际上传递的是main()方法中x的“复印件”此时不管x作什么修改都不会影响“原件”因此最后的打印语句打印的x是1. setvalue中的参数至关于此方法内的局部变量。因为x2在局部变量x的生命周期中打印的值因此打印的是1+1=2.
下面代码插入那条语句会致使编译错误 * A:x++ * B:y++ * C:y=x * D:z[0]++ * E:n[0]++ * F:z = n * @author chenyangkai * */ public class Test1 { public static void main(String[] args) { int x = 0; final int y = 1; int [] z = {2}; final int [] n = {3}; user(x,y,z,n); } public static void user(final int x,int y,final int[] z,int []n) { //插入内容是 } } 答案：AF,final修饰的变量不能改变。final int[] z,表示z不能指向其余的数组对象，可是数组内的值仍是能够改变的。
下面那些是数组的合法声明：() A:int []a[]; B:char [] c; C:int [10] b; D:Student s[]; E:Student s1[10]; 答案：ABD.A能够理解为多维数组。