Java复习题

一、选择题

1、编译Java Application 源程序文件将产生相应的字节码文件，这些字节码文件的扩展名为( B )。

A. java B. .class C. html D. .exe

2、设 x = 1 , y = 2 , z = 3，则表达式 y＋＝z－－/＋＋x 的值是( A )。 A. 3 B. 3. 5 C. 4 D. 5

3、不允许作为类及类成员的访问控制符的是( C )。 A. public B. private C. static D. protected

4、为AB类的一个无形式参数无返回值的方法method书写方法头，使得使用类名AB作为前缀就可以调用它，该方法头的形式为( A )。

A. static void method( ) B. public void method( ) C. final void method( ) D. abstract void method( ) 5、指出下列程序运行的结果( B) public class Example{ String str=new String(\ 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+\ Sytem.out.print(ex.ch); }

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

A、good and abc B、good and gbc C、test ok and abc

D、test ok and gbc

6、运行下列程序, 会产生什么结果( A )

public class X extends Thread implements Runable{ public void run(){

System.out.println(\ }

public static void main(String args[]){ Thread t=new Thread(new X()); t.start(); } }

A、第一行会产生编译错误 B、第六行会产生编译错误 C、第六行会产生运行错误 D、程序会运行和启动

7、Java语言是( D ) A、面向问题的解释型高级编程语言 B、面向机器的低级编程语言

C、面向过程的编译型高级编程语言 D、面向对象的解释型高级编程语言

8、下列的变量定义中，错误的是( D ) A、int i;

B、int i=Integer.MAX_VALUE; C、static int i=100; D、int 123_$;

9、以下的变量定义语句中，合法的是( C ) A、float $_*5= 3.4F; B、byte b1= 15678;

C、double a =Double. MAX_VALUE; D、int _abc_ = 3721L;

10、若以下变量均已正确定义并赋值，下面符合Java语言语法的语句是( Ａ ) 不定。 A、b = a!=7 ; B、a = 7 + b + c=9; C、i=12.3* % 4;

D、a = a + 7 = c + b;

11、给定下面的代码片段：

1) String str = null;

2) if ((str != null) && (str.length() > 10)) { 3) System.out.println(\ 4) }

5) else if ((str != null) & (str.length() < 5)) { 6) System.out.println(\ 7) }

8) else { System.out.println(\

哪些行会导致错误？（C）解析：此题需要将代码仔细看清楚，查询没有逻辑错误。If?

A、line 1 B、line 2 C、line 5 D、line 8

12、看下面一段程序： class Aclass{

void go(){

System.out.println(\} }

public class Bclass extends Aclass{ void go{

System.out.println(\ }

public static void main(String args[]){ Aclass a=new Aclass(); Aclass a1=new Bclass(); a.go(); a1.go(); }

}

以上程序运行结果是：（Ｃ） A、Aclass

Aclass B、Bclass

Bclass C、Aclass

Bclass

else的使用没有问题，也没有拼写错误，错误在于第5行的“与”操作符的使用。逻辑操作符(logical operator)的“与”应该是&&，而&是位逻辑操作符(bitwise logical operator)的“与”，两者使用的对象不一样。逻辑操作符的“与”的左右操作数都应该是布尔型(logical boolean)值，而位逻辑操作符的左右操作数都是整型(integral)值。

D、Bclass

Aclass

13、运行下列程序，会产生什么结果：（Ｂ） class Outer1{

private int a;

void foo(double d,final float f){

String s;

final boolean b;

class Inner{

void methodInner(){

System.out.println(\ } } }

public static void main(String args[]) {

Outer1 me=new Outer1(); me.foo(123,123);

System.out.println(\ } }

A、in the Inner outer B、outer

C、in the Inner D、编译不通过

14、既能作为类的修饰符, 也能作为类成员的修饰符的是（Ａ） A、public B、extends C、Float D、static

15、下列选项中，用于定义接口的关键字是（Ｃ） A、import B、implements C、interface D、protected

16．下列语句序列执行后，k 的值是(Ｂ )。 int m=3, n=6, k=0;

while( (m++) < ( -- n) ) ++k; A) 0 B) 1 C) 2 D) 3

17．设 i、j 为int型变量名，a 为int型数组名，以下选项中，正确的赋值语句是( Ｂ)。

A) i = i + 2 B) a[0] = 7; C) i++ - --j; D) a(0) = 66;

18．Java语言的类间的继承关系是( Ｂ)。

