第三周考试

测试题(笔试)

一 选择题（每道题一分）

1.在Java接口中，下列选项中有效的方法声明是（a,b）   （选择2项）

a) public void aMethod();

b) void aMethod();  // public abstract void aMethod()

c) void aMethod(){};

d) private void aMethod();

2.在Java语言中，下列关于类的继承的描述，正确的是（b）。

a) 一个类可以继承多个父类。

b) 一个类可以具有多个子类。

c) 子类可以使用父类的所有方法。

d) 子类一定比父类有更多的成员方法。

3.在Java的异常处理模型中，能单独与finally语句一起使用的块是（a）。

a) try

b) catch

c) throw

d) throws

4.Java中的错误处理是通过异常处理模型来完成的，那么异常处理模块可以处理的错误是（a ）。

a) 运行时错误

b) 逻辑错误

c) 语法错误

d) 内部错误

5.下列关于封装的说法，不正确的是：(d)

a)封装就是将属性私有化，提供公有的方法访问私有属性

b)属性的访问方法包括setter和getter

c)赋值时用setter方法，取值时用getter方法

d)包含属性的类都必须封装属性，否则无法通过编译

6.在Java中，多态的实现不仅能减少编码的工作量，还能大大提高程序的可维护性及可扩展性，那么实现多态的步骤包括以下几个方面除了（ b）。

a) 子类重写父类的方法

b) 子类重载同一个方法

c) 定义方法时，把父类类型作为参数类型；调用方法时，把父类或子类的对象作为参数传入方法

d) 运行时，根据实际创建的对象类型动态决定使用哪个方法

7..在Java中，有如下两个类Student和Person。如果Student是Person的子类，则下列声明对象x的语句中错误的是（ c）。

a) Person x = new Student();

b) Person x = new Person();

c) Student x = new Person();

d) Student x = new Student();

8.分析如下所示的Java代码，其中this关键字的意思是（b ）。

public class Test {

   private String name;

   public String getName() {

      return name;

   }

   public void setName(String name) {

      this.name=name; //this关键字所在的行

   }

}

a) 是指name属性。

b) 是在Test类的内部指代自身的引用

c) Test类的对象引用其他Test类对象

d) 指所在的方法

9.在Java中，下面关于构造方法的说法错误的是（ b）。

a) 当一个类未定义构造方法时，Java虚拟机便提供一个默认构造方法

b) 构造方法不能够被重载

c) 构造方法可以接受参数

d) 当类的父类只有一个带参数的构造方法时，这个类必须提供自定义的构造方法

10.在以下Java程序的方法中，两个方法之间属于方法重载的是（a,c）。（选择二项）

a) int f1(){}

   int f1(int a){}

b) void f1(int a){}

   int f1(int a){}

c) void f1(){}

   int f1(int a){}

d) int f1(int b){}

   int f1(int a){}

11.下列选项中关于Java中super关键字的说法正确的是 。

a) super关键字是在子类对象内部指代其父类对象的引用。

b) super关键字不仅可以指代子类的直接父类，还可以指代父类的父类。

c) 子类通过super关键字只能调用父类的方法，而不能调用父类的属性。

d) 子类通过super关键字只能调用父类的属性，而不能调用父类的方法。

12.给定如下一个Java源文件Child.java，编译并运行Child.java, 以下结果正确的是（b ）。

class Parent1 {

 Parent1(String s) {

  System.out.println(s);

 }

}

class Parent2 extends Parent1 {

 Parent2() {

  System.out.println("parent2");

 }

}

public class Child extends Parent2 {

 public static void main(String [] args) {

  Child child = new Child();

 }

} 

a) 编译错误：没有找到构造器Child()

b) 编译错误：没有找到构造器Parent1()

c) 正确运行，没有输出值

d) 正确运行，输出结果为：parent2

13.下面的Java 程序编译运行结果是（c）。(选择一项)

interface A{

int x=0; //public static final int x =10  A.x

 }

 class B{

    int x=1;

 }

 public class C extends B implements A{

    public void pX(){

     System.out.println(super.x);

    }

    public static void main(String[] args){

     new C().pX();

    }

 }

