2011网络工程专业《Java程序设计》编程题
Java语言考试题编程题知识点规定
a:固定题
b:简单题
c:中等题
d:难题

###
~~~b
一个数如果恰好等于它的因子之和，这个数就称为“完数”。例如，6的因子为1、2、3，而6 = 1 + 2 + 3，因此6是“完数”。编程序找出1000之内的所有完数，并按下面的格式输出其因子：
6 -〉1，2，3
~
参考程序如下：
public class 完数 {
public static void main(String[] args) {
int i,j,sum=0,k=0,t;
int[] a=new int[50];
for(i=1;i<=1000;i++)
{
sum=0;
for(j=1;j<i;j++)
{
if(i%j==0)
{
sum+=j;
a[k++]=j;
}
}
t=k;
if(sum==i)
{
System.out.print(i+"->");
for(k=0;k<t;k++)
{
System.out.print(a[k]);
if(k<t-1)
System.out.print(",");
}
System.out.println();
}
k=0;
}
}

}

评分标准：
1、写出能完成题目要求功能的、可正常运行的Java程序，给满分，否则0分。
~~~b
打印出1000以内的所有的“水仙花数”。所谓“水仙花数”是指一个三位数，其各位数字立方和等于该数本身。例如，153是一水仙花数，因为153 = 13 + 53 + 33。
~
参考程序如下：
public class 水仙花数 {
public static void main(String[] args) {
int i=0,j=0,k=0,n=1;
for(int m=100;m<1000;m++){
i=m%10;
j=m/10%10;
k=m/100%10;
if(Math.pow(i, 3)+Math.pow(j, 3)+Math.pow(k,3)==m){
System.out.print(m+"\t");
if(n%2==0){
System.out.println();
}
n++;
}
}
}
}

评分标准：
1、写出能完成题目要求功能的、可正常运行的java程序，给满分，否则0分
~~~b
求Sn=a+aa+aaa+…+aa…a之值，其中a是一个数字。例如：2+22+222+…+22222（此时n=5），n由键盘输入。
~
参考程序如下：
import java.util.Scanner;
public class N位相同数字和 {
public static void main(String[] args) {
int i=0,n=0,sum=0,result=0;
Scanner sc=new Scanner(System.in);
System.out.println("input a number,from 1 to 9:");
i=sc.nextInt();
System.out.println("input N number");
n=sc.nextInt();
sum=i;
for(int j=1;j<n;sum=sum*10+i,j++){
result+=sum;
System.out.print(sum+"+");

}
System.out.print(sum+"="+(result+sum));
}

评分标准：
1、写出能完成题目要求功能的、可正常运行的Java程序，给满分，否则0分
~~~b
一球从100米高度自由落下，每次落地后反跳回原高度的一半，再落下。求它在第10次落地时，共经过了多少米？第10次反弹多高？
~
参考程序如下：
public class 小球 {
public static void main(String[] args) {
double h1=100,h2=100,sum=100;
for(int i=1;i<=10;i++){
h1=h1/2;
h2=h1*2;
sum+=h2;
//System.out.println("第"
+i+"次反弹"+h1+"米");
}
System.out.println("共经过了"+(sum-h2)+"米");
System.out.println("第十次反弹"+h1+

"米");
}

评分标准：
1、写出能完成题目要求功能的、可正常运行的java程序，给满分，否则0分
~~~b
编写一个程序，要求输入一个整数，将各位数字反序后输出。
~
参考程序如下：
import java.util.*;
public class 输出反序数字 {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
int right_number;
while(n!=0){
right_number=n%10;
System.out.print(right_number);
n/=10;
}
}
}

评分标准：
1、写出能完成题目要求功能的、可正常运行的java程序，给满分，否则0分
~~~b
猴子吃桃问题。猴子第一天摘下若干个桃子，当即吃了一半，还不过瘾，又多吃了一个。第二天早上又将剩下的桃子吃掉了一半，又多吃了一个。以后每天早上都吃了前一天剩下的一半零一个。到第10天早上想再吃时，见只剩一个桃子了。求第一天共摘了多少桃子。
~
参考程序如下：
public class 猴子吃桃 {
public static void main(String[] args) {
int number=1;
for(int i=10;i>1;i--){
number=(number+1)*2;
}
System.out.println("第一天总共摘了"+number+"个桃子。");
}
}

评分标准：
1、写出能完成题目要求功能的、可正常运行的java程序，给满分，否则0分
~~~b
编写一个Java Application类型的程序，从键盘上输入三角形的三条边的长度，计算三角形的面积和周长并输出。根据三角形边长求面积公式如下：
，其中a、b、c为三角形的三条边，s=(a+b+c)/2。

~
参考程序如下：
import java.io.*;
public class 三角形 {
public static void main(String[] args) throws IOException {
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader br = new BufferedReader(isr);
double a, b, c, s, area;
String str;
str = br.readLine();
a = Double.parseDouble(str);
str = br.readLine();
b = Double.parseDouble(str);
str = br.readLine();
c = Double.parseDouble(str);
if (a + b <= c || a + c <= b || c + b <= a) {
System.out.println("输入边构不成三角形!");
return;
}
s = (a + b + c) / 2.0;
area = Math.sqrt(s * (s - a) * (s - b) * (s - c));
System.out.println("area = " + area);
}
}

评分标准：
1、写出能完成题目要求功能的、可正常运行的java程序，给满分，否则0分
~~~b
编写一个程序，要求读入若干个整数，统计出正整数个数和负整数个数，读入0则结束。
~
参考程序如下：
import java.util.*;
public class 统计负整数正整数 {

public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
int i=0,j=0,num;
num=sc.nextInt();
while(num!=0){
if(num>0)i++;
if(num<0)j++;
num=sc.next
Int();
}
System.out.println("正整数的个数有"+i+"个");
System.out.println("负整数的个数有" +j+"个");

}
}