A) 多重的 B) 单重的 C) 线程的 D) 不能继承

19．下列选项中，用于在定义子类时声明父类名的关键字是( Ｃ)。 A）interface B) package C) extends D) class 20．若已定义 byte[ ] x= {11,22,33,-66} ;

其中0≤k≤3，则对x数组元素错误的引用是( Ｃ)。 A) x[5-3] B) x[k] C) x[k+5] D) x[0]

21. 下列类定义中，不正确的是( Ｃ)。 A) class x { .... }

B) class x extends y { .... }

C) static class x implements y1,y2 { .... } D) public class x extends Applet { .... } 22. 设 x、 y为已定义的类名，下列声明x类的对象x1的语句中正确的是( Ａ)。 A) static x x1; B) public x x1=new x(int 123); C) y x1; D) x x1=x( );

23. 设 i、j、k 为类 x 中定义的 int 型变量名，下列类 x 的构造函数中不正确的是(Ｂ )。

A) x( int m){ ... } B) void x( int m){ ... }

C) x( int m, int n){ ... } D) x( int h,int m,int n){ ... }

24.61. 用于定义类成员的访问控制权的一组关键字是(Ｄ )。 A) class, float, double, public B) float, boolean, int, long C) char, extends, float, double D) public, private, protected

25．Java application中的主类需包含main方法，以下哪项是main方法的正确形参？（Ａ） A、String args args[]

26．以下关于继承的叙述正确的是（A）。 A、在Java中类只允许单一继承 B、在Java中一个类只能实现一个接口

C、在Java中一个类不能同时继承一个类和实现一个接口 D、在Java中接口只允许单一继承 27.设有下面两个赋值语句： a = Integer.parseInt(“12”);

b = Integer.valueOf(“12”).intValue(); 下述说法正确的是（ D ）。

A、a是整数类型变量，b是整数类对象。 B、a是整数类对象，b是整数类型变量。 C、a和b都是整数类对象并且值相等。

B、String ar[]

C、Char arg

D、StringBuffer

D、a和b都是整数类型变量并且值相等。

28．FilterOutputStream是BufferedOutputStream、DataOutputStream及PrintStream的父类，以下哪个类可能是FilterOutputStream构造函数的参数类型？ A A、OutputStream C、InputStream

B、File

D、BufferedOutputStream

29. 在使用interface声明一个接口时，只可以使用（ D）修饰符修饰该接口。 A、private

B、protected

C、private protected

D、public

30、已知如下定义：String s = \下面哪个语句不是合法的(Ｃ) A、s += \

B、s=s+100; D、String t =s+“abc”;

C、int len = s.length; A、import java.sql.*; C、import java.io.*; A、FileInputStream

31.下列哪一个import命令可以使我们在程序中创建输入/输出流对象（Ｃ）

B、import java.util.*; D、import java.net.*; B、FileOutputStream D、FileWriter

32、如果需要从文件中读取数据，则可以在程序中创建哪一个类的对象（Ａ） C、DataOutputStream

33、下列程序段执行后的结果是( Ａ )。

String s=new String(\for(int i=0;i

A) aceg B) ACEG C) abcdefg D) abcd

34、有整型数组：int[] x={12,35,8,7,2};,则调用方法Arrays.sort(x)后，数组x中的元素值依次是( Ａ ). A) 2 7 8 12 35

B) 12 35 8 7 2

D) 8 7 12 35 2

C) 35 12 8 7 2

35、下面的程序段创建了BufferedReader类的对象in，以便读取本机c盘my文件夹下的文件1.txt。File构造函数中正确的路径和文件名的表示是( Ｃ )。

File f = new File(填代码处); file =new FileReader(f); in=new BufferedReader(file);

A) \ B) \ C) \ D) \ 36、应用程序的main方法中有以下语句，则输出的结果是 ( Ａ )。

String s1=new String(\

String s2=new String(\ boolean b1=s1.equals(s2);

boolean b2=(s1==s2);

System.out.print(b1+\ \

A)true false B) false true C) true true D)false false 37.应用程序的main方法中有以下语句，则输出的结果是 ( A )。

String s1=\

double x=Double.parseDouble(s1); int y=Integer.parseInt(s2);

System.out.println(x+y);

A)12.5 B) 120.5 C) 12 D) “12.5”

38.以下关于java异常说法不正确的是（Ｄ）。

A)Throwable 类是 Java 语言中Error类和Exception类的父类。

