J2SE几道选择填空题

我的博客：http://blog.csdn.net/wzwdcld 转载请注明出处

 

Comparable接口的作用

之前Arrays类中存在sort()方法，此方法可以直接对对象数组进行排序。

  

Comparable接口

可以直接使用java.util.Arrays类进行数组的排序操作，但对象所在的类必须实现Comparable接口，用于指定排序接口。

Comparable接口的定义如下：

public  interface  Comparable<T>{

        public  int compareTo(T  o);

}

此方法返回一个int类型的数据，但是此int的值只能是一下三种：

1：表示大于

-1：表示小于

0：表示相等

  

另一种比较器：Compartor

如果一个类已经开放完成，但是在此类建立的初期并没有实现Comparable接口，此时肯定是无法进行对象排序操作的，所以为了解决这一的问题，java又定义了另一个比较器的操作接口 Comparator 此接口定义在java.util包中，接口定义如下：

public  interface  Comparator<T>{

                 public  int  compare(T o1，T o2);

                 boolean  equals(Object  obj);

}
 
public class MyComparator implements Comparator<Student> {  //实现比较器  
 
    @Override 
    public int compare(Student stu1, Student stu2) { 
        // TODO Auto-generated method stub  
        if(stu1.getAge()>stu2.getAge()){ 
            return 1; 
        }else if(stu1.getAge()<stu2.getAge()){ 
            return -1; 
        }else{ 
            return 0; 
        } 
    } 
 
} 

static <T> void

sort(List<T> list, Comparator<? super T> c)            Sorts the specified list according to the order induced by the specified comparator.

 

 

 

1. public class TestTryAndTry {
   public static void main(String args[]){
   System.out.println(ma());
   }
   public static int ma(){
   try{
   return 100;
   }finally{
   try{
   return 200;
   }finally{
   return 500;
   }
   return 1000;
   }
   }
   }
   选择正确答案：
   A. 编译错误
   B. 输出100
   C. 输出200
   D. 输出500
   E. 输出1000

    

   答案是编译错误，去掉return 1000，就是输出500

2. public class Something {
   void doSomething () {
   private String s = "";
   int l = s.length();
   }
   }
   有错吗?
   答案: 错。局部变量前不能放置任何访问修饰符 (private，public，和protected)。final可以用来修饰局部变量
   (final如同abstract和strictfp，都是非访问修饰符，strictfp只能修饰class和method而非variable)

   指出下列类型转换中正确的是______________。（A）

   A）int i='A' B）long L=8.4f C）int i=(boolean)8.9 D)int i=8.3

   B和D都是向下转换

   class MyClass {
   int a;
   static int b;
   void fa(){}
   static void fb(){}
   public void m1(){
   System.out.println(a); //1
   System.out.println(b); //2
   fa(); //3
   fb(); //4
   }
   public static void m2(){
   System.out.println(a); //5
   System.out.println(b); //6
   fa(); //7
   fb(); //8
   }
   }
   请问哪些行会编译出错？
   A. //1
   B. //2
   C. //3
   D. //4
   E. //5
   F. //6
   G. //7
   H. //8

    

   5和7 是错的，静态方法不能调用非静态方法和变量。

    

   【重要】

   interface IA {
   void m1();
   public void m2();
   public abstract void m3();
   }
   abstract class Super{}
   class Sub1 extends Super{}
   class Sub2 extends Super{}
   public class TestInterface{
   public static void main(String args[]){
   Super sup = new Sub1();
   Sub1 sub1 = (Sub1)sup;
   //1
   }
   }
   在//1 处可以编译（不考虑运行时是否会产生异常）通过的代码为：
   A． Sub2 sub2 = (Sub2) sup;
   B． Sub2 sub2 = (Sub2) sub1;
   C． IA ia = (IA) sup;
   D． IA ia = (IA) sub1;

   答案：A

    

   package com.sumiplus.example;

    

   public class ABCD {

    

       /**

        * @param args

        */

       static class A {

           public void N() {

               System.out.print("A");

           }

       }

    

       static class B extends A {

           public void N() {

               System.out.print("B");

           }

       }

    

       static class C extends B {

           public static void N2() {

               System.out.print("C");

           }

       }

    

        static class D extends C {

           public static void N2() {

               System.out.print("D");

           }

       }

    

       public static void main(String[] args) {

           // TODO Auto-generated method stub

           D d = new D();

           C c = d;

           B b = c;

           A a = b;

           d.N2();

           c.N2();

           b.N();

           a.N();

    

       }

    

   }

   答案：DCBB

    

   字符串取长是.length() 数组为.length

    

    

   String s = new String("ABC")创建了几个对象？http://blog.csdn.net/lubiaopan/article/details/4774044

   short s1 = 1; s1 = s1 + 1;有什么错? short s1 = 1; s1 += 1;有什么错
   答：short s1 = 1; s1 = s1 + 1; （s1+1运算结果是int型，向下转换需要强制转换类型）

   short s1 = 1; s1 += 1;（可以正确编译）

    

   String类是final类故不可以继承

   在下列供选的代码中，不能作为Java整型常量的是

   A.

   A.038 B. 0x3ACC C. 065 D. 0x3BCA

    

   publicclass MyClass {

       intx = 10;

       publicstaticvoid main(String args[ ]){

           for(intn = 3; n > 0; n--){

               x = x*x;

               }

           System.out.println(x);

           } }

   A. 1000 B. 1000000 C. 100000000 D. 编译错误

   ①char c1 = '1';

   ②char c2 = '2';

   ③char c3 = '1'+'2';

   ④char c4 = c1+c2;

   ⑤char c5 = (char)(c1+c2);

   下列说法正确的是：

   A：①②③④⑤编译、运行都不会出错

   B：①②③⑤编译、运行都不会出错；④编译出错

   C：①②⑤编译、运行都不会出错；③④编译出错

   D：①②③⑤编译、运行都不会出错；④编译不会出错，但运行会出错

   答案：B。'1'+'2'是在编译期间就可以确定的常量，所以能够确定是哪个char，从而自动转换为char。但是c1 + c2在编译期间确定不了它的值，只能在运行期间确定，所以需要强制转换，如果不强制转换，编译器就认为语句是错的。