评分标准：

1、写出能完成题目要求功能的、可正常运行的java程序，给满分，否则0分
~~~b
编写一个Java Application类型的程序，从键盘上输入摄氏温度C，计算华氏温度F的值并输出。其转换公式如下：
F = (9 / 5) * C + 32

~
参考程序如下：
import java.io.*;
public class 华氏温度 {
public static void main(String[] args) throws IOException {
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader br = new BufferedReader(isr);
double C, F;
String str;
str = br.readLine();
C = Double.parseDouble(str);
F = (9 / 5.0) * C + 32;
System.out.println("F = " + F);
}
}

评分标准：
1、写出能完成题目要求功能的、可正常运行的java程序，给满分，否则0分
~~~b
编写打印“九九乘法口诀表”的程序。
~
参考程序如下：
public class 九九乘法表 {
public static void main(String[] args) {
int i, j;
for(i=1;i<10;i++){
for(j=1;j<=i;j++)
System.out.print(i + "x" + j +"=" + i*j + "\t");
System.out.println("");
}
}
}

评分标准：
1、写出能完成题目要求功能的、可正常运行的java程序，给满分，否则0分
~~~c
编写一个根据上下限求回文数的方法，要求输出上下限范围内的回文数及个数。编写测试类进行测试。例如100-200之间的回文数为： 101 111 121 131 141 151 161 171 181 191，总共有10个。
~
参考程序如下：
import java.util.*;
public class 求回文数 {
private int couti;
private int n1,n2;

boolean isPalindromic(int n){
int m=0,i=n;
while(i>0){
m=m*10+i%10;
i/=10;
}
if(m==n){
return true;
}else{
return false;
}
}
void setN1N2(int n1,int n2){
this.n1=n1;
this.n2=n2;
}
private void changeSort(){
int temp;
if(n1>=n2){
temp=n2;
n2=n1;
n1=temp;
}
}

int getN(){
changeSort();
for(int i=n1;i<=n2;i++){
if(isPalindromic(i)){
couti++;
}
}
return couti;
}
void showNumber(){
changeSort();
System.out.println(n1+"与"+n2+"之间的回文数为：");
for(int i=n1;i<=n2;i++){
if(isPalindromic(i)){
System.out.print(i+"\t");
}
}
}
}
class 回文数测试类{
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
int n1=sc.nextInt();
int n2=sc.nextInt();
求回文数 p1=new 求回文数();
p1.setN1N2(n1, n2);
p1.showNumber();
System.out.println("\n"+n1+"与"+n2+"之间的回文数个数为："+p1.getN());
}
}

评分标准：
1、写出能完成题目要求功能的、可正常运行的java程序，给满分，否则0分
~~~b
编写一个程序，
接受用户输入的两个数据为上、下限，然后输出上、下限之间的所有素数。
~
参考程序如下：
import java.io.*;
public class 素数 {
public static void main(String[] args) throws IOException{

InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader br = new BufferedReader(isr);
int top, bottom, i, j,m=0;
System.out.print("请输入上限：");
top = Integer.parseInt(br.readLine());
System.out.print("请输入下限：");
bottom = Integer.parseInt(br.readLine());
if(top<bottom){
System.out.println("输入的上、下限不正确！");
System.exit(1);
}
for(i=bottom; i<=top; i++){
int k = (int)Math.sqrt(i);
for(j=2; j<=k; j++){
if(i % j == 0) break;
}
if(j>k)
{
if(m%4==0)
{
System.out.println();
}
m++;
System.out.print(i + "\t");
}
}
System.out.println();
}
}

评分标准：
1、写出能完成题目要求功能的、可正常运行的java程序，给满分，否则0分
~~~b
已知一个数值矩阵A为 ，另一个矩阵B为 ，求出A与B的乘积矩阵C[3][4]并输出出来，其中C中的每个元素C[i][j]等于 。
~
参考程序如下：
import java.io.*;
public class 矩阵成绩 {
public static void main(String[] args) {
final int M = 3, N = 4, P = 4;
int i, j, k;
int[][] a = { { 3, 0, 4, 5 }, { 6, 2, 1, 7 }, { 4, 1, 5, 8 } };
int[][] b = { { 1, 4, 0, 3 }, { 2, 5, 1, 6 }, { 0, 7, 4, 4 },
{ 9, 3, 6, 0 } };
int[][] c = new int[M][N];
for (i = 0; i < M; i++)
for (j = 0; j < N; j++)
for (k = 0; k < P; k++)
c[i][j] += a[i][k] * b[k][j];
for (i = 0; i < M; i++) {
for (j = 0; j < N; j++)
System.out.print(c[i][j] + "\t");
System.out.println();
}
}
}

评分标准：
1、写出能完成题目要求功能的、可正常运行的java程序，给满分，否则0分
~~~c
从键盘上输入一个字符串，试分别统计出该字符串中所有数字、大写英文字母、小写英文字母以及其他字符的个数并分别输出这些字符。
~
参考程序如下：
public class 统计字符 {
public static void main(String args[]) throws IOException {
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader br = new BufferedReader(isr);
String str = br.readLine();
int i, ditNo = 0, upCharNo = 0, loCharNo = 0, otherCharNo = 0;
for (i = 0; i < str.length(); i++) {
if (str.charAt(i) <= '9' && str.charAt(i) >= '0')
ditNo++;
else if (str.charAt(i) <= 'Z' && str.charAt(i) >= 'A')
upCharNo++;
else if (str.charAt(i) <= 'z' && str.charAt(i) >= 'a')
loCharNo++;
else
otherCharNo++;
}
System.out
.println("数字数目= " + ditNo + "\t" + "大写字母数目=" + upCharNo);
System.out.println("小写字母数目=" + loCharNo + "\t"
+ "其它字母数目= "
+ otherCharNo);
}
}

