Java程序练习100题

更新时间：2023-09-28 20:24:01 阅读量：综合文库文档下载

说明：文章内容仅供预览，部分内容可能不全。下载后的文档，内容与下面显示的完全一致。下载之前请确认下面内容是否您想要的，是否完整无缺。

400套JAVa程序推荐度：
相关推荐

上机练习题

一、java语言基础和面向对象

练习1（4）

掌握：各种数据类型变量的定义和访问，各种数据类型常量的使用，数据类型转换。

1. 编写Applet，其功能为：取两个小于1000的正随机数，若两个数均小于10，先将它们都放大50倍，否则不改变这两个数。最后，求这两个数的和并将结果输出。要求这些功能在主类的方法init( ) 中实现，并使输出结果仅保留小数点后4位（不需四捨五入）。 @程序

import java.awt.*; import java.applet.*;

public class Applet1 extends Applet { public void init( ) {

Label out1=new Label(\ \ Label out2=new Label(\ \ double x,y; add(out1); add(out2); x=Math.random( )*1000; y=Math.random( )*1000;

if(x<10&y<10) { x*=50; y*=50; } out1.setText(\约等于 \ out2.setText(\ } }

2. 请编写一个Applet，其功能为：取一个小于10000的正随机整数，并输出该数的平方根。要求这些功能在主类的方法paint( ) 中实现，并使输出结果在四捨五入后保留小数点后4位。 @程序

import java.awt.*; import java.applet.*;

public class Applet1 extends Applet { public void paint(Graphics g) { int k;

k=(int)(Math.random( )*1000); g.drawString(\的平方根约等于 \ (int)((Math.sqrt(k)+0.00005)*10000)/10000.0,20,20); } }

3. 编写一个Applet，其功能为：取一个50~200之间的正随机整数，如果该数为奇数则求它的平方根并转换成float型数后再输出；如果该数为偶数则求它的平方并输出。 @程序

import java.awt.*; import java.applet.*;

public class Applet1 extends Applet { public void paint(Graphics g) { int k; k=50+(int)(Math.random( )*150); if(k%2!=0) g.drawString(\的平方根约等于 \ else g.drawString(\的平方等于 \ } }

4. 请编写一个Application，其功能为：取一个小于800的正随机整数，将其以如下形式输出：所取随机数为：*** 它的百位数字为：* 它的十位数字为：* 它的个位数字为：* @程序

//import java.io.*;

public class Class1 { public static void main (String[] args) { int x=(int)(Math.random( )*800); System.out.println(\所取随机数为:\ System.out.println(\它的百位数字为:\ System.out.println(\它的十位数字为:\ System.out.println(\它的个位数字为:\ //try{ System.in.read( ); }catch(IOException e){ } } }

练习2（5）

掌握：（1）数组的定义、创建和初始化。（2）方法的定义和调用。

（3）方法的参数是数组、方法的返回值是数组的编程。（4）方法的递归调用。

（5）在应用程序中，接受并处理命令行参数。

1.请编写一个Applet,其中定义了两个double类型数组a和b，还定义了一个方法square( )。数组a各元素的初值依次为1.2、2.3、3.4、4.5、5.6，数组b各元素的初值依次为9.8、8.7、7.6、6.5、5.4、4.3；方法square( )的参数为double类型的数组，返回值为float类型的数组,功能是将参数各元素的平方做为返回数组的元素的值。请在方法paint（）中分别以a和b为实在参数调用方法square( )，并将返回值输出在屏幕上。要求调用square( a )的返回数组输出在Applet的一行上，数组的第一个元素的输出坐标为（20，20），其后的每个元素间隔40个像素。调用square( b )的返回数组输出在Applet的一列上，即下标为i+1(i=0,1,2,3,......)的元素的值,在下标为i的元素的值的正下方，其返回数组的第一个元素的输出坐标为（20，40），行隔为20像素。 @程序

import java.awt.*; import java.applet.*;

public class Applet1 extends Applet { double a[ ]={1.2,2.3,3.4,4.5,5.6}; double[ ] b={9.8,8.7,7.6,6.5,5.4,4.3}; public void paint(Graphics g) { float[ ] x=new float[a.length]; float[ ] y=new float[b.length]; x=square(a); y=square(b); for(int i=0; i

2. 请编写一个Application实现如下功能：在主类中定义两个double类型数组a和b，再定义一个方法sqrt_sum( )。数组a各元素的初值依次为1.2、2.3、3.4、4.5、5.6，数组b各元素的初值依次为9.8、8.7、7.6、6.5、5.4、4.3；方法sqrt_sum ( )的参数为double类型的数组，返回值类型为float型,功能是求参数各元素的平方根之和。请在主方法main（）中分别以a和b为实在参数调用方法sqrt_sum ( )，并将返回值输出在屏幕上。 @程序

//import java.io.*; public class Class1 { }

3. 请编写一个Application实现如下功能：在主类中定义方法f1(int n) 和方法f2(int n)，它们的功能均为求 n!，方法f1( ) 用循环实现，方法f2( )用递归实现。在主方法main( ) 中，以4为实在参数分别调用方法f1( ) 和方法f2( )，并输出调用结果。 @程序

//import java.io.*; public class Class1 {

public static void main (String[] args) {

System.out.println(\用循环实现求 n! 的结果(n=4):\System.out.println(\用递归实现求 n! 的结果(n=4):\//try{ char c=(char)System.in.read( );}catch(IOException e){ } static double a[ ]={1.2,2.3,3.4,4.5,5.6}; static double b[ ]={9.8,8.7,7.6,6.5,5.4,4.3}; public static void main (String[] args) { }

static float sqrt_sum(double[ ] x) { }

double y=0.0;

for(int i=0; i

System.out.println(\数组a各元素的平方根之和为:\System.out.println(\数组b各元素的平方根之和为:\//try{ char c=(char)System.in.read( );}catch(IOException e){ }

}

static long f1(int n) {

long k=1;

for(int i=1;i<=n;i++)

k*=i;

}

static long f2(int n) { }

if(n==1) return 1; else return n*f2(n-1); return k;

}

4. 请编写一个Application实现如下功能：接受命令行中给出的三个参数x1、x2和op，其中x1和x2为float型数，op是某个算数运算符（+、 —、*、/ 之一），请以如下形式输出 x1 和x2执行 op 运算后的结果（假设x1的值为269，x2的值为18，op为运算符—）： 269 – 18=251 @程序

public class Class1 { public static void main (String[] args) { float x,y; char op; if(args.length >= 3) { x=Float.valueOf(args[0]).floatValue( ); y=Float.valueOf(args[1]).floatValue( ); op=args[2].charAt(0); switch(op) { case '+': System.out.println(x+\ break; case '-': System.out.println(x+\ break; case '*': System.out.println(x+\ break; case '/': System.out.println(x+\ break; default : System.out.println(\非法运算符!\ } } else { System.out.println(\命令行参数错!\ System.exit(-1); } } }

5. 编写Application，主类中包含以下两个自定义方法： void printA( int[ ] array )和int[]

myArray(int n)。方法printA(int[ ] array)的功能是把参数数组各元素在屏幕的一行中输出。方法myArray(int n)的功能是生成元素值是50~100之间的随机值的int型数组，数组元素的个数由参数n指定。在应用程序的main（）方法中，用命令行传入的整数作为myArray(int n) 方法调用时的实际参数，生成一个整型数组，并调用方法printA（）输出该数组的所有元素。 @程序

public class Class1 { static int n; public static void main (String[] args) { if(args.length > 0) { n=Integer.parseInt(args[0]); int[ ] a=new int[n]; a=myArray(n); printA(a); } else { System.out.println(\缺命令行参数!\ System.exit(-1); } } static void printA(int[ ] x) { for(int i=0; i< x.length; i++) System.out.print(x[i]+\ \ System.out.println( ); return; } static int[ ] myArray(int k) { int x[ ]=new int[k]; for(int i=0; i< k; i++) x[i]=50+(int)(Math.random( )*50); return x; } }

练习3（3）

掌握：方法的重载。

1. 请编写一个Applet，其主类名为Applet1，其中包含两个同名方法arrayMin( ),它们都只有一个参数，其中一个arrayMin( )方法的参数为int型数组，返回值类型为int型数；另一个arrayMin( )方法的参数为double型数组，返回值类型为double型数；这两个方法的功能均为返回参数数组元素的最小值。通过paint( )方法调用上述两个同名方法arrayMin( )，求数组a (其元素的值依次为26，82，-3，65，18，9)和数组b (其元素的值依次为3.6，57.2，8.5，78.8) 的最小元素的值并输出。 @程序

import java.awt.*;

import java.applet.*;

public class Applet1 extends Applet { int a[ ]={26,82,-3,65,18,9}; double b[ ]={3.6,57.2,8.5,78.8}; public void paint(Graphics g) { g.drawString(\数组a 的最小元素的值为: \ g.drawString(\数组b 的最小元素的值为: \ } int arrayMin(int x[ ]) { int y=x[0]; for(int i=1; i< x.length; i++) if(y>x[i]) y=x[i]; return y; } double arrayMin(double x[ ]) { double y=x[0]; for(int i=1; i< x.length; i++) if(y>x[i]) y=x[i]; return y; } }

2. 请编写一个Application，其主类名为Class1，其中包含三个同名方法mySqrt()，它们都只有一个参数，参数的类型分别为int型、float型和double型，它们的功能均为返回参数的平方根，返回值的类型与参数的类型相同。在主方法main( ) 中调用上面的三个方法，这三个方法的参数均来自命令行参数，最后将计算结果输出在屏幕上。 @程序

public class Class1 { static int n; public static void main (String[] args) { if(args.length >= 3) { int n; float f; double d; n=Integer.parseInt(args[0]); f=Float.valueOf(args[1]).floatValue( ); d=Double.valueOf(args[2]).doubleValue( ); System.out.println(n+\的平方根为: \ System.out.println(f+\的平方根为: \ System.out.println(d+\的平方根为: \ } else { System.out.println(\缺命令行参数!\ System.exit(-1); }

} static int mySqrt(int x) { return (int)Math.sqrt(x); } static float mySqrt(float x) { return (float)Math.sqrt(x); } static double mySqrt(double x) { return Math.sqrt(x); } }

3. 请编写一个Applet，其主类名为Applet1，其中包含三个同名方法addM(int x, byte y)、addM(float x,double y)、addM(double x,double y)，它们的功能均为求两个参数之和，返回值类型与第一个参数的类型相同。在主类Applet1中，通过paint( )方法调用上面的三个方法，实现12345+67、89.6f+6.9e-8、0.987654321+32.1，然后将计算结果输出，输出位置分别为坐标（20，40）、（20，60）、（20，80）。 @程序

import java.awt.*; import java.applet.*;

public class Applet1 extends Applet { public void paint(Graphics g) { g.drawString(\ g.drawString(\

g.drawString(\ } int addM(int x, byte y) { return x+y; } float addM(float x,double y) { return (float)(x+y); } double addM(double x,double y) { return x+y; } }

练习4（3）

掌握: (1) 类的继承。

(2) 在子类中如何操作父类中的私有属性。 (3) 变量的作用域。

1. 请编写Applet，它由三个类定义组成，类名分别为A、B和Applet1：类A中定义了一个类型为float的属性f和一个类型为byte的私有属性k；类A还定义了一个带有一个参数的构造函数（用于初始化f），和两个公共方法setk( )和getk( ), 其中setk( ) 的功能为给私有属性k赋值,getk( )的功能为返回私有属性k的值。类B是类A的子类，其中仅定义了一个类型为boolean的属性b和一个带两个参数的构造函数（用来为父类中的变量f和本类的变量b做初始化）。主类Applet1中定义了一个初值为123的int型变量n和一个B类的对象x，请通过创建x为上述f和b赋值(f的值为68.963,b的值为true); 在paint()方法中, 给A类的私有属性k赋值66，然后显示f，k，b，n的值。

@程序

import java.awt.*; import java.applet.*;

public class Applet1 extends Applet { int n=123; B x=new B(68.963f,true); public void paint(Graphics g) { x.setk((byte)66); g.drawString(\ k=\ b=\ n=\ } }

class A { float f; private byte k; A(float f1){ f=f1; } public byte getk( ){ return k; } public void setk(byte m){ k=m; } }

class B extends A { boolean b; B(float ff,boolean bb){ super(ff); b=bb; } }

2. 请按如下要求定义两个类A和B, 类A中定义一个double 类型变量d（将其赋值为8.8）和一个方法int_d(double dd )，该方法的功能是返回参数dd的整数部分。类B是类A的子类，其中定义一个float 类型变量f（将其赋值为18.3）和一个方法int_f(float ff )，该方法的功能是返回参数ff的整数部分。编写一个Application，创建类B的对象b，在主方法main( ) 中先显示d和f的值，然后分别以d和f为实在参数调用int_d( )方法和int_f( )方法，并将它们的返回值显示在屏幕上。 @程序

public class Class1 { public static void main (String[] args) { B b=new B( ); System.out.println(\ f=\ System.out.println(\的整数部分=\ f的整数部分=\ } }

class A { double d=8.8; int int_d(double dd){ return (int)dd; } }

class B extends A { float f=18.3f;

int int_f(float ff){ return (int)ff; } }

3. 请编写一个Application ，在其主类中定义一个int 类型变量i ，并令其初值为123 ；主类中还定义了 m1( )和m2( )等两个方法。在主方法main( ) 和方法m1( )中也各定义一个int 类型变量i ，它们的初值分别为456和789 ；方法m1( )的功能是输出它的局部变量i的值；方法m2( )的功能是先输出类变量i 的值，然后使类变量i 增加值 6后再次输出其值；主方法main( ) 的功能是先输出它的局部变量i的值，然后先后调用m1( )和m2( )实现它们的功能。 @程序

public class Class1 { static int i=123; public static void main (String[] args) {

int i=456; System.out.println(\中的 i=\ m1( ); m2( ); } static void m1( ) { int i=789; System.out.println(\中的 i=\ } static void m2( ) { System.out.println(\类变量 i=\ i+=6; System.out.println(\加 6后的类变量 i=\ } }

练习5（5）

掌握：（1）方法的参数为类对象、方法的返回值为类对象。

（2）方法覆盖：在子类中调用被子类覆盖了的父类的同名方法。（3）属性隐藏：在子类中访问被子类隐藏了的父类的同名属性。（4）构造函数的重载。

1. 请编写一个Applet，它由两个类定义组成：类A中定义了short型变量i和char型变量ch，及一个带两个参数的构造函数（为变量i和ch做初始化）。主类Applet1中创建了两个A类的对象x1（i的初始值为12，ch的初始值为’6’）和x2（i的初始值为62，ch的初始值为65），还定义了一个方法b，b的参数和返回值均为A类的对象，功能为将参数对象的属性i加3，属性ch也加3，使返回结

果为另一个A类的对象（即不破坏实在参数的值）。请在paint()方法中先输出x1、x2的属性值，然后再分别以x1、x2为实在参数调用方法b( )，并输出调用结果，最后再次输出x1、x2的属性值。 @程序

import java.awt.*; import java.applet.*;

public class Applet1 extends Applet { A x1,x2; public void init( ) { x1=new A((short)12,'6'); x2=new A((short)62,(char)65); } public void paint(Graphics g) { A a1=new A((short)0,' '); A a2=new A((short)0,' '); g.drawString(\对象x1的属性值: i=\ ch=\ g.drawString(\对象x1的属性值: i=\ ch=\ a1=b(x1); a2=b(x2);

g.drawString(\以x1为实参调用方法b( ) 生成的新的A类对象的属性值: i=\ +a1.i+\ ch=\ g.drawString(\以x2为实参调用方法b( ) 生成的新的A类对象的属性值: i=\ +a2.i+\ ch=\ g.drawString(\调用后，对象x1的属性值: i=\ ch=\ g.drawString(\调用后，对象x1的属性值: i=\ ch=\ } A b(A y) { A a=new A((short)0,' '); a.i=(short)(y.i+3); a.ch=(char)(y.ch+3); return a; } }

class A { short i; char ch; A(short i1,char c1){ i=i1; ch=c1; } }

2. 请按如下要求定义两个类A和B, 类A中定义一个char类型属性x（将其赋值为65）和一个在小程序窗口中输出x值的方法myPrint()。类B是类A的子类，其中定义一个int 类型属性y（将其赋值为16）和String类型的属性s（将其赋值为“java program!”）；类B中也定义了一个名为myPrint的方法，其功能为在小程序窗口中输出y和s值；类B中还有一个方法printAll( )，该方法中分别调用父类和子类的myPrint()方法做输出。编写一个Applet，在主类Applet1中创建类B的对象b，调用printAll( )方法输出对象b 的属性值。 @程序

import java.awt.*; import java.applet.*;

public class Applet1 extends Applet

{ B b=new B( ); public void paint(Graphics g) { b.printAll( g); } }

class A { char x=65;

void myPrint(Graphics g) { g.drawString(\} }

class B extends A { int y=16; String s=\ void myPrint(Graphics g) { g.drawString(\ s=\ } void printAll( Graphics g) { super.myPrint(g); myPrint(g); } }

3. 请按如下要求定义两个类A和B, 类A中定义一个方法area(float r), 其返回值类型为float型，该方法的功能是返回半径为r的圆的面积（圆的面积公式为：?r2，其中 r是圆的半径）。类B是类A的子类，其中也定义了一个名为area的方法area(float r)，该方法的功能是返回半径为r的球的表面积（球的表面积的计算公式为：4πr2，其中r为球的半径），返回值类型也为float型；在类B中还定义了另一个方法myPrint(float r)，功能是分别调用父类和子类的方法area( )计算半径相同的圆的面积和球的表面积并输出调用结果。编写一个Application，创建类B的对象b，在主方法main( )中调用myPrint(float r), 输出半径为1.2的圆的面积和半径为1.2的球的表面积。 @程序

public class Class1 { public static void main (String[] args) { B b=new B( ); b.myPrint(1.2f ); } }

class A {

float rear(float r) { return (float)Math.PI*r*r; } }

class B extends A { float rear(float r) { return 4*(float)Math.PI*r*r; } void myPrint(float r) { System.out.println(\半径为 \的圆的面积=\ +\ 同半径的球的表面积=\

} }

4. 请编写Applet，它由三个类定义组成: 类A中只定义了一个类型为String的对象x和带有一个参数的构造函数（用来初始化x）；类B是类A的子类，其中定义了一个int类型的变量x和一个带两个参数的构造函数（用来为父类中的对象x和类B中的变量x做初始化），还定义了一个方法myPrint( )，功能为输出父类A中的x和其子类B 中的x的值；主类Applet1中定义了B类的对象b，请通过创建b为上述两个x赋值(类A中的x的值为“这是父类的x.”, 类B中的x的值为68)，通过paint()方法在坐标（20，30）处显示两个x的值。 @程序

import java.awt.*; import java.applet.*;

public class Applet1 extends Applet { } class A {

String x; }

class B extends A { }

5. 请编写Applet，它由三个类定义组成, 类名分别为A、B和Applet1：类A中定义了类型为int的变量i、类型为float的变量f和类型为char的变量ch；类A还定义了三个构造函数，其中,第一个构造函数带有一个int类型的参数（用于初始化i），第二个构造函数带有两个参数（参数类型分别为int和float,用于初始化i和f）, 第三个构造函数带有三个参数（参数类型分别为int、float和char,用于初始化i、f和ch）。类B是类A的子类，其中仅定义了一个类型为boolean的变量b和一个带四个参数的构造函数（用来为父类中的变量i、f、ch和本类的变量b做初始化）。主类Applet1中定义了一个初值为32.6的double型变量d和一个B类的对象b，请通过创建b为上述i、f、ch和b赋值(i的值为50,f的值为7.2,ch的值为’h’,b的值为true)，用paint()方法在（10，30）位置处显示i,f,ch,b,d的值。

int x;

B(String x1,int x2){ super(x1); x=x2; void myPrint(Graphics g) {

g.drawString(\父类A中x的值=\ 子类B中x的值=\ }

}

A(String x1){

x=x1;

}

B b=new B(\这是父类的x.\public void paint(Graphics g) {

b.myPrint(g);

}

@程序

import java.awt.*; import java.applet.*;

public class Applet1 extends Applet { double d=32.6; B b=new B(50,7.2f,'h',true ); public void paint(Graphics g) { g.drawString(\ f=\ ch=\ b=\ d=\ } }

class A {

int i; float f; char ch; A(int x){ i=x; } A(int x,float y){ this(x); f=y; }

A(int x,float y,char z){ this(x,y); ch=z; } }

class B extends A { boolean b; B(int x,float y,char z,boolean w){ super(x,y,z); b=w; } }

练习6（5）

掌握：接口、抽象类、最终类的编程；字符串的使用。

1. 定义接口A，接口内有两个方法： method1(int x)和method2(int x,int y)，它们的返回值类型均为int。请编写一个Applet，并使其实现接口A：令方法method1(int x)的功能是求5的x次方、方法method2(int x,int y) 的功能是求两参数的最大值。在paint（）方法中调用这两个方法，显示method1(2)和 method2(2,8)的结果。 @程序

import java.awt.*; import java.applet.*;

public class Applet1 extends Applet implements A { public void paint(Graphics g) { g.drawString(\调用method1(2)的结果： \ g.drawString(\调用method2(2,8)的结果： \

} public int method1(int x) { int result=1; for(int i=1;i<=x;i++) result*=5; return result; } public int method2(int x,int y) { return x>y?x:y; } }

interface A { public abstract int method1(int x); public abstract int method2(int x,int y); }

2. 定义名为VolumeArea的抽象类，在其中定义圆周率?的值为3.14159，并定义两个抽象方法volume(double r)和area(double r)，它们的返回值类型均为float。再定义以类VolumeArea为父类的子类VolumeAndArea，在该子类中实现父类中的抽象方法：方法volume(double r) 的功能是求半径为r的球的体积（公式为：4?r3?3）；方法area(double r)的功能是求半径为r的圆的面积（公式为：?r2）。请编写一个Application ，在其主类中定义一个VolumeAndArea类的对象x，通过对象x求半径为r(r的值由命令行给定)的球的体积及该球最大切面的圆的面积，并输出计算结果。 @程序

public class Class1 {

static VolumeAndArea x=new VolumeAndArea( ); public static void main(String[ ] args) {

float r=Float.valueOf(args[0]).floatValue( );

System.out.println(\半径为\的球的体积=\ System.out.println(\半径为\的圆的面积=\ } }

abstract class VolumeArea {

static final float myPI=3.14159f;

public abstract float volume(double r); public abstract float area(double r); }

class VolumeAndArea extends VolumeArea {

public float volume(double r) {

return (float)(4*myPI*r*r*r/3); }

public float area(double r) {

return (float)(myPI*r*r); } }

3. 定义类A，在其中定义一个final变量myPI，其类型为float，值为3.1416；类A中还定义一个final方法 m1(float r)，该方法返回值类型为float，功能是求半径为r的圆的周长（公式为：2?r）。再定义类A的子类B，B为final类，其中定义一个返回值类型为void的方法 m2(float r)，功能是先调用父类的方法m1( )求半径为r的圆的周长并输出计算结果，然后输出同一个圆的面积（公式为：?r2）。请编写一个Application ，利用类B计算并输出半径为5的圆的周长和面积。 @程序

public class Class1 {

static B x=new B( );

public static void main(String[ ] args) {

x.m2(5); } }

class A {

final float myPI=3.1416f;

public final float m1(float r) { return 2*myPI*r; } }

final class B extends A {

public void m2(float r) {

System.out.println(\半径为\的圆的周长=\ System.out.println(\半径为\的圆的面积=\ } }

4．编写应用程序，功能为：从命令行传入一个包含十个字符的字符串，把该字符串与程序中给定的字符串\依次比较，统计两个串中对应字符相等的数目。然后输出命令行输入的字符串，并把两个串中对应字符不相等的字符替换为'@'后生成的新串输出,最后输出两个串中相等字符的数目。 @程序

public class Class1 {

public static void main(String args[]) throws IOException {

if(args[0].length()<10) System.out.print(\else

}

{ }

String str=new String(\int n=0;

System.out.print(\for (int x=0;x

System.out.print(\ \

System.out.println();

System.out.print(\ Student answer:\for (int x=0;x

System.out.println( );

System.out.println(\

if (args[0].charAt(x)==str.charAt(x)) {

n++; System.out.print(\ \}

System.out.print(\ \

else

5. 请编写一个Application实现如下功能：接受命令行中给出的一个字母串，先将该串原样输出，然后判断该串的第一个字母是否为大写，若是大写则统计该串中大写字母的个数，并将所有大写字母输出；否则输出信息串”第一个字母不是大写字母!”。 @程序

public class Class1 { public static void main(String args[]) {

int count=0; if(args.length!=0) { System.out.println(args[0]); if((int)args[0].charAt(0)>=65 && (int)args[0].charAt(0)<=90) {

for(int i=0;i=65 && (int)args[0].charAt(i)<=90)

{ System.out.print(args[0].charAt(i)); Count++; } System.out.println( );

System.out.println(―共有 ‖+count+‖ 个大写字母。‖); } else System.out.println(\第一个字母不是大写字母!\ }

}

else System.out.println(\请给出命令行参数!\

练习7（5）

掌握：命令行传参数。

1．请编写一个实现如下功能的Application：比较命令行中给出的两个整数是否相等，并根据比较结果显示\相等\或\不相等\。 public class Class1 { public static void main (String[] args) { int x,y; String str=\ if(args.length < 2) { System.out.println(\请在命令行输入两个参数\ System.exit(-1); } x=Integer.parseInt(args[0]); y=Integer.parseInt(args[1]); if (x==y) str=\命令行输入的两个参数相等\ else str=\命令行输入的两个参数不相等\ System.out.println( str ); } }

2．编写一个Application程序，比较命令行中给出的两个字符串是否相等，并输出比较的结果。 import java.io.*; public class Class1 { public static void main (String[] args) { if( args.length < 2 ) { System.out.println( \ string2\ System.exit(-1); } if(args[0].equals(args[1])) System.out.println( args[0]+\和 \相等 \ else System.out.println( args[0]+\和 \不等 \ } }

3．从命令行传入3个整数，求3个整数的和、积、最大值、最小值。 public class Class1 { public static void main (String[] args) { int n=args.length; if(n<3) System.out.println(\请输入三个整数!\ else { int a,b,c; a=Integer.parseInt(args[0]); b=Integer.parseInt(args[1]); c=Integer.parseInt(args[2]); System.out.println(\和：\ System.out.println(\积：\ System.out.println(\最大值：\ System.out.println(\最小值：\ } } }

4．请编写一个Application实现如下功能：通过命令行中给出的float型参数x, 和int型参数y（如果参数少于两个，给出提示后退出系统），调用Math类中的方法求x的y次方并输出。 import java.io.*; public class Class1 { public static void main (String[] args) { int x,y; String str=\ if(args.length < 2) { System.out.println(\ number2\ System.exit(-1); } x=Float.valueOf(args[0]).floatValue( ); y=Integer.parseInt(args[1]); str=str+x+\的 \次方 = \ System.out.println( str ); } }

5．编写Application,求从命令行传入任意多个整数的最大值、最小值、平均值。 public class Class1 { public static void main (String[] args) { int n=args.length; if(n==0)

System.out.println(\ else { int x[]=new int[n]; for(int i=0;i

static int ArrayMax( int array[] ) { int max = array[0]; for( int i =1; i < array.length; i++) { if ( array[i] > max ) { max = array[i]; } } return max; }

static int ArrayMin( int array[] ) { int min = array[0]; for( int i =1; i < array.length; i++) if ( array[i] < min ) min = array[i]; return min; } static int ArrayAve( int array[] ) { int sum=0; for( int i =0; i < array.length; i++) sum+=array[i]; return sum/array.length; } }

6．请编写一个实现如下功能的Application：从命令行依次取三个参数 x, y, op 做算术运算，其中 x, y为 int 型数据，op 为运算符（＋、－、×、÷ 之一）,请显示 x op y 的结果。 public class MainParameters { public static void main(String args[]) { int x, y; char op; String str=\

j = myList.getSelectedIndex(); repaint(); }

public void paint( Graphics g ) {

if(b) switch(j) {

case 0: g.setColor( colors[j] );g.drawRect(10,10,30,60); break; case 1: g.setColor( colors[j] );g.drawOval(10,10,30,30); break; case 2: g.setColor( colors[j] );g.drawOval(10,10,60,30); break; case 3: g.setColor( colors[j] );g.fillArc(10,10,80,60,30,30); break; case 4: g.setColor( colors[j] );g.drawLine(10,10,60,60); } } }

练习14（11）

掌握：（1）鼠标事件（鼠标进入、移出、压下、点击、释放）的编程。（2）键盘事件（按下键、松开键、点击键）的编程。（3）布局管理器。

1. 编写Applet, 当鼠标进入Applet时，通过paint()方法以（60，60）为左上角坐标，填充一个颜色为黄色的、边长为60的正方形；鼠标移出时，以（60，120）为左上角坐标，画一个颜色为绿色的、边长为30的正方形框。 @程序

import java.awt.*; import java.applet.*; import java.awt.event.*;

public class Applet1 extends Applet implements MouseListener { int i; public void init(){ addMouseListener(this); } public void paint(Graphics g) { if(i==1) { g.setColor(Color. yellow); g.fillRect(60,60,60,60); } if(i==2) { g.setColor(Color.green); g.drawRect(60,120,30,30); } } public void mouseClicked(MouseEvent e){ } public void mousePressed(MouseEvent e){ } public void mouseEntered(MouseEvent e){ i=1; repaint(); } public void mouseExited(MouseEvent e) { i=2; repaint(); } public void mouseReleased(MouseEvent e) { } }

2. 编写Applet, 当鼠标进入Applet时，通过paint()方法在坐标（20，50）处，显示一幅图像，图像名称为a.gif，显示的高、宽分别为50、80；鼠标移出时，在坐标（70，130）处，显示另一幅图像，图像名称为b.gif，显示的高、宽分别为80、60。这些图像与嵌入该小程序的网页在同一目录下（程

序中用到的图像在计算机中找）。 @程序

import java.awt.*; import java.applet.*; import java.awt.event.*;

public class Applet1 extends Applet implements MouseListener { int i; Image pic1,pic2; public void init() { pic1=getImage(getDocumentBase(),\ pic2=getImage(getDocumentBase(),\ addMouseListener(this); } public void paint(Graphics g) { if(i==1) { g.drawImage(pic1,20,50,50,80,this); } if(i==2) { g.drawImage(pic2,70,130,80,60,this); } } public void mouseClicked(MouseEvent e) { } public void mousePressed(MouseEvent e) { } public void mouseEntered(MouseEvent e) { i=1; repaint(); } public void mouseExited(MouseEvent e) { i=2; repaint(); } public void mouseReleased(MouseEvent e) { } }

3. 编写Applet, 通过paint()方法在鼠标压下时，在坐标（30，30）处显示一幅图像，图像名称为a.gif，显示的高、宽分别为90、90（程序中用到的图像在计算机中找，并使其与嵌入该小程序的网页在同一目录）。点击鼠标时，在窗口的状态栏中输出字符串“这个图像真美丽！”。 @程序

import java.awt.*; import java.applet.*; import java.awt.event.*;

public class Applet1 extends Applet implements MouseListener { int i; Image pic; public void init() { pic=getImage(getDocumentBase(),\ addMouseListener(this); } public void paint(Graphics g) { if(i==1) { g.drawImage(pic,30,30,90,90,this); } if(i==2) showStatus(“这个图像真美丽！”); } public void mouseClicked(MouseEvent e) { i=2; repaint(); }

public void mousePressed(MouseEvent e) { i=1; repaint(); } public void mouseEntered(MouseEvent e){ } public void mouseExited(MouseEvent e){ } public void mouseReleased(MouseEvent e){ } }

4. 编写Applet, 当压下鼠标时，在鼠标压下处显示字符串“释放鼠标将显示图象”，要求显示字体的名称为\、普通体、字体大小为25。当释放鼠标时，以鼠标释放处为左上角坐标，显示一幅jpg图像，图像显示的宽、高分别为200、120像素（图像在计算机中查找）。 @程序

import java.awt.*; import java.applet.*; import java.awt.event.*;

public class Applet1 extends Applet implements MouseListener { int x,y,k; Image pic; public void init() { pic=getImage(getDocumentBase(),\ addMouseListener(this); } public void paint(Graphics g) { if(k==1) { Font f1=new Font(\ g.setFont(f1); g.drawString(\释放鼠标将显示图象。\ } if(k==2) { g.drawImage(pic,x,y,200,160,this); } } public void mouseClicked(MouseEvent e){ } public void mousePressed(MouseEvent e) { k=1; x=e.getX(); y=e.getY(); repaint(); } public void mouseEntered(MouseEvent e){ } public void mouseExited(MouseEvent e){ } public void mouseReleased(MouseEvent e) { k=2; x=e.getX(); y=e.getY(); repaint(); } }

5．编写Applet, 当按下键盘键时，在Applet中通过paint()方法，在（25,20）位置处显示你按下的键的名称。 @程序

import java.awt.*; import java .awt .event .*; import java.applet.*;

public class Applet1 extends Applet implements KeyListener

{

String name=\public void init() {

addKeyListener(this);

requestFocus(); }

}

public void paint(Graphics g) { g.drawString (\你按下的键是:\

public void keyPressed(KeyEvent e) {

name=e.getKeyText (e.getKeyCode ());

} }

repaint(); }

}

public void keyReleased(KeyEvent e) { public void keyTyped(KeyEvent e)

{

6．编写小程序，响应键盘事件：敲击字母r，改变小程序背景色为red；敲击字母b，改变小程序背景色为blue；敲击字母g，改变小程序背景色为green；其他字母，改变小程序背景色为black。 // Key.java

import java.applet.Applet; import java.awt.*; import java.awt.event.*;

public class Applet1 extends Applet implements KeyListener {

char ch;

public void init() {

addKeyListener( this ); requestFocus();//获取焦点 }

public void paint( Graphics g ) {

if(ch=='r'|ch=='R')

this.setBackground(Color.red);

}

public void keyPressed( KeyEvent e )//键压下时执行 { }

public void keyReleased( KeyEvent e )//键释放时执行 { }

public void keyTyped( KeyEvent e )////键敲击时执行 { ch=e.getKeyChar(); repaint(); } }

7．编写java小程序，在小程序界面画一个彩色球，当压下键盘上的4个方向键时，彩色球能向指定

的方向移动。 import java.awt.*; import java.applet.*; import java.awt.event.*;

public class Applet1 extends Applet { char ch; int x=20,y=20; public void init() { this.addKeyListener(new KeyAdapter() { public void keyPressed(KeyEvent e) { if(e.getKeyCode()==e.VK_DOWN) y+=2; if(e.getKeyCode()==e.VK_UP) y-=2; if(e.getKeyCode()==e.VK_RIGHT) x+=2; if(e.getKeyCode()==e.VK_LEFT) x-=2; repaint(); } }); this.requestFocus(); } public void paint(Graphics g) { g.setColor(Color.blue); g.fillOval(x,y,30,30); } }

8．编写小程序，使用内部类响应鼠标点击事件：点击鼠标，以点击处为中心画圆。 import java.awt.*; import java.applet.*; import java.awt.event.*; //点击鼠标，以该点为中心画圆 public class Applet1 extends Applet {

int x,y; public void init() {

addMouseListener(new MyMouse()); }

}

x =Integer.parseInt(args[0]); y =Integer.parseInt(args[1]); op=args[2].charAt(0); switch(op) {

case '+' : str=str+x+\ break; case '-' : str=str+x+\ break; case '*' : str=str+x+\ break; case '/' : str=str+x+\ break;

default : System.out.println(\不能识别的运算符 \ System.exit(0); }

System.out.println(str);

二、异常、多线程和输入输出处理

练习7 异常处理（1）

了解java中异常的处理：除运行时异常外，其他异常必须要捕捉或声明抛弃。例如，多线程编程或输入输出编程中异常的处理。

1.通过下面的程序了解异常的处理、以及异常发生时程序的执行情况。 import java.io.*; public class Class1 { public static void main(String args[]) { int a=5; int b=0; System.out.println(a/b); try { System.out.println(\ System.out.println(a/b); System.out.println(\ } catch(ArithmeticException e) { System.out.println(\除数为0，这是不行的！\ } finally { System.out.println(\ } System.out.println(\异常已发生，但不影响程序的执行！\ }

}

练习8 多线程（5）

掌握：java中实现多线程的两种方法，能编写多线程的简单程序。多线程的相关知识还可与管道流结合、或应用他们编写小程序界面的简单动画等（参考练习15）。

1.请编写一个类，类名为subThread ，它是Thread 类的子类。该类中定义了含一个字符串参数的构造函数和run( )方法，方法先在命令行显示线程的名称，然后随机休眠小于1秒的时间，最后显示线程结束信息: \线程名。编写Application，在其中创建subThread类的三个对象t1、t2、t3，它们的名称分别为\、\、\，并启动这三个线程。 public class Class1 { public static void main( String[ ] args ) { Thread t1 = new subThread( \ Thread t2 = new subThread( \ Thread t3 = new subThread( \ t1.start( );t2.start( );t3.start( ); } }

class subThread extends Thread { public subThread( String str ) { super( str ); }

public void run( ) { System.out.println( \ try { sleep( ( int )( Math.random( ) * 1000 ) ); } catch( InterruptedException e ) { } System.out.println( \ } }

2.请编写一个类，类名为subThread ，它是Thread 类的子类。该类中定义了含一个字符串参数的构造函数和run( )方法，方法中有一个for循环，循环一共进行5次，循环体中先在命令行显示该线程循环到了第几次，然后随机休眠小于1秒的时间，循环结束后显示线程结束信息: 线程名+\。编写Application，在其中创建subThread类的三个对象t1、t2、t3，它们的名称分别为\、\、\，并启动这三个线程。 public class Class1

{ public static void main( String[ ] args ) { Thread t1 = new subThread( \ Thread t2 = new subThread( \ Thread t3 = new subThread( \ t1.start( ); t2.start( ); t3.start( ); } }

class subThread extends Thread { public subThread( String str ) { super( str ); }

public void run( ) { for(int i=1;i<=5;i++) { System.out.println( getName( )+\ try { sleep( ( int )( Math.random( ) * 1000 ) ); } catch( InterruptedException e ) { } } System.out.println( \ } }

3.请编写一个类，类名为MulThread ，类中定义了含一个字符串参数的构造函数，并实现了Runnable接口，接口中的run( )方法如下实现：方法中先在命令行显示该线程信息，然后随机休眠小于1秒的时间，最后后显示线程结束信息: \线程名。编写Application，在其中通过Runnable创建MulThread类的三个线程对象t1、t2、t3，并启动这三个线程。 public class Class1 { public static void main( String[ ] args ) { Runnable r1 =new MulThread( \ Runnable r2 =new MulThread( \ Runnable r3 =new MulThread( \ Thread t1 = new Thread( r1 ); Thread t2 = new Thread( r2 ); Thread t3 = new Thread( r3 ); t1.start( );t2.start( );t3.start( ); } }

class MulThread implements Runnable { String s; public MulThread(String str) { s=str;} public void run( ) { System.out.println(s); try { Thread.sleep( ( int ) ( Math.random( ) * 1000 ) ); } catch( InterruptedException e ){ } System.out.println( \ \

} }

4.编写小程序实现一个数字时钟。 import java.awt.*; import java.applet.*; import java.util.Calendar;

public class Applet1 extends Applet implements Runnable { Thread timeThread; Font wordFont; int year,month,day; int weekday; int hour,minute,second; public void init() { this.setBackground(Color.black); wordFont=new Font(\楷体_gb2312\ } public void start() { if(timeThread==null) { timeThread=new Thread(this); timeThread.start(); } } public void stop() { if(timeThread!=null) { timeThread.stop(); timeThread=null; } } public void run() { while(true) { Calendar time=Calendar.getInstance();//创建类的实例 year=time.get(Calendar.YEAR); month=time.get(Calendar.MONTH); day=time.get(Calendar.DAY_OF_MONTH ); weekday=time.get(Calendar.DAY_OF_WEEK); hour=time.get(Calendar.HOUR); minute=time.get(Calendar.MINUTE); second=time.get(Calendar.SECOND); repaint ();

try { Thread.sleep( 300); } catch (InterruptedException e) { } } } public void paint (Graphics g) { String s1=year+\年\月\日\ String s2=\星期\ String s3=hour+\ g.setFont (wordFont); g.setColor (Color.green); g.drawString (s1, 20, 50); g.drawString (s2, 20, 120); g.drawString (s3, 20, 200); } }

5.编写小程序实现Runnable接口，通过多线程实现在小程序窗口中不断的显示自然数：从1直到100。 import java.awt.*; import java.applet.*;

public class Javaapplet extends Applet implements Runnable { int counter=0; Thread t;

public void init() { t=new Thread(this); t.start(); } public void run() { while( counter<=100 ) { counter++; try { Thread.sleep(1000); } catch ( InterruptedException e ) { } repaint(); } } public void paint( Graphics g ) { setBackground(Color.black); g.setColor(Color.green); g.setFont(new Font(\ g.drawString( String.valueOf(counter),60,60 );

}

练习9 输入输出（15）

掌握：java的输入输出处理

1．编写应用程序，使用System.in.read()方法读取用户从键盘输入的字节数据，回车后，把从键盘输入的数据存放到数组buffer中,并将用户输入的数据通过System.out.print()显示在屏幕上。 import java.io.*; public class Class1 { public static void main(String args[]) { byte buffer[]=new byte[128]; int n; try { n=System.in.read(buffer); //把键盘输入的数据读到数组buffer中，返回实际读取的字节数 for(int i=0;i

2．编写应用程序，使用System.in.read()方法读取用户从键盘输入的字节数据，回车后，把从键盘输入的数据存放到数组buffer中,并将用户输入的数据保存为指定路径下的文件。 import java.io.*; public class Class1 { public static void main(String args[]) { byte buffer[]=new byte[128]; int n; try { n=System.in.read(buffer);

FileOutputStream out=new FileOutputStream(\追加 //FileOutputStream out=new FileOutputStream(\ out.write(buffer,0,n); out.close( ); } catch(IOException e) { System.out.print(e); } } }

3. 编写java应用程序，使用FileInputStream类对象读取程序本身（或其他目录下的文件）并显示在屏幕上。

import java.io.*; public class Class1 { public static void main (String[] args) { try { //FileInputStream fis=new FileInputStream(\ FileInputStream fis=new FileInputStream(\ int n; while((n=fis.read())!=-1) System.out.print((char)n); fis.close(); } catch(IOException e) { System.out.println(e.toString()); } } }

4. 编写java应用程序，使用FileInputStream类对象读取程序本身（或其他目录下的文件）到字节数组中，并显示在屏幕上(或存储为其他文件)。 import java.io.*;//读取程序本身，显示在屏幕上 public class Class1 { public static void main (String[] args) { try { FileInputStream fis=new FileInputStream(\ byte[] b=new byte[fis.available()]; System.out.println(\文件流的大小：\ int n=fis.read(b); myprint(b); System.out.print(\实际读取的字节数：\ fis.close(); } catch(IOException e) { System.out.println(e.toString()); } } static void myprint(byte[] x) { for(int i=0;i

} }

5．编写应用程序，程序中创建一个文件输入流对象fis，读取当前目录下文本文件test1.txt，该文件内容有如下两行文本：

Java program is easy. I like it.

从文件输入流fis中读取5个字节数据存放到数组b中，字节数据存放的位置从数组下标3开始。将读取的数据在屏幕输出。 import java.io.*; public class Class1 { public static void main( String[ ] args ) throws IOException { File file = new File(\ FileInputStream fis = new FileInputStream( file); int n=0; byte b[]=new byte[8]; n=fis.read(b,3,5); fis.close(); for(int i=3;i

6．编写应用程序，程序中创建一个文件输出流对象out向当前目录下已有的文件abc.txt（内容为：\）写入字符串\中的所有字符和大写字母'A'。 import java.io.*; public class Class1 { public static void main (String[] x) throws IOException { String s=\ byte[] b; FileOutputStream out=new FileOutputStream(\添加字节数据 b=s.getBytes(); out.write(b,0,b.length); out.write(65);//写入字节数据65---‘A’ out.close(); } }

7．编写两个线程子类，分别用来创建管道输出流和管道输入流，其中管道输出流向管道发送5个0~20之间的随机整数；管道输入流接收管道中传过来的5个随机整数，并求他们的和。编写Java应用程序测试管道流的数据传送。 //TestPipedStream.java import java.io.*;

public class TestPipedStream { public static void main( String[] args ) { try {//创建没有连接的管道输出流和管道输入流

PipedOutputStream out = new PipedOutputStream( ); PipedInputStream in = new PipedInputStream( ); out.connect( in );//连接两个管道流 ThreadOut to = new ThreadOut( out ); ThreadIn ti = new ThreadIn( in ); to.start( );//启动线程 ti.start( ); } catch( IOException e ) { System.out.println( e ); } } }

/*向管道输出数据的线程子类：发送0~20之间的5个随机整数*/ class ThreadOut extends Thread { private int[] data1=new int[5]; //管道输出流要发送的数据 private DataOutputStream dos;//声明数据输出流对象dos public ThreadOut( PipedOutputStream out) { //将数据输出流和管道输出流连接，以便向管道发送int类型的数据 dos = new DataOutputStream(out); } public void run( ) {//重写线程类的方法，线程启动后将执行该方法 try {//向管道中写入数据 for(int i=0;i

/*从管道中读取数据的线程子类：接收管道中传过来的5个随机整数*/ class ThreadIn extends Thread { private int sum=0; //5个随机整数 private DataInputStream dis;//声明数据输入流对象dis public ThreadIn( PipedInputStream in ) { //将数据输入流和管道输入流连接，以便从管道读取int类型的数据

dis = new DataInputStream( in ); } public void run( ) {//重写线程类的方法，线程启动后将执行该方法 try {//接收输出管道发送的数据： int x; for(int i=0;i<5;i++) { x=dis.readInt(); sum+=x; System.out.println(\第\次接收数据：\ +x+\接收数据的和：\ try {sleep(1000);} catch(InterruptedException e) { } } dis.close( );//关闭流 } catch( IOException e ) { System.out.println( e ); } } }

8．使用RandomAccessFile类及其方法。 import java.io.*; public class Class1 { public static void main( String[ ] args ) { try { //以随机方式写入数据 RandomAccessFile out = new RandomAccessFile( \ out.writeInt(12345);//4 out.writeChar('A');//2 out.writeBoolean(true);//1 out.writeUTF(\程序设计\ //显示字符‘A' 和”程序设计“ out.seek(4); System.out.println(out.readChar()); out.skipBytes(1);//out.seek(7); System.out.println(out.readUTF()); System.out.println(out.getFilePointer()); System.out.println(out.length()); out.close(); System.in.read(); } catch( IOException e ) {

System.out.println( e ); System.exit( -2 ); } } }

9．编写应用程序，使用RandomAccessFile类及其方法，把程序本身分两次显示在屏幕上。第一次直接显示，第二次给每一行添加的行号显示。 import java.io.*; public class Test { public static void main( String[ ] args ) throws IOException { RandomAccessFile randomfile = new RandomAccessFile(\ String s; while((s=randomfile.readLine())!=null) { System.out.println(s); } long filePointer=0,fileLength=randomfile.length(); randomfile.seek(0); //文件指针已到文件尾，将文件指针重设到文件开始位置 int i=1; while(filePointer

10．在程序所在的目录下有子目录b，目录b下有文本文件testb.txt。编写应用程序，创建文件对象：

File file=new File(\

通过文件对象file得到它的文件名、相对路径、绝对路径、父目录名。 import java.io.*; public class Class1 { public static void main( String args[ ] ) { File file=new File(\ System.out.println(\文件名:\ System.out.println(\相对路径:\ System.out.println(\绝对路径:\ System.out.println(\父目录名:\ } }

11．请编写一个名为Class1.java的Application，其功能为：测验文件Class1.java是否存在并输出其长度。

import java.io.*; public class Class1 { public static void main (String[] args) { File f1=new File(\ System.out.println(\ System.out.println(\ } }

12．编写应用程序：创建目录c:\\temp，并创建一个文件2.txt，向该文件中写入字符串\came.\共5次。 import java.io.*; public class Class1 { public static void main(String args[]) throws IOException { File file1=new File(\ file1.mkdir(); File file2=new File(file1,\ FileOutputStream out1=new FileOutputStream(file2); String s=\ byte[] b=s.getBytes(); for(int i=0;i<5;i++) { out1.write(b,0,b.length); } } }

13．过滤文件并显示。 import java.io.*; public class Class1 { public static void main( String[ ] args ) { try { File oDir = new File( \ String[ ] strList; //如果没有命令行参数就取当前目录下的所有文件列表 if( 0 == args.length ) strList = oDir.list( ); else strList = oDir.list( new DirFilter(args[0])); for( int i = 0; i < strList.length; i ++ ) System.out.println( strList[ i ] ); } catch( Exception e )

{ System.out.println( e ); } } }

class DirFilter implements FilenameFilter { String strPick; DirFilter( String pickname ) { this.strPick = pickname; } public boolean accept( File dir, String name ) { return name.endsWith( strPick ); } }

14．编写java应用程序，使用FileReader类对象读取程序本身（或其他目录下的文件）并显示在屏幕上。

import java.io.*;//读取程序本身，显示在屏幕上 public class Class1 { public static void main (String[] args) { try { FileReader fis=new FileReader(\ //FileReader fis=new FileReader(\ int n; while((n=fis.read())!=-1) System.out.print((char)n); fis.close(); } catch(IOException e) { System.out.println(e.toString()); } }

}

15．编写应用程序,创建BufferedReader的对象,从某个文本文件中的字符输入数据流中读取一行字符（该文件与程序在同一目录下），跳过10个字节后将其显示出来。 import java.io.*; public class Class1 { public static void main(String args[]) throws IOException { BufferedReader b_reader=new BufferedReader(new FileReader(\ String str;

}

b_reader.skip(10);

str=b_reader.readLine(); System.out.println(str);

三、图形图像、常用组件和事件处理、布局

练习10（6）

掌握：（1）绘制字符串、字符、字节（2）字体、字型、字号的使用（3）颜色的设置

1. 请编写一个Applet，其功能为：在坐标（20，30）处以绿色显示“我喜欢绿色。 ” ，在坐标（20，60）处以蓝色显示“我也喜欢蓝色。” 。 @程序

import java.awt.*; import java.applet.*;

public class Applet1 extends Applet { public void paint( Graphics g) { g.setColor(Color. green); g.drawString(\我喜欢绿色。\ g.setColor(Color.blue); g.drawString(\我也喜欢蓝色。\ } }

2. 请编写一个Applet，分别以红、绿、黄、粉、白、蓝等六种颜色，在同一行上显示六个数字 1、2、3、4、5、6。 @程序

import java.applet.*; import java.awt.*;

public class Applet1 extends Applet { public void paint(Graphics g) { int j=0; Color color[ ]=new Color[6]; color[0]=Color.red; color[1]=Color.green; color[2]=Color.yellow; color[3]= Color.pink; color[4]=Color.white; color[5]=Color.blue; for(char ch='1'; ch <= '6'; ch++) { g.setColor( color[ch-'1']); g.drawString(\

}

j+=20;

3. 请编写一个Applet，以不同的灰度值在一行上显示数字 0 - 9 。

@程序

import java.applet.*; import java.awt.*;

public class Applet1 extends Applet { public void paint(Graphics g) { int j=0;

int red=0, green=0,blue=0; for(char ch='0'; ch <= '9'; ch++) { g.setColor( new Color(red,green,blue)); g.drawString(\ j+=20;

red+=85; green+=85; blue+=85; } } }

4. 编写Java小程序，将字符串“I like java!”重复显示5次，每次显示在1行上。要求显示字体为\字体，字体风格为斜体，第1行字符串的字体大小是15，后面的每一行的字体大小依次增加5，每行的间隔为30像素。 @程序

import java.awt.*; import java.applet.*;

public class Applet1 extends Applet { Font f1; int size=15; int y=30; String str=\ public void paint(Graphics g) { for(int i=0;i<5;i++) { f1=new Font(\ g.setFont(f1); g.drawString(str,30,y); size+=5; y+=30; } } }

5. 请编写一个Applet，其功能为：在标签上输出字符串 \ is a Java program. \。要求标签以蓝色为背景，以红色为前景。

@程序

import java.awt.*; import java.applet.*;

public class Applet1 extends Applet { Label p=new Label(\ is a Java program. \ public void init( )

{

add(p);

p.setBackground(Color.blue); p.setForeground(Color.red); } }

6. 请编写一个Applet，以不同颜色在一列上显示字符串 \每个字的颜色都不同！\。 @程序

import java.applet.*; import java.awt.*;

public class Applet1 extends Applet { public void paint(Graphics g) { int j=0; char[ ] b={ '每', '个', '字', '的', '颜', '色', '都', '不', '同', '！'}; int red=188, green=220,blue=99; for(int i=0; i < b.length; i++) { g.setColor( new Color(red,green,blue)); g.drawString(\ j+=15;

red+=35; green+=55; blue+=85; } } }

练习11（6）

掌握：(1)画直线(2)画长方形、画正方形(3)画圆、画椭圆、画扇形、画弧

1. 编写Java小程序，将小程序窗口的右上的1/4区域用红色画成实心的长方形；将小程序窗口的左下的1/4区域用蓝色画成实心的长方形。 @程序

import java.awt.*; import java.applet.*;

public class Applet1 extends Appl et { public void paint(Graphics g) { int w=getSize().width; int h=getSize().height; g.setColor(Color.red); g.fillRect(w/2,0,w/2,h/2); g.setColor(Color.blue); g.fillRect(0,h/2,w/2,h/2); } }

2. 请编写一个Applet，其功能为：在Applet窗口中用绿色画一个左上角坐标为 (10,10)、高为90、宽为110的矩形框；然后画内切于该矩形的红色椭圆。 @程序

import java.awt.*; import java.applet.*;

public class Applet1 extends Applet { public void paint( Graphics g ) { g.setColor( Color.green); g.drawRect(10,10,110,90); g.setColor( Color.red); g.drawOval(10,10,110,90); } }

3. 请编写一个Applet，其功能为：在Applet窗口中先画一条从坐标（100，100）到坐标（200，100）的绿线；然后以该线中心点为圆心，画半径为50，边框为红色的圆。 @程序

import java.awt.*; import java.applet.*;

public class Applet1 extends Applet { public void paint( Graphics g ) { g.setColor(Color.green); g.drawLine(100,100,200,100); g.setColor(Color.red); g.drawOval(50,50,100,100); } }

4. 编写Applet，功能为：在Applet窗口中以坐标（100，20）为左上角，填充边长为80、厚度为10的红色正方形框；再以坐标（10，20）为左上角，画边长为80的绿色正方形，然后将其擦去；最后在窗口的状态栏中显示字符串“画的是正方形。”。 @程序

import java.awt.*; import java.applet.*;

public class Applet1 extends Applet { public void paint(Graphics g) { g.setColor(Color.red); g.fillRect(100,20,80,80); g.setColor(getBackground( )); g.fillRect(110,30,60,60); g.setColor(Color.green); g.drawRect(10,20,80,80);

showStatus(\画的是正方形\

for(int i=0; i < Integer.MAX_VALUE -1 ; i++); g.setColor(getBackground( )); g.drawRect(10,20,80,80); } }

5. 请编写一个Applet，其功能为：在窗口中画一个任意的红边的六边形，然后将其擦去。 @程序

import java.awt.*; import java.applet.*;

public class Applet1 extends Applet {

int[ ] x={40,80,100,180,200,70}; int[ ] y={40,10,30,70,180,90}; public void paint(Graphics g) { g.setColor(Color.red); g.drawPolygon(x,y,6); for(int i=0;i<123456789;i++); g.setColor(getBackground( )); g.fillRect(0,0,getSize().width,getSize().height); } }

6. 请编写一个实现如下功能的Applet：在窗口中从60°开始逆时针画一个30°的绿色扇形，并令其内切于左上角坐标为 (100,60)、长为110、宽为90的矩形区域。 @程序

import java.awt.*; import java.applet.*;

public class Applet1 extends Applet { public void paint(Graphics g) {

g.setColor(Color.green);

g.fillArc(100,60,90,110,60,30); } }

练习12（3）

掌握：标签、文本框的编程。

1. 请编写一个Applet，其功能为：在Applet窗口上摆放两个标签。构造第一个标签时，令其上面的文本信息为“我将参加Java程序设计考试。”，将第二个标签构造为空标签。程序将第一个标签的信息复制到第二个标签上，并增加信息“希望自己考取好成绩。”。要求第一个标签以红色为背景，绿色为前景；第二个标签以绿色为背景，蓝色为前景。 @程序

import java.applet.Applet; import java.awt.*;

public class Applet1 extends Applet

{ Label p1=new Label(\我将参加Java程序设计考试。\ Label p2=new Label(\ \ public void init( ) { add(p1); add(p2);

p2.setText(p1.getText( )+ \希望自己考取好成绩。\ p1.setBackground(Color. red); p1.setForeground(Color.green); p2.setBackground(Color. green); p2.setForeground(Color.blue); } }

2. 请编写一个Applet实现如下功能：定义一个用于给出提示信息的标签和两个文本框，其中，一个文本框用于获取用户给出的一个整数，求该数的平方后将计算结果置在另一个文本框中输出。 @程序

import java.applet.*; import java.awt.*;

import java.awt.event.*;

public class Applet1 extends Applet implements ActionListener {

Label p; TextField in,out; int x;

String str=\

public void init( ) { p=new Label(\请输入一个整数: \ in=new TextField(18); out=new TextField(28); add(p); add(in); add(out); in.addActionListener(this); }

public void actionPerformed(ActionEvent evt)

{ x=Integer.parseInt(in.getText()); repaint( ); } public void paint(Graphics g) { str=x+\的平方为: \ out.setText(str); } }

3. 请编写一个Applet实现如下功能：定义三个文本框。其中，第一个文本框上面的文本信息为“请输入口令：”；第二个文本框为口令输入域；第三个文本框上的信息由程序设置：若口令（假设口令为字符串‖MyKey‖）正确，则设置为“通过！”，否则设置为“口令错！”；。 @程序

import java.awt.*; import java.applet.*;

import java.awt.event.*;

public class Applet1 extends Applet implements ActionListener

{

TextField p; TextField in; TextField out; String s=\

public void init( ) { p=new TextField (\请输入口令: \ in=new TextField(18); out=new TextField(38);

add(p); add(in); add(out); in.addActionListener(this); }

public void actionPerformed(ActionEvent evt) {

s=in.getText(); if(s.equals(\通过！\ else out.setText(\口令错！\ } }

练习13（8）

掌握：按钮、单选按钮、复选按钮、列表的编程。

1. 编写Applet, 其中包含两个按钮b1、b2，初始时b1的前景为兰色，b2的前景为红色，它们的标签分别为‖兰按钮‖、‖红按钮‖。当点击b1时，通过paint()方法在坐标（100，100）处画一个兰色的椭圆框，椭圆的长半轴为30，短半轴为20；点击b2时，在坐标（100，100）处，画一个红色的圆框，圆的半径为50。无论那个按钮被点击，都将该按钮上的标记改为“已按过”,并使该按钮变灰。 @程序

import java.awt.*;

import java .awt .event .*; import java.applet.*;

public class Applet1 extends Applet implements ActionListener { int i; Button b1,b2; public void init() { b1=new Button(\兰按钮\ b2=new Button(\红按钮\ add(b1); b1.setForeground(Color.blue); add(b2); b2.setForeground(Color.red); b1.addActionListener(this); b2.addActionListener(this); } public void paint(Graphics g) {

if(i==1) { g.setColor(Color.blue); g.drawOval(100,100,60,40); b1.setLabel(\已按过\ b1.setForeground(Color.gray); } if(i==2) { g.setColor(Color.red); g.drawOval(100,100,100,100); b2.setLabel(\已按过\ b2.setForeground(Color.gray); } } public void actionPerformed(ActionEvent e) { if(e.getSource()==b1) { i=1; } if(e.getSource()==b2) { i=2; } repaint(); } }

2. 编写Applet, 其中包含两个按钮，它们的标签分别为“画正方形”和“画圆”，点击按钮“画正方形”时，通过paint()方法以坐标（10，10）为左上角画一个边长为60的兰色正方形框；点击按钮“画圆”时，画一个半径为50的红色填充圆，该圆内切于左上角坐标为（100，100）的正方形。如果那个按钮被点击，就使该按钮变得不可见。 @程序

import java.awt.*;

import java .awt .event .*; import java.applet.*;

public class Applet1 extends Applet implements ActionListener { int i; Button btn1, btn2; public void init() { btn1=new Button(\画正方形\ btn2=new Button(\画圆\ add(btn1); add(btn2); btn1.addActionListener(this); btn2.addActionListener(this); } public void paint(Graphics g) { if(i==1) { g.setColor(Color. blue); g.drawRect(10,10,60,60); btn1.setVisible(false); } if(i==2) { g.setColor(Color. red); g.fillOval(100,100,100,100); btn2.setVisible(false); } } public void actionPerformed(ActionEvent e) { if(e.getSource()==btn1) { i=1; } if(e.getSource()==btn2) { i=2; } repaint(); } }

3. 编写Applet, 其中包含两个按钮：按钮上的标签分别为“确定”和“取消”。当点击“确定” 按

钮时，通过paint()方法在坐标（20，80）处，用绿色显示点击“确定”按钮的次数；当点击“取消” 按钮时，通过paint()方法在坐标（20，100）处，用红色显示点击“取消”按钮的次数（要求“确定”和“取消”的次数同时显示在Applet中）。 @程序

import java.awt.*;

import java .awt .event .*; import java.applet.*;

public class Applet1 extends Applet implements ActionListener { int j=0,k=0; Button btn1, btn2; public void init() { btn1=new Button(\确定\ btn2=new Button(\取消\ add(btn1); add(btn2); btn1.addActionListener(this); btn2.addActionListener(this); } public void paint(Graphics g) { g.setColor(Color.green); g.drawString(\你点击了\\\确定\\\按钮 \次\ g.setColor(Color.red); g.drawString(\你点击了\\\取消\\\按钮 \次\ } public void actionPerformed(ActionEvent e) { if(e.getSource()==btn1) j++; if(e.getSource()==btn2) k++; repaint( ); } }

4. 编写Applet, 其中包含两个按钮，初始时两个按钮的前景均为绿色。当点击一个按钮时，通过paint( )方法在坐标（10，50）处显示一幅图象，图象名称为a.gif，显示的高、宽分别为50、50；图象与嵌入该小应用程序的网页在同一目录（程序中用到的图片由学生在计算机中找）。当点击另一个按钮时，在窗口的状态栏中输出字符串“好漂亮！”。同时要求当反复点击按钮时，就令被点击按钮的前景变为红色，而使另一个按钮的前景恢复为绿色。 @程序

import java.awt.*;

import java .awt .event .*; import java.applet.*;

public class Applet1 extends Applet implements ActionListener { int i; Image pic; Button btn1,btn2; public void init() { btn1=new Button(\ btn2=new Button(\

add(btn1); btn1.setForeground(Color.green); add(btn2); btn2.setForeground(Color.green); btn1.addActionListener(this); btn2.addActionListener(this); pic=getImage(getDocumentBase(),\ } public void paint(Graphics g) { if(i==1) g.drawImage(pic,10,50,50,50,this); if(i==2) showStatus(\好漂亮！\ } public void actionPerformed(ActionEvent e) { if(e.getSource()==btn1) { i=1; btn1.setForeground(Color.red); btn2.setForeground(Color.green); } if(e.getSource()==btn2) { i=2; btn2.setForeground(Color.red); btn1.setForeground(Color.green); } repaint(); } }

5. 编写Applet, 显示一幅后缀名为jpg的图片，图片显示的左上角坐标为（20，40），宽、高为80、80像素（图片在计算机中查找）。小程序中还包含两个按钮，按钮名称分别为\放大图片\和\缩小图片\。每次按下\放大图片\按钮时，把图片显示的宽、高分别增加10像素；每次按下\缩小图片\按钮时，把图片显示的宽、高分别减小10像素。 @程序

import java.awt.*;

import java .awt .event .*; import java.applet.*;

public class Applet1 extends Applet implements ActionListener { Image pic; Button btn1,btn2; int w=80,h=80; public void init() { pic=getImage(getDocumentBase(),\ btn1=new Button(\放大图片\ btn2=new Button(\缩小图片\ add(btn1); add(btn2); btn1.addActionListener(this); btn2.addActionListener(this); } public void paint(Graphics g) { g.drawImage(pic,20,40,w,h,this); } public void actionPerformed(ActionEvent e) { if(e.getSource()==btn1) { w+=10; h+=10; } if(e.getSource()==btn2) { w-=10; h-=10; } repaint(); } }

6. 请编写一个Applet，其功能为：在其窗口中摆放三个单选按钮，令它们的标签分别为“选项1”、“选项2”、“选项3”，初始时，所有按钮均可见；以后，如果某个单选按钮被选中了，就显示它被选中的信息（如，若点击了第二个单选按钮，则显示“你选择了‖选项2‖”），并使该单选按钮自身不可见，而使其它单选按钮变为可见的。 @程序

import java.awt.*;

import java .awt .event .*; import java.applet.*;

public class Applet1 extends Applet implements ItemListener { CheckboxGroup optGroup; Checkbox opt1,opt2,opt3; String s=\ boolean b=false; public void init() { optGroup=new CheckboxGroup( ); opt1=new Checkbox(\选项1\ add(opt1); opt1.addItemListener(this); opt2=new Checkbox(\选项2\ add(opt2); opt2.addItemListener(this); opt3=new Checkbox(\选项3\ add(opt3); opt3.addItemListener(this); } public void paint(Graphics g) { if(b) g.drawString(\你选择了\ } public void itemStateChanged(ItemEvent e) { b=true; if(e.getSource()==opt1)

{ opt1.setVisible(false); opt2.setVisible(true); opt3.setVisible(true); s=opt1.getLabel( ); } if(e.getSource()==opt2)

{ opt1.setVisible(true); opt2.setVisible(false); opt3.setVisible(true); s=opt2.getLabel( ); } if(e.getSource()==opt3)

{ opt1.setVisible(true); opt2.setVisible(true); opt3.setVisible(false); s=opt3.getLabel( ); } repaint( ); } }

7. 请编写一个Applet，在其窗口中摆放两复选按钮框，显示它们被选中（那个被选中、或两个均被选中、或两个均未选中）的信息。 @程序

import java.awt.*;

import java .awt .event .*; import java.applet.*;

public class Applet1 extends Applet implements ItemListener

{ private TextField t; private Checkbox opt1,opt2; public void init() { t=new TextField(\ \ add(t); opt1=new Checkbox(\选项1\ add(opt1); opt1.addItemListener(this); opt2=new Checkbox(\选项2\ add(opt2); opt2.addItemListener(this); } public void itemStateChanged(ItemEvent e) { String s=\ if(opt1.getState( )) s=\选择了选项1\ if(opt2.getState( )) s=s+\选择了选项2\ t.setText(s); } }

8. 使用List列表组件，选择画何种几何图形（黄色矩形、绿色圆、红色椭圆、白色扇形、兰色直线之一），并通知程序实现之。 @程序

import java.applet.Applet; import java.awt.*;

import java.awt.event.*;

public class Applet1 extends Applet implements ActionListener , ItemListener {

List myList;

String itemNames[] =

{ \黄色矩形\红色圆\绿色椭圆\白色扇形\兰色直线\ //项目名称 Color colors[] =

{ Color.yellow , Color.red, Color.green, Color.white, Color.blue }; //颜色对象数组 int j;

boolean b=false; public void init() {

myList = new List( 6, false );

for ( int i = 0; i < itemNames.length; i++ ) myList.add( itemNames[ i ] ); add( myList );

myList.addActionListener( this ); myList.addItemListener( this ); }