a) 产生运行期错误

b) 产生编译期错误

c) 程序运行，输出结果为1

d) 程序运行，输出结果为0

14.分析下面的Java代码，编译运行结果是（c ）。

public class Test {

   int number;

   String strname;

   Test(int num, String name) {

      number = num;

      strname = name;

      System.out.println("学号: " + number + " 姓名：" + name);

   }

   public static void main(String[] args) {

        Test objTest1 = new Test();

        Test objTest2 = new Test(1,"张三");

   }

}

a) 运行结果为：

   学号：1 姓名：张三

b) 运行结果为：

   学号：null 姓名：null

c) 程序出现编译错误

d) 程序出现运行时异常

15.在如下所示的Test类中，共有（ c）个构造方法。

public class Test{

 private int x;

 public Test() {

  x = 34;

 }

 public void Test(double f) {

  this.x = (int)f;

 }

 public Test(String s) {

 }

}  

a) 0

b) 1

c) 2

d) 3

16.下面代码的运行结果是（b）。

public class Car{

  public void run(){

System.out.println(“汽车在跑”);

}

}

public class Benz extends Car{

public void run(){

System.out.println(“奔驰在跑”);

}

}

public static void main(String[] args){

Car car = (Car)(new Benz());

car.run();

}

a汽车在跑

b奔驰在跑

c无法编译

d运行时将抛出异常

17.在Java中，Object类是所有类的父亲，用户自定义类默认扩展自Object类，下列选项中的（d）方法不属于Object类的方法。

a) equals(Object obj)

b) getClass()

c) toString()

d) trim() //String

18.在Java中，类Test 的代码如下所示，假设类Test的实例化对象名为 t,则选项（c）中的语句能正确调用Test类的方法。

Class Test{

   public int Change(){

      System.out.println("No Parameters");

      return 0;

   }

   public void change(double m){

      System.out.println("parameter is:"+m);

   }

}

a) Test.change(15.2f);

b) Test.change();

c) t.change(250.5);

d) int a=t.change(13);

19.给定如下Java代码，关于super的用法，以下描述正确的是（c）。(选择一项)

Class C extends B{

    public C(){

      super();

    }

}

a) 用来调用类B中定义的super()方法

b) 用来调用类C中定义的super()方法

c) 用来调用类B的无参构造方法

d) 用来调用类B中第一个出现的构造方法

20.在java中，如果类C是类B的子类，类B是类A的子类，那么下面描述正确的是(a)

a) C不仅继承了B中的成员，同样也继承了A中的成员

b)C只继承了B中的成员

c)C只继承了A中的成员

d)C不能继承A或B的成员

21.下列选项中关于Java中this关键字的说法正确的是(a)  (选择一项)

a)this关键字是在对象内部指代对象自身的引用

b)this关键字可以在类中的任何位置使用

c)this关键字和类关联，而不是和特定的对象关联

d) 同一个类的不同对象共用同一个this

22.在java中，下列(a,c)可以成为类Orange的构造方法.（选择两项）

A)public Orange(){...}

b)public void Orange(){...}

c)public Orange(String s){...}

d)public String Orange(String s){...}

23.在Java类中，使用以下（d ）声明语句来定义公有的int型常量MAX。（选择一项）

a) public int MAX = 100;

b) int MAX = 100;

c) public static int MAX = 100;

d) public static final int MAX = 100;

24.在Java中，已定义两个接口B和C，要定义一个实现这两个接口的类，以下语句正确的是（ 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

25.下面有关Java异常处理模型的说法错误的是（a）。（选择一项）

a) 一个try块只能有一条catch语句

b) 一个try块中可以不使用catch语句

c) catch块不能单独使用，必须始终与try块在一起

d) finally块不能单独使用，必须始终与try块在一起

26.在Java中，类可以派生自一个父类，并实现（d ）个接口。（选择一项）

a) 1

b) 2

c) 3

d) 任意多个

27.下面关于Java接口说法错误的是（c ）。 （选择一项）

