补充完整以下程序，实现从键盘输入某名同学 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] ){// 增强 for
System.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是一个有序集合，会自动排序和去重