Java趣味编程100例.doc

第1章 变幻多姿的图表
第1章 变幻多姿的图表
图表简洁直观，在各种场合得到广泛应用，给人以很强的视觉冲击，经常让人难以忘怀。我们的程序中如果能够灵活地应用图表，一定能给我们的程序增色不少。本章将带你进入变换多姿的图表世界，体会图表编程带来的乐趣。
1.1 金字塔图案
1．问题描述
打印出金字塔图案，如图1.1所示。
2．问题分析
这个问题是一个很经典的循环应用的题目。我们都知道，打印输出的时候，都是从最左端输出，而这里，第一个星号是在中间。这实际是因为星号之前有很多空格。当我们使用问号来表示空格，实际的输出效果应该是图1.2的形式。

图1.1 金字塔 图1.2 金字塔的分析图
从图1.2分析，我们就可以发现这个题目的奥秘了。
（1）确定程序框架
从图1.2中，我们可以发现，一共需要打印5行，而每一行都是打印几个空格，然后再打印几个星号。这样我们就可以写出程序框架了。程序框架代码如下：

public class Ch1_1
{
public static void main(String[] args)
{
**************
for(i=1;i<=5;i++) //循环5次，打印5行
{
//打印若干个空格
//打印若干个星号
}
}
}

由于我们这里明确知道打印的行数，所以我们使用for循环来实现。下面我们就需要考虑如何打印每行的星号。
（2）寻找空格和星号的规律
从图1.2中，我们可以发现：第1行的空格为4个，第2行是3个，第3行是2个，……，每行依次递减，直至最后一行空格数为0；而星号数目是第1行是1个，第2行是3，第3行是5，……，每行依次递增2，直至最后一行星号数为9。总结数据，我们可以得到表1.1所示的规律。
表1.1 空格和星号的规律
行数
空格数
星号数
1
4
5–1
1
1*2–1
2
3
5–2
3
2*2–1
3
2
5–3
5
3*2–1
4
1
5–4
7
4*2–1
5
0
5–5
9
5*2–1
规律
依次递减1
5–行数
依次递增2
行数*2–1

从表1.1中，我们不难发现行数和空格数、星号数之间有一种很有趣的联系。根据这个联系，我们就可以考虑完善我们上面的程序了。
（3）打印空格数
由于每行空格数有着“5–行数”的规律。所以在第i行的时候，空格数就为5–i。所以我们只要把5–i个空格打印出来即可。对应代码如下：

for(i=1;i<=n;i++)
{
for(j=1;j<=n-i;j++) //根据外层行号，输出星号左边空格
System.out.print(" ");
}

虽然每行的空格数不同，但是对于特定的行，其空格数是固定的，所以循环打印的次数是确定的。所以这里同样适用了for循环。
（4）打印星号数
由于每行星号数有着“行数*2–1”的规律。所以在第i行的时候，星号数就为2*i–1。所以我们只要把2*i–1个星号打印出来即可。对应代码如下：

for(i=1;i<=5;i++)
{
for(k=1;k<=2*i-1;k++) //根据外层行号，输出星号个数
System.out.printf("*");
}

（5）完整程序
现在我们就需要把刚才的程序进行组合，构成我们的完整程序。
import java.util.Scanner;

public class Ch1_1
{
public static void main(String[] args)
{
int i,j,k,n;
Scanner input=new Scanner(System.in);
System.out.print("请输入金字塔层数：");
n=input.nextInt();
//外层循环控制层数
for(i=1;i<=n;i++)
{
//根据外层行号，输出星号左边空格
for(j=1;j<=n-i;j++)
System.out.print(" ");
//根据外层行号，输出星号个数
for(k=1;k<=2*i-1;k++)
System.out.printf("*");
//一行结束，换行
System.out.printf("\n");
}
}
}

（6）扩展训练
为了方便大家训练，我们提供几个金字塔图案的同胞兄弟——倒金字塔、直角三角形，如图1.3所示。大家可以尝试和它们过过招。

图1.3 各种形状图案
1.2 九九乘法表
1．问题描述
输出九九乘法口诀表，如图1.4所示。