评分标准：
1、写出能完成题目要求功能的、可正常运行的java程序，给满分，否则0分
~~~c
写两个方法，分别求两个整数的最大公约数和最小公倍数，用主方法调用这两个函数，并输出结果，

两个整数由键盘输入。
~
参考程序如下：
import java.util.*;
public class 最大公约数 {

// 最大公约数
int cdivisor(int x1, int y1)
{
int r, temp;
if (x1 < y1) {
temp = x1;
x1 = y1;
y1 = temp;
}
// 当较大数除以较小数余数等于0时，较小数为最大公约数
while (x1 % y1!=0)
{
r = x1 % y1;
x1 = y1;
y1 = r;
}
return y1;
}
/*递归方法
int cdivisor(int x1, int y1){
int r,temp,result;
if(x1<y1){
temp = x1;
x1 = y1;
y1 = temp;
}
if((x1%y1)==0){
result=y1;
}else{
result=cdivisor(y1,x1%y1);
}
return result;
}
*/
// 最小公倍数
int cmultiple(int x2, int y2, int d1)
{
return x2 * y2/d1;// 两数相乘结果除以它们的最大公约数为最小公倍数
}

public static void main(String[] args){
最大公约数 xx=new 最大公约数();
int x,y;
Scanner sc=new Scanner(System.in);
System.out.println("请输入两个正整数：");
x=sc.nextInt();
y=sc.nextInt();
System.out.println(x+"和"+y+"的最大公约数为："+xx.cdivisor(x, y));
System.out.println(x+"和"+y+"的最小公倍数为："+xx.cmultiple(x, y, xx.cdivisor(x, y)));
}
}
评分标准：
1、写出能完成题目要求功能的、可正常运行的java程序，给满分，否则0分
~~~b
编写程序，读取一个在0和1000之间的整数，并将该整数的各位数字加和。
~
参考程序如下：
import java.util.Scanner;
public class Question2 {
public static void main(String[] args){
//初始化，数据准备
int inputNum;//用户输入的整数
int sum;//整数的各位数字和
//输入，读取一个整数
inputNum = getInput();
//运算，整数的各位数字相加
sum = getResult(inputNum);
//输出，整数的各位数字和
showResult(inputNum,sum);
}

static int getInput(){
int num=0;
Scanner sc = new Scanner(System.in);

boolean isValidNum = false;
while (!isValidNum){
System.out.println("请输入一个在0和1000之间的整型数：");
num = sc.nextInt();
if (num > 0 && num < 1000){
isValidNum = true;
}
else {
System.out.println("您输入的数字不合法！");
}
}
return num;
}

static int getResult(int Num){
int result = 0;

int temp = Num;//方便计算的临时变量
while (temp>0){
result += temp % 10;//余数就是末位数字
temp = temp / 10;//去掉末位数字
}

return result;
}

static void showResult(int num,int result){
System.out.println("num="+num);
System.out.println("result="+result);

}

}


评分标准：
1、写出能完成题目要求功能的、可正常运行的java程序，给满分，否则0分
~~~b
编写程序对数组a={20,39,45,78,43,23,45,89,131}进行排序，输出各个元素并求出数组当中的最大值和最小值及平均值。
~
参考程序如下：

import java.util.Arrays;
public class 数组排序 {
public static void main(String[] args) {
int[] a={20,39,45,78,43,23,45,89,131};
Arrays.sort(a);
System.out.println("排序后的数组元素为：");
int sum=0;
float av=0.0f;
for(int i=0;i<a.length;i++){
System.out.print(a[i]+"\t");
sum+=a[i];
}
av=sum/(float)a.length;
System.out.println("\n数组中最小的元素为："+a[0]+",最大元素为："+a[a.length-1]);
System.out.println("所有元素的平均值为："+av);
}
}

~~~c
设计一个名为Location的类，定位二维数组中的最大值及其位置。这个类包括公共的数据域row、column和maxValue，
二维数组中的最大值及其下标用int型的row和column以及double型的maxValue存储。编写下面的方法，返回一个二维数组中最大值的位置。
public static Location LocateLargest(double[][] a)

~
参考程序如下：
import java.util.Scanner;
public class Question9{
public static void main(String[] args){
int row,col;
Scanner sc = new Scanner(System.in);
System.out.print("请输入二维数组的行列数：");
row = sc.nextInt();
col = sc.nextInt();

System.out.println("在下面输入数组的数据：");
double[][] a = new double[row][col];
for (int i = 0; i < row; i++){
for (int j = 0; j < col; j++){
a[i][j] = sc.nextDouble();
}
}

Location location = new Location(a);

System.out.println("最大元素是：" + location.GetMax() +
"，位置为：（" + location.GetRow() + "," + location.GetCol() + "）");

}
}

