4月26日用友面试题__全解析
1、下面哪些是Thread类的方法（）
A start() B run() C exit() D toString()答案：ABD
解析：看Java API docs吧：http://docs.oracle.com/javase/7/docs/api/，exit()是System类的方法，如System.exit(0)。
2、下面关于java.lang.Exception类的说法正确的是（）
A 继承自Throwable B Serialable C 以上说法都不对答案：A
解析： Java异常的基类为java.lang.Throwable，java.lang.Error和java.lang.Exception继承 Throwable，RuntimeException和其它的Exception等继承Exception，具体的RuntimeException继承RuntimeException。
3、下面程序的运行结果是（）
String str1 = "hello";
String str2 = "he" + new String("llo");
System.err.println(str1 == str2);答案：false
解析： 因为str2中的llo是新申请的内存块，而==判断的是对象的地址而非值，所以不一样。
如果是String str2 = str1，那么就是true了。
4、下面程序的运行结果：（）
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
解析： 这里考的是Thread类中start()和run()方法的区别了。start()用来启动一个线程，当调用start方法后，系统才会开启一个新的线程，进而调用run()方法来执行任务，而单独的调用run()就跟调用普通方法是一样的，已经失去线程的特性了。因此在启动一个线程的时候一定要使用start()而不是run()。
扩展：这里如果是.start()，输出的就是A pingpong了，原因在于每个 Java 程序都至少有一个线程 —主线程。当一个 Java 程序启动时，JVM 会创建主线程，并在该线程中调用程序的 main() 方法。在主线程挂起的时候，Thread线程才开始运行。所以，如果是start()，结果会是pingpong。
5、数据库表A有两行数据(A,1)，(B,2)，数据库表B有两行数据(A,1)，(B,4），10分
1）SELECT * FROM A UNION SELECT * FROM B 的结果集？
答：(A,1),(B,2),(B,4)
2)SELECT * FROM A UNION ALL SELECT * FROM B 的结果集？
答：(A,1),(B,2),（A，1），(B,4)效率：
UNION和UNION ALL关键字都是将两个结果集合并为一个，但这两者从使用和效率上来说都有所不同。
1、对重复结果的处理：UNION在进行表链接后会筛选掉重复的记录，Union All不会去除重复记录。
2、对排序的处理：Union将会按照字段的顺序进行排序；UNION ALL只是简单的将两个结果合并后就返回。
从效率上说，UNION ALL 要比UNION快很多，所以，如果可以确认合并的两个结果集中不包含重复数据且不需要排序时的话，那么就使用UNION ALL。
6、下列属于关系型数据库的是（）
A. Oracle B MySql C IMS D MongoDB答案：AB
解析： IMS（Information Management System ）数据库是IBM公司开发的两种数据库类型之一;
一种是关系数据库，典型代表产品：DB2；
另一种则是层次数据库，代表产品：IMS层次数据库。
非关系型数据库有MongoDB、memcachedb、Redis等。
7、Javascript “1”==1和”1”===1的结果分别是什么（）
A false false B true true C true false D false true答案：C
解析： 在javascript里，”==”与”===”是不同的,一个是判断值是否相等,一个是判断值及类型是否完全相等。
对于string，number等基本类型而言，
1）不同类型间比较，==之比较“转化成同一类型后的值”看“值”是否相等，===如果类型不同，其结果就是不等
2）同类型比较，直接进行“值”比较，两者结果一样
8、存在使i + 1 < i的数吗（）
答案：存在
解析： 如果i是int的最大值，那么i+1就会溢出位整型的最小值，小于号就成立了。
9、0.6332的数据类型是（）
A float B double C Float D Double答案：B
解析： 小数的默认类型为double型，如果为float型，要加上f显示说明，即0.6332f
10、下面哪个流类属于面向字符的输入流( )
A BufferedWriter B FileInputStream C ObjectInputStream
D InputStreamReader答案：D
解析： Java的IO操作中有面向字节(Byte)和面向字符(Character)两种方式。
面向字节的操作为以8位为单位对二进制的数据进行操作，对数据不进行转换，这些类都是InputStream和OutputStream的子类。
面向字符的操作为以字符为单位对数据进行操作，在读的时候将二进制数据转为字符，在写的时候将字符转为二进制数据，这些类都是Reader和Writer的子类。
总结：以InputStream（输入）/OutputStream（输出）为后缀的是字节流；
以Reader（输入）/Writer（输出）为后缀的是字符流。
扩展：Java流类图结构，一目了然，解决大多数选择题。
11、System.out.println(“5” + 2);的输出结果应该是（）。
A 52 B 7 C 2 D 5答案：A
解析： Java会自动将2转换为字符串。
12 、指出下列程序运行的结果 （）
public class Example {
String str = new String("good");
char[] ch = { 'a', 'b', 'c' };
public static void main(String args[]) {
Example ex = new Example();
ex.change(ex.str, ex.ch);
System.out.print(ex.str + " and ");
System.out.print(ex.ch);
}
public void change(String str, char ch[]) {
str = "test ok";
ch[0] = 'g';
}
}
A、 good and abc
B、 good and gbc
C、 test ok and abc
D、 test ok and gbc 答案：B
解析： 大家可能以为Java中String和数组都是对象所以肯定是对象引用，然后就会选D，其实这是个很大的误区：因为在java里没有引用传递，只有值传递。这个值指的是实参的地址的拷贝，得到这个拷贝地址后，你可以通过它修改这个地址的内容（引用不变），因为此时这个内容的地址和原地址是同一地址，
但是你不能改变这个地址本身使其重新引用其它的对象，也就是值传递，可能说的不是很清楚，下面给出一个完整的能说明情况的例子吧：
package test;
/**
* @description Java中没有引用传递只有值传递
*
* @author Moy
* @date 2016-4-26
*
*/
class Person {
private String name;
private String sex;
public Person(String x, String y) {
this.name = x;
this.sex = y;
}
// 重写toString()方法，方便输出
public String toString() {
return name + " " + sex;
}
// 交换对象引用
public static void swapObject(Person p1, Person p2) {
Person tmp = p1;
p1 = p2;
p2 = tmp;
}
// 交换基本类型
public static void swapInt(int a, int b) {
int tmp = a;
a = b;
b = tmp;
}
// 交换对象数组
public static void swapObjectArray(Person[] p1, Person[] p2) {
Person[] tmp = p1;
p1 = p2;
p2 = tmp;
}
// 交换基本类型数组
public static void swapIntArray(int[] x, int[] y) {
int[] tmp = x;
x = y;
y = tmp;
}
// 改变对象数组中的内容
public static void changeObjectArray(Person[] p1, Person[] p2) {
Person tmp = p1[1];
p1[1] = p2[1];
p2[1] = tmp;
// 再将p1[1]修改
Person p = new Person("wjl", "male");
p1[1] = p;
}
// 改变基本类型数组中的内容
public static void changeIntArray(int[] x, int[] y) {
int tmp = x[1];
x[1] = y[1];
y[1] = tmp;
x[1] = 5;
}
}
public class ByValueTest {
public static void main(String[] args) {
// 建立并构造两个对象
Person p1 = new Person("Alexia", "female");
Person p2 = new Person("Edward", "male");
System.out.println("对象交换前：p1 = " + p1.toString());
System.out.println("对象交换前：p2 = " + p2.toString());
// 交换p1对象和p2对象
Person.swapObject(p1, p2);
// 从交换结果中看出，实际对象并未交换
System.out.println("\n对象交换后：p1 = " + p1.toString());
System.out.println("对象交换后：p2 = " + p2.toString());
// 建立两个对象数组
Person[] arraya = new Person[2];
Person[] arrayb = new Person[2];
// 分别构造数组对象
arraya[0] = new Person("Alexia", "female");
arraya[1] = new Person("Edward", "male");
arrayb[0] = new Person("jmwang", "female");
arrayb[1] = new Person("hwu", "male");
System.out.println('\n' + "对象数组交换前：arraya[0] = "
+ arraya[0].toString() + ", arraya[1] = "
+ arraya[1].toString());
System.out.println("对象数组交换前：arrayb[0] = "
+ arrayb[0].toString() + ", arrayb[1] = "
+ arrayb[1].toString());
// 交换这两个对象数组
Person.swapObjectArray(arraya, arrayb);
System.out.println('\n' + "对象数组交换后：arraya[0] = "
+ arraya[0].toString() + ", arraya[1] = "
+ arraya[1].toString());
System.out.println("对象数组交换后：arrayb[0] = "
+ arrayb[0].toString() + ", arrayb[1] = "
+ arrayb[1].toString());
// 建立两个普通数组
int[] a = new int[2];
int[] b = new int[2];
// 给数组个元素赋值
for (int i = 0; i < a.length; i++) {
a[i] = i;
b[i] = i + 1;
}
System.out.println('\n' + "基本类型数组交换前：a[0] = " + a[0] + ", a[1] = " + a[1]);
System.out.println("基本类型数组交换前：b[0] = " + b[0] + ", b[1] = " + b[1]);
// 交换两个基本类型数组
Person.swapIntArray(a, b);
System.out.println('\n' + "基本类型数组交换后：a[0] = " + a[0] + ", a[1] = " + a[1]);
System.out.println("基本类型数组交换后：b[0] = " + b[0] + ", b[1] = " + b[1]);
// 改变对象数组的内容
Person.changeObjectArray(arraya, arrayb);
System.out.println('\n' + "对象数组内容交换并改变后：arraya[1] = " + arraya[1].toString());
System.out.println("对象数组内容交换并改变后：arrayb[1] = " + arrayb[1].toString());
// 改变基本类型数组的内容
Person.changeIntArray(a, b);
System.out.println('\n' + "基本类型数组内容交换并改变后：a[1] = " + a[1]);
System.out.println("基本类型数组内容交换并改变后：b[1] = " + b[1]);
}
}程序有些啰嗦，但能反映问题，该程序运行结果为：
对象交换前：p1 = Alexia female
对象交换前：p2 = Edward male
对象交换后：p1 = Alexia female
对象交换后：p2 = Edward male
对象数组交换前：arraya[0] = Alexia female, arraya[1] = Edward male
对象数组交换前：arrayb[0] = jmwang female, arrayb[1] = hwu male
对象数组交换后：arraya[0] = Alexia female, arraya[1] = Edward male
对象数组交换后：arrayb[0] = jmwang female, arrayb[1] = hwu male
基本类型数组交换前：a[0] = 0, a[1] = 1
基本类型数组交换前：b[0] = 1, b[1] = 2
基本类型数组交换后：a[0] = 0, a[1] = 1
基本类型数组交换后：b[0] = 1, b[1] = 2
对象数组内容交换并改变后：arraya[1] = wjl male
对象数组内容交换并改变后：arrayb[1] = Edward male
基本类型数组内容交换并改变后：a[1] = 5
基本类型数组内容交换并改变后：b[1] = 1说明：不管是对象、基本类型还是对象数组、基本类型数组，在函数中都不能改变其实际地址但能改变其中的内容。
13、下列哪种异常是检查型异常，需要在编写程序时声明 （）
A、NullPointerException B、ClassCastException
C、FileNotFoundException D、IndexOutOfBoundsException 答案：C
解析： Error和RuntimeException 及其子类都是未检查的异常（unchecked exceptions），而所有其他的Exception类都是检查了的异常（checked exceptions）.
checked exceptions: 通常是从一个可以恢复的程序中抛出来的，并且最好能够从这种异常中使用程序恢复。比如FileNotFoundException, ParseException等。检查了的异常发生在编译阶段，必须要使用try…catch（或者throws）否则编译不通过。
unchecked exceptions: 通常是如果一切正常的话本不该发生的异常，但是的确发生了。发生在运行期，具有不确定性，主要是由于程序的逻辑问题所引起的。比如ArrayIndexOutOfBoundException, ClassCastException等。从语言本身的角度讲，程序不该去catch这类异常，虽然能够从诸如RuntimeException这样的异常中catch并恢复，但是并不鼓励终端程序员这么做，因为完全没要必要。因为这类错误本身就是bug，应该被修复，出现此类错误时程序就应该立即停止执行。 因此，面对Errors和unchecked exceptions应该让程序自动终止执行，程序员不该做诸如try/catch这样的事情，而是应该查明原因，修改代码逻辑。
RuntimeException：RuntimeException体系包括错误的类型转换、数组越界访问（IndexOutOfBoundsException ）和试图访问空指针等等。
处理RuntimeException的原则是：如果出现 RuntimeException，那么一定是程序员的错误。例如，可以通过检查数组下标和数组边界来避免数组越界访问异常。其他（IOException等等）checked异常一般是外部错误，例如试图从文件尾后读取数据等，这并不是程序本身的错误，而是在应用环境中出现的外部错误。
14、下面的方法，当输入为2的时候返回值是多少?（）
public static int getValue(int i) {
int result = 0;
switch (i) {
case 1:
result = result + i;
case 2:
result = result + i * 2;
case 3:
result = result + i * 3;
}
return result;
}
A 0 B 2 C 4 D 10答案：D
解析： 注意这里case后面没有加break，所以从case 2开始一直往下运行。
result = 2*2+2*3=10。
15、选项中哪一行代码可以替换题目中//add code here而不产生编译错误？（）
public abstract class MyClass {
public int constInt = 5;
//add code here
public void method() {
}
}
A public abstract void method(int a);
B constInt = constInt + 5;
C public int method();
D public abstract void anotherMethod() {}答案：A
解析： 考察抽象类的使用。
抽象类遵循的原则：
（1）abstract关键字只能修饰类和方法，不能修饰字段。
（2）抽象类不能被实例化（无法使用new关键字创建对象实例），只能被继承。
（3）抽象类可以包含属性，方法，构造方法，初始化块，内部类，枚举类，和普通类一样，普通方法一定要实现，变量可以初始化或不初始化但不能初始化后在抽象类中重新赋值或操作该变量（只能在子类中改变该变量）。 B错
（4）抽象类中的抽象方法（加了abstract关键字的方法）不能实现。 D错
（5）含有抽象方法的类必须定义成抽象类。
C错 的原因是跟已经存在的相同方法名和参数列表的方法产生了冲突。
附加题
一个面试题 oracle:学生表s（sno、sname)，课程表c（cno、cname,cteacher）选课表sc（sno、cno、score）
问题：
1、找出没有选过“老师2”所有学生的姓名
2、列出2门以上（含2门）不及格学生姓名以及对应科目名称、成绩
3、学过1号又学过2号课程的所有学生姓名
用SQL语句作答。
1、找出没有选过“老师2"所有学生的姓名
SELECT * FROM s
WHERE s.sno NOT IN(SELECT sno FROM c,sc WHERE c.cno=sc.cno AND c.cteacher='老师2')2、列出2门以上（含2门）不及格学生姓名以及对应科目名称、成绩
SELECT (SELECT sname FROM s WHERE s.sno=main.sno),AVG(sc.score)
FROM s main,sc
WHERE main.sno=sc.sno
AND main.sno IN(SELECT s1.sno FROM s s1,sc sc1 WHERE s1.sno=sc1.sno AND sc1.score<60
GROUP BY s1.sno HAVING COUNT(s1.sno)>=2)
GROUP BY main.sno3、学过1号又学过2号课程的所有学生姓名
SELECT s.sname FROM s,sc
WHERE s.sno=sc.sno
AND sc.cno='001' AND exists( SELECT * FROM sc AS sc_2 WHERE sc_2.sno=sc.sno AND sc_2.cno='002');