java面试

来源：互联网发布：淘宝开店怎么装修店铺编辑：程序博客网时间：2024/06/05 15:08

友迪资讯机试

今天机试得出经验,就是eclipse和myeclipse的区别,实在是太大了

1.eclipse没有ssh所有的包,我们做题的时候都要自己去另外的项目去找,然后复制进去.

2.eclipse也没有很多视图比如databaseexplorer,因为MyEclipse只是一个优化简化eclipse,方便操作的工具,其实可以自己手打配置文件来达到MyEclipse的效果.

3.在new project的时候,eclipse比MyEclipse少了一个"MyEclipse子菜单",这个子菜单里面有Webproject,Enterprise application project,Web server project,EJBProject.也就是说eclipse中是不可能新建webproject的,唯有用插件,除了用myeclipse这个大功能的插件之外,应该还有其他的插件可以满足此个.今天看到的就是可以新建dynamicweb project 和static web project.

PS:这次机试大概就是要你熟悉SSH框架+AJAX+CSS+JSP罢了.内容是编一个简单的系统.

上面所说的dynamic webproject现在在eclipse3.6中可以完成1！

某公司的几道面试题目！

Java语言: 临时自用代码@代码发芽网01public class Jtest{
02 int m=1;
03 int i=3;
04 void Jtest(){
05 m=2;
06 i=4;
07 }
08 public static void main(String[] args){
09 Jtest app=new Jtest();
10 System.out.println(app.m+","+app.i);
11 }
12 }

写出输出.
结果是1,3;
因为在这里void Jtest();并没有并调用,它只是一个
方法,而非构造方法,这样的编写是有警告的,不过
可以运行.

Java语言: 临时自用代码@代码发芽网01public class Jtest{
02 int m=1;
03 int i=3;
04 Jtest(){
05 m=2;
06 i=4;
07 }
08 public static void main(String[] args){
09 Jtest app=new Jtest();
10 System.out.println(app.m+","+app.i);
11 }
12 }

写出输出:

结果是2,4;
调用了构造方法,不加修饰符,默认访问权限是
package access,在Java里没有关键字表示,就是
包内的能访问,包外就不行了(即使导入也不行).

Java语言: 临时自用代码@代码发芽网01public class Test
02 {
03     staticvoid oper(int b)
04    {
05       b = b + 100;
06    }
07
08     publicstatic void main(String[] args)
09    {
10       int a = 99;
11       oper(a);
12       System.out.println(a);
13    }
14
15 }

输出为99.
我们来分析一下内存:
int a = 99;
首先在栈里面开辟一块空间保存a
比如:a:xxxx
然后调用oper(a);
这时把a 的值99赋给int b;
b在内存里也开辟了自己的空间,此时
值也是99.
然后执行oper(a);方法体,b = b + 100;
此时b的值为199,a的值为99.

Java语言: 临时自用代码@代码发芽网01public class Test {
02 public static void main(String[] args) {
03       String a=new String("A");
04       String b=new String("B");
05       oper(a,b);
06       System.out.print(a+","+b);
07    }
08 static void oper(String c,String d){
09     c.concat("B");
10     d=c;
11 }
12 }

此程序输出:A和B.
原因就是String是final类型的.并不会被改变.
这个还是会输出A,B
原因同上.
package intervie;

public class Test
{
    publicstatic void main(String[] args)
    {
       String a = new String("A");
       String b = new String("B");
       a = a.concat("aa");
       System.out.println(a + "," + b);
    }

}

做了下改动,再来看看.结果就不同了.
输出的是Aaa,B
因为String 是final类型的.所以执行到
a = c.concat("aa");
会在heap里新创建一个对象,而a指向它.
这是一新的地址,同String a 这个已经不同了.
所以输出的是后一个.即改变后的值.

Java语言: 临时自用代码@代码发芽网01public class Test
02 {
03     staticvoid oper(StringBuffer c,StringBuffer d)
04    {
05       d = c.append("B");
06    }
07
08     publicstatic void main(String[] args)
09    {
10       StringBuffer a = new StringBuffer("A");
11       StringBuffer b = new StringBuffer("B");
12       oper(a, b);
13       System.out.println(a + "," + b);
14    }
15
16 }

此程序会输出:AB,B

StringBuffer是可变的线程安全的.
原试题下载地址:点此下载

上海群硕软件公司的一道Java笔试题

要求是写出结果，并说明为什么。
据回忆程序是这样的:

01 packageorg;
02
03 public classTest
04 {
05
06    publicstatic void main(String[] args)
07   {
08       A a = new B();
09       a.print();
10   }
11
12 }
13
14 classA
15 {
16    private inti = 1;
17    publicA()
18   {
19       int i = 2;
20   }
21
22    public voidprint()
23   {
24       System.out.println("The result is:" + i);
25   }
26 }
27
28 class B extendsA
29 {
30    private inti = 3;
31
32    publicB()
33   {
34       int i = 6;
35   }
36
37    public voidprint()
38   {
39       System.out.println("The result is:" + i);
40   }
41 }

