java 基础选择题--3

Java面向对象试题

1) 在Java中，如果父类中的某些方法不包含任何逻辑，并且需要有子类重写，应该使用（ ）关键字来申明父类的这些方法。(选择一项)

  a) Final

 b) Static

 c) Abstract

 d) Void

2) 给定两个java程序，如下：

public interface Face{
  int counter = 40;    //40
    }
    public class Test implements Face{
  private static int counter;  // 0
  public static void main(String[  ]args){
      System.out.println(++counter);    +1=1
        }
    }

 Test.java 的编译运行结果是（ ）。(选择一项)

 a) 40

 b) 41

 c) 0

 d) 1

3) 给定java代码，如下：

给定java代码,如下:

public class Test{

static int i=0;

public int aMethod( ){

i++;

return i;

}

public static void main(String [] args){

Test test = new Test( );

test.aMethod( ); // i=1

System.out.println(test.aMethod( )); //i=2

}

 }编译运行后，输出结果是（ ）。(选择一项)

 a) 0

 b) 1

 c) 2

 d) 3

在给出的Java代码中，Test 类有一个静态变量 i 初始化为0，以及一个非静态方法 aMethod()。aMethod() 每次被调用时都会将 i 的值增加1，并返回新的值。

在 main 方法中，首先创建了一个 Test 类的实例 test，然后调用了两次 aMethod() 方法，但只打印了第二次调用的结果。

当 Test test = new Test(); 执行时，i 已经是0（因为静态变量在类加载时初始化）。
接着调用 test.aMethod();，由于 aMethod() 是非静态的，它可以通过实例 test 被调用。这个方法将 i 的值从0增加到1，但不返回任何值（尽管它实际上返回了一个值，但在这里没有被使用）。
然后调用 System.out.println(test.aMethod());，这次 aMethod() 再次被调用，它将 i 的值从1增加到2，并返回这个新值2。System.out.println() 打印出这个返回值。

因此，编译运行后的输出结果是 2
 

4) 给定java代码，如下：

    abstract class Shape

    {

  abstract void draw( );

    }

 要创建Shape类的子类Circle，以下代码正确的是（ ）。(选择二项)

 a) class Circle extends Shape{

   int draw( ){}

     }

 b) abstract class Circle extends Shape{

     }

 c) class Circle extends Shape{

   void draw( );

 d) class Circle extends Shape{

   void draw( ){}

}

在给定的Java代码中，Shape 是一个抽象类，它有一个抽象方法 draw()。要创建一个 Shape 类的子类 Circle，这个子类必须提供 draw() 方法的具体实现，除非它也声明为抽象类。

现在，我们逐一分析给出的选项：

a) class Circle extends Shape{ int draw( ){} }
这个选项是不正确的，因为 draw() 方法在 Shape 类中被声明为返回类型为 void，但在 Circle 类中被错误地声明为返回类型为 int。

b) abstract class Circle extends Shape{ }
这个选项是部分正确的，因为你可以创建一个抽象子类而不实现父类的所有抽象方法。

c) class Circle extends Shape{ void draw( ); }
这个选项也是不正确的，因为它只是声明了 draw() 方法，但没有提供具体的实现。在Java中，如果一个类不是抽象的，那么它必须实现从其超类（或接口）继承的所有抽象方法。

d) class Circle extends Shape{ void draw( ){} }
这个选项是正确的，因为它创建了一个 Shape 类的具体子类 Circle，并提供了 draw() 方法的具体实现。

6) 给定java程序Test.java,如下：

    import ;

    private class Testing extends ArrayList{

         private void aMethod( ){

         }

    }

    public class Test extends Testing{

    }

 现在该程序编译无法通过，错误原因是 （ ） (选择一项)

 a) ArrayList不能被继承

 b) 一个Test.java文件中不能声明两个类

 c) Test的继承语法有错误

 d) Testing不能被声明为private

//public class Test extends Testing{ ... } 这一行声明了一个公共类Test，它试图继承上面声明的私有内部类Testing。这是不可能的，因为Testing是私有的，所以不能被其他类（即使是同一个文件中的类）继承。

