补充完整以下程序，实现从键盘输入某名同学 10 门课的考试成绩并求平均分。

Int score[ ]= [1] int[10];
int sum=0;
Scanner scanner=new Scanner(System.in);
for(int i=0;i<score.length; i++){score[i]=scanner.nextInt();sum= [2] ;
}
double avg=sum/10.0;
System.out.println(avg);

[1]：new

[2]：sum+score[i]

很明显是利用for循环遍历求和，然后第8行求平均数

创建类 Student 及其子类 College,请将以下程序补充完整。

Class Student {
String name;
[3] ;
Student(String n, int a) {
name=n;
age=a;
}
public void print(){System.out.println(name+” 的年龄是”+age);}
}
public class College extends Student {String school;public College (____[4] _______, int a, String s){super(name, a);_____[5] _______;}public void print(){System.out.println(name+” 的年龄是”+age+”，学校是”+school);}
}

[3]：int age

由第4，5，6，9行可知

[4]：String name

由第15行可知

[5]：school=s

阅读下面这段程序：

abstract class SuperAbstract{void a( ) {System.out.print(“A”);}abstract void b();abstract int c(int i);
}
interface AsSuper{void x( );
}
abstract class SubAbstract extends SuperAbstract implements AsSuper {public void b() {};abstract String f();
}
public class InheritAbstract extends SubAbstract {public void x() { }public int c(int i) { return i*i;}public String f() { return “ABC”; }public static void main(String[] args) {InheritAbstract in = new InheritAbstract();in.x(); in.a(); in.b();System.out.print(in.c(8));System.out.print(in.f());}
}

在以上程序中，抽象类有__[6] _个，接口是__[7] __（写

接口名）。InheritAbstract 的父类是__[8] __，SuperAbstract

的父类是__[9]__，程序的最终输出结果是__[10] __

[6]：2

由第1行和第9行的"abstract class"可知：SuperAbstract和SubAbstract是抽象类

[7]：AsSuper

由第6行的"interface"可知

[8]：SubAbstract

由第13行"InheritAbstract extends SubAbstract"可知

[9]：Object

由第1行可知，该类并没有被指定父类，所以默认为Object

Object 是 Java 类库中的一个特殊类，也是所有类的父类。也就是说，Java 允许把任何类型的对象赋给 Object 类型的变量。当一个类被定义后，如果没有指定继承的父类，那么默认父类就是 Object 类。

[10]：A64ABC

先看main方法，in.x()：该类InheritAbstract有这个方法，结果为空;in.a()：该类没有这个方法，去其父类SuperAbstract哪里找，也没有，就再去父类的父类SuperAbstract找有,输出"A"；

in.b()：该类没有这个方法，去父类SuperAbstract找，为空

in.c(8)：调用这个方法，看第15行，返回64，输出

in.f()：调用这个方法，看第16行，返回ABC，输出

某 Java 源代码的文件名为 SubClass.java，具体代码如下所示。

class SuperClass{String fun1( ){ return "fun1"; }String fun2( ){ return "fun2"; }
}
[1] Inf{void infFun( );
}
public class [2] extends SuperClass implements Inf {String fun2( ){return "sub, " + super.fun2( );}public void [3] ( ) {System.out.println("inf fun");}public static void main(String[] args) {SubClass sc = [4] SubClass();System.out.println(sc.fun1( ) + ", " + sc.fun2( ));}
}

根据所给代码填写[1]、[2]、[3]、[4]四个空缺处的内容。

运行后在控制台输出的内容是 [5]

[1]：interface

由第8行的"implements Inf"可知：Inf是一个接口，所以用interface修饰

[2]：SubClass

由题意和第16行可知

[3]：infFun

因为该类要实现接口，所以由第6行可知要实现的方法为infFun()

[4]：new

使用new——实例化对象，创建内存

[5]：fun1,sub,fun2

先从main方法开始看，sc.fun1()的值为：fun1（SubClass继承SuperClass，SuperClass中的fun1( )是返回"fun1"）；sc.fun2()的值为：sub,fun2（SubClass本身的fun2( )方法中得到"sub, "又通过super来调用了被隐藏的父类SuperClass的fun2()方法，得到"fun2"）

根据所给代码填写[6]、[7]、[8]、[9]四个空缺处的内容。运行后在控制台输出的内容是 [10]

public class ListSet {public static void main(String[] args) {int [] a = {2,4,3,3,1};TreeSet ts = new TreeSet();for ( int i = 0; i < a.length; i++ ){ts. [6] ;//向 ts 中依次加入数组 a 中的数据}for( [7] number : [8] ){// 增强 forSystem.out.print ([9] + ", "); //依次输出 ts 中的每个元素}}
}

[6]：add(a[i])

由第4行的TreeSet是一个有序集合，添加需要用add()，第6行的注释可知

[7]：Integer

[8]：ts

由第8行，增强for语句格式：for(声明语句：迭代对象）

[9]：number

由第9行注释

[10]：1，2，3，4，

TreeSet是一个有序集合，会自动排序和去重