图1.4 九九乘法口诀表
2．问题分析
观察九九乘法口诀表，可以得出图表的规律：总共有9行，第几行就有几个表达式。同时要注意每行表达式的规律：第j行，表达式就从j*1开始，一直到j*j结束，共有j个表达式，这个效果可以通过一次循环实现。这样的话，正好可以通过双重循环来控制输出，外层循环控制行数，内层循环控制列。还有个地方需要注意的是，内层和外层之间的联系，内层列的个数是根据外层的行数来控制的。
（1）确定程序框架
从图1.4中，我们可以发现，一共需要打印9行，每行又有若干个表达式，可以通过双重循环来实现，外层循环控制行数，内层循环控制列，这样我们就可以写出程序框架了。程序框架代码如下：

public class Ch1_2
{
public static void main(String[] args)
{
//外循环控制行数
for(int i=1;i<10;i++)
{
//内循环控制每行表达式个数
for(int j=1; j<=n; j++)
{
//输出表达式
}
//一行结束换行
System.out.println();
}
}
}

（2）寻找每行表达式个数规律
从图1.4中，我们可以发现，第1行一个表达式，第2行两个表达式，第3行三个表达式，……，第几行就有几个表达式，所以内循环控制列的个数的变量n等于控制外循环个数的变量i，所以内循环代码就可以写成如下形式：

for(int j=1; j<=i; j++) //内循环控制每行表达式个数，i代表行数

（3）表达式写法
表达式的写法都是一致：乘数1*乘数2=积。从图1.4中，我们可以发现每行表达式的规律：第i行，表达式就从i*1开始，一直到i*j结束。乘数1不变，一直是i，其实就是行数，乘数2从1变化到j，正好与内循环变量变化一样，所以乘数2就可以用j表示。所以表达式的写法如下：

i+"*"+j+"="+i*j //i代表行，j代表列

（4）完整程序
现在我们就需要把刚才的程序进行组合，构成我们的完整程序：

public class Ch1_2
{
public static void main(String[] args)
{
//外循环控制行数
for(int i=1;i<10;i++)
{
//内循环控制每行表达式个数
for(int j=1; j<=i; j++)
{
System.out.print(" "+i+"*"+j+"="+(i*j));
}
//一行结束换行
System.out.println();
}
}
}

（5）运行结果
运行程序，结果如图1.5所示。

图1.5 程序输出结果
1.3 余 弦 曲 线
1．问题描述
在屏幕上画出余弦函数cos(x)曲线，如图1.6所示。

图1.6 余弦函数cos(x)曲线
2．问题分析
连续的曲线是由点组成的，点与点之间距离比较近，看上去就是曲线了，画图的关键是画出每个点。Java提供了三角函数方法，直接调用cos()方法就可以根据x坐标计算出y坐标。需要注意的是，cos()方法输入的参数是弧度值，要进行坐标转换，同样，得到的结果也要进行转换处理。从图1.6中可以看出，这条余弦曲线有两个周期，我们可以把x坐标控制在0～720。
（1）确定程序框架
从图1.6中，我们可以发现，整个图形包括x轴、y轴及余弦曲线。控制台不方便输出图形，这里以Applet形式输出。这样我们就可以写出程序框架了，代码如下：

public class Ch1_3 extends Applet
{
int x,y;
public void start() //当一个Applet被系统调用时，系统会自动调用 start()方法
{
Graphics g=getGraphics(); //画画之前，必须先取得画笔
//画x轴
//画y轴
//画cos(x)曲线
}
}

（2）画x轴
为了画出图1.6所示效果，我们可以把坐标原点设定为（360,200），x轴就是从左到右的很多点组成，通过循环语句很容易实现，代码如下：

for(x=0;x<=750;x+=1)
{
g.drawString("·",x,200); //画x轴
}

细心的读者会发现，x轴上还有个箭头，这个是如何实现的呢，其实很简单，是由两条线段交汇而成。为方便起见，两条线段都与x轴成45°角，很容易得到表达式的方程：y=x–550，y=950–x。代码如下：

for(x=740;x<=750;x+=1)
{
g.drawString("·",x,x-550); //x轴上方斜线
g.drawString("·",x,950-x); //x轴下方斜线
}

