复习提纲及练习题和答案

2020-01-02 来源：爱go旅游网

一、选择题

1.Java标识符的命名规则是什么？

答:用数字，字母，下滑线，美元符号来表示。不能以数字开头。 2.源文件名与public类名必须相同吗？答：必须的。

3.一个源文件中可以有多个public类吗？答：不可以。

4.Java源文件的扩展名是什么？答：. java

5.打包之后的Java项目扩展名是什么？答：. jar

6.package语句必须位于程序的第一条语句吗？答：必须的

7.一个类能否实现多个接口？答：能

8.所有类的祖宗类是什么？答：java.lang.Object

9.接口和Object类有关系吗？答：没关系。

10.Object类位于哪个包中？答：java.lang

11.Object类中定义了toString()方法吗？答：定义了。

12.final类能否有子类？答：不能。

13.如果一个方法被修饰为final方法，则这个方法还能被重写吗？答：不能。

14.如果一个成员变量被修饰为final的，就是常量，必须赋给初值，而且不能再改变吗？

答：是的。

15.方法重载是指什么？

答：在一个类中，方法名相同，参数列表不同(参数数据类型不同或参数个数不同)，与访问权限和返回类型无关。

16.一个方法在所属的类中只能被重载一次吗？答：不是。

17.抽象类允许被实例化吗？答：不允许

18.接口中包含变量和方法实现吗？答：不包含。

19.构造方法能有返回值吗？答：不能。

20.String类的substring方法怎么用？

答：public String substring(int index)提取从位置索引开始的字符串部分