B)当异常对象是Exception类（或其子类）的实例时，能通过 Java 虚拟机或者 throw 语句抛出该异常对象，并能通过try…catch…finally处理。

C)如果只用一个catch块捕捉多个异常对象，则catch 子句中的参数类型应是所有异常对象的父类。 D)以上说法都不对。

39．关于对象成员占用内存的说法哪个正确？ （ Ｂ ） A．同一个类的对象共用同一段内存

B、同一个类的对象使用不同的内存段，但静态成员共享相同的内存空间 C．对象的方法不占用内存 D．以上都不对

40．下列说法哪个正确？（C） A．不需要定义类，就能创建对象 B．对象中必须有属性和方法

C．属性可以是简单变量，也可以是一个对象 D、属性必须是简单变量

41．下列说法哪个正确？ （ A ） A、一个程序可以包含多个源文件 B、一个源文件中只能有一个类 C、一个源文件中可以有多个公共类 D、一个源文件只能供一个程序使用

42．关于方法main（）的说法哪个正确？（ C ）

A．方法main（）只能放在公共类中 B main()的头定义可以根据情况任意更改 C．一个类中可以没有main()方法

D．所有对象的创建都必须放在main()方法中 43．构造函数何时被调用？ （ A ） A、创建对象时 C、使用对象的方法时 A、可以有方法体 B、可以出现在非抽象类中 C、是没有方法体的方法

D、抽象类中的方法都是抽象方法

45．关于继承的说法正确的是： （ Ｂ ） A、子类将继承父类所有的属性和方法。 B、子类将继承父类的非私有属性和方法。 C、子类只继承父类public方法和属性 D、子类只继承父类的方法，而不继承属性

46．关于构造函数的说法哪个正确？ （ Ｃ ） A、一个类只能有一个构造函数 B、一个类可以有多个不同名的构造函数 C、构造函数与类同名

D、构造函数必须自己定义，不能使用父类的构造函数 47． this和super： C A、都可以用在main()方法中 B、都是指一个内存地址 C、不能用在main()方法中 D、意义相同

48．关于super的说法正确的是： B A、是指当前对象的内存地址

B、是指当前对象的父类对象的内存地址 C、是指当前对象的父类 D、可以用在main()方法中

49．覆盖与重载的关系是 （ Ａ ）

A、覆盖只有发生在父类与子类之间，而重载可以发生在同一个类中

B、类定义时

D、使用对象的属性时

44． 抽象方法： （ Ｃ ）

B．覆盖方法可以不同名，而重载方法必须同名 C．final修饰的方法可以被覆盖，但不能被重载 D．覆盖与重载是同一回事

50．关于接口哪个正确？ （ Ａ ） A、实现一个接口必须实现接口的所有方法 B．一个类只能实现一个接口 C．接口间不能有继承关系 D．接口和抽象类是同一回事

51．异常包含下列哪些内容？ （ Ａ ） A．程序执行过程中遇到的事先没有预料到的情况 B．程序中的语法错误 C．程序的编译错误 D．以上都是

52． 对于已经被定义过可能抛出异常的语句，在编程时： （ A、必须使用try／catch语句处理异常，或用throws将其抛出 B．如果程序错误，必须使用 try／catch语句处理异常 C．可以置之不理

D．只能使用try／catch语句处理

53． 字符流与字节流的区别在于（ Ｄ ） A．前者带有缓冲，后者没有 B．前者是块读写，后者是字节读写 C. 二者没有区别，可以互换使用 D. 每次读写的字节数不同

54．下列流中哪个不属于字节流 （ Ｄ ） A．FileInputStream B．BufferedInputStream C. FilterInputStream D. InputStreamReader

55. 8.下面不是面向对象技术特点的是(A)

(A).模块化 (B).封装 (C).继承性 (D).多态性56. 17.Java语言的编译器命令是(A) (A).javac

(B).java

(C).javaw

(D).jar

57. 19.关于实例方法和类方法的区别,下列描述正确的是(B) (A).实例方法是不用创建类的实例就可以直接调用

A ） (B).类方法是通过static关键字声明的方法 (C).实例方法属于类

(D).类方法是通过new以后才能调用的方法 58. 29.下列不是重载方法的特征的是(D) (A).参数个数不同 (B).参数名相同而类型不同 (C).参数类型不同 (D).参数名相同且类型相同

30.在Java中,名字必须与它所在的类的名字相同,而且不返回任何数据类型的方法是(A) (A).构造方法

(B).类方法

(C).实例方法

(D).重载方法