class Location{
private int row;
private int column;
private double maxValue;

public Location(double[][] a){
this.row = 0;
this.column = 0;
this.maxValue = a[0][0];

for (int i = 0; i < a.length; i++){
for (int j = 0; j < a[0].length; j++){
if (a[i][j] > maxValue){
this.row = i;
this.column = j;
this.maxValue = a[i][j];
}
}
}
}

public int GetRow(){
return this.row;
}
public int GetCol(){
return this.column;
}
public double GetMax(){
return this.maxValue;
}
}
评分标准：
1、写出能完成题目要求功能的、可正常运行的java程序，给满分，否则0分
~~~c
一些网站设定了一些制定密码的规则。编写一个方法，检验一个字符串是否是合法的密码。假设密码规则如下：(1)密码必须至少有8个字符(2)密码只能包括字母和数字(3)密码必须至少有2个数字。编写一个程序，提示用户输入密码，如果该密码符合规则就显示“有效密码”，否则显示“无效密码”。
~
参考程序如下：
import java.util.Scanner;
public class Question11{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
String str;

System.out.print("请输入密码：");
str = sc.next();
if (isValidPass(str)) System.out.println("有效密码");
else System.out.println(

"无效密码");
}
private static boolean isValidPass(String str){
if (isLengthValid(str) && isCharValid(str) && isNumberValid(str)) return true;
else return false;
}
private static boolean isLengthValid(String str){
if (str.length() >= 8) return true;
else return false;
}
private static boolean isCharValid(String str){
boolean isCharValid = true;
for (int i = 0; i < str.length() ; i++){
if (!Character.isLetterOrDigit(str.charAt(i))){
isCharValid = false;
break;
}
}
return isCharValid;
}
private static boolean isNumberValid(String str){
int count = 0;
for (int i = 0; i < str.length(); i++){
if (Character.isDigit(str.charAt(i))) count++;
}
if (count >= 2) return true;
else return false;
}
}
评分标准：
1、写出能完成题目要求功能的、可正常运行的java程序，给满分，否则0分

~~~b
使用匿名内部类编写程序，程序运行界面如下所示。当依次点击“新建”、“打开”、“保存”、“打印”按钮时，要求得到的输出信息如下：
~
参考程序如下：
import javax.swing.*;
import java.awt.event.*;

public class Question18 extends JFrame{
public Question18(){
JButton jbtNew = new JButton("新建");
JButton jbtOpen = new JButton("打开");
JButton jbtSave = new JButton("保存");
JButton jbtPrint = new JButton("打印");

JPanel panel = new JPanel();
panel.add(jbtNew);
panel.add(jbtOpen);
panel.add(jbtSave);
panel.add(jbtPrint);

add(panel);

jbtNew.addActionListener(
new ActionListener(){
public void actionPerformed(ActionEvent e){
System.out.println("响应新建按钮被点击的动作");
}
}
);

jbtOpen.addActionListener(
new ActionListener(){
public void actionPerformed(ActionEvent e){
System.out.println("响应打开按钮被点击的动作");
}
}
);

jbtSave.addActionListener(
new ActionListener(){
public void actionPerformed(ActionEvent e){
System.out.println("响应保存按钮被点击的动作");
}
}
);

jbtPrint.addActionListener(
new ActionListener(){
public void actionPerformed(ActionEvent e){
System.out.println("响应打印按钮被点击的动作");
}
}
);

}

public static void main(String[] args){
JFrame frame = new Question18();
frame.setTitle("匿名内部类监听器演示");
frame.setLocationRelativeTo(null);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.pack();//依据放在框架中组件的大小来自动调整框架的大小
frame.setVisible(true);
}

}
评分标准：
1、写出能完成题目要求功能的、可正常运行的java程序，给满分，否则0分

~~~b
编写程序实现点击放大或者缩小按钮时可以改变圆的大小。程序运行界面如下所示。实现一个按钮的功能即可。
~
参考程序如下：
import javax.swing.*;
i

mport java.awt.*;
import java.awt.event.*;

public class Question19 extends JFrame{
private JButton jbtEnlarge = new JButton("放大");
private JButton jbtShrink = new JButton("缩小");
private CirclePanel canvas = new CirclePanel();

public Question19(){
JPanel panel = new JPanel();
panel.add(jbtEnlarge);
panel.add(jbtShrink);

this.add(canvas, BorderLayout.CENTER);
this.add(panel, BorderLayout.SOUTH);

jbtEnlarge.addActionListener(new EnlargeListener());
}

public static void main(String[] args){
JFrame frame = new Question19();
frame.setTitle("控制圆");
frame.setLocationRelativeTo(null);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setSize(200, 200);
frame.setVisible(true);
}

class EnlargeListener implements ActionListener{
public void actionPerformed(ActionEvent e){
canvas.enlarge();
}
}

class CirclePanel extends JPanel{
private int radius = 5;

public void enlarge(){
radius++;
repaint();
}

protected void paintComponent(Graphics g){
super.paintComponent(g);
g.drawOval(getWidth()/2 - radius, getHeight()/2 - radius, 2*radius, 2* radius);
}
}

}
评分标准：
1、写出能完成题目要求功能的、可正常运行的java程序，给满分，否则0分

~~~c
用文件输入和文件输出流实现将文件FileOutputStreamTest.java复制到newFile.txt。
~
参考程序如下：
import java.io.*;

public class FileOutputStreamTest {

public static void main(String[] args) throws IOException {
FileInputStream fis = null;
FileOutputStream fos = null;
try {
//创建字节输入流
fis = new FileInputStream("FileOutputStreamTest.java");
//创建字节输入流
fos = new FileOutputStream("newFile.txt");
byte[] bbuf = new byte[32];
int hasRead = 0;
//循环从输入流中取出数据
while ((hasRead = fis.read(bbuf)) > 0) {
//每读取一次，即写入文件输出流，读了多少，就写多少。
fos.write(bbuf, 0, hasRead);
}
} catch (IOException ioe) {
ioe.printStackTrace();
} finally {
//使用finally块来关闭文件输入流
if (fis != null) {
fis.close();
}
//使用finally块来关闭文件输出流
if (fos != null) {
fos.close();
}
}
}
}

评分标准：
1、写出能完成题目要求功能的、可正常运行的java程序，给满分，否则0分

~~~d
用线程编程模拟两个客户从银行同一账
户中取钱过程，该账户共有800元，要求在取钱金额为负数、余额不足和账户透支情况下给出提示信息。
~
参考程序如下：
public class FetchMoney
{
public static void main(String[] args)
{
Bank bank =

new Bank();

//银行中只有800元，但两个线程都尝试取出800元
Thread t1 = new MoneyThread(bank); // 柜台

//bank = new Bank();

Thread t2 = new MoneyThread(bank); // 取款机

t1.start();
t2.start();
}
}

