Java笔试题【转】

1.写出程序运行结果

  

public class TestString {

    public static void link(String a){
         a+="World" ;
    }
    public static void main(String []args){
         String a = "Hello" ;
         link(a);
         System.out.println(a);
    }
}

答: 这道题考两个方面:

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

 

3.继承时候类的执行顺序问题,一般都是选择题,问你将会打印出什么?

public class Parent {
    //1
    static int a = 1;
    //2
    static   
    {
       a=10;
       System.out.println("parent static code" );
    }
    //4
    public Parent(){
      System.out.println("Parent constructor" );
      System.out.println("Parent a =" +a);
    }
    public static void main(String []args){
      System.out.println("*****************" );
      Parent c = new Child();
    }  
}

public class Child extends Parent{
  
    static int a = 2;
    //3
    static {
      a=20;
      System.out.println("child static code" );
    }
    public Child(){
      System.out.println("Child constructor" );
      System.out.println("Child var a=" +a);
    }
}

输出结果:

parent static code
*****************
child static code
Parent constructor
Parent a =10
Child constructor
Child var a=20

由此可看出在还没有实例化类的时候(注意*号)已经执行了static代码块。顺序是先父类后子类.然后才调用父类的构造方法,再调用子类的构造方法.就是这个顺序了.

4.内部类的实现方式:

public class OuterClass {

    static int a;
    int b;
    private class InnerClass{
     public InnerClass(){
      System.out.println("InnerClass create:" +a);
     } 
  }
    public OuterClass(){
       InnerClass ic = new InnerClass();
       System.out.println("OuterClass create" );
    }
    public static void main(String []args){
        OuterClass oc = new OuterClass();
    }
}

总结：

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

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

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

 

5. Float类型

public class TestFloat {
  
    public static void main(String []args){
    Float a = new Float(3.4);
    System.out.println(a.SIZE);
    a = new Float(34000);
    System.out.println(a.SIZE);
    }
}

让我们来看看此程序会输出什么呢?
我们先来看看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 变量一旦被定义就不能被改变~

 

第二个Float类型题：

public   class  Test2
{
     public   static   void  main(String[] args)
     {
         float  a  =   3.4 ;
    }

}

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

float  a  =  ( float ) 3.4 ;

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

public   class  Test2
{
     public   static   void  main(String[] args)
     {
        Float a  =   new  Float( 3.4 );
        
    }

}

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

   public  Float( double  value)  {
     this .value  =  ( float )value;
    }

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

 

6.选出用法错误的:

a: Stirng a  = " Gone With Wind " ; 
String t =   " Wind " ; 
String m; 
m = a - t; 
B: Stirng a  = " Gone With Wind " ; 
String m ; 
m = a[ 3 ] + " one " ; 
C: Stirng a  = " Gone With Wind " ; 
Sting m; 
m = a.toUpperCase(); 
D: 不记得了 

7.此程序会输出什么?

public class A {
   //3
    public A(){
       a1();
    }
    public void a1(){
      System.out.println("A-a1" );
    }
}

public class B extends A{

    int bb = 0;
    //2
    public B(){
    //5
  bb=1000;
    }
    //4
    public void a1(){
  System.out.println("bb is" +bb);
  System.out.println("B-a1" );
    }
    public static void main(String []args){
  new B();
    }
}

答案:
bb is 0
B-a1
看看执行顺序就明白了.
在方法被a1()被重写的情况下,父类的a1是没有机会
被调用的.