a） 一个java接口是一些方法特征的集合，但没有方法的实现

b） java接口中定义的方法在不同的地方被实现，可以具有完全不同的行为

c） java接口中可以声明私有成员

d） java接口不能被实例化

28.在Java中，程序员可以在子类的构造方法中使用关键字（ a）调用父类的构造方法。（选择一项）

a) super

b) this

c) extends

d) implements

29.给定如下Java程序的代码片段，在下划线处，加入（a,c  ）语句，可以使这段代码编译通过。

public void method1() throws IOException{}

public void method2()__________{

    method1();

}

(选择二项)

a) throws IOException

b) throw IOException

c) throws Exception

d) throws RuntimeException

30.给定Java代码如下所示，则编译运行后，输出结果是（c ）。

class Parent{

   public void count(){

      System.out.println(10%3);

   }

}

public class Test extends Parent{

   public void count(){

      System.out.println(10/3);//3

   }

   public static void main(String args[]) {

      Parent p = new Test();

      p.count();

   }

}

(选择一项)

a) 1

b) 1.0

c) 3

d) 3.33333333333333335

31.给定如下Java代码，下面（d ）代码能被合理地添加到下划线的位置，从而实现方法重写。

class Base{

 public void method(int i){}

}

public class Scope extends Base {

 public static void main(){}

 __________ //此处填写代码

} (选择一项)

a) public void method(){}

b) public void method(double i){}

c) public void method(long i){}

d) public void method(int i){}

32.在Java中，尝试对null对象操作时，会产生（b ）类型的异常。（选择一项）

a) ArithmeticException

b) NullPointerException

c) IOException

d) ClassNotFoundException

33.以下关于Object类说法错误的是（b  ）。（选择一项）

a) 一切类都继承自Object类

b) 接口亦继承Object类

c) Object类中定义了toString()方法

d) Object类在java.lang包中

34.Java异常处理机制主要为了捕获（b ）错误，发生错误时，将引发异常，该异常由一个Java代码块捕获。（选择一项）

a) 编译期

b) 运行期

c) 测试期

d) 调试期

35.在Java中，阅读如下代码，则编译运行后的输出结果是（d ）。

interface Face{

 int counter = 40;

}

public class Test implements Face {

 private static int counter;

 public static void main(String[] args) {

  System.out.println(++counter);

 }

}

(选择一项)

a) 40

b) 41

c) 0

d) 1

二 简单题(每道题5分)

java中构造方法的功能和特点，构造方法和一般方法的区别？

   构造方法的功能：用来构建对象和对类中的成员变量进行初始化

   特点：构造方法没有具体返回值，方法名必须和类名保持一致，在类中可以以重载形式存在，

   区别：子类可通过继承拥有父类当中的成员方法，但是构造方法不可以继承

         子类在调用成员方法时，不用考虑父类是否需要调用父类的成员方法，但是子类在调用构造方法时，内部优先调用父类的构造方法，如果父类当中没有无参构造方法时，需要显示调用父类的带参构造方法。              

       

方法的重载和方法的重写的区别？

方法重载：同一类中，方法名一样，参数列表不一样的，对于返回值和修饰符不影响。

方法重写：一般在父子类中或者接口与实现类中，要求：方法名称一致，参数列表一致，返回值一致，修饰符必须大于等于父类或者父接口当中的权限范围。

 

this和super的作用

This：指代当前类的一个对象，当方法内部的局部变量和类中的成员变量重名时，需要通过this关键字来指代类中的成员变量，防止出现类中成员变量被隐藏问题，this可以调用类中的成员变量，可以调用类中的成员方法，也可以通过this(...)来调用本类当中的其他构造方法。

Super:指代父类中一个引用(或者父类的存储空间标识)，可以通过super来调用父类当中的成员变量，成员方法，也可以通过super(...)来调用父类当中的构造方法。

在java中一个类被声明为final类型，表示了什么意思？

由于final含有最终的，不可改变的意思，所以由final修饰的类，类中的成员信息不可改变，表示该类没有子类，不允许任何类继承一个被final修饰的类。