class Bank
{
private int money = 1000;

public synchronized int getMoney(int number)
{
if(number < 0)
{
return -1;
}
else if(number > money)
{
return -2;
}
else if(money < 0)
{
return -3;
}
else
{
try
{
Thread.sleep(1000);
}
catch (InterruptedException e)
{
e.printStackTrace();
}

money -= number;

System.out.println("left money: " + money);

return number;
}
}
}

class MoneyThread extends Thread
{
private Bank bank;

public MoneyThread(Bank bank)
{
this.bank = bank;
}

@Override
public void run()
{
int result=bank.getMoney(800);
switch (result) {
case -1:
System.out.println("取的金额不能是负数");
break;
case -2:
System.out.println("余额不足");
break;
case -3:
System.out.println("您的帐户已透支");
break;
default:
System.out.println("成功取出："+result+"元");
break;
}

}
}

评分标准：
1、写出能完成题目要求功能的、可正常运行的java程序，给满分，否则0分

~~~b
编写程序，求1+3+7+15+…+(220-1)
~
参考程序如下：
public class 求表达式值1 {
public static void main(String[] args) {
int i=0,sum=0,m=1;
for(i=1;i<=20;i++){
m*=2;
sum+=m-1;
}
System.out.println("表达式的值是："+sum);
}
}

评分标准：
1、写出能完成题目要求功能的、可正常运行的java程序，给满分，否则0分

~~~b
已知，s=1-1/2+1/3-1/4+…+1/(n-1)-1/n,编写程序,求n=100时，s的值。
~
参考程序如下：
public class 求表达式值2 {
public static void main(String[] args) {
int k=1,i;
double s=0;
for(i=1;i<101;i++){
s=s+(double)k/(double)i;
k=-k;
}
i--;
System.out.println("n="+i+"时，s="+s);
}
}

评分标准：
1、写出能完成题目要求功能的、可正常运行的java程序，给满分，否则0分
~~~d
利用面向对象的思想，编写程序，实现一个计算器控制台程序，要求输入两个数和运算符号，得到结果。
~
参考程序如下：
import java.util.*;

//操作类
public abstract class Operation {
private double number_A=0;
private double number_B=0;
double getA(){
return number_A;
}
void setA(double number_A){
this.number_A=number_A;
}
double getB(){
return number_B;
}
void setB(double number_B){
this.number_B=number_B;
}
abstract double getResult();
}

//加法类
class OperationAdd extends Operation{
dou
ble getResult(){
return getA()+getB();
}
}
//减法类
class OperationSub extends Operation{
double getResult(){
return getA()-getB();
}
}
/

/乘法类
class OperationMul extends Operation{
double getResult(){
return getA()*getB();
}
}
//除法类
class OperationDiv extends Operation{
double getResult(){
if(getB()==0){
try{
throw new Exception("除数不能为0!");
}catch(Exception e){
System.out.println(e.getMessage());
System.exit(0);
}
}
return getA()/getB();
}
}
//静态工厂 简单运算类
class OperationFactory{
public static Operation createOperate(char operate){
Operation op=null;
switch(operate){
case '+':op=new OperationAdd();
break;
case '-':op=new OperationSub();
break;
case '*':op=new OperationMul();
break;
case '/':op=new OperationDiv();
break;
}
return op;
}
}

//界面类
class MyConsole{
private double x,y;
private char oper;
public MyConsole(){
Scanner sc=new Scanner(System.in);
System.out.println("请输入两个数字，中间用一个空格隔开：");
x=sc.nextDouble();
y=sc.nextDouble();
System.out.println("请输入运算符号(+,-,*,/)：");
oper=sc.next().charAt(0);
}
void showReult(){
Operation op=OperationFactory.createOperate(oper);
op.setA(x);
op.setB(y);
System.out.println("运算结果为："+op.getResult());
}
}

//测试类
class TestOperation{
public static void main(String[] args){
MyConsole mc=new MyConsole();
mc.showReult();
}
}

评分标准：
1、写出能完成题目要求功能的、可正常运行的java程序，给满分，否则0分
~~~d
利用面向对象知识，用Java语言编写圆类(Circle)和矩形类(Retangle)继承自形状类(Shape),计算周长和面积,并编写测试类测试完成测试。
~
参考程序如下：
import java.util.*;
public abstract class Shape {
abstract void setParm(double... a);
abstract double getArea();
abstract double getPerimeter();
}