59. 34.组成java程序的基本要素是(C) (A).源代码 (B).软件

(C).类 (D).指令代码

60. 上转型对象的特点是(D)

(A).不能操作子类新增的成员对象 (B).可以操作子类继承或重写的对象 (C).可以将对象的上转型对象强制转移到一个子类的对象

二、简答题

1.Java中异常处理的机制

(D).以上都是

异常机制 1. try catch(先小后大) finally

2. 声明抛出异常：throws 3. 手动抛出异常：throw 4. 自定义异常

a) extends Exception或者他的子类

2.继承的概念

承是指一个对象直接使用另一对象的属性和方法。继承可以使得子类具有父类的各种属性和方法，而不需要再次编写相同的代码。在令子类继承父类的同时，可以重新定义某些属性，并重写某些方法，即覆盖父类的原有属性和方法，使其获得与父类不同的功能。同类事物具有共同性，在同类事物中，每个事物又具有其特殊性。运用抽象的原则舍弃对象的特殊性，抽取其共同性，则得到一个适应于一批对象的类，这便是基类（父类）,而把具有特殊性的类称为派生类（子类），派生类的对象拥有其基类的全部或部分属性与方法，称作派生类对基类的继承。

3.重载和重写的区别。 .重写必须继承，重载不用。

重写的方法名，参数数目相同，参数类型兼容，重载的方法名相同，参数列表不同。 重写的方法修饰符大于等于父类的方法，重载和修饰符无关。 .重写不可以抛出父类没有抛出的一般异常，可以抛出运行时异常

4.Java语言的特点

面向对象：所有设计都必须在类中实现，一个Java程序就是多个类的集合。 –安全性：良好的安全模型；摈弃了其它语言的不安全成份。

–多线程：提供环境级和语言级的多线程支持，提高了程序执行的并发度，提高

系统执行效率。-简单：Java源代码的书写不拘泥于特定的环境，可以用记事本、文本编辑器等编辑软件来实现，然后将源文件进行编译，编译通过后可直接运行，通过调试则可得到想要的结果。-动态：java可以在分布环境中动态地维护程序及其类库

–平台无关性：借助虚拟机，程序不经修改即可在不同硬件或软件平台上运行。 5.抽象类和接口的区别

抽象类的成员可以具有访问级别,而接口的成员全部public级别，抽象类可以包含字段,而接口不可以,抽象类可以继承接口,而接口不能继承抽象类，抽象类的成员可以具有具体实现,而接口不行。

抽象的子类可以选择性实现其基类的抽象方法,而接口的子类必须实现 6.Java多态性的概念，隐藏、覆盖和重载的概念

7.Java中构造方法的概念及特点。

构造方法的概念：构造方法是一种特殊的方法，它是一个与类同名且没有返回值类型的方法。对象的创建就是通过构造方法来完成，其功能主要是完成对象的初始化。当类实例化一个对象时会自动调用构造方法。构造方法和其他方法一样也可以重载。在Java中,任何变量在被使用前都必须先设置初值.Java提供了为类的成员变量赋初值的专门方法。特点：１．构造方法名一定与类同名

２．构造方法无返回值类型（void 也不行） 3、构造方法可以没有（默认一个无参构造方法），也可以有多个构造方法，他们之间构成重载关系

4、如果定义有参构造函数，则无参构造函数将被自动屏蔽 5、构造方法不能被继承

6、构造方法不能手动调用，在创建类实例的时候自动调用构造方法

8.接口的概念、性质和作用，接口回调的概念和作用

接口概念：Java接口是一系列方法的声明，是一些方法特征的集合，一个接口只有方法的特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为（功能）。 9. JVM加载class文件的原理机制 在Java中，类装载器把一个类装入Java虚拟机中，要经过三个步骤来完成：装载、链接和初始化，其中链接又可以分成校验、准备、解析 装载：查找和导入类或接口的二进制数据；

链接：执行下面的校验、准备和解析步骤，其中解析步骤是可以选择的； 校验：检查导入类或接口的二进制数据的正确性； 准备：给类的静态变量分配并初始化存储空间； 解析：将符号引用转成直接引用；

初始化：激活类的静态变量,初始化Java代码和静态Java代码块 10. final、static修饰符的作用

一、static修饰符：static修饰符可以修饰变量、方法或代码块。用static修饰的变量叫静态变量。静态变量有如下注意事项：类中的静态变量属于类，而不属于某个特定的对象。类的静态成员可以与类的名称一起使用，而无须创建类的对象。静态变量或方法也称为类的变量或方法。不管创建了类的多少实例，整个类中静态变量的副本只有一个，声明为static的变量实质上就是全局变量。

