JAVA经典习题集

  1,下面程序的运行结果是_12_
public class J_test {
 public static void main(String[] args) {
        int i = 0;             
        while (true) {        
         if(i++ > 10){
          break;
         }              //i++的考查,在右边时是先执行，再加1
 }
        System.out.println(i);
 }
}
  2,下面程序的运行结果是_11_
public class J_test {
 public static void main(String[] args) {
        int i = 0;             
        while (true) {        
         if(++i > 10){
          break;     
         }              //++i的考查,在右边时是先加1，再执行
 }
        System.out.println(i);
 }
}
  3,请写出下面程序的输出结果_4_
public class J_test {         //i++的考查,在右边时是先执行，再加1
 public static void main(String[] args) {
          int a = 1,b = 2;
          if((a == 0) & (++b == 6)){
          a = 100;
          }                    //逻辑与的考查,即使&前面的值为false,也会执行&后面的语句
          System.out.println(a+b);
 }
}
  4,请写出下面程序的输出结果_3_
public class J_test {      //i++的考查,在右边时是先执行，再加1
 public static void main(String[] args) {
          int a = 1,b = 2;
          if((a == 0) && (++b == 6)){
          a = 100;
          }                       //逻辑短路与的考查,只要&&前面的值为false
          System.out.println(a+b);   //就不会执行&后面的语句
 }
}
  5,请写出下面程序的输出结果_18_
public class J_test {
 public static void main(String[] args) {
        int sum = 0;
        outer:
            for (int i = 0; i < 100; i++) {
  inner:
     for (int j = 0; j < 3; j++) {
    sum += j;
    if(i+j > 6){
    break outer;      //表示跳出外部循环,首先i的取值有[0-5]
           }                 //这6个数字,内部每循环以此,sum便加上3
     }                       //共加了6次,所以最终结果为18
     }
        System.out.println(sum);
 }
}
  6,下面那些语句不会出现编译警告或错误_CGHIJ_
      A:float f = 1.3;     B:char c = "a";            //只能为单引号, float值后需加f
      C:byte b = 25;       D:boolean d = null;  //boolean为基本类型,不能为null
      E:char a = 'abc';    F:byte b = 1234;
      G:long c = 0x123;    H:double = 1e-3f;
      I:float c = 2e1f;    J:float d = 0x1234;

  7,下面那些结论是正确的_B_
public class J_test {
      public static void main(String[] args) {
       int a,b,c;
       a = 1;
       b = 2;
       c = (a+b>3?a++:++b);
       System.out.println("a="+a+",b="+b+",c="+c);
      }
}
    A.a = 2,b = 3;B.a = 1,b = 3;
    C.a = 1,b = 2;D.c为false;
  8,可以用作switch表达式的基本数据类型是_ABCD_
    A.char; B.byte; C.short; D.int; E.long;
  9.针对下面的程序,那些结论是正确的_B_
public class J_test {
 public static void main(String[] args) {
         byte b = 1;
         while (++b > 1)
          ;            //根据byte的取值范围,当++B=128时while循环结束
         System.out.println("loop?");
 }
}
    A.运行程序将会进入死循环,从而导致什么都部输出
    B.每运行一次程序,则输出一次loop?并退出
    C.每运行一次程序,会输出多次loop?
    D.程序红含有编译错误

  10.判断正误:错：因为在类只能由成员变量的定义和方法的定义两部分组成
public class J_test {
 static int m_data;
 m_data = 3;
      public static void main(String[] args) {
        System.out.println(m_data);
      }
}
  11.判断正误:错：没有重定义子类的构造方法,子类的构造方法的第一条语句隐含的调用父类的不带参数的构造方法
class J_Rock{
 public J_Rock(int i) {
   System.out.println("create Rock"+i);
 }
}
public class J_subRock extends J_Rock{
 public static void main(String[] args) {
           new J_Rock(2);
 }
}
  12.请写出下列程序的输出结果_Test_
class J_Base{
    public void mb_method(){
     System.out.println("Base");
    }
}             //这是父类的引用指向子类的实例,在调用方法时:若父类子类都有就调用子类的，若父类有子类没有就调用父类的,若父类没有而子类有则出错
public class J_test extends J_Base{
    public void mb_method(){
     System.out.println("Test");
    } 
 public static void main(String[] args) {
         Object o = new J_test();
         ((J_Base)o).mb_method();
 }
}
  13.下面程序输是:  J_test::mb_method,J_Superclass::mb_methodstatic,
                                    J_test::mb_method,J_test::mb_methodstatic
class J_Superclass{
    void mb_method(){
     System.out.println("J_Superclass::mb_method");
    }
    static void mb_methodstatic(){
     System.out.println("J_Superclass::mb_methodstatic");
    }
}
public class J_test extends J_Superclass{
      void mb_method(){
       System.out.println("J_test::mb_method");
      } 
      static void mb_methodstatic(){
       System.out.println("J_test::mb_methodstatic");
      }
 public static void main(String[] args) {
          J_Superclass a = new J_test();  //这是属于父类的引用指向子类的实例情况
          a.mb_method();                            //打印J_test::mb_method,因该方法被覆盖了
          a.mb_methodstatic();                   //打印J_Superclass::mb_methodstatic,因该方法                                                             //是static的,属于类本身,不被覆盖
          J_test b = new J_test();
          b.mb_method();
          b.mb_methodstatic();
 }
}
   14.下列程序输出的结果是:_18_
class J_Superclass{
    int m_data;
    J_Superclass() {
 mb_add(1);     //在执行这个mb_add(1)时,是子类的引用调用的,所以将执行子类重写的mb_add()方法,此时变量
    }                     //m_data的值是2,在执行子类构造方法中的m_add(2)方法,
    public void mb_add(int i){
     m_data += i;
    }
    public void mb_print(){
     System.out.println(m_data);
    }
}
class J_Subclass extends J_Superclass{
 J_Subclass() {
     mb_add(2);  //该方法不用说肯定是调用自己类中的mb_add()方法,所以此时m_data的值

                           //变为6,到这才只是程序执行的开始,即刚刚才执行完new J_Subclass()这一步,
 }                         //接下来才开始执行mb_method(new J_Subclass())
 public void mb_add(int i){
     m_data += i*2;
 }
}
public class J_test extends J_Superclass{
        public static void mb_method(J_Superclass a){
        a.mb_add(6);       //这是父类J_Superclass的引用指向子类的实例,所以毫无疑问,变量a肯定是调用子类的
        a.mb_print();      //mb_add()方法,最后程序执行mb_print()方法,这是执行父类中的方法,所以程序最终输出18
        }
 public static void main(String[] args) {
           mb_method(new J_Subclass()); //程序出发点,在执行构造方法J_Subclass()时,先执行父类的构造方法
 }
}
   15.下面程序输出的是_4_
public class J_test{
    static int m_data = 0;
    public int mb_method(){
     m_data++;
     return m_data;
    }
            //static变量的考查,属于所有类共享的变量,所以最终结果是4
            //若去掉static,则由面向对象变成封装性的特性,可知结果是2
    public static void main(String[] args) {
         J_test a = new J_test();
         J_test b = new J_test();
         J_test c = new J_test();
         a.mb_method();
         b.mb_method();
         c.mb_method();
         int i = a.mb_method();
         System.out.println(i);
    }
}