输出结果是:3
此题考查的是多态.
在这里是父类的引用指向子类的对象.
父类的引用只能访问子类和父类共有的
方法.
这个程序我通过Eclipse和Debug程序观察它的
执行顺序是这样的:

01 packageorg;
02
03 public classTest
04 {
05
06    publicstatic void main(String[] args)
07   {
08       A a = new B();
09       a.print();
10   }
11
12 }
13
14 classA
15 {
16   //3
17    private inti = 1;
18   //2
19    publicA()
20   {
21       //4
22       int i = 2;
23   }
24
25    public voidprint()
26   {
27       System.out.println("The result is:" + i);
28   }
29 }
30
31 class B extendsA
32 {
33   //5
34    private inti = 3;
35   //1
36    publicB()
37   {
38       //6
39       int i = 6;
40   }
41
42    public voidprint()
43   {
44       System.out.println("The result is:" + i);
45   }
46 }

现在将程序稍微改动一下:

01 packageorg;
02
03 public classTest
04 {
05
06    publicstatic void main(String[] args)
07   {
08       A a = new B();
09       a.print();
10   }
11
12 }
13
14 classA
15 {
16   //3
17    private inti = 1;
18   //2
19    publicA()
20   {
21       //4
22       int i = 2;
23   }
24
25    public voidprint()
26   {
27       System.out.println("The result is:" + i);
28   }
29 }
30
31 class B extendsA
32 {
33   //5
34    private inti = 3;
35   //1
36    publicB()
37   {
38       //6
39       int i = 6;
40   }
41
42    public voidprint2()
43   {
44       System.out.println("The result is:" + i);
45   }
46 }

这时输出结果就是1了.
因为父类的引用无法访问子类独有的方法.

[转载] 2007最后一套JAVA面试题(内部类)

内部类的实现方式:

01 packagecom.test;
02
03 public classOuterClass
04 {
05    static int a;
06    int b;
07    privateclass InnerClass
08   {
09       public InnerClass()
10       {
11           System.out.println("InnerClass create:" + a);
12       }
13   }
14
15    publicOuterClass()
16   {
17       InnerClass ic = new InnerClass();
18       System.out.println("OuterClass create");
19   }
20
21    publicstatic void main(String[] args)
22   {
23       OuterClass oc = new OuterClass();
24   }
25 }

总结:

一.静态内部类可以有静态成员，而非静态内部类则不能有静态成员。

二.静态内部类的非静态成员可以访问外部类的静态变量，而不可访问外部类的非静态变量；

三.非静态内部类的非静态成员可以访问外部类的非静态变量

[转载] 2007年最后一套Java面试题解析(Float续)

01 public classTest2
02 {
03    publicstatic void main(String[] args)
04   {
05       Float a = new Float(3.4);
06       System.out.println(a.SIZE);
07       a = new Float(34000);
08       System.out.println(a.SIZE);
09   }
10
11 }

让我们来看看此程序会输出什么呢?
我们先来看看JDK的解释吧.

public static final int SIZE
The number of bits used to represent a float value.

意思是说:通常去描述一个float值的位数.
这个是一个常量,来看看源码吧:
public static final int SIZE = 32;

final int 变量一旦被定义就不能被改变~

[转载] 2007年最后一套Java面试题解析(Float)

1 public classTest2
2 {
3    publicstatic void main(String[] args)
4   {
5       float a = 3.4;
6   }
7
8 }

这个简单的程序能不能编译通过呢？
其实是不能的。
原因是精度问题，应该用强制类型转换.
float a = (float)3.4;

再来看看这个能不能编译通过

1 public classTest2
2 {
3    publicstatic void main(String[] args)
4   {
5       Float a = new Float(3.4);
6
7   }
8
9 }

其实是没问题的。
我们来看看Float类的源代码吧:

1 publicFloat(double value) {
2 this.value =(float)value;
3 }

其中有一个构造方法在方法里已经进行了向下转型。
所以这样写是没有问题的.

[转载] 两道Java面试题解析(String,equals(),==)

内容摘要：本文通过写出代码结果的方式向你解析了java面试中常面倒的几个知识点：string,equals(),==.

1.写出下面代码的结果

01 public class TestString{

02 public static void link(String a){

03 a += "World";

04 }

06 　　 public static void main(String[] args){

07 　　String a = "Hello";

08 　　link(a);

09 　　System.out.println(a);

10 　　 }

11 　}

答: 这道题考两个方面:

1).　String对象的内容是不能改变的,a+="World"并不是把a所指对象改变,

　　而是先生成一个临时String对象,其值为a+"World",然后在把这个临时

　　对象赋给a.

2).　Java中函数参数传递方式为Call by value,link方法中会生产a的一个

　　拷贝,同样指向a所指的对象,综合以上两点,得出结果为 Hello

2.写出下面代码的结果

System.out.println("ja"+"va" == "java");

答:"=="用来比较对象的引用,而equals()用来比较对象的内容,但是如果是字符串常量,用"=="也可以比较内容

是否相等,"ja"+"va"和"java"都是字符串常量,因此结果为true

同理,下面代码结果也是true

final String str = "java";

System.out.println(str=="java")