//圆形类
class Circle extends Shape{
private double r;
public Circle(){}
public Circle(double r){
this.r=r;
}
void setParm(double... r){
this.r=r[0];
}
double getArea(){
return Math.PI*r*r;
}
double getPerimeter(){
return 2*Math.PI*r;
}
}
class Retangle extends Shape{
private double w,h;
public Retangle(){}
public Retangle(double w,double h){
this.w=w;
this.h=h;
}
public void setParm(double...ds ){
this.w=ds[0];
this.h=ds[1];
}
double getArea(){
return w*h;
}
double getPerimeter(){
return 2*(w+h);
}
}
class ShapeFactory{
public static Shape createShape(int shape){
Shape sh=null;
switch(shape){
case 1:sh=new Circle();
break;
case 2:sh=new Retangle();
break;
}
return sh;
}
}
class MyShapeConsole{
private int shape;
private Scanner sc;
private Shape sp;
private boolean flag=t
rue;
private String s="y";
public MyShapeConsole(){
sc=new Scanner(System.in);
setMenu();
while(true){
shape=sc.nextInt();
sp=S

hapeFactory.createShape(shape);
setParm();
showResult();
System.out.println("continue?（y/n）");
s=sc.next();
if(s.equals("y")||s.equals("Y")){
setMenu();
flag=true;
}else if(s.equals("n")||s.equals("N")){
flag=false;
System.out.println("程序终止运行！");
System.exit(0);
}

}
}
private void setMenu(){
System.out.println("\t控制菜单");
System.out.println("***************************");
System.out.print("*[1]圆形 \t *\n");
System.out.print("*[2]矩形 \t *\n");
System.out.print("*[3]退出 \t *\n");
System.out.println("***************************");
System.out.println("请输入要计算面积和周长图形数字:");
}
private void setParm(){
switch(shape){
case 1:System.out.println("请输入圆形的半径：");
sp.setParm(sc.nextDouble());
break;
case 2:System.out.println("请输入矩形的宽度和长度：");
sp.setParm(sc.nextDouble(),sc.nextDouble());
break;
case 3:return;
default:System.out.println("输入参数错误！");
}
}
private void showResult(){
switch(shape){
case 1:System.out.println("圆形的面积为："+sp.getArea()+",周长为："+sp.getPerimeter());
break;
case 2:System.out.println("矩形的面积为："+sp.getArea()+",周长为："+sp.getPerimeter());
break;
case 3:System.out.println("程序终止运行！");
System.exit(0);
}
}
}
class Test{
public static void main(String[] args){
MyShapeConsole ms=new MyShapeConsole();
}
}

评分标准：
1、写出能完成题目要求功能的、可正常运行的java程序，给满分，否则0分
~~~c
有n个人围成一圈，顺序排号。从第一个人开始报数（从1到3报数），凡报到3的人退出圈子，问最后留下的是原来第几号的那位。
~
参考程序如下：
import java.util.Scanner;
public class lianxi37 {
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
System.out.print("请输入排成一圈的人数：");
int n = s.nextInt();
boolean[] arr = new boolean[n];
for(int i=0; i<arr.length; i++) {
arr[i] = true;
}
int leftCount = n;
int countNum = 0;
int index = 0;
while(leftCount > 1) {
if(arr[index] == true) {
countNum ++;
if(countNum == 3) {
countNum =0;
arr[index] = false;
leftCount --;
}
}
index ++;
if(index == n) {
index = 0;
}
}
for(int i=0; i<n; i++) {
if(arr[i] == true) {
System.out.println("原排在第"+(i+1)+&qu
ot;位的人留下了。");
}
}
}
}

评分标准：
1、写出能完成题目要求功能的可正常运行的java程序，给满分，否则0分
~~~c
输入某年某月某日，判断这一天是这一年的第几天。计算方法为：h =（q+[26(m+1)/10]+k+[k/4]+[j/4

]+5*j）%7，各变量含义如下：（1）h是一个星期中的每一天（0为星期六；1为星期天；2为星期一；3为星期二；4为星期三；5为星期四；6为星期五）（2）q是某月的某一天（3）m是月份（3为三月，4为四月，...，12为十二月）。一月和二月分别记为上一年的13和14月。（4）j是世纪数（即|year/100|）（5）k是世纪的年数（即year%100）。

~
参考程序如下：
import java.util.*;
public class lianxi14 {
public static void main(String[] args) {
int year, month, day;
int days = 0;
int d = 0;
int e;
input fymd = new input();
do {
e = 0;
System.out.print("输入年：");
year =fymd.input();
System.out.print("输入月：");
month = fymd.input();
System.out.print("输入天：");
day = fymd.input();
if (year < 0 || month < 0 || month > 12 || day < 0 || day > 31) {
System.out.println("输入错误，请重新输入！");
e=1 ;
}
}while( e==1);
for (int i=1; i <month; i++) {
switch (i) {
case 1:
case 3:
case 5:
case 7:
case 8:
case 10:
case 12:
days = 31;
break;
case 4:
case 6:
case 9:
case 11:
days = 30;
break;
case 2:
if ((year % 400 == 0) || (year % 4 == 0 && year % 100 != 0)) {
days = 29;
} else {
days = 28;
}
break;
}
d += days;
}
System.out.println(year + "-" + month + "-" + day + "是这年的第" + (d+day) + "天。");
}
}
class input{
public int input() {
int value = 0;
Scanner s = new Scanner(System.in);
value = s.nextInt();
return value;
}
}

评分标准：
1、写出能完成题目要求功能的、可正常运行的java程序，给满分，否则0分

~~~c
两个乒乓球队进行比赛，各出三人。甲队为a,b,c三人，乙队为x,y,z三人。已抽签决定比赛名单。有人向队员打听比赛的名单。a说他不和x比，c说他不和x,z比，请编程序找出三队赛手的名单。
~
参考程序如下：
public class lianxi18 {
static char[] m = { 'a', 'b', 'c' };
static char[] n = { 'x', 'y', 'z' };
public static void main(String[] args) {
for (int i = 0; i < m.length; i++) {
for (int j = 0; j < n.length; j++) {
if (m[i] == 'a' && n[j] == 'x') {
continue;
} else if (m[i] == 'a' && n[j] == 'y') {
continue;
} else if ((m[i] == 'c' && n[j] == 'x')
|| (m[i] == 'c' && n[j] == 'z')) {
continue;
} else if ((m[i] == 'b' && n[j] == 'z')
|| (m[i] == 'b' && n[j] == 'y')) {
continue;
}
else
System.out.println(m[i] + " vs " + n[j]);
}
}
}
}

评分标准：
1、写出能完成题目要求功能的可正常运行的java程序，给满分，否则0分
~~~b
编写程序，使用FileInputStrea

