几道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是没有机会
被调用的.