（3）画y轴
参考上面x轴的绘制，很容易画出y轴，代码如下：

//y轴
for(y=0;x<=385;y+=1)
{
g.drawString("·",360,y); //画y轴
}
//y轴箭头
for(x=360;x<=370;x+=1)
{
g.drawString("·",x-10,375-x);
g.drawString("·",x,x-355);
}

（4）画cox(x)曲线
图形的主体是cox(x)曲线，从图1.6中可以看出，这条余弦曲线有两个周期，我们可以把x坐标控制在0～720。cox(x)返回的结果小于1，为了看到图1.6效果，必须进行放大处理，这里放大了80倍，同时把图形向下平移了200个像素。代码如下：

//两个周期，即4Л
for(x=0;x<=720;x+=1)
{
a=Math.cos(x*Math. PI/180);
y=(int)(200+80*a); //放大80倍并向下平移200个像素
g.drawString("·",x,y);
}

（5）完整程序
现在我们就需要把刚才的程序进行组合，构成我们的完整程序：

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

public class Ch1_3_2 extends Applet
{
int x,y;

public void start()
{
//画画之前，必须先取得画笔
Graphics g=getGraphics();
//画x轴、y轴
for(x=0;x<=750;x+=1)
{
g.drawString("·",x,200);
if(x<=385) g.drawString("·",360,x);
}
g.drawString("Y",330,20);
//画y轴箭头
for(x=360;x<=370;x+=1)
{
g.drawString("·",x-10,375-x);
g.drawString("·",x,x-355);
}
//画x轴箭头
g.drawString("X",735,230);
for(x=740;x<=750;x+=1)
{
g.drawString("·",x,x-550);
g.drawString("·",x,950-x);
}
//画cox()曲线
for(x=0;x<=720;x+=1)
{
double a=Math.cos(x*Math. PI/180+Math.PI);
y=(int)(200+80*a); //放大80倍并向下平移200个像素
g.drawString("·",x,y);
}
}
}

Ch1_3.html网页代码如下：

<html>
<head><title>余弦曲线测试</title></head>
</body>
<p>
<!--调用Ch1_3字节码文件 -->
<applet code=Ch1_3.class
<!--设置窗口大小 -->
width=900
height=600>
</applet>
</body>
</html>

（6）运行结果
把Ch1_3.java文件编译后的Ch1_3.class文件放到Ch1_3.html网页同一目录下，直接用IE浏览器打开Ch1_3.html，运行程序，结果如图1.6所示。
3．扩展训练
前面介绍的余弦曲线的绘制，我们看到的是一个完整的静态图形，能否动态地展现绘制的过程？答案是肯定的，我们可以采用线程的方式来实现，参考代码如下：

import java.applet.Applet;
import java.awt.Color;
import java.awt.Graphics;