静态方法：类的静态方法只能访问其他的静态成员，不能访问非静态成员。静态方法中没有this关键字。静态方法不能被覆盖（重写）为静态方法。 静态代码块：静态代码块是由static和{}组成的代码片段 静态代码块使用时有如下注意事项：

如果需要通过计算来初始化静态变量，可以声明一个静态块。 静态块仅在该类被加载时执行一次。 只能初始化类的静态数据成员。

二、final修饰符：final修饰符可修饰类、方法和变量。final在修饰类、方法和变量时表示的意义是不同的，但本质是一样的，即final表示不可改变。 final修饰类：final修饰的类不能被子类继承。

final修饰方法时，有如下规定：使用在方法声明中使用final关键字向编译器表明子类不能覆盖此方法。使用在声明类中，一个final方法只能被实现一次。使用如果一个类为final类，那么它的所有方法都为隐式的final方法。

final修饰变量：一个变量可以声明为final，这样的目的是阻止它的内容被修改。声明final变量后，变量只能被初始化一次，然后就不能对其值进行修改了，一个final变量实质上是一个常量。 12. 面向对象的主要特征 1.抽象：抽象就是忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。抽象并不打算了解全部问题，而只是选择其中的一部分，暂时不用部分细节。抽象包括两个方面，一是过程抽象，二是数据抽象。过程抽象是指任何一个明确定义功能的操作都可被使用者看作单个的实体看待，尽管这个操作实际上可能由一系列更低级的操作来完成。数据抽象定义了数据类型和施加于该类型对象上的操作，并限定了对象的值只能通过使用这些操作修改和观察。

2.继承：继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。对象的一个新类可以从现有的类中派生，这个过程称为类继承。新类继承了原始类的特性，新类称为原始类的派生类（子类），而原始类称为新类的基类（父类）。派生类可以从它的基类那里继承方法和实例变量，并且类可以修改或增加新的方法使之更适合特殊的需要。

3.封装：封装是面向对象的特征之一，是对象和类概念的主要特性。封装是把过程和数据包围起来，对数据的访问只能通过已定义的界面。面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象，这些对象通过一个受保护的接口访问其他对象。一旦定义了一个对象的特性，则有必要决定这些特性的可见性，即哪些特性对外部世界是可见的，哪些特性用于表示内部状态。在这个阶段定义对象的接口。通常，应禁止直接访问一个对象的实际表示，而应通过操作接口访问对象，这称为信息隐藏。

4. 多态性：多态性是指允许不同类的对象对同一消息作出响应。多态性包括参数化多态性和包含多态性。多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题。 三、程序填空题 1.public class Sum{

public static void main(String [] args){

int j=10;

}

}