接口是否可继承接口? 抽象类是否可实现(implements)接口? 抽象类是否可继承类

    接口可以继承接口，抽象类可以实现接口，抽象类可以继承类

abstract class和interface有什么区别

 

 

 

删除数组中指定的元素，然后将后面的元素向前移动一位，将最后一位设置为NULL 。

String[] strs={“aaa”,”ccc”,”ddd”,”eee”,”fff”,”ggg”};

指定删除字符串“ccc”,把后的元素依次向前移动！！！

 

谈谈你对abstract、static修饰符的理解。

   Abstract修饰符：意思是抽象的，可以修饰类和方法

   当修饰类时，该类属于抽象类，在抽象类中可以声明抽象方法，但是抽象不能直接实例化对象，需要借助于它的子类，才可以调用类中的成员方法，

    当修饰方法时，该方法为抽象方法，抽象方法没有方法体内容，一般是需要被覆盖重写的

   Static修饰符：静态的，可以修饰类中成员变量和成员方法

   当static修饰成员变量时，该变量属于静态变量，类变量，类变量被该类所有的对象所共享；

当static修饰成员方法时，该方法是静态方法，在静态方法中不能调用非静态成员信息，不能使用this关键字

Static还可以修饰代码块，此代码块为静态代码块，静态代码块优先于构造方法和main方法加载，并且在程序当中只会被加载一次。

谈谈你对多态的理解。

   理解：多态是面向对象的三大特征之一，多态描述的是当一个对象能够表现出多种形态时，那么该对象就具有多态性

具体表现形式是父类引用指向子类对象地址，使用多态可以让程序具有良好的可扩展性和便利性。

多态出现的前提一般符合三个条件：继承或者实现关系、方法重写、父类引用指向子类对象

谈谈你对内部类与外部类的成员访问情况以及匿名内部类的见解。

   见解：

内部类描述的是当一个事物内部包含另外一种事物时时，可以使用内部类结构设计。

 内部类一般分为成员内部类和局部内部类

 成员内部类，定义在类中方法外，充当类中成员信息

 成员内部类访问外部类没有障碍，直接访问

但是外部类访问成员内部类信息时，需要首先创建内部类的对象，通过内部类对象调用。

在开发当中，大多使用匿名内部类，匿名内部类本质是一个带着具体实现父接口或者父类的匿名的子类对象。当方法的形式参数是接口或者抽象类时，可以使用匿名内部类来进行参数传递。

给定任意两个正整数，求最大公约数和最小公倍数

 static Scanner sc = new Scanner(System.in);

    static int a,b;

    public static void main(String[] args) {

        input();//输入a和b

        f();//计算输出

    }

    public static void input() {

        a = sc.nextInt();

        b = sc.nextInt();

    }

    public static void f() {

        int small = a<b?a:b;//a和b的最小数

        for(int i=small;i>=1;i--) {

            if(a%i==0 && b%i==0) {

                System.out.println("最大公约数："+i);

                System.out.println("最小公倍数："+(i*(a/i)*(b/i)));

                break;

            }

        }

    }

1. 求完美数，如6 = 1+2+3。

 public static void main(String[] args) {

System.out.println("1000以内的完数如下：");

fun();

}

//求完数；完数的定义：一个数恰好等于它的所有因子之和

public static void fun(){

for(int i=1;i<=1000;i++){

int factor=0; //定义因子变量和，初始值0

for(int j=1;j<i/2+1;j++){

if(i%j==0)

factor+=j;

}//内层循环结束；

if(factor==i)

System.out.println("  "+i);

}//外层循环结束

}



public class A { 
static{ 
System.out.print("1"); 
} 
public A(){ 
System.out.print("2"); 
} 
} 

public class B extends A { 
static{ 
System.out.print("a"); 
} 
public B(){ 
System.out.print("b"); 
} 
} 
public class Hello{ 
public static void main(String[] arge){ 
System.out.println(" "); 
A ab = new B();  //1a2b 
System.out.println(" "); 
ab = new B(); //2b
} 
}

输出结果：  1a2b     2b