public String substring(int beginindex,int endindex)提取beginindex和endindex之间的字符串部分,但是不包含endindex处字符串 21.如何编写方法求一维数组的最大值？答： public void max(){

for(int i=1;i22.什么是上转型？下转型？

答：上转型：假设B类是A类子类或间接子类，当我们用子类B创建一个对象，并把这个对象的引用放到A类的对象中时:

A a;

B b=new B();

a=b; 或者A a=new B();

称这个A类对象：a是子类对象b的上转型对象. 父类引用指向子类对象。下转型：子类引用指向父类对象（需要强制性转换）。 23.字符输入流类的父类是什么？字符输出流的父类是什么？ Reader Writer

24.自定义异常类的父类是什么？、答：Exception

25. Java2的三个版本Java SE主要用于什么开发？Java ME主要用于什么？Java EE主要用于什么？

26.在Java中如何定义一个常量？修饰符是什么？ Final 数据类型常量名 =

27.调用父类构造方法的关键字是什么？答：super

28.在异常处理中，将可能抛出异常的方法放在什么语句块中？答：try{ }catch{ }

29.“+”运算符的两种含义？答：字符串连接运算符加号 30．多态是怎么回事？如何实现多态？

 子类重写父类的方法

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

为参

数传入方法

 运行时，根据实际创建的对象类型动态决定使用哪个方法二、判断题

1. Java类中能否存在两个同名的方法？答：能

2. 无论Java源程序包含几个类的定义，若该源程序文件以B.java命名，编译后生成的都只有一个名为B的字节码文件吗？

答：不是是B.class

3. 一个Java类允许有多个父类吗？答；不能

4. StringBuffer类对象创建之后能否修改和变动？答：能

5. 对象是类的实例，类是对象的模板？答：对

6. 实现一个接口意味着什么？答：实现接口内的所有方法。 7. 引用数据类型是什么？答: 类接口数组

8. 编译成功后生成的文件的名字叫什么？答：.class

9. Java语言中一个char类型的数据占几个字节的存储空间？答：2

10. 抽象类中的所有方法都是抽象方法吗？答：不是，既有抽象又有非抽象 11. 创建对象有什么关键字？答：new

12. Java的字符类型采用的是什么编码？答：Unicode编码

13. 子类能否继承父类所有的成员变量及成员函数？答：能

14. break语句终止当前这一轮循环，跳到下一轮循环并执行，对吗？答：不对

15. Java应用程序中类方法可以调用类变量，也可以调用实例变量吗？答：不对，类方法可以调用类变量，但不可以直接调用实例变量。三、程序填空

1. 会使用封装完善类的定义，包括构造方法和属性、getter和setter方法和toString方法。 2. 会模拟声卡和网卡使用PCI插槽。 class SoundCard implements PCI{ public void start() {

System.out.println(\"Du du...\"); }

public void stop() {

System.out.println(\"Sound stop!\"); } }

class NetworkCard implements PCI{ public void start() {

System.out.println(\"Send...\"); }

public void stop() {

System.out.println(\"Network stop!\"); } }

public interface PCI { void start();

void stop(); }

public class MainBoard{

public void usePCICard(___PCI___ p) { p.start(); p.stop(); } }

public class Assembler {

public static void main(String[] args) { MainBoard mb=new MainBoard(); //在主板上插入网卡

PCI nc=new NetworkCard(); mb.usePCICard(nc); //在主板上插入声卡

PCI sc=new SoundCard(); mb.usePCICard(sc);

} }

3. 会设计和使用抽象类及抽象方法。四、编程题（30分）附：参考程序：

1. 输入一个正整数N，判断该数是不是质数，如果是质数输出“N是一个质数”，否则输出“N不是质数”。质数的含义：除了1和它本身不能被任何整数整除。 import java.util.Scanner; public class Number {

public static void main(String[] args) {

Scanner input=new Scanner(System.in); System.out.println(\"请输入一个正整数：\"); int N=input.nextInt(); int i;

for(i=2;iif(N%i==0){

break;

}

} if(N==i){ } else

}

System.out.println(N+\"是一个质数！\");

System.out.println(N+\"不是质数！\");

}

2. 编程实现打印出所有的 \"水仙花数 \"，所谓 \"水仙花数 \"是指一个三位数，其各位数字立方和等于该数本身。 public class number {

public static void main(String[] args){

int i,g,s,b;

System.out.println(\"所有的水仙花数为：\"); for(i=100;i<=999;i++){

g=i%10; s=i/10%10; b=i/100;

if(i==g*g*g+b*b*b+s*s*s)

System.out.printf(\"%d\\

}

3. 将一个数组中的元素逆序，即第一个元素和最后一个元素交换，第二个元素与倒数第二个元素交换……。例如：输出效果示例原数组为：9 2 5 7 8 逆序后的数组为：8 7 5 2 9 import java.util.Scanner;

public class Numbersort {

public static void main(String[] args) { Scanner input=new Scanner(System.in);

System.out.printf(\"请输入你要输的元素个数：\"); int n=input.nextInt(); int[] number=new int[n]; int i,j,t;

System.out.printf(\"原数组为：\"); for(i=0;ifor(i=0,j=n-1;it=number[i];

number[i]=input.nextInt();

}

number[i]=number[j]; number[j]=t;

System.out.printf(\"逆序后的数组为：\"); for(i=0;iSystem.out.printf(\"%d\\

}

4. 编程实现输入某个班的某次考试50位同学成绩，存放到数组中。求平均成绩，将50位同学的成绩从小到大排序并输出。 import java.util.Scanner; import java.util.Arrays; public class Score {

public static void main(String[] args) {

Scanner input=new Scanner(System.in); double[] score=new double[5]; int i;

double sum=0.0;

System.out.printf(\"请输入成绩：\"); for(i=0;i9

score[i]=input.nextDouble();

}

for(i=0;iSystem.out.printf(\"平均成绩：%f\Arrays.sort(score); System.out.println(\"\\n\");

System.out.printf(\"成绩从小到大的排序为：\"); for(i=0;iSystem.out.printf(\"%f,\sum=sum+score[i];

}

5. 请编码实现以下继承关系：人类：具有属性：姓名，年龄；具有行为：自我介绍；学生类：继承自人类，同时新增学号属性，重写自我介绍方法。教师类：继承自人类，同时新增类别（如英语老师）属性，重写自我介绍方法。请实现以上需求，画出UML图，并编写测试类进行测试。 package cn.bzu.k;

public class Person { private String name; private int age;

public Person(String name,int age){

this.name=name; this.age=age;

}

public void information(){ } }

package cn.bzu.k;

public class Student extends Person{ }

package cn.bzu.k;

public class Teacher extends Person{

System.out.println(\"姓名：\"+name+\"\\n年龄：\"+age);

private String sno;

public Student(String name,int age,String sno){ }

public void information(){ }

super.information();

System.out.println(\"学号：\"+sno); super(name,age); this.sno=sno;

private String teacher;

public Teacher(String name,int age,String teacher){ }

super(name,age); this.teacher=teacher;

}

public void information(){ }

super.information();

System.out.println(\"职业：\"+teacher);

package cn.bzu.k;

public class Test {

public static void main(String[] args) { }

6. 编写手机（Phone）类，有以下属性和行为：属性：品牌，型号；功能：查看手机信息，打电话；构造方法：定义一个无参构造方法，定义一个包含俩个参数构造方法，并分别为品牌、型号赋值；请实现手机类，画出UML图，并编写测试类对手机功能进行测试。 package bzu.java.ks2;

public class Phone {

}

// TODO Auto-generated method stub

Student stu=new Student(\"Tom\stu.information();

Teacher t=new Teacher(\"Tom\英语老师\"); t.information();

private String brand;

}

private String style;

public Phone(){}

public Phone(String brand ,String style){ this.brand=brand; }

public void infomation(){ }

public void lookInformation(){ }

public void call(){ }

System.out.println(\"打电话！\"); System.out.println(\"查看手机信息\");

System.out.println(\"品牌：\"+brand+\"\\n型号：\"+style); this.style=style;

package bzu.java.ks2;

public class Test {

public static void main(String[] args) {

Phone phone=new Phone();

Phone phone1=new Phone(\"苹果\

phone1.infomation(); phone1.lookInformation(); phone1.call();

}

附：练习题

第一部分 java基本语法

1、下面（AC）是合法的Java变量名。

A._myString B. $a+b C. myString D.9myString 2、下列叙述中,正确的是（ A ）。 A.Java语言的标识符是区分大小写的 C.Java源文件扩展名为.jar 运行。

//添加代码 public class A { //省略代码 }

A.import java.util.*; B. package com.mypackage; C.int a = 1; D.以上都不对 4、下列（C）中main方法可以作为应用程序入口。 A.public void main(String[ ] args){ //程序主体} B.public static void main(){ //程序主体}

C.public static void main(String[ ] a){ //程序主体} D.public static void main(String args){ //程序主体}

5、在一个Java文件中，使用import、class和package的正确顺序是（A）。 A.package、import、class B.class、import、package C.import、package、class D.package、class、import 第二部分控制结构

1、阅读下列代码，i值为（E）时输出结果中不包括“Test2”。 switch(i){

default: System.out.println(\"无匹配\"); case 1:

System.out.println(\"Test1\"); case 2:

}

B.源文件名与public类名可以不相同

D.源文件中public类的数目不限

3、A.java文件包含下面的程序片段，（AB）放到“//添加代码”处，程序仍可以正常

case 3:

System.out.println(\"Test2\"); break; case 4:

System.out.println(\"Test3\"); break; }

A.0 B. 1 C. 2 D. 3 E. 4 2、执行下面的程序片段，变量x的值为（ D）。 int c = ‘A’; int x = 0; switch(c) {

case 1: x++; break; case 10: x--; break; default: x+=c;} A.变量x的值为0 C.变量x的值为-1 if(val > 4){

System.out.println(\"Test A\"); }else if(val > 9){

System.out.println(\"Test B\"); }else {

System.out.println(\"Test C\");

}

A.val = 0输出“Test C” B.val介于0到4 之间输出“Test C” C.val = 14输出“Test B” D. val = 5 输出“Test A” 4、阅读代码片段，下面（C）代码导致程序出错。

int count; //第1行 int x[ ] = new int[10]; //第2行 for(int i = 0; i < 5){ //第3行 count++; //第4行 i++; //第5行 } //第6行 System.out.println(x[5]); //第7行

A.第1行 B.第2行 C.第3行 D. 第4行 E.第7行 5、有下面程序，语句a=a+1执行的次数是（C）。

public class Test {

public static void main(String[ ] args){ int x=8,a=1; do{

B.变量x的值为1 D.变量x的值为65

3、假设val是整型变量，下面（C）说法不正确。

a=a+1;

} while (x>0);

}

A.0 B.1 C.无限次 D.有限次

6、下面代码输出结果是（B）。

int i=0,s=0; do{

if(i%2==0){ i++; continue; } i++; s = s + i; }while(i<7); System.out.println(s);

A.16 B.12 C.28 D.21 7、以下循环体的执行次数是（C）。 int i, j;

for (i=0, j=1; i<=j+1; j--) { i = i + 2; }

A.3 B.2 C.1 D.0

8、关于下面代码片段，说法正确的是（D）。 int a = 8, b = 9; if (a = b){

System.out.println(\"true\"); }else{

System.out.println(\"false\");

}

A.输出true B.输入false C.无输出 D.编译错误 9、运行下面代码，正确的输出结果是（D）。 public class MyClass { int x = 10;

public static void main(String args[ ]){ for(int n = 3; n > 0; n--){ x = x * x; }

System.out.println(x); } }

A.1000 B.1000000 C.100000000 D.编译错误第三部分数组和字符串

1、如果arr[ ]仅仅包括正整数，下面代码的功能是（ C ）。 public int guessWhat( int arr[ ] ){ int x= 0;

for( int i = 0; i < arr.length; i++ ){ if(x < arr[i]){

x = arr[i]; } } return x; }

A.返回数组最大值的下标 B.返回数组最小值的下标 C.返回数组中的最大值 D.返回数组中的最小值 2、下面（AC）正确创建包含5个\"\"字符串的数组。 A. String[ ] a = new String[5]; for(int i=0 ; i< 5;i++ ){ a[i]=\"\"; }

B. String a[ ] = new String[ ] ; a = {\"\ C. String[ ] a = {\"\

D. String a[ ] = new String[5] {\"\ E. String a[5] = {\"\

3、阅读下面代码片段，输出结果是（D）。

StringBuffer sb = new StringBuffer(\"Hello\"); String t = \" MY\"; t = t + \" FRIEND\"; sb.append(t);

System.out.println(sb.toString().toLowerCase());

A. my friend hello B. Hello MY FRIEND C. MY FRIEND Hello D. hello my friend 4、声明s1，String s1 = new String(\"phenobarbital\");

经过下面代码之后， String s2 = s1.substring(3, 5); s2的值是（D）。 A.null B.\"eno\" C.\"enoba\" D.\"no\" 5、下面（C）不是String对象合法的方法。

A.equals(String) B.trim() C.append() D.indexOf() 6、下面说法中正确的是（AD）。

A.调用String对象的length()方法可获得字符串长度 B.调用String对象的length属性可获得字符串长度 C.调用数组变量的length()方法可以获得数组的长度 D.调用数组变量的length属性可以获得数组的长度 7、阅读下面代码，运行输出（A）。

String space = \" \"; // trim() 去掉字符串左边和右边的空格

String composite = space + \"hello\" + space + space; composite.concat(\"world\"); String trimmed = composite.trim(); System.out.println(trimmed.length()); A.5 B.6 C.8 D.13 第四部分面向对象设计

1、下面代码片段创建（B）个对象。 int a = 10; String b = \"abc\";

String c = new String(\"abc\"); MyTest test = new MyTest(); A.4 B.3 C.2 D.1

2、阅读下面代码，myMethod被调用时，正确的输出结果（C）。 public class MyPoint { public void myMehtod() { int x = 5, y= 3;

System.out.print(\"(\" + x + \（5,3） switchCoords(x,y);

System.out.print(\"(\" + x + \（5,3） }

public void switchCoords(int x,int y){ int temp; temp = x; x = y; y = temp;

System.out.print(\"(\" + x + \（3,5） } }

A.(5,3)(3,5)(3,5) B.(5,3)(5,3)(5,3) C.(5,3)(3,5)(5,3) D.编译出错 3、下列关于修饰符混用的说法错误的是（B）。

A. abstract不能与final并列修饰同一个类B. static方法中能处理非static的属性 C. abstract方法必须在abstract类中 D. abstract类中可以有private的成员 4、字符输入流类都是（ D ）抽象类的子类。

A.InputStream B.OutputStream C.FilterlnputStream

D．Reader

5、给定下列程序，正确的叙述是？( C )。

class A {

public static void main(String[] args) {

B x = new B();

x.a(); }

void a() { System.out.println(\"A\"); } }

class B extends A{

void a(){ System.out.println(\"B\"); } }

A.程序编译正确，运行java A将输出A C.程序编译正确，运行java A将输出B A.final类可以被继承，即可以有子类。

B.如果一个方法被修饰为final方法，则这个方法不能被重写。

C.如果一个成员变量被修饰为final的，就是常量，必须赋给初值，而且不能再改

B. 程序有语法错误 D.以上选项都不对

6、关于final关键字，下面说法不正确的是（ A ）。

变。 D. final修饰的类不能被继承。 7、下列叙述中，错误的是( D )。

A.Java中，方法的重载是指多个方法可以共同一个名字 B.Java中，用abstract修饰的类称为抽象类它不能实例化 C.Java中，接口不包含成员变量和方法的实现. D.Java中，构造方法可以有返回值

8、下列程序输出结果是( A )。 class A{ int x=1; void print(){

System.out.println(x); } }

class B extends A{ int x=100; void print(){

System.out.println(\"super.x=\"+super.x);

super.print();

System.out.println(\"x=\"+x);} A a=new A(); a.print();

public static void main(String[] args) {

B b=new B(); b.print(); } }

A.1 B.1 C.100 D.100 super.x=1 super.x=1 super.x=100 super.x=1 1 100 1 100 x=100 x=1 x=1 x=1 9、下面程序运行的结果是( B )。 public class Test{

public static void main(String args[]){ String s=”hello”; int a=1,b=2,c=3; System.out.println(s+a+b+c); } }

A.helloabc B.hello123 C.hello6 10、字符输出流类都是（C）抽象类的子类。 A.FilterWriter B.FileWriter public class Test {

public static void main(String[ ] args1){ Test test = new Test(); int x = 10; if (test.methodA()){ x++;

System.out.println(x); } }

public int methodA(){ return 10; } }

A.第5行有编译错误 B.第7行有编译错误 C.第11行有编译错误 D.运行输出11 E.运行输出12 12、运行下面这段代码，输出结果是（D）。 public class MyTest { int x = 30;

D.abc123

C.Writer D.OutputStreamWriter

11、关于下面代码，说法正确的是（A）。

public static void main(String args[]){ int x = 20; MyTest ta = new MyTest(); ta.Method(x);

System.out.println(x); }

public void Method(int y){ int x = y * y; } }

A.30 B. 400 C. 900 D. 20 13、以下可以插入到第1行的是（ D ）。 public class Test{ //do sth }

A.Test t=new Test() B.public class A{ } C.class Test { } D.package com.abc.ex.;

14、Java类中，使用以下（ D ）声明语句来定义公有的String型常量SEX_MALE。

A. public String SEX_MALE = “男”; B. final String SEX_MALE = “男”;

C. public static String SEX_MALE = “男”; D. public static final String SEX_MALE = “男”;

15.下列对Java中的继承描述错误的说法是（C）。 A.子类至少有一个基类 B.子类可作为另一个子类的基类

C.子类可以通过this关键字来访问父类的私有属性 D.子类继承父类的方法访问权限保持不变

16. try {}里有一个return语句，那么紧跟在这个try后的finally {}里的代码会不会被执行，什么时候被执行？B A.不会执行

B.会执行，在return前执行 C.会执行，在return后执行

D.会执行，可能在return前执行，也可能在return后执行 17.构造方法是否可被重写和重载（A）。

A.不能重写，可以重载 B.可以重写，不能重载 C.不能重写，不能重载 D.可以重写，可以重载 18. 下列属于方法重载好处的是（BD）。

A.实现多态 B.方法名的复用 C.提高程序运行速度 D.使用方便，提高可读性 19.面向对象方法的多态性是指（C）。 A.一个类可以派生出多个特殊类

B.一个对象在不同的运行环境中可以有不同的变体

C.拥有相同父类或接口的不同对象可以以适合自身的方式处理同一件事 D.一个对象可以是由多个其他对象组合而成的 20. Dog是Animal的子类，下面代码错误的是（C）。

A.Animal a = new Dog(); B.Animal a = (Animal )new Dog(); C.Dog d = (Dog)new Animal()(下转型); D.Object o = new Dog() ; 21. 下面定义Java的常量，正确的是（ABCD）。 A.public static final double PI = 3.14; B.public final static double PI = 3.14; C.final public static double PI = 3.14; D.static public final double PI = 3.14; 22. 这段代码的输出结果是（C）。 try{

System.out.print(\"try，\"); return;

} catch(Exception e){

System.out.print(\"catch，\"); } finally {

System.out.print(\"finally\"); }

A.try， B. try，catch， C.try，finally D.try， catch，finally 23. 下面代码的运行结果是（C）。 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. 运行时将抛出异常 24. 下面的异常处理代码的输出结果是（A）。 public static void main(String[] arg){

try{

int result = 6/0;

System.out.print(\"try，\"); } catch(ArithmeticException e1) {

System.out.print(\"ArithmeticException异常，\"); throw new Exception(); } catch(Exception e2) {

System.out.print(\"Exception异常，\"); } finally {

System.out.print(\"finally\"); } } A.程序编译错误

B.ArithmeticException异常，finally

C.ArithmeticException异常， Exception异常， finally D.try， ArithmeticException异常， Exception异常， finally 25. 关于Java的接口，下面说法错误的是（D）。

A.可以被继承 B.可以只定义常量，而没有任何方法 C.可以这样定义常量： public int EVEREST = 8848; D.方法的参数不可以是接口

26. 下列代码的输出结果是（B）。 public class Example {

String str = new String(\"good\"); char[] ch = {'a','b','c'};

public static void main(String[] args) { Example ex=new Example(); ex.change(ex.str,ex.ch);

System.out.print(ex.str+\" and \"); System.out.println(ex.ch); }

public void change(String str,char ch[]){ str=\"test ok\"; ch[0]='g'; } }

A.good and abc B.good and gbc C.test ok and abc D.test ok and gbc

27.能与public void methodA(){ }方法形成重载的有（C）。 A.private void methodA(){ } B.private int methodA(){ return 1;} C.public void methodA(int a){ }

D.public void methodA() throws Exception{ }

28. 子类中能与父类public void methodA(int a){ }方法形成重写的有（D）。 A.public int methodA(int a){return 1;}

B.public void methodA(int a) throws Exception{ } C.private void methodA(int a){ } D.public void methodA(int b){ }

29. 关于构造方法，下面说法错误的是（BC）。

A.父类只有一个带参的构造方法，子类必须显示声明带参构造方法 B.子类无参构造方法中没有写super();不会调用父类无参构造方法 C.子类无参构造方法不可以用super(int a);调用父类对应的带参构造方法 D.实例化一个类的对象时，一定会先调用java.lang.Object的构造方法 30.阅读下面代码，将会输出（B）。 public class Testa {

Integer a = new Integer(10); Integer b = new Integer(10);

public static void main (String[ ] args){ Testa testA = new Testa(); if (testA.a==testA.b){

System.out.print(\"很\"); }

if (testA.a.equals(testA.b)){ System.out.print(\"好\"); } } }

A.很 B. 好 C. 很好 D. 抛出NullPointerException异常 E. 编译错误 31. 阅读下面的代码，B类注释处可以放置的方法是（BCD）。 class A {

public void method(int a,float b){ //一些声明等等 } }

public class B extends A { // 这里放置方法 }

A.private void method(int i,float a) {…} B.public void method(int i,float f) {…} C.public void method() {…}

D.private int method(float f,int b) {…}

32. 关于Java的异常和异常处理，下面说法错误的是（CD）。 A.try/catch/finally块里都可以嵌套try/catch/finally

B.一个try可以对应多个catch

C.如果发生的异常没有被捕捉，异常将被系统忽略 D.异常处理时可以只用try块。

33. 关于Java的继承，下面说法错误的是（CD）。 A.接口可以继承接口

B.子类不可以继承父类的私有属性和私有方法

C.所有类都是java.lang.Object的子类，但是不可以这样写：public class Earth extends Object{}

D.一个类不可以继承(extends)另一个类，同时又实现(implements)一个接口 34. Thing是一个类，下面的代码可以产生（B）个Thing类型的对象。 Thing item; Thing stuff;

item = new Thing();

Thing entity = new Thing();

A.1 B.2 C.3 D.4 答案：

第一部分 1-5 AC A AB C A

第二部分 1-5 E D C CD C 6-9 B D D D 第三部分 1-5 C AC D D C 6-7 AD A

第四部分 1-5 B C B D C 6-10 A D A B C 11-15 A D D D C\\ 16-20 B A BD C C 21-25 ABCD C B A D 26-30 B C D BC B 31-34 BCD CD CD B

因篇幅问题不能全部显示，请点此查看更多更全内容

查看全文

全部栏目

复习提纲及练习题和答案