System.out.println(\calculate(j);

System.out.println(\

static void calculate(int j){ }

for (int i=0;i<10;i++)

j++;

System.out.println(\

输出结果为：

j is : 10 (1) j in calculate() is : 20(2) At last j is : 10(3) 2.按要求填空

abstract class SuperAbstract{ }

interface AsSuper { }

abstract class SubAbstract extends SuperAbstract implements AsSuper {

public void b(){…} }

public class InheritAbstract extends SubAbstract{

public void x(){…} public int c(int i ) {…} public String f(){…}

public static void main(String args[]){ abstract String f(); void x(); void a(){…} abstract void b(); abstract int c(int i);

}

}

InheritAbstract instance=new InheritAbstract(); instance.x(); instance.a(); instance.b(); instance.c(100);

System.out.println(instance.f());

在以上这段程序中：

抽象类有：SuperAbstract （1） (写出类名)

非抽象类有：InheritAbstract （2） (写出类名) 接口有：AuSuper （3） (写出接口名)

AsSuper中的x()方法是（4）抽象方法，所以在InheritAbstract中必须对它进行（5） 覆盖和实现 3.按注释完成程序 public class Leaf{ }

输出结果为 i=3 (3)

4. 按注释提示完成文件复制的程序 //FileStream源代码如下： import java.io.*; class FileStream {

private int i=0;//此属性值用于检验

Leaf increment(){//定义方法increment()，返回值是Leaf类的对象 }

void print(){ }

public static void main(String args[]){

Leaf x= new Leaf(); (2);//创建Leaf类的对象x x.increment().increment().increment().print(); System.out.println(\

i++;

return (1)this ;//将当前对象的地址作为返回值返回

}//多次调用方法increment()，返回的都是x的地址，i 值表示调用次数

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

File inFile = new File(\//指定源文件 File outFile = new File(\指定目标文件 FileInputStream fis =new FileInputStream(inFile);（1）; FileOutputStream fos = new FileOutputStream(outFile);

int c;

while ((c = fis.read ())!=-1)

}

5. 阅读程序，给出结果：

// AbstractClassDemo.java源代码如下：

abstract class Shape { //定义抽象类Shape和抽象方法display }

class Circle extends Shape { }

class Rectangle extends Shape { }

class Triangle extends Shape {

void display() { //实现抽象类的方法

System.out.println(\}

void display() { }

//实现抽象类的方法

System.out.println(\abstract void display();

fos.write(c);（2）;

fis.close(); fos.close();

}

catch (Exception e) {

System.out.println(\

}

//逐字节从源文件中输入，再输出到fos流

}

}

void display() { }

//实现抽象类的方法

System.out.println(\

public class AbstractClassDemo{ }

输出结果是 ? (1)Circle (2)Rectangle (3)Triangle 四、程序设计题

1.编写一个截取字符串的函数，输入为一个字符串和字节数，输出为按字节截取的字符串。 但是要保证汉字不被截半个，如\我ABC\，应该截为\我AB\，输入\我ABC汉DEF\，6，应该输出为\我ABC\而不是\我ABC+汉的半个\。 public class B1{

public static boolean isLetter(char c){ int k=0X80;

return c/k==0?true:false; }

public static int lengths(String strSrc){ if (strSrc==null){ return 0; }

int len=0;

char[] strChar=strSrc.toCharArray(); for (int i=0;i

if (!isLetter(strChar[i])) len++; }

return len; }

public static String subString(String origin,int len){ if (origin==null || origin.equals(\len<1){ return \ }

if (len>lengths(origin)){

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

(new Circle()).display(); //定义无名对象来调用对应的display方法 (new Rectangle()).display(); (new Triangle()).display();

return origin; }

byte[] strByte=new byte[len];

System.arraycopy(origin.getBytes(),0,strByte,0,len); int count=0;

for (int i=0;i

int value=(int)strByte[i]; if (value<0) count++; }

if (count % 2 !=0){

len=(len==1)?++len:--len; }

return new String(strByte,0,len);

}

public static void main(String[] args) {

System.out.println(\subString(\我ABC汉DEF\} }

2. 编写一个输出\！\的程序，用两种方式实现。 （１） public class a {

public static void main(String args[]) {

System.out.println(\ } } }

（２） public class B1{

public static void main(String[] args){ String a = \World\System.out.println(a); } }

3.设计类A和A的派生类B，要求：

1）A有两个数据成员a和b（都为int型）；B中继承了A中的a和b，又定义了自己的数据成员c（int型）。

2）为A添加含有两个参数的构造方法，对a和b初始化。 3）为B添加含有一个参数的构造方法，对c初始化。

4）完成主控方法，在主控方法中用B e1=new B(5)创建对象，把a、b、c分别初始化成3、4、5，最后输出它们的和。

4.打印输出10行杨晖三角形 public class YangHui {

public static void main(String args[]) { int r = 5;

int a[][] = new int[r + 1][]; for (int i = 0; i <= r; i++) { a[i] = new int[i + 1]; }

yanghui(a, r); }

static void yanghui(int a[][], int r) { for (int i = 0; i <= r; i++)

for (int j = 0; j <= a[i].length - 1; j++) {

if (i == 0 || j == 0 || j == a[i].length - 1) a[i][j] = 1; else

a[i][j] = a[i - 1][j - 1] + a[i - 1][j]; }

for (int i = 0; i <= r; i++) {

for (int j = 0; j <= a[i].length - 1; j++) System.out.print(a[i][j] + \ System.out.println(); } } }

5.编写一个程序用选择法对数组a[]={20,10,50,40,30,70,60,80,90,100}进行由大到小的排序。

public class B1 {

public static void main(String[] arg){ int a[]={20,10,50,40,30,70,60,80,90,100} ; int i,n,max;

for(i=0;i<=8;i++) {

for(n=i+1;n<=9;n++) {

if(a[i]

max=a[i]; a[i]=a[n]; a[n]=max;

} } }

for(i=0;i<=9;i++) {

System.out.println(a[i]); } } }

本文来源：https://www.bwwdw.com/article/8ibr.html