1.if(username.equals(‘zxx’)){}有什么不妥？
答：如果username为空的话,会报空指针错误.java.lang.NullPointerException
实际开发中应这么写: if(“zxx”.equals(username)){};这样就不会报错。
2.求2/1+3/2+5/3+8/4+12/5+17/6……前20项和？
1 package com.Test; 2 3 public class Test2 { 4 5 /** 6 * @param args 7 */ 8 public static void main(String[] args) { 9 // TODO Auto-generated method stub 10 System.out.println(fun(20)); 11 } 12 13 public static float fun(int num){ 14 float sum=0; 15 int j=2; 16 for(int i=1;i<=num;i++){ 17 j+=i-1; 18 sum+=(float)j/i; 19 } 20 return sum; 21 } 22 }
这道题笔试的时候，在No18行没有强转为float型，导致出来的结果不正确。
3.jvm的工作机制
答：Java语言的一个非常重要的特点就是与平台的无关性。而使用Java虚拟机是实现这一特点的关键。一般的高级语言如果要在不同的平台上运行,至少需要编译成不同的目标代码。而引入Java语言虚拟机后,Java语言在不同平台上运行时不需要重新编译。Java语言使用模式Java虚拟机屏蔽了与具体平台相关的信息,使得Java语言编译程序只需生成在Java虚拟机上运行的目标代码(字节码),就可以在多种平台上不加修改地运行。Java虚拟机在执行字节码时,把字节码解释成具体平台上的机器指令执行。
4：异常分为几种？有什么区别？
答：1，编译时异常:Java.lang.Exception，2，运行期异常:Java.lang.RuntimeException，3，错误:Java.lang.Error
编译时异常：程序正确，但因为外在的环境条件不满足引发。例如：用户错误及I/O问题----程序试图打开一个并不存在的远程Socket端口。这不是程序本身的逻辑 错误，而很可能是远程机器名字错误(用户拼写错误)。对商用软件系统，程序开发者必须考虑并处理这个问题。Java编译器强制要求处理这类异常，如果不捕 获这类异常，程序将不能被编译。
运行时异常：这意味着程序存在bug，如数组越界，0被除，入参不满足规范.....这类异常需要更改程序来避免，Java编译器强制要求处理这类异常。
错误：一般很少见，也很难通过程序解决。它可能源于程序的bug，但一般更可能源于环境问题，如内存耗尽。错误在程序中无须处理，而有运行环境处理
5：public class SomeThing(){
void SomeThing(){
private String s=null;
int l=s.length();
}
}
有什么错？
答：局部变量前不能放置任何修饰符（private，protected或public），final可以用来修饰局部变量。
6，今天2013/8/5 面试的一道上机题是这样的，一个整型数组arr[] ，存有若干整形数据，求各个数值出现的次数。
这道题用了大概20到30分钟，才写出下面的代码。
public static void fun(int[] arr){
int len=arr.length;
for(int i=0;i<len;i++)
for(int j=i;j<len;j++){
if(arr[i]>arr[j]){
int k=arr[j+1];
arr[j+1]=arr[j];
arr[j]=k;
}
}
int k=0;
int num=1;
while(k<len-1){
if(arr[k]==arr[k+1]){
num++;
}else{
System.out.println(arr[k]+"出现频率次数："+num);
num=1;
if(k==len-2){
System.out.println(arr[k+1]+"出现频率次数："+num);
}
}
k++;
}
}
后来回来上网查询，才发现我这样做是多么不入流。
网上有看到有如下做法，比较简单。
public static void fun1(int[] arr){
int num=arr.length;
int [] count=new int[10];
for(int i=0;i<num;i++){
count[arr[i]]++;
}
for(int j=0;j<count.length;j++){
if(count[j]!=0)
System.out.println(j+"出现频率："+count[j]);
}
}
7.父类子类构造方法的一个题目。
package Test; public class Test3 { /** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub Father f=new Child(); } } class Father { public Father() { System.out.println("Father无参数构造方法！"); /* 1 */ } public Father(int i) { System.out.println("Father有参数构造方法(参数类型int）！"); /* 2 */ } public Father(String s) { System.out.println("Father有参数构造方法（参数类型Stirng)"); /* 3 */ } } class Child extends Father { public Child() { super(1); System.out.println("child"); } }
原题大概是没有super(1);这条语句的运行结果！
结果是报错。
说明：如果没有1处的无参数构造方法，那么2或3处一定要在子类中主动调用父类带参数的构造方法，可以用super方法。
如果有1处的构造方法，那么super处代码可以不要，因为Java会自动默认调用父类的无参数构造方法。
8 一个数组存放了2n+1个整数，其中有n个数出现了2次，1个数出现了1次，找出出现1次的数是多少？
当时我没能想出来，后来回去后找到了解法：对数组A的所有元素做异或，即A[0]异或A[1]…… 异或A[2n]结果就是答案，理由：相同的数异或等于0，而0和任何数以后等于任何数，且异或运算可交换。
public static void main(String[] args) {
// TODO Auto-generated method stub
int num=0;
int[] array={1,2,2,5,1,11,12,11,5};
for(int i=0;i<array.length;i++){
num=array[i]^num;
}
System.out.println(num);
}
9.redirect， forward区别
forward方式：request.getRequestDispatcher("/somePage.jsp").forwardrequest, response);
redirect方式：response.sendRedirect("/somePage.jsp");
1.从地址栏显示来说
forward是服务器请求资源,服务器直接访问目标地址的URL,把那个URL的响应内容读取过来,然后把这些内容再发给浏览器.浏览器根本不知道服务器发送的内容从哪里来的,所以它的地址栏还是原来的地址.
redirect是服务端根据逻辑,发送一个状态码,告诉浏览器重新去请求那个地址.所以地址栏显示的是新的URL.
2.从数据共享来说
forward:转发页面和转发到的页面可以共享request里面的数据.
redirect:不能共享数据.
3.从运用地方来说
forward:一般用于用户登陆的时候,根据角色转发到相应的模块.
redirect:一般用于用户注销登陆时返回主页面和跳转到其它的网站等.
4.从效率来说
forward:高.
redirect:低.
10 选择排序,冒泡排序,插入排序,快速排序
public static void main(String[] args) { // TODO Auto-generated method stub int[] array = { 2, 4, 5, 1, 12, 9, 6 }; fun1(array); fun2(array); fun3(array); fun4(array, 0, 6); for (int i : array) { System.out.println(i); } } /* 选择排序 */ public static void fun1(int[] array) { int num = array.length; int temp; for (int i = 0; i < num - 1; i++) for (int j = i + 1; j < num; j++) { if (array[i] > array[j]) { temp = array[i]; array[i] = array[j]; array[j] = temp; } } for (int i : array) { System.out.println(i); } } /* 冒泡排序 */ public static void fun2(int[] array) { int num = array.length; int temp; for (int i = 0; i < num - 1; i++) for (int j = 0; j < num - i - 1; j++) { if (array[j] > array[j + 1]) { temp = array[j]; array[j] = array[j + 1]; array[j + 1] = temp; } } for (int i : array) { System.out.println(i); } } /* 插入排序 */ public static void fun3(int[] array) { int num = array.length; int temp; for (int i = 1; i < num; i++) { // 循环从第二个数组元素开始，因为arr[0]作为最初已排序部分 temp = array[i]; int j = i - 1; while (j >= 0 && array[j] > temp) {/* * 将temp与已排序元素从大到小比较，寻找temp应插入的位置 */ array[j + 1] = array[j]; j--; } array[j + 1] = temp; } for (int i : array) { System.out.println(i); } } /* 快速排序 */ static int partition(int[] array, int low, int high) { int temp = array[low]; while (low < high) { while (low < high && array[high] >= temp) { high--; } int t = array[low]; array[low] = array[high]; array[high] = t; while (low < high && array[low] <= temp) { low++; } int tt = array[low]; array[low] = array[high]; array[high] = tt; } return low; } static void fun4(int[] array, int low, int high) { if (low < high) { int n = partition(array, low, high); fun4(array, low, n); fun4(array, n + 1, high); } }
11.
public class Test {
public static void main(String[] args) {
A a=new B();
a.method();
}
}
class A{
public void method(){
System.out.println("a:aa");
}
}
class B extends A{
void method(){
System.out.println("b:bb");
}
}
结果是编译出错。
方法重写/覆写（Override）：他是是发生在继承关系之中，是由子类进行覆写的，并且方法名称相同，参数的类型或个数需相同，而重写方法的访问权限则不能太严格。
优点：能够定义子类中特有的特征
注意：访问修饰符的限制一定要大于被重写方法的访问修饰符即 （public>protected>default>private）
上列中类A中public去掉或类B中方法加修饰符public则编译正确
若类A中public改为private，在a.method()编译出错。因为private修饰的方法只能在本类内访问。