7)

给定java程序,如下:

public class Test{

private static final int counter=10;

public static void main(String [] args){

System.out.println(++counter);

}

}

编译运行Test.java,结果是 ( )

(选择一项)

 a) 10

 b) 11

 c) 编译错误

 d) 运行时出现异常

这段Java程序将不会编译成功，因为它尝试对一个final变量counter进行自增操作（++counter）。在Java中，final关键字表示一个变量是一个常量，其值在初始化之后不能被改变。

因此，当你尝试在main方法中执行++counter时，编译器会报错，因为counter是一个final变量，其值不能被修改。

如果你尝试编译这段代码，你会得到一个编译错误，

8) 在java中，以定义了两个接口B和C，要定义一个实现这两个接口的类，以下语句正  确的是 （ ） (选择一项)

 a) interface A extends B,C

 b) interface A implements B,C

 c) class A implements B,C

 d) class A implements B,implements C

9） 给定一个Java程序代码,如下:

public class Test{

int count = 9;    //在Test类中，有一个实例变量count，它在对象被创建时被初始化为9。

public void count1(){

int count =10;

System.out.println("count1="+count); // count1()方法中，你定义了一个局部变量count（注意它和实例变量同名，但它们是两个完全不同的变量），并初始化为10。然后，你打印这个局部变量的值，所以输出是count1=10

}

public void count2(){

System.out.println("count2="+count); // count2()方法中，你没有定义任何局部变量count，所以当你打印count时，你实际上是在引用实例变量count，它的值是9（在对象创建时设置的）。所以输出是count2=9。

}

public static void main(String args[]){

Test t=new Test();

t.count1();

t.count2();

}

}

编译运营后,输出结果是

A.  

count1=9 count2=9

B.  

count1=10 count2=9

C.  

count1=10 count2=10

D.  

count1=9 count2=10

10) 在JAVA中 ，com包中某类的方法使用下列（ ）访问修饰符修饰后，可以被com.db包中的子类访问，但不能被com.db中其他类访问。（选择一项）

 a) Private

 b) protecte0

 c) Public

 d) Fridndly

a) Private: 当一个成员（变量、方法或内部类）被声明为private时，它只能被声明它的类访问。因此，它不能被子类或其他包中的任何类访问。

b) protecte0: 这个选项似乎是一个拼写错误。正确的应该是 protected。当一个成员被声明为protected时，它可以被同一个包中的其他类访问，也可以被子类访问，即使子类在不同的包中。

c) Public: 当一个成员被声明为public时，它可以从任何地方被访问

11) 给定如下 java 代码， 以下（）修饰符可以填入下划线处。（选择二项）

 class Parent{

protected void eat(){}

 }

 class Child extends Parent{

_________ void eat(){}

 }

 a) Protected

 b) Private

 c) 什么也不填

 d) Public

在给定的Java代码中，Child 类继承了 Parent 类，并且 Parent 类中有一个 protected 修饰的 eat 方法。在 Child 类中，你可以重写（override）这个方法，但是关于访问修饰符，有一些规则需要遵守：

如果父类的方法被声明为 public，则子类的方法也必须是 public（或者和父类一样为 public）。
如果父类的方法被声明为 protected，则子类的方法可以是 protected 或 public。
如果父类的方法有默认（包级）访问权限，则子类的方法可以是默认、protected 或 public。
子类不能重写父类的 private 方法，因为 private 方法在子类中是不可见的。
在这个特定的情况下，因为 Parent 类的 eat 方法是 protected 的，所以 Child 类的 eat 方法可以是 protected 或 public

12) 在Java中，下面关于抽象类的描述正确的是（）。（选择两项）

  a) 抽象类可以被实例化

 b) 如果一个类中有一个方法被声明为抽象的，那么这个类必须是抽象类

 c) 抽象类中的方法必须都是抽象的

 d) 声明抽象类必须带有关键字abstract

a) 抽象类可以被实例化
这是不正确的。抽象类不能被直接实例化，即不能使用new关键字来创建抽象类的实例。但是，抽象类可以有非抽象的子类，这些子类可以被实例化。