public class donghua_cos extends Applet implements Runnable
//通过实现Runnable接口实现线程操作
{
int x,y;
double a;
int xpos=0;
Thread runner;
boolean painted=false;

public void init() //Applet创建即启动执行，坐标初始化
{
// TODO Auto-generated method stub
Graphics g=getGraphics(); //画画之前，必须先取得画笔
for(x=0;x<=750;x+=1) //画x轴
{
g.drawString("·",x,200);
if(x<=385) g.drawString("·",360,x);

}
g.drawString("Y",330,20); //画y轴
for(x=360;x<=370;x+=1) //画y轴箭头
{
g.drawString("·",x-10,375-x);
g.drawString("·",x,x-355);
}
g.drawString("X",735,230);
for(x=740;x<=750;x+=1) //画x轴箭头
{
g.drawString("·",x,x-550);
g.drawString("·",x,950-x);
}
}

public void start() //Applet创建后自启动方法
{
// TODO Auto-generated method stub
if(runner==null){
runner=new Thread(this); //通过Thread类来启动Runnable
runner.start(); //线程启动
}
}

public void stop() //Applet生命周期结束后自启动方法
{
// TODO Auto-generated method stub
if(runner!=null){
runner=null; //结束线程
}
}

public void run() //线程运行方法
{
// TODO Auto-generated method stub
while(true){
for(xpos=0;xpos<900-90;xpos+=3) //循环设置曲线x轴坐标边界
{
repaint(); //调用paint()方法
try{
Thread.sleep(100); //线程休息100毫秒
}catch(InterruptedException e){}
if(painted)
{
painted=false;
}
}
}
}

public void paint(Graphics g) //画图方法
{
for(x=0;x<=xpos;x+=1) //循环画曲线
{
a=Math.cos(x*Math. PI/180+Math.PI);
y=(int)(200+80*a); //放大80倍并向下平移200个像素
g.drawString("·",x,y);
}
painted=true;
}
1.4 奥运五环旗
1．问题描述

图1.7 奥运五环旗
在屏幕上画出奥运五环旗，如图1.7所示。
2．问题分析
观察奥运五环旗的图案，直观的感觉，由五个圆组成，每个圆的颜色不一样，大小一样，按照一定的位置摆放，找到圆心坐标的规律，就可以通过Graphics类提供的绘制椭圆的方法drawOval()来实现画圆操作。
（1）确定程序框架
奥运五环旗由五个不同颜色的圆组成，我们可以通过循环依次输出五个圆环。控制台不方便输出图形，这里以Applet形式输出。这样我们就可以写出程序框架了，代码如下：

public class Ch1_4_3 extends Applet //简单实用为主
{
//paint()方法是由浏览器调用的。每当Applet需要刷新的时候都会调用该方法
public void paint(Graphics g)
{
for(int i=0;i<5;i++)
{
//设置当前圆的颜色
//根据圆心坐标画出当前圆
}
}
}

（2）圆环的坐标分析
分析出圆的圆心坐标是画图的关键，对照图1.8标示，分析圆的位置规律。
O

图1.8 奥运五环旗坐标分析
上面三个圆的圆心a、b、c的y坐标相同，下面两个圆的圆心d、e的y坐标相同，ab=bc=ad=de，为保证两个圆相交，两个圆的圆心距离必须小于2r（r代表圆的半径）。f为ab的中点，adf组成直角三角形，af=ad/2，只要给定五个圆的任何一个圆心坐标，就可以推倒出其他几个圆的圆心坐标。我们这里使用数组来存放每个圆环的颜色、坐标。代码如下：

//clr[]存储颜色
private Color clr[]={Color.blue,Color.black,Color.red,Color.yellow,Color. green};
//x[]存储圆心的x坐标
private int[] x={100,136,172,118,154};
//y[]存储圆心的y坐标
private int[] y={60,60,60,91,91};
//r代表半径
Private r=20;

（3）画五环旗
根据上面给出的圆的圆心坐标，通过循环语句控制，依次画出每个圆环。代码如下：

for(int i=0;i<5;i++)
{
//设置颜色
g.setColor(clr[i]);
//画圆，第一个参数代表圆心x坐标，第二个参数代表圆心y坐标
g.drawOval(x[i], y[i], d, d);
}

（4）完整程序
现在我们就需要把刚才的程序进行组合，构成我们的完整程序：

import java.awt.*;
import java.awt.event.*;
import java.applet.Applet;
import java.awt.Color;
import java.awt.Font;
public class Ch1_4 extends Applet
{
private Color clr[]={Color.blue,Color.black,Color.red,Color.yellow,
Color.green}; //clr[]存储颜色
private int[] x={100,136,172,118,154}; //x[]存储圆心的x坐标
private int[] y={60,60,60,91,91}; //y[]存储圆心的y坐标
private int[][] xy={{100,60},{136,60},{172,60},{118,91},{154,91}}; //存储圆心的坐标
private int r=20,d=40;
public void paint(Graphics g) //画图方法
{
Font font = new Font("楷体",Font.PLAIN,20); //文字字体、大小
g.setFont(font);

for(int i=0;i<5;i++) //循环5次，画5个圆环
{
g.setColor(clr[i]);
g.drawOval(x[i], y[i], d, d); //d代表椭圆外切矩形的长宽，相等代表圆
}
g.setColor(Color.blue); //设置颜色
g.setFont(font);

g.drawString("奥运五环旗",120,169);
} //END PAINT
} //END CLASS

图1.9 程序输出结果
（5）运行结果
再编写一个测试Ch1_4.html文件，内容参考前面的代码，把Ch1_4.java文件编译后的Ch1_4.class文件放到Ch1_4.html文件同一目录下，直接用IE浏览器打开Ch1_4.html，运行程序，结果如图1.9所示。
3．扩展训练
图1.9所示奥运五环旗没有图1.7看着舒服，线条有点细，如果能加粗就好了，可惜Graphics类创建的画笔的粗细是默认的，我们不能改变它。有人提出一个圆环可以由两个圆重叠而成，通过在一个圆的内部紧贴一个稍小的圆即可达到加粗线条的目的，这个思路是可以的，感觉比较麻烦哟，感兴趣可以试一下，有没有简单点的办法？答案是肯定的。我们可以通过Graphics2D类来实现，Graphics2D类扩展Graphics类，以提供对几何形状、坐标转换、颜色管理和文本布局更为复杂的控制。参考代码如下：

public void paint(Graphics g)
{
Font font = new Font("楷体",Font.PLAIN,20); //文字字体、大小
BasicStroke a=new BasicStroke(3.0f); //粗细设置对象
((Graphics2D)g).setStroke(a); //设置粗细

for(int i=0;i<5;i++) //循环5次，画5个圆环
{
((Graphics2D)g).setColor(clr[i]); //设置圆环的颜色
((Graphics2D)g).drawOval(x[i], y[i], d, d);
}
g.setColor(Color.blue); //设置文字颜色
g.setFont(font);

g.drawString("奥运五环旗",120,169);
} //END PAINT
1.5 杨 辉 三 角
1．问题描述
根据输入行数，打印出杨辉三角形，如图1.10所示。
2．问题分析
观察杨辉三角形的图案，可以发现其中的规律：三角形的竖边和斜边都是“1”，三角形里面的任意一个数字正好等于它正上方的数字和左上角的数字两个数字之和。第几行就有几个数字，可以把它补充成如图1.11所示效果。

图1.10 杨辉三角形 图1.11 方阵
方阵（行列相等的矩阵）大家都很熟悉了，可以通过二维数组来处理方阵，一个双重循环就能实现，外循环控制行数，内循环控制列来完成方阵内数字的计算和存储。
（1）确定程序框架
由前面的问题分析可知，先从键盘接收杨辉三角的高度，然后通过二维数组计算存储杨辉三角，最后把杨辉三角打印出来。程序框架代码如下：

public class Ch1_5
{
public static void main(String[] args)
{
System.out.print("请输入行数：");
Scanner scanner = new Scanner(System.in);
int num = scanner.nextInt(); //键盘接收行数

int[][] ary = getTriangle(num); //得到杨辉三角

print(ary); //打印杨辉三角
}
}

（2）得到杨辉三角
由前面的问题分析可知，用二维数组计算存储杨辉三角，杨辉三角竖边、斜边都为1，可以先赋值，然后再给中间元素赋值，当前位置的值等于它的上方数和左上角上的数之和。程序代码如下：

private static int[][] getTriangle(int num)
{
int[][] ary = new int[num][num]; //用二维数组存储

for(int i = 0; i < ary.length; i++) //竖边、斜边置1
{
ary[i][0] = 1;
ary[i][i] = 1;
}

for(int i = 1; i < ary.length; i++) //外循环控制行数
{
for(int j = 1; j <= i; j++) //内循环控制列
{
//里面部分，等于当前位置的上方和左上角之和
ary[i][j] = ary[i-1][j-1] + ary[i-1][j];
}
}
return ary;
}

（3）打印杨辉三角
杨辉三角保存在二维数组中，通过一个双重循环就可以打印出来，但是要注意的是，不需要把所有元素都打印出来，内循环列的控制要小于等于当前行数。程序代码如下：

private static void print(int[][] ary)
{
for(int i=0;i<ary.length;i++) //外循环控制行
{
for(int j=0;j<=i;j++) //内循环控制列
{
System.out.printf(" %-3d", ary[i][j]);
}
System.out.println(); //换行
}
}

（4）完整程序
现在我们就需要把刚才的程序进行组合，构成我们的完整程序：

import java.util.Scanner;

public class Ch1_5
{
public static void main(String[] args)
{
System.out.print("请输入行数：");
Scanner scanner = new Scanner(System.in);
int num = scanner.nextInt(); //从键盘接收行数

int[][] ary = getTriangle(num); //得到杨辉三角

print(ary); //打印杨辉三角
}

//得到杨辉三角
private static int[][] getTriangle(int num)
{
int[][] ary = new int[num][num]; //用二维数组存储

for(int i = 0; i < ary.length; i++) //竖边、斜边置1
{
ary[i][0] = 1;
ary[i][i] = 1;
}

for(int i = 1; i < ary.length; i++) //外循环控制行
{
for(int j = 1; j <= i; j++) //内循环控制列
{
//里面部分，等于当前位置的上方和左上角之和
ary[i][j] = ary[i-1][j-1] + ary[i-1][j];
}
}
return ary;
}

private static void print(int[][] ary)
{
for(int i=0;i<ary.length;i++) //外循环控制行
{
for(int j=0;j<=i;j++) //内循环控制列
{
System.out.printf(" %-3d", ary[i][j]);
}
System.out.println(); //输出换行
}
}

}

（5）运行结果
运行程序，结果如图1.12所示。

图1.12 程序输出结果
3．扩展训练
图1.12输出的杨辉三角是直角三角形，能不能输出等腰三角形呢？答案是肯定的。等腰三角形类似于前面的金字塔图案，参考前面介绍的思路，不难输出等腰三角形。
（1）参考代码

import java.util.*;

public class Ch1_5_2
{
public static void main(String[] args)
{
Scanner in = new Scanner(System.in); //获取控制台输入对象
System.out.print("请输入行号： ");
int m = in.nextInt(); //从键盘接收输入
int n=2*m-1; //列元素个数

int arr[][]=new int[m][n];
for(int i=0;i<m;i++) //外循环控制行
{
for(int j=0;j<n;j++) //内循环控制列
{
if(j<(m-i-1)||(j>=(m+i))) //输出等腰三角形两边空格
System.out.print(" ");
else if((j==(m-i-1))||(j==(m+i-1)))
//计算并输出等腰三角形两个腰
{
arr[i][j]=1;
System.out.printf("%-3d",arr[i][j]);
}
else if((i+j)%2==0&&m%2==0||(i+j)%2==1&&m%2==1)
//中间默认数字0用空格替换
System.out.print(" ");
else //计算并输出中间数字
{
arr[i][j]=arr[i-1][j-1]+arr[i-1][j+1];
System.out.printf("%-3d",arr[i][j]);
}
}
System.out.println(); //输出换行
}
}
}

（2）运行结果
运行程序，结果如图1.13所示。

图1.13 程序输出结果
1.6 国际象棋棋盘
1．问题描述
打印出国际象棋棋盘，如图1.14所示。

图1.14 国际象棋棋盘
2．问题分析
观察国际象棋棋盘的图案，可以发现其中的规律：棋盘由八行八列黑白方块相间组成，可以用i控制行，j来控制列，根据i+j的和的变化来控制输出黑方块还是白方块。这里我们使用了Swing的标签组件JLable，通过设置JLabel组件的背景色和透明度来实现黑白方块。
（1）确定程序框架
这是一个绘图案例，这里我们采用JFrame创建窗口，然后在窗口里添加JLabel标签组件，通过前面的问题分析可知，JLabel标签要设置一些属性实现黑白方块，然后显示窗口，实现如图1.14所示的效果。程序框架代码如下：

public class Ch1_6
{
public static void main(String[] args)
{
JFrame f=new JFrame("国际象棋棋盘");
//窗口属性设置

JLabel l = new JLabel(); //生成标签实例
//标签属性设置
f.add(l); //添加标签
f.setVisible(true); //显示窗口
}
}

（2）窗口属性设置
窗口属性设置包括窗口大小、位置等设置，其中窗口大小要满足能够容纳黑白方格，这里指定黑白方格大小为：20*20，那么窗口属性大小大概为：168*195。窗口位置可以随便指定，这里指定为：（350,200）。程序代码如下：

/