java面试

友迪资讯机试

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

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

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

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

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

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

某公司的几道面试题目！

Java语言: 临时自用代码@代码发芽网01 public 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语言 :  临时自用代码@代码发芽网 01 public 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语言 :  临时自用代码@代码发芽网 01 public class Test
02 {
03     static void oper(int b)
04     {
05         b = b + 100;
06     }
07     
08     public static 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语言 :  临时自用代码@代码发芽网 01 public 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
{
    public static 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语言 :  临时自用代码@代码发芽网 01 public class Test
02 {
03     static void oper(StringBuffer c,StringBuffer d)
04     {
05         d = c.append("B");
06     }
07     
08     public static 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 package org;
02 
03 public class Test
04 {
05 
06     public static void main(String[] args)
07     {
08         A a = new B();
09         a.print();
10     }
11 
12 }
13 
14 class A
15 {
16     private int i = 1;
17     public A()
18     {
19         int i = 2;
20     }
21     
22     public void print()
23     {
24         System.out.println("The result is:" + i);
25     }
26 }
27 
28 class B extends A
29 {
30     private int i = 3;
31     
32     public B()
33     {
34         int i = 6;
35     }
36     
37     public void print()
38     {
39         System.out.println("The result is:" + i);
40     }
41 }

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

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

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

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

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

 

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

内部类的实现方式:

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

总结:

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

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

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

 

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

01 public class Test2
02 {
03     public static 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 class Test2
2 {
3     public static void main(String[] args)
4     {
5         float a = 3.4;
6     }
7 
8 }

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

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

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

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

1 public Float(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      }

5

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")