m类对象读取程序本身并显示在屏幕上。
~
参考程序如下：
import java.io.*;
public class FileInputStreamTest
{
public static void main(String[] args) throws IOException
{

FileInputStream fis = new FileInputStream("FileInputStreamTest.java");

byte[] bbuf = new byte[1024];

int hasRead = 0;

while ((hasRead = fis.read(bbuf)) > 0 )
{

System.out.print(new String(bbuf , 0 , hasRead ));
}
fis.close();
}
}
评分标准：
1、写出能完成题目要求功能的、可正常运行的java程序，给满分，否则0分
~~~c
某个公司采用公用电话传递数据，数据是四位的整数，在传递过程中是加密的，加密规则如下：每位数字都加上5,然后用和除以10的余数代替该数字，再将第一位和第四位交换，第二位和第三位交换。
~
参考程序如下：
import java.util.*;
public class lianxi48 {
public static void main(String args[]) {
Scanner s = new Scanner(System.in);
int num=0,temp;
do{
System.out.print("请输入一个4位正整数：");
num = s.nextInt();
}while (num<1000||num>9999);
int a[]=new int[4];
a[0] = num/1000; //取千位的数字
a[1] = (num/100)%10; //取百位的数字
a[2] = (num/10)%10; //取十位的数字
a[3] = num%10; //取个位的数字
for(int j=0;j<4;j++)
{
a[j]+=5;
a[j]%=10;
}
for(int j=0;j<=1;j++)
{
temp = a[j];
a[j] = a[3-j];
a[3-j] =temp;
}
System.out.print("加密后的数字为：");
for(int j=0;j<4;j++)
System.out.print(a[j]);
}
}