b) 如果一个类中有一个方法被声明为抽象的，那么这个类必须是抽象类
这是正确的。在Java中，一个类只要有至少一个抽象方法，那么这个类就必须被声明为抽象类。

c) 抽象类中的方法必须都是抽象的
这是不正确的。抽象类可以包含非抽象的方法，也可以包含抽象的方法。但是，如果类中有任何抽象方法，那么这个类就必须是抽象类。

d) 声明抽象类必须带有关键字abstract
这是正确的。在Java中，要声明一个类为抽象类，必须使用abstract关键字。

13) 给定如下Java代码,以下（）方法可以加入Child类中。（选择两项）

Public class Parent{

int change(){…}

}

 Class Child extends Parent{

 }

a) public int change(){}

 b) int change(int i){}

 c) private int change(){}

 d) abstract int change(){}

14) 在java中，在定义类时加上修饰符（）可以实现该类不能被实例化。（选择一项）

a) Final  //当一个类被声明为final时，它不能被继承。但这并不阻止该类被实例化

 b) Public

 c) Private

 d) Abstract

15) 在java中，下面（）的陈述是正确的。（选择二项）

  a) 私有方法不能被重载

 b) 静态方法能被重载

 c) 公有方法被重写后的访问修饰符可以变成private

 d) 一个被重写的方法不能抛出一个在基类中不被检查的异常

a) 私有方法不能被重载

这是不正确的。重载（Overloading）是指在一个类中定义多个同名但参数列表不同的方法。私有方法（private methods）也可以被重载，但由于它们是私有的，所以只能在同一个类中被调用，这通常不会造成混淆。

b) 静态方法能被重载

这是正确的。静态方法（static methods）也可以被重载，只要它们在同一类中，并且具有不同的参数列表。

c) 公有方法被重写后的访问修饰符可以变成private

这是不正确的。当子类重写父类的方法时，子类方法的访问修饰符不能比父类方法更严格（即子类方法的访问修饰符至少应该是public或相同的访问修饰符）。将公有方法重写为私有方法会导致编译错误。

d) 一个被重写的方法不能抛出一个在基类中不被检查的异常

这是正确的。在Java中，被重写的方法（即子类中的方法）不能抛出比父类方法更宽泛的异常（即子类方法抛出的异常必须是被父类方法声明抛出的异常的子类或者是同一个异常）。如果父类方法没有声明抛出任何异常（即没有throws子句），那么子类方法也不能声明抛出任何异常（除非是RuntimeException或其子类，因为这类异常在Java中是不被检查的异常）。

16) 分析下面的java代码输出结果为（）。（选择一项）

 Class Point{

    Int x,y;

    Point(int x,int y){

      This.x=x;

      This.y=y;

   }

   Public ststic void main(String[] args){

     Point pt1,pt2;

     Pt1=new Pint (3,3);

     Pt2=new Pint(4,4);

     System.out.print(pt1.x+pt2.x);;

}

 }

a) 6

 b) 34

 c) 8

 d) 7

System.out.print 打印了 pt1.x 和 pt2.x 的和。

pt1.x 的值为 3，pt2.x 的值为 4，所以它们的和是 7。

17) 在java中，以下程序的输出结果是（）。（选择一项）

a) 运行错误

 b) 0

Ture

 c) 0

False

 d) 0

0

我们有两个成员变量：x和y。在output方法中，我们打印了这两个变量的值。但是，在main方法中，我们并没有给x和y赋值。因此，x的值将是它的默认值（对于int类型是0），而y的值也将是它的默认值（对于boolean类型是false）。

18) 给定java代码如下，编译运行结果是（）。（选择一项）?????

a) 编译错误

 b) 运行时出现例外

 c) 正常运行，输出1

 d) 正常运行，输出0

在 main 方法中，你试图直接调用 count() 方法，但是 count() 方法是一个实例方法，不是静态方法。因此，你不能在静态的 main 方法中直接调用它，除非你已经创建了 Test 类的一个实例。

19) 1、在Java中，如果父类中的某些方法不包含任何逻辑，并且需要有子类重写，应该使用（ ）关键字来申明父类的这些方法。(选择一项)

a) final

 b) static

 c) abstract

 d) void

20) 在Java接口中，下列选项里有效的方法声明是（）（选择二项）

  a) public void aMethod();

 b) void aMethod();

 c) static void aMethod();

 d) protected void aMethod();

public void aMethod(); - 这是有效的，因为在接口中，方法默认就是public的，所以显式地声明为public是可以的，但通常我们省略public关键字。

b) void aMethod(); - 这也是有效的，因为当我们在接口中声明方法时，不指定public也是允许的，因为默认就是public。

c) static void aMethod(); - 这是无效的，因为接口中的方法不能是静态的。静态方法属于类而不是实例，而接口本身不是类，它不能被实例化。

d) protected void aMethod(); - 这是无效的，因为接口中的方法不能是protected或private的。它们必须是公开的（public），因为实现类需要能够访问这些方法

21) 给定java代码，如下：String s=null;

s.concat(“abc”);           运行时，会产生（）类型的异常。（选择一项）

a) ArithmeticException

 b) NullPointerException

 c) IOException

 d) EOFException

22) 在java中，下面捕获异常的语句正确的是（）。（选择二项）

  a) try{

}finally{

}

 b) try{}

 c) try{

try{}

 d) try{

try{

}finally{}

         }catch(Exception ex){}

23) 给定一段Java代码，如下：运行后，输出结果将是（）    （选择一项）

 public class Test

{

     public static void main(String []args)

     {

      int a[] = {0,1,2,3,4};

      int sum = 0;

      try

      {

       for (int i=1;i<6;i++)

       {

        sum = sum + a[i];

       }

       "sum="+sum);

       }

       catch (ArrayIndexOutOfBoundsException e)

       {

        "数组越界");

       }

       Finally

      {

        "程序结束");

      }

      }

}

 a) sum = 10

     程序结束

 b) sum = 10

 c) 数组越界

                程序结束

 d) 数组越界

24) 给定java代码，如下：编译运行，结果是（）（选择一项）

 public static void main (String [] args){

String s;

;

}

 a) 编译错误

 b) 编译通过，但出现运行时错误

 c) 正常运行，输出s=null

 d) 正常运行，输出s=

25) 关于Java的异常处理，以下说法正确的是（）。（选择一项）

  a) 任何可能引发Error类异常的语句必须封装在try块中

 b) 任何可能引发Exception异常的语句必须封装在try块中

 c) 任何可能引发RuntimeException异常的语句必须封装在try块中

 d) 正常情况下，程序无法捕获Error类的异常

26) 给定java代码，如下，编译运行后,结果是 ( )。 (选择一项) ??????

a) 编译错误 - 这是正确的。在尝试访问s.charAt(0)之前，s没有被初始化，因此编译器会报错，因为它不能确保s非空。

 b) 运行期异常,异常类型为 NullpointerException  ???????

 c) 运行期异常,异常类型为 ArithmeticExceptioin

 d) 运行正常,但无输出内容

27) 在java 的异常处理中，用户自定义的异常类应该是（）的子类。（选择一项）

  a) Exception

 b) Throwable

 c) Error

 d) RuntimeException

28) 给定入下JAVA代码，运行结束后，控制台上将输出（）。（选择一项）

 public class Test{

    public static String output=””;

 public static void foo(int i){

      try{

         Output+=”1”;

}

catch(Excepion e){

   Output+=”2”;

}

finally{

Output+=”3”;

}

Output+=”4”;

}

}

public static void main(String args[]){

    foo(0);

 ;

 }

 a) 1234

 b) 134

 c) 124

 d) 13

29) 在Java中，出现算术错误时,会产生（）类型的异常。(选择一项)

a) ArithmeticException

 b) NullPointerException

 c) IOException

 d) EOFException

30) 给定java代码如下,运行时会产生()类型的异常(选择一项)

 String s=null;

s.concat(“abc”);

 a) NullPointerException

 b) IOException

 c) EOFException

 d) ArithmeticException