评分标准：
1、写出能完成题目要求功能的、可正常运行的java程序，给满分，否则0分
~~~c
有五个学生，每个学生有3门课的成绩，从键盘输入以上数据（包括学生号，姓名，三门课成绩），计算出平均成绩，把原有的数据和计算出的平均分数存放在磁盘文件 "stud "中。
~
参考程序如下：
import java.io.*;
import java.util.*;
public class lianxi50 {
public static void main(String[] args){
Scanner ss = new Scanner(System.in);
String [][] a = new String[5][6];
for(int i=1; i<6; i++) {
System.out.print("请输入第"+i+"个学生的学号：");
a[i-1][0] = ss.nextLine();
System.out.print("请输入第"+i+"个学生的姓名：");
a[i-1][1] = ss.nextLine();
for(int j=1; j<4; j++) {
System.out.print("请输入该学生的第"+j+"个成绩：");
a[i-1][j+1] = ss.nextLine();
}
System.out.println("\n");
}
//以下计算平均分
float avg;
int sum;
for(int i=0; i<5; i++) {
sum=0;
for(int j=2; j<5; j++) {
sum=sum+ Integer.parseInt(a[i][j]);
}
avg= (float)sum/3;
a[i][5]=String.valueOf(avg);
}
//以下写磁盘文件
String s1;
t
ry {
File f = new File("C:\\stud");
if(f.exists()){
System.out.println("文件存在");
}else{
System.out.println("文件

不存在，正在创建文件");
f.createNewFile();//不存在则创建
}
BufferedWriter output = new BufferedWriter(new FileWriter(f));
for(int i=0; i<5; i++) {
for(int j=0; j<6; j++) {
s1=a[i][j]+"\r\n";
output.write(s1);
}
}
output.close();
System.out.println("数据已写入c盘文件stud中！");
} catch (Exception e) {
e.printStackTrace();
}
}
}

评分标准：
1、写出能完成题目要求功能的、可正常运行的java程序，给满分，否则0分
~~~a
编写程序，将自己的班级、学号、姓名等真实信息按顺序写入文件“*****信息.txt”中。其中，“****”代表自己的学号，程序运行后打开生成的文本文件效果如下图所示。记事本文件内信息格式为：2011网络工程(物联网) 11101161 Rose。
~

参考程序如下：
import java.io.*;
public class InfoToFile {
public static void main(String[] args){
try{
FileWriter fr=new FileWriter("11101161信息.txt");
BufferedWriter bw=new BufferedWriter(fr);
String s="2011网络工程(物联网) 11101161 Rose";
bw.write(s,0,s.length());
bw.close();
}catch(IOException e){
System.out.println(e.getMessage());
}
}
}

评分标准：
1、写出能完成题目要求功能的、可正常运行的java程序，给满分，否则0分

~~~b
编写程序，从键盘上任意输入两个整数，并将其结果按格式打印输出。程序运行效果示意图如下：。
~

参考程序如下：
import java.util.*;
public class TestOutputFormat {
public static void main(String[] args) {
try {
Scanner sc = new Scanner(System.in);
int i1 = sc.nextInt();
int i2 = sc.nextInt();
System.out.println(i1 + "×" + i2 + "=" + (i1 * i2));
} catch (InputMismatchException e) {
System.out.println("数据输入格式不正确！");
}
}
}

评分标准：
1、写出能完成题目要求功能的、可正常运行的java程序，给满分，否则0分
~~~c
对于给定数组ary={3,50,25,10,90,85}编写程序完成下述功能：1.对其中元素进行排序并格式化输出；2.对其中的元素求和并格式化输出。要求定义接口，并编写测试类完成测试，程序运行效果如下图所示。
~
参考程序如下：
import java.util.*;
//接口CommandMode，定义指令
public interface CommandMode {
void op(int[] ary);
}

// 操控指令类operateCommand
class OperateCommand {
private int[] ary;

public OperateCommand(int[] ary) {
this.ary = ary;
}

public void operate(CommandMode c) {
c.op(ary);
}
}

// ArraySortedPrint类，指令1，对数组元素排序并格式化输出
class ArraySortedPrint implements CommandMode {
private int[] ary;

public ArraySortedPrint(int[] ary) {
this.ary = ary;
}


public void op(int[] ary) {
Arrays.sort(ary);
System.out.println("**********************************************");
System.out.pr

intln("数组排序后输出结果为：");
for (int i = 0; i < ary.length; i++) {
System.out.print("ary[" + i + "]=" + ary[i] + "\t");
if ((i + 1) % 2 == 0) {
System.out.print("\n");
}

}
System.out.println("**********************************************");
}
}
//ArrayElementSum类，指令2，对数组元素求和并格式化输出。
class ArrayElementSum implements CommandMode {
private int[] ary;

public ArrayElementSum(int[] ary) {
this.ary = ary;
}

public void op(int[] ary) {
int sum = 0;
for (int temp : ary) {
sum += temp;
}
System.out.println("**********************************************");
System.out.println("数组求和后的结果为：");
for (int i = 0; i < ary.length - 1; i++) {
System.out.print("ary[" + i + "]+");
}
System.out.print("ary[" + (ary.length - 1) + "]=" + sum);
System.out.println("\n**********************************************");
}
}
//测试类Test
class Test {
public static void main(String[] args) {
int[] ary = { 3, 50, 25, 10, 90, 85 };
ArrayElementSum aes = new ArrayElementSum(ary);
ArraySortedPrint asp = new ArraySortedPrint(ary);
OperateCommand oc = new OperateCommand(ary);
oc.operate(asp);
oc.operate(aes);
}
}


评分标准：
1、写出能完成题目要求功能的、可正常运行的java程序，给满分，否则0分
~~~d
利用网络编程知识编写程序，将指定地址ftp://172.19.11.4/下的文件TurboC2.0.zip下载到当前目录下的子目录download中，并编写测试类完成测试。
~
参考程序如下：
import java.io.*;
import http://.*;
//下载类Download
public class Download {
public void down(URL url){
InputStream is = null;
RandomAccessFile raf;
File f;
try{
is=url.openStream();
f=new File("./download");
if(!f.exists()){
f.mkdir();
}
raf=new RandomAccessFile("./download/"+url.getFile(),"rw");
byte[] buff=new byte[1024];
int hasRead=0;
while((hasRead = is.read(buff)) > 0){
raf.write(buff,0,hasRead);
}
}catch(MalformedURLException e){
System.out.println("地址不正确！");
}
catch(Exception e){
System.out.println(e.getMessage());
}finally{
try{
is.close();
}catch(IOException e){
System.out.println(e.getMessage());
}
}
}
}
//测试类TestDownload
class TestDownload{
public static void main(String[] args){
Download d=new Download();
try {
d.down(new URL("ftp://172.19.11.4/TurboC2.0.zip"));
} catch (MalformedURLException e) {
e.printStackTrace();
}
}
}

评分标准：
1、写出
能完成题目要求功能的、可正常运行的java程序，给满分，否则0分
~~~d
用面向对象的思想定义一个接口Area，其中包含计算面积的方法getArea()，定义MyCircle和MyRectangle两个类实现了接口Area，分别计算圆和矩形的面积，最后写出测试类，从工作目录的下的子

目录download下input1.txt和input2.txt中读取参数，完成测试。input1.txt中的测试数据如下图a所示，input2.txt中的测试数据如下图b所示。
~
参考程序如下：
import java.util.*;
import java.io.*;

public interface Area {
double getArea();
}

class MyCircle implements Area {
private double r;

public MyCircle() {
};

public MyCircle(double r) {
this.r = r;
}

public double getArea() {
return Math.PI * r * r;
}

public void printCircleArea(Redirect d, File f) throws Exception {
d.readDataFromFile(f);
Scanner sc1 = new Scanner(System.in);
while (sc1.hasNext()) {
r = sc1.nextDouble();
System.out.println("圆形面积为" + getArea());
System.out.println("*****************************");
}
}
}

class MyRetangle implements Area {
private double width, height;

public MyRetangle() {
}

public MyRetangle(double width, double height) {
this.width = width;
this.height = height;
}

public double getArea() {
return width * height;
}

public void printRetangleArea(Redirect d, File f) throws Exception {
d.readDataFromFile(f);
BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
String str = null;
while ((str = bf.readLine()) != null) {
String[] strs = str.split(" ");
width = Double.parseDouble(strs[0]);
height = Double.parseDouble(strs[1]);
System.out.println("矩形面积为：" + getArea());
System.out.println("*****************************");
}
}
}
//重定向类Redirect
class Redirect {
public void readDataFromFile(File f) {
try {
FileInputStream fis = new FileInputStream(f);
System.setIn(fis);
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}
}

class TestMyShape {
public static void main(String[] args) throws Exception {
File f1 = new File("./download/input1.txt");
File f2 = new File("./download/input2.txt");
Redirect d = new Redirect();
MyCircle mc = new MyCircle();
mc.printCircleArea(d, f1);
MyRetangle mr = new MyRetangle();
mr.printRetangleArea(d, f2);
}
}

评分标准：
1、写出能完成题目要求功能的、可正常运行的java程序，给满分，否则0分
~~~d
利用网络套接字编程，将服务器端server目录下的文件TurboC2.0.zip传输到客户端download目录下，更名为TC.zip
~
参考程序如下：
import java.io.*;
import http://.*;

public class TransFileServer {

public static void main(String[] args)throws Exception {
ServerSocket ss=new ServerSocket(20000);
while(true){
Socket s=ss.accept();
File f=new File("./server/TurboC.zip");
OutputStream os=s.getOutputStream();
FileInputStream fis=new FileInputStream(f);
byte[] b=new byte[1024];
int hasRead=0;
while((hasRe
ad=fis.read(b))>0){
os.write(b,0,hasRead);
}
os.close();
s.close();
}
}
}

class TransFileClient2{
public static void main(String[]