您的当前位置：首页河北工业大学Java程序设计实验报告

河北工业大学Java程序设计实验报告

来源：九壹网

Java程序设计实验报告

班级：网络 151 姓名：徐毅民学号: 153299 .

实验一 Java语言基础

一．实验目的

掌握 Java语言的基本语法、基本数据类型的使用方法，掌握从键盘输入基本类型的数据，熟练运用分支、循环等语句控制程序流程。

二．实验内容

1、编写一个Java应用程序，用户从键盘输入十名学生的信息，至少包括姓名、年龄、出生年月日、java课程实验成绩，成绩使用浮点数，年龄使用整型，程序将输出年龄、java课程实验成绩的平均值。

提示：Scanner对象调用nextDouble()或nextFloat()可以获取用户从键盘输入的浮点数。

2、使用Arrays类实现数组排序：使用java.util包中的Arrays类的类方法public static void sort(double a[])可以把参数a指定的double类型数组按升序排序；public static void sort(double a[], int start , int end)可以把参数a指定的double类型数组中从位置start到end位置的值按升序排序。

给定数组 int a[]={12,34,9,-23,45,6,90,123,19,45,34}; 从键盘读入一个整数，使用折半查找判断该整数是否在这个数组中，并将结果输出。

3、输出100~200之间的所有素数。

4、采用for循环求1至1000之内的所有“完全数”。所谓“完全数”是指一个数，恰好等于它的因子之和。例如，6是一个完全数，因为6的因子为1、2、3，而6＝1+2+3。

5、已知XYZ+YZZ=532，其中X、Y和Z为数字，编程求出X，Y和Z的值。

三．实验步骤

实验1以最终学生信息管理系统为准

实验2代码如下： import java.util.Arrays; import java.util.Scanner; public class test2 {

public static void printDoubleArray(double a[]) { }

public static void printfIntegerArray(int a[]) { }

public static void main(String[] args) {

for(int i = 0; i < a.length; i++) { }

System.out.println(); System.out.print(a[i]+\" \");

for(int i = 0; i < a.length; i++) { }

System.out.println(); System.out.print(a[i]+\" \");

double a[] = {2.6, 4.6, 2, 8, 888, 569.5, 454.5, 100, -84.5, 45}; System.out.println(\"原double数组a:\"); printDoubleArray(a); Arrays.sort(a, 0, a.length/2);

System.out.println(\"排序double数组a前一半:\"); printDoubleArray(a); Arrays.sort(a);

System.out.println(\"排序整个double数组a:\"); printDoubleArray(a);

int b[] = {12, 34, 9, -23, 45, 6, 90, 123, 19, 45, 34}; Arrays.sort(b);

System.out.println(\"排序整个double数组b:\"); printfIntegerArray(b);

Scanner in = new Scanner(System.in); System.out.print(\"输入要查询的数字:\"); int key = in.nextInt();

int i = Arrays.binarySearch(b, key); if(i < 0 || i >= b.length) {

System.out.println(i+\"输入数字不在数组中!\");

} else {

System.out.println(b[i]+\"在数组b第\"+(i+1)+\"位！\");

} }

}

实验3代码如下： public class test3 {

public static boolean isPrime(int x) { }

public static void main(String[] args) {

if(x == 1) return false; int s = (int)Math.sqrt(x); for(int i = 2; i <= s; i++) { }

return true;

if(x%i == 0) return false;

int cnt = 0;

for(int i = 100; i < 200; i++) {

if(isPrime(i)) { }

if(isPrime(i) && cnt%10 == 0) System.out.println(); cnt++;

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

} }

}

实验4代码如下： public class test4 {

public static boolean isCompleteNumber(int x) { }

public static void main(String[] args) {

int sum = 0;

for(int i = 1; i < x; i++) { }

return x == sum; if(x%i == 0) sum += x;

int cnt = 0;

for(int i = 1; i <= 1000; i++) {

if(isCompleteNumber(i)) { }

if(isCompleteNumber(i) && cnt%10 == 0)

System.out.println();

cnt++;

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

} }

}

实验5代码如下： public class test5 {

public static void main(String[] args) {

Z=\"+z);

} }

} } } }

return;

for(int x = 0; x < 10; x++) {

for(int y = 0; y < 10; y++) {

for(int z = 0; z < 10; z++) {

if(100*x+110*y+12*z == 532) {

System.out.println(\"X=\"+x+\" Y=\"+y+\"

四．详细的调试和运行结果

实验2运行结果：

原double数组a：

2.6 4.6 2.0 8.0 888.0 569.5 454.5 100.0 -84.5 45.0 排序double数组a前一半：

2.0 2.6 4.6 8.0 888.0 569.5 454.5 100.0 -84.5 45.0 排序整个double数组a：

-84.5 2.0 2.6 4.6 8.0 45.0 100.0 454.5 569.5 排序整个double数组b：

-23 6 9 12 19 34 34 45 45 90 123 输入要查询的数字：-23 -23在数组b第一位！

实验3运行结果：

101 103 107 109 113 127 131 137 139 149 151 157 163 167 173 179 181 191 193 197 199

实验4运行结果：

2 3 5 7 11 13 17 19 23 29

888.0 .

31 37 41 43 47 53 59 61 67 71 73 79 83 97 101 103 107 109 113 127 131 137 139 149 151 157 163 167 173 179 181 191 193 197 199 211 223 227 229 233 239 241 251 257 263 269 271 277 281 283 293 307 311 313 317 331 337 347 349 353 359 367 373 379 383 3 397 401 409 419 421 431 433 439 443 449 457 461 463 467 479 487 491 499 503 509 521 523 541 547 557 563 569 571 577 587 593 599 601 607 613 617 619 631 1 3 7 653 659 661 673 677 683 691 701 709 719 727 733 739 743 751 757 761 769 773 787 797 809 811 821 823 827 829 839 853 857 859 863 877 881 883 887 907 911 919 929 937 941 947 953 967 971 977 983 991 997

实验5运行结果： X=3 Y=2 Z=1

五．实验感想

通过本次从实验对java语言的基本语法有了基本了解，学会了

使用控制台命令行的方式运行java程序。

实验二面向对象程序设计

一．实验目的

通过编程和上机实验，掌握类和构造方法的定义及创建对象的方法，掌握类的封装及继承原则，正确使用重载和覆盖等多态概念设计可复用方法，熟悉包、接口的使用方法，掌握面向对象的程序设计方法。

二．实验内容

1、编写MyDate类，完善上次实验中的人员信息录入，实现日期合法性判断，包括大小月和闰年。

2、声明一个Person类和派生类Student，成员变量包括学号、姓名、入学时间、身份证号、学分绩点等信息，成员方法包括开户、存款、取款、查询（余额、明细）、销户等操作。

3、定义接口Shape及其抽象方法getArea()和getPerimeter()用于计算图形和面积和周长。定义类Rectangle(矩形)、类Circle(圆形)、类Triangle(三角形)，要求这些类继承点类Coordinates()并实现接口的抽象方法。提示：

class Coordinates { long x; long y;

Coordinate(long x, long y) {

this.x=x; this.y=y; } }

4、包的定义和使用  创建自定义包Mypackage

在存放源程序的文件夹中建立一个子文件夹 Mypackage。例如，在“E:\\java\\程序”文件夹之中创建一个与包同名的子文件夹 Mypackage（E:\\java\\程序\\Mypackage），并将编译过的 class 文件放入该文件夹中。注意：包名与文件夹名大小写要一致。再添加环境变量 classpath 的路径，例如：E:\\j2sdk1.4.2_01\\lib; E:\\java\\程序  在包中创建类

YMD.java 程序功能：在源程序中，首先声明使用的包名Mypackage，然后创建YMD 类，该类具有计算今年的年份并输出一个带有年月日的字符串的功能。编译Test_YMD.java文件，然后将Test_YMD.class文件存放到Mypackage文件夹中。  编写使用包Mypackage中Test_YMD类的程序

YMD_2.java程序功能：给定某人姓名与出生日期，计算该人年龄，并输出该人姓名，年龄，出生日期。程序使用了Test_YMD 的方法来计算年龄。

三．实验步骤

实验1代码如下：

MyDate类：

public class MyDate { private int year; //年 private int month; //月 private int day; public MyDate() { }

public MyDate(MyDate other) { }

public MyDate(int year, int month, int day) { }

public static int getDaysOfMonth(int year, int month) {

12:return 31;

case 4:case 6:case 9:case 11: return 30; switch(month) {

case 1:case 3:case 5:case 7:case 8:case 10:case this.year = year; this.month = month; this.day = day;

this(other.year, other.month, other.day); this(1903, 1, 1);

//日

}

case 2: return MyDate.isLeapYear(year)?29:28; default: return Integer.MIN_VALUE; //错误

public boolean isValidDate() { }

public void setMyDate(int year, int month, int day) { }

public int getYear() { }

public int getMonth() { }

public int getDay() { }

public static boolean isValidDate(int year, int month, int day) {

return MyDate.isValidDate(this.year, this.month, this.day);

this.year = year; this.month = month; this.day = day;

return year;

return month;

return day;

}

if(day > MyDate.getDaysOfMonth(year, month)) { }

return true; return false;

public static boolean isLeapYear(int year) { }

public static void main(String args[]) {

正确！\");

不正确！\");

return year%400==0 || year%100!=0 && year%4==0;

int sel, y, m, d;

Scanner in = new Scanner(System.in); while(true) {

System.out.println(\"请输入年月日:\"); y = in.nextInt(); m = in.nextInt(); d = in.nextInt();

if(MyDate.isValidDate(y, m, d)) {

System.out.println(y+\"年\"+m+\"月\"+d+\"日\"+\"信息

} else {

System.out.println(y+\"年\"+m+\"月\"+d+\"日\"+\"信息

} }

}

System.out.println(\"是否继续输入？(1:是,0:否)\"); sel = in.nextInt();

if(sel == 0) break;

实验2以最终学生信息管理系统为准

实验3代码如下：

Shape接口： public interface Shape { public abstract double getArea(); public abstract double getPerimeter(); }

Rectangle类：

public class Rectangle implements Shape { private double width; private double height;

private Coordinate c; //矩形左下角的点

public Rectangle() {

this.width = 0;

}

this.height = 0;

this.c = new Coordinate(0, 0);

public Rectangle(double width, double height, int x, int y) { }

@Override

public double getArea() { }

@Override

public double getPerimeter() { } } Circle类

public class Circle implements Shape { private double radius; private Coordinate center;

this.width = width; this.height = height; this.c = new Coordinate(x, y);

return this.width*this.height;

return 2*(this.width+this.height);

public Circle() { }

public Circle(double radius, long x, long y) { }

@Override

public double getArea() { }

@Override

public double getPerimeter() { } }

Triangle类

public class Triangle implements Shape { private double a, b, c; private Coordinate c1, c2, c3; public Triangle() {

this.radius = 0;

this.center = new Coordinate(0, 0);

this.radius = radius;

this.center = new Coordinate(x, y);

return Math.PI*this.radius*this.radius;

return 2*Math.PI*this.radius;

}

this.a = 0; this.b = 0; this.c = 0;

this.c1 = new Coordinate(0, 0); this.c2 = new Coordinate(0, 0); this.c3 = new Coordinate(0, 0);

@Override

public double getArea() { }

@Override

public double getPerimeter() { }

public static boolean isVaild(double a, double b, double c) {

if(a+b <= c || a+c <= b || b+c <= a) { }

if(Math.abs(a-b) >= c || Math.abs(a-c) >= b || return false;

return this.a+this.b+this.c; double s = this.getPerimeter()/2; return Math.sqrt(s*(s-a)*(s-b)*(s-c));

Math.abs(b-c) >= a) {

} }

}

return false;

return true;

测试类

public class test3 {

public static void main(String[] args) {

Shape shape;

Scanner in = new Scanner(System.in);

System.out.println(\"请输入矩形的宽、高，左下角点的

横坐标、纵坐标:\");

shape = new Rectangle(in.nextDouble(), in.nextDouble(),

in.nextInt(), in.nextInt());

System.out.println(\"矩形的面积：\"+shape.getArea()+\" 周

长\"+shape.getPerimeter());

纵坐标:\");

in.nextInt());

System.out.println(\"圆形的面积：\"+shape.getArea()+\" 周shape = new Circle(in.nextDouble(), in.nextInt(), System.out.println(\"请输入圆的半径，圆心的横坐标、

长\"+shape.getPerimeter());

double a, b, c;

System.out.println(\"请输入三角形的三条边长:\"); a = in.nextDouble(); b = in.nextDouble(); c =

in.nextDouble();

三条边长:\");

a = in.nextDouble(); b = in.nextDouble(); c = while(!Triangle.isVaild(a, b, c)) {

System.out.println(\"这不是一个三角形，请重新输入

in.nextDouble();

坐标:\");

shape = new Triangle(a, b, c, in.nextInt(), in.nextInt(), }

System.out.println(\"请分别输入三个顶点的横坐标、纵

in.nextInt(), in.nextInt(), in.nextInt(), in.nextInt());

System.out.println(\"三角形的面积：\"+shape.getArea()+\"

周长\"+shape.getPerimeter());

} }

实验4代码如下：

五．详细的调试和运行结果

实验1运行结果：请输入年月日： 2001 12 56

2001年12月56日信息不正确！是否继续输入？（1：是，0：否） 1

请输入年月日： 1900 2 29

1900年2月29日信息不正确！是否继续输入？（1：是，0：否） 0

实验2以最终学生信息管理系统为准

实验3运行结果：

请输入矩形的宽、高，左下角点的横坐标、纵坐标： 7 8 9 10

矩形的面积：56.0 周长30.0

请输入圆的半径，圆心的横坐标、纵坐标： 2 3 4

圆形的面积：12.566370614359172 周长12.566370614359172 请输入三角形的三条边长：

3 4 5

请分别输入三个顶点的横坐标、纵坐标： 4 5 8 5 4 8

三角形的面积：6.0 周长12.0

实验4运行结果：

五．实验感想

通过本次从实验对java语言的基本语法有了更深刻的了解，对java中类的定义和面向对象的设计有了基本的了解。

实验三异常处理程序设计

一．实验目的

了解Java中异常处理（exception）的作用及常用的异常类，掌握异常处理的设计方法。

二．实验内容

1、用try-catch-finally结构实现异常处理。编译并运行程序，写出程序运行结果。

2、设计一个Java程序，自定义异常类，从命令行（键盘）输入一个字符串，如果该字符串值为“XYZ”，则抛出一个异常信息“This is a XYZ”，如果从命令行输入ABC，则没有抛出异常。（只有XYZ和ABC两种输入）。

3、声明一个Average接口，其中约定求平均值的方法；声明多个类实现Average接口，分别给出求平均值的方法实现。例如，在一组数值中，一种算法是，全部数值相加后求平均值，另一种算法是，去掉一个最高分和一个最低分后，再将总分求平均等；使用键盘输入数据时，对于不能转换成数值的字符串进行异常处理。

三．实验步骤实验1代码如下：

public class ExceptionTest {

public static void main(String[] args) { int i = 0;

String greeting[] = {\"Hello\ while(i < 4) { try {

System.out.println(greeting[i]); } catch(ArrayIndexOutOfBoundsException e) { System.out.println(\"数组越界\"); } finally {

System.out.println(\"总会运行\"); } i++; } } }

实验2代码如下：

import java.util.Scanner;

public class MyException extends Exception { private static final long serialVersionUID = 1L; String information; public MyException() {

this.information = this.toString(); }

public MyException(String s) {

this.information = s; }

public String getString() { return this.information; }

public static void main(String[] args) { int sel; String input;

Scanner in = new Scanner(System.in); while(true) { try {

input = in.next(); if(input.equals(\"XYZ\")) {

throw new MyException(\"This is a XYZ\"); }

} catch(MyException e) {

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

System.out.print(\"是否继续输入？(1:是,0:否)\");

sel = in.nextInt(); if(sel == 0) break;

} } } }

实验3以最终学生信息管理系统为准

四．详细的调试和运行结果实验1运行结果： Hello 总会运行 Only 总会运行 Test 总会运行数组越界总会运行

实验2运行结果：请输入XYZ或ABC: ABC

是否继续输入？（1：是，0：否）： 1

请输入XYZ或ABC: XYZ

This is a XYZ

是否继续输入？（1：是，0：否）： 0

五．实验感想

通过本次实验对java的异常处理机制有了很深的了解。

实验四图形用户界面程序设计

1.实验目的：掌握组件的使用方法，理解委托事件处理模型。熟悉图形用户界面

基本组件的使用方法，熟悉如何使用布局管理器对组件进行管理及如何使用Java的事件处理机制。实验内容：

1、输入一个整数，分别显示其百位、十位和个位数字，图形用户界面如图4.1所示。要求：整数文本行可编辑且能实现事件处理，当输入数据错误时，处理异常，弹出对话框，提示重新输入信息；其他文本行仅用于显示不可编辑。

源代码：

package sy4;

import java.awt.FlowLayout; import java.awt.Label; import java.awt.TextField;

import java.awt.event.ActionEvent; import java.awt.event.ActionListener;

import javax.swing.JButton; import javax.swing.JFrame; import javax.swing.JOptionPane;

public class Mineframe extends JFrame implements ActionListener {

static TextField T=new TextField(20); static TextField T1=new TextField(20); static TextField T2=new TextField(20);

static TextField T3=new TextField(20); {

super(\"Display the number of integers\"); this.setSize(300,140); this.setLocation(300,240); this.setLayout(new FlowLayout()); this.add(new Label(\"整数\")); this.add(T);

this.add(new Label(\"百位\")); T1.setEditable(false); this.add(T1);

this.add(new Label(\"十位\"));

public Mineframe()

T2.setEditable(false); this.add(T2);

this.add(new Label(\"个位\")); T3.setEditable(false); this.add(T3);

JButton button=new JButton(\"确定\"); this.add(button);

button.addActionListener(this);

this.setResizable(true);

this.setDefaultCloseOperation(EXIT_ON_CLOSE);

this.setVisible(true); T.addActionListener(this); }

public void actionPerformed(ActionEvent e)throws NumberFormatException {

try {

String str=T.getText(); int t1,t2,t3; t1=num/100; t2=(num/10)%10; t3=(num%100)%10;

T1.setText(String.valueOf(t1)); T2.setText(String.valueOf(t2));

T3.setText(String.valueOf(t3));

}

catch(NumberFormatException nfe) { } finally

{String str=T.getText(); int t1,t2,t3; t1=num/100; t2=(num/10)%10; t3=(num%100)%10;

T1.setText(String.valueOf(t1)); T2.setText(String.valueOf(t2));

JOptionPane.showMessageDialog(this, \"不能转换为整数\");

int num=Integer.parseInt(str);

}

T3.setText(String.valueOf(t3));

}

public static void main(String args[]) {

new Mineframe(); } }

实验结果：

2、模拟实现一个可视化的简单计算器，至少提供进行加法、减法、乘法、除法等基本运算的功能，希望能支持加正负号、求平方根、清零等其他功能。源代码：

package sy4;

import java.awt.*; import javax.swing.*; import javax.swing.event.*; import java.awt.event.ActionEvent; import java.awt.event.ActionListener;

public class Counter extends JFrame implements {

private JTextField text; private JButton[] button; private MessageJDialog jdialog; static String ope=\"\"; static String flag=\"\";

//标记操作数 //标记运算符号

//number用来表示当前数字

ActionListener//,WindowListener

private static String number=\"\";

static double save=0,result=0,num=0; //save保留前一值，result

为结果，num用来记录小数点个数

String operation[]={ \"sqrt\", \"+/-\", \"backspace\", \"C\", \"7\", \"8\", \"9\",

\"/\", \"4\", \"5\", \"6\", \"*\", \"1\", \"2\", \"3\", \"-\", \"0\", \".\",\"=\", \"+\" };

public Counter() { }

public void actionPerformed(ActionEvent e) {

if(e.getSource()==button[16]) {

if(ope==\"\") {

if(!text.getText().equals(\"0\")) {

number=text.getText()+\"0\";

// \"0\"

super(\"计算器\");

button=new JButton[operation.length]; this.setBounds(280,100,300,240);

this.setDefaultCloseOperation(EXIT_ON_CLOSE); JPanel panel=new JPanel(new FlowLayout()); this.getContentPane().add(panel);

JPanel panelR=new JPanel(new GridLayout(1,1)); panel.add(panelR);

text=new JTextField(\"0\",6); panelR.add(text);

JPanel panelID[]=new JPanel[5]; }

this.setVisible(true);

jdialog=new MessageJDialog(this);

if(i%4==0) { }

button[i]=new JButton(operation[i]);// 这里是按钮的布局 button[i].addActionListener(this); panelID[i/4].add(button[i]);

panelID[i/4]=new JPanel(new GridLayout(1,4)); panel.add(panelID[i/4]);

//设置按钮

设置text文本框

for (int i=0;i//四个键为一行

text.setText(number);

}

else {

text.setText(\"0\");

}

else { ope=\"\";

text.setText(\"0\");

}

if(flag==\"\")

save=Double.parseDouble(text.getText());

}

if(e.getSource()==button[12])

{ if(ope==\"\") { if(!text.getText().equals(\"0\")) { number=text.getText()+\"1\"; text.setText(number);

} else {

text.setText(\"1\");

}

} else { ope=\"\";

text.setText(\"1\");

}

if(flag==\"\")

save=Double.parseDouble(text.getText());

}

if(e.getSource()==button[13])

{ if(ope==\"\") { if(!text.getText().equals(\"0\")) {

number=text.getText()+\"2\";

// \"1\"

// \"2\

text.setText(number);

}

else {

text.setText(\"2\");

}

else { ope=\"\";

text.setText(\"2\");

}

if(flag==\"\")

save=Double.parseDouble(text.getText());

}

if(e.getSource()==button[14])

{ if(ope==\"\") { if(!text.getText().equals(\"0\")) { number=text.getText()+\"3\"; text.setText(number);

} else {

text.setText(\"3\");

}

} else { ope=\"\";

text.setText(\"3\");

}

if(flag==\"\")

save=Double.parseDouble(text.getText());

}

if(e.getSource()==button[8])

{ if(ope==\"\") { if(!text.getText().equals(\"0\")) {

number=text.getText()+\"4\";

// \"3\" //\"4\"

text.setText(number);

}

else {

text.setText(\"4\");

}

else { ope=\"\";

text.setText(\"4\");

}

if(flag==\"\")

save=Double.parseDouble(text.getText());

}

if(e.getSource()==button[9])

{ if(ope==\"\") { if(!text.getText().equals(\"0\")) { number=text.getText()+\"5\"; text.setText(number);

} else {

text.setText(\"5\");

}

} else { ope=\"\";

text.setText(\"5\");

}

if(flag==\"\")

save=Double.parseDouble(text.getText());

}

if(e.getSource()==button[10])

{ if(ope==\"\") { if(!text.getText().equals(\"0\")) {

number=text.getText()+\"6\";

// \"5\"//\"6\"

text.setText(number);

}

else {

text.setText(\"6\");

}

else { ope=\"\";

text.setText(\"6\");

}

if(flag==\"\")

save=Double.parseDouble(text.getText());

}

if(e.getSource()==button[4])

{ if(ope==\"\") { if(!text.getText().equals(\"0\")) { number=text.getText()+\"7\"; text.setText(number);

} else {

text.setText(\"7\");

}

} else { ope=\"\";

text.setText(\"7\");

}

if(flag==\"\")

save=Double.parseDouble(text.getText());

}

if(e.getSource()==button[5])

{ if(ope==\"\") { if(!text.getText().equals(\"0\")) {

number=text.getText()+\"8\";

// \"7\"// \"8\"

text.setText(number);

}

else {

text.setText(\"8\");

}

else { ope=\"\";

text.setText(\"8\");

}

if(flag==\"\")

save=Double.parseDouble(text.getText());

}

if(e.getSource()==button[6])

{ if(ope==\"\") { if(!text.getText().equals(\"0\")) { number=text.getText()+\"9\"; text.setText(number);

} else {

text.setText(\"9\");

}

} else { ope=\"\";

text.setText(\"9\");

}

if(flag==\"\")

save=Double.parseDouble(text.getText());

}

if(e.getSource()==button[0])

{ double d=Double.parseDouble(text.getText()); d=Math.sqrt(d); text.setText(\"\"+d); if(flag==\"\")

save=d;

// \"9\"

//\"sqrt\"

}

if(e.getSource()==button[1]) { double d=Double.parseDouble(text.getText());

d=0-d;

text.setText(\"\"+d); if(flag==\"\")

save=d;

}

if(e.getSource()==button[2])

{ save=0; ope=\"\"; flag=\"\";

text.setText(\"\");

}

if(e.getSource()==button[3])

{ num=0;

text.setText(\"\");

}

if(e.getSource()==button[19])

{ flag=\"+\"; ope=\"+\";

text.setText(\"+\"); num=0;

}

if(e.getSource()==button[15])

{ flag=\"-\"; ope=\"-\";

text.setText(\"-\"); num = 0;

}

if(e.getSource()==button[11])

{ flag=\"*\"; ope=\"*\";

text.setText(\"*\"); num=0;

}

if(e.getSource()==button[7])

{

//\"C\"

//\"+\"

// \"-\"// \"*\"// \"/\"

}

flag=\"/\"; ope=\"/\";

text.setText(\"/\"); num=0;

// \".\"

if(e.getSource()==button[17]) { }

if(e.getSource()==button[18]) { }

if(flag.equals(\"+\")) { }

if(flag.equals(\"-\")) { }

if(flag.equals(\"*\")) { }

if(flag.equals(\"/\")) { }

save=result; num=0; flag=\"\"; ope=\"=\";

//进行连续运算

String str=text.getText()+\".\"; text.setText(str);

//\"=\"

result=save+Double.parseDouble(text.getText()); text.setText(\"\"+result);

result=save-Double.parseDouble(text.getText()); text.setText(\"\"+result);

result=save*Double.parseDouble(text.getText()); text.setText(\"\"+result);

result=save/Double.parseDouble(text.getText()); text.setText(\"\"+result);

private class MessageJDialog extends JDialog {

JFrame jframe; JLabel jlabel;

}

} }

MessageJDialog(JFrame jframe) { }

void show(String message) { }

jlabel.setText(message);

this.setLocation(jframe.getX()+30,jframe.getY()+70); this.setVisible(true); super(jframe,\"提示\",true); this.jframe=jframe; this.setSize(240,100);

jlabel=new JLabel(\"\",JLabel.CENTER); this.getContentPane().add(jlabel);

this.setDefaultCloseOperation(HIDE_ON_CLOSE);

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

new Counter();

实验结果：

3、设计图形界面实现学生的信息录入，至少包括姓名、年龄、出生年月日、Java课程实验成绩，成绩使用浮点数，年龄使用整型，使用数据存储输入对象，程序输出按年龄排序的学生信息。源代码：

package sy4;

import java.awt.event.ActionEvent; import java.awt.event.ActionListener;

import javax.swing.JButton; import javax.swing.JFrame; import javax.swing.JLabel; import javax.swing.JPanel; import javax.swing.JScrollPane; import javax.swing.JTable; import javax.swing.JTextField;

public class Sframe extends JFrame implements ActionListener {

private JTextField T1,T2,T3,T4; private JButton button,button2; private JTable table; int num=10;

String a[]=new String[num] ; String b[]=new String[num] ; String c[]=new String[num] ; String d[]=new String[num] ;

int k=0; public Sframe() {

super(\"学生信息管理\");

this.setBounds(300,240,740,400);

this.setDefaultCloseOperation(EXIT_ON_CLOSE);

JPanel panel=new JPanel();

this.getContentPane().add(panel,\"North\"); panel.add(new JLabel(\"姓名\")); T1=new JTextField(6); panel.add(T1);

panel.add(new JLabel(\"年龄\")); T2=new JTextField(6); panel.add(T2);

panel.add(new JLabel(\"出生日期\")); T3=new JTextField(6); panel.add(T3);

panel.add(new JLabel(\"分数\")); T4=new JTextField(6); panel.add(T4);

button=new JButton (\"确定\");

panel.add(button);

button.addActionListener(this);

button2=new JButton(\"排序\"); panel.add(button2);

button2.addActionListener(this);

actionPerformed(null);

this.getContentPane().add(new JScrollPane(table)); this.setVisible(true);

}

public void actionPerformed(ActionEvent e) {

String titles[]= {\"姓名\",\"年龄\",\"出生日期\",\"成绩\"}; Object datas[][]=new Object[num][4]; a[k]=T1.getText(); b[k]=T2.getText(); c[k]=T3.getText(); d[k]=T4.getText(); if(k<9) k++; for(int i=0;idatas[i][0]=a[i]; datas[i][1]=b[i]; datas[i][2]=c[i]; datas[i][3]=d[i]; }

table=new JTable(datas,titles);

this.getContentPane().add(new JScrollPane(table)); this.setVisible(true);

} }

{

new Sframe();

public static void main(String args[])

}

实验结果：

实验五多线程程序设计

实验目的：理解多线程的概念，掌握创建、管理和控制Java线程对象的方法，包括创建Java线程对象、改变线程状态、设置线程优先级及控制线程调度等方法，掌握实现线程互斥和线程同步的方法。实验内容：

1、编写一个有两个线程的程序，第一个线程用来计算2~1000之间的偶数及

个数，第二个线程用来计算1000~2000之间的偶数及个数。源代码：

public class Even_Count extends Thread{ 的操作

System.out.print(this.getName()+\": \"); if(first == 2){

for(int i=first;i<=1000;i+=2){ System.out.print(i+\" \"); count++; }

private int first; private int count;

public Even_Count(String name,int first){//起始数字 }

public Even_Count(String name){ }

public void run(){//run方法中根据起始数字的不同执行不同

this(name,0); super(name); this.first = first; count = 0;

System.out.println(this.getName()+\"结束,2~1000之间的偶

数个数为：\"+count);

}

if(first == 1000){

for(int i=first;i<=2000;i+=2){ }

System.out.print(i+\" \"); count++;

System.out.println(this.getName()+\"结束,1000~2000之间

的偶数个数为：\"+count);

());

Even_Count even1 = new Even_Count(\"2~1000之间的偶

}

public static void main(String[] args) {

}

System.out.println(\"currentThread=\"+Thread.currentThread().getName

数\初始化线程对象

Even_Count even2 = new Even_Count(\"1000~2000之间的

偶数\

even1.start(); //线程开始 even2.start();

System.out.println(\"activeCount=\"+Even_Count.activeCount());

}

结果：

}

2、编写一个Java应用程序，在主线程中再创建两个线程，要求线程经历四种状态：新建，运行、中断和死亡。按模板要求，将【代码1】~【代码8】替换为Java程序代码。源代码： package sy5;

class Rabit extends Thread {

int sleepTime=0, liveLength=0;

public Rabit(String name,int sleepTime, int liveLength) {

super(name);

this.sleepTime=sleepTime; this.liveLength=liveLength; }

public void run() {

while (true ) {

liveLength--;

System.out.println(\"*_*\");

try{

sleep( sleepTime); }

catch (InterruptedException e) {} if (liveLength<=0 )

{

System.out.println(getName()+\"进入死亡状态\\n\");

break;

} } } }

class Tortoise extends Thread { int sleepTime=0, liveLength=0;

public Tortoise(String name,int sleepTime, int liveLength) {

super(name);

this.sleepTime=sleepTime;

this.liveLength=liveLength; }

public void run() { while (true) {

liveLength--;

System.out.println(\"@_@\"); try{

sleep(sleepTime); // 让线程调用sleep()方法进入中断状态 }

catch (InterruptedException e) {} if (liveLength<=0 ) {

System.out.println(getName()+\"进入死亡状态\\n\"); break; } }

} }

public class ThreadExample {

public static void main(String a[]) {

Rabit rabit;

rabit =new Rabit(\"Rabit\ // 新建线程rabit

Tortoise tortoise =new Tortoise(\"Tortoise\新建线程tortoise tortoise.start(); rabit.start(); } } 结果：

3、编写一个Java应用程序，在主线程中创建三个线程：zhangWorker，wangWorker 和 boss。线程zhangWorker和wangWorker分别负责在命令行输出“搬运苹果”和“搬运香蕉”，这两个线程分别各自输出20行，每输出一行信息就准备休息10秒钟，但是boss线程负责不让zhangWorker和wangWorker休息。按模板要求，将【代码1】~【代码8】替换为Java程序代码。

源代码： package sy5;

class Shop implements Runnable {

Thread zhangWorker, wangWorker, boss; public Shop()

{ boss = new Thread(this); // 创建boss，Shop对象为boss目标对象

zhangWorker = new Thread(this); // 创建zhangWorker，Shop对象为boss目标对象

wangWorker = new Thread(this); // 创建wangWorker，Shop对象为boss目标对象

boss.setName(\"老板\"); zhangWorker.setName(\"张工\"); wangWorker.setName(\"王工\"); }

public void run() {

//System.out.println(\"1\"); int i=0;

if (Thread.currentThread()==zhangWorker) { while (true ) {

try { i++;

System.out.printf(\"\\n%s 已搬运了%d 箱苹果\\n\

if (i==20) return ;

zhangWorker.sleep(10000); // zhangWorker休眠10秒（10000毫秒）

}

catch(InterruptedException e) {

System.out.printf(\"\\n%s 让 %s 继续工作\

} } }

else if (Thread.currentThread()==wangWorker) {

while (true ) {

try { i++;

System.out.printf(\"\\n%s 已搬运了%d 箱香蕉\\n\

if (i==20) return ;

wangWorker.sleep(10000); }

catch(InterruptedException e) {

System.out.printf(\"\\n%s 让 %s 继续工作\

} } }

else if (Thread.currentThread()==boss) {

while (true )

{

zhangWorker.interrupt(); // 吵醒zhangWorker wangWorker.interrupt(); // 吵醒wangWorker if (!(wangWorker.isAlive()|| zhangWorker.isAlive())) {

System.out.printf(\"%n%s 下班\

return; } } } } }

public class ShopExample {

public static void main(String a[]) { Shop shop=new Shop(); shop.wangWorker.start(); shop.zhangWorker.start(); shop.boss.start(); } } 结果：

4、编写一个Java应用程序，模拟5个人排队买票。售票员只有1张五元的钱，电影票五元钱一张。假设5个人的名字及排队顺序是：赵、钱、孙、李、周。“赵”拿1张二十元的人民币买2张票，“钱”拿1张二十元的人民币买1张票，“孙”1张十元的人民币买1张票，“李”拿1张十元的人民币买2张票，“周”拿1张五元的人民币买1张票。要求售票员按如下规则找赎：（1）二十元买1张票，找零：1张十元；不许找零2张五元。（2）二十元买1张票，找零：1张十元，1张五元；不许找零3张五元。（3）十元买一张票，找零1张五元。

源代码： package sy5;

public class Buyer extends Thread{ Seller buy; int id; int twenty,ten,five; int ticket; public Buyer(String name,Seller buy,int id,int twenty,int ten,int five,int ticket){

super(name); //买家类，初始化进程名 this.id = id; //ID号即排队顺序 this.twenty = twenty; //零钱数量 this.ten = ten; this.five = five;

this.ticket = ticket;//买票的张数 this.buy = buy; //共享一个售货员对象 }

public void run(){ buy.sell(ticket,twenty,ten,five,id); System.out.println(getName()+\"买完票了\"); }

public static void main(String[] args) { Seller buy = new Seller(1,0); Buyer zhao = new Buyer(\"赵\ Buyer qian = new Buyer(\"钱\ Buyer sun = new Buyer(\"孙\ Buyer li = new Buyer(\"李\ Buyer zhou = new Buyer(\"周\ zhao.start(); qian.start(); sun.start(); li.start(); zhou.start(); }

}

package sy5;

public class Buyticket { public static void main(String[] args) { Seller buy = new Seller(1,0); Zhao zhao = new Zhao(buy); Qian qian = new Qian(buy); Sun sun = new Sun(buy); Li li = new Li(buy); Zhou zhou = new Zhou(buy); zhao.start(); qian.start(); sun.start(); li.start(); zhou.start(); } }

package sy5;

public class Li extends Thread{ Seller buy; int id = 4; int twenty,ten,five; int ticket; public Li(Seller buy){ twenty=0; ten=1; five=0; ticket = 2; this.buy = buy; } public void run(){ buy.sell(ticket,twenty,ten,five,id); System.out.println(\"李买完票了\"); } }

package sy5;

public class Qian extends Thread{ Seller buy;

int id = 2;

int twenty,ten,five; int ticket;

public Qian(Seller buy){ twenty=1; ten=0; five=0; ticket = 1; this.buy = buy; }

public void run(){ buy.sell(ticket,twenty,ten,five,id);

System.out.println(\"钱买完票了\"); } }

package sy5;

public class Seller { int five,ten; //五元十元的数量 int balance; int id = 0; int customer[];

public Seller(int five,int ten){ //初始化售票员的零钱数量 this.five = five; this.ten = ten; balance = 5*five+10*ten; customer = new int[5]; customer[0] = 1; customer[1] = 2; customer[2] = 3; customer[3] = 4; customer[4] = 5; }

public int getFive(){ return five; }

public int getTen(){ return ten; }

public int balance(){ return balance; }

public synchronized void sell(int ticket,int twenty,int ten,int five,int id){ //System.out.println(this.id);

while(twenty==1&&ticket==2){ //判断是谁 while(customer[this.id]!=id) //用ID来判断是不是轮到了自己 try{ //System.out.println(this.id);

this.wait(); //若不是则等待 }

catch(InterruptedException e){}

if(this.ten>=1){ //轮到自己后，若有零钱则买票 this.ten--;

System.out.println(\"已售票给赵并找零10元一张\"); this.balance = this.five*5+this.ten*10+20;

int newcustomer[] = new int[customer.length-1]; for(int i=0;ithis.customer = newcustomer; this.id=0;

notifyAll(); //买完后唤醒其他买家进程 return; } else

try{ //没零钱找零则唤醒其他进程，并休眠 //System.out.println(this.id); this.id++; notifyAll(); this.wait(); } catch(InterruptedException e){} }

while(twenty==1&&ticket==1){ while(customer[this.id]!=id) try{ this.wait(); } catch(InterruptedException e){} if(this.ten>=1&&this.five>=1){ this.ten--; this.five--; System.out.println(\"已售票给钱并找零10元一张，5元一张\"); this.balance = this.five*5+this.ten*10+20; int newcustomer[] = new int[customer.length-1];

for(int i=0;iwhile(ten==1&&ticket==1){ while(customer[this.id]!=id) try{ this.wait(); } catch(InterruptedException e){} if(this.five>=1){ this.five--; this.ten++; System.out.println(\"已售票给孙并找零5元一张\"); this.balance = this.five*5+this.ten*10+10; int newcustomer[] = new int[customer.length-1]; for(int i=0;i.

this.id++; notifyAll(); this.wait(); } catch(InterruptedException e){} }

while(ten==1&&ticket==2){ while(customer[this.id]!=id) try{ this.wait(); } catch(InterruptedException e){} if(true){ this.ten++;

System.out.println(\"已售票给李\"); this.balance = this.five*5+this.ten*10+10; int newcustomer[] = new int[customer.length-1]; for(int i=0;iwhile(five==1&&ticket==1){ while(customer[this.id]!=id) try{ this.wait(); } catch(InterruptedException e){} if(true){ this.five++; System.out.println(\"已售票给周\"); this.balance = this.five*5+this.ten*10+5; int newcustomer[] = new int[customer.length-1]; for(int i=0;i.

newcustomer[i]=customer[i+1]; } this.customer = newcustomer; this.id=0; notifyAll(); return; } } } }

package sy5;

public class Sun extends Thread{ Seller buy; int id = 3; int twenty,ten,five; int ticket; public Sun(Seller buy){ twenty=0; ten=1; five=0; ticket = 1; this.buy = buy; } public void run(){ buy.sell(ticket,twenty,ten,five,id); System.out.println(\"孙买完票了\"); } }

package sy5;

public class Zhao extends Thread{ Seller buy; int id = 1; int twenty,ten,five; int ticket; public Zhao(Seller buy){ twenty=1; ten=0; five=0; ticket = 2; this.buy = buy; } public void run(){

buy.sell(ticket,twenty,ten,five,id);

System.out.println(\"赵买完票了\"); } }

package sy5;

public class Zhou extends Thread{ Seller buy; int id = 5; int twenty,ten,five; int ticket; public Zhou(Seller buy){ twenty=0; ten=0; five=1; ticket = 1; this.buy = buy; } public void run(){ buy.sell(ticket,twenty,ten,five,id); System.out.println(\"周买完票了\"); } }

结果：

实验六输入输出流

实验目的：理解文件和流的概念、Java流的层次结构，掌握Java提供的各种字节流类和字符流类的功能和使用方法。实验内容：

1、

import java.io.*;

public class FileStreamsTest {

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

try {

FileInputStream fis=new FileInputStream(\"e:\\\\input.txt\"); FileOutputStream fos=new FileOutputStream(\"e:\\\\output.txt\"); int c;

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

fos.write(c); }

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

读入一个文件的内容拷贝到另一个文件中去，源代码如下：

package sy6;

}

catch(FileNotFoundException e) {

System.out.println(\"FileStreamsTest:\"+e); }

catch(IOException e) {

System.out.println(\"FileStreamsTest:\"+e); }

}

实验结果:

2、从标准设备中输入多名学生信息（包括学号、姓名、出生日期、所属院

系等），直到输入\"END\"结束，将这些学生信息写入文件。源代码： package sy6;

import java.io.*; import java.util.Scanner;

public class StudentStream {

private String filename;

public StudentStream(String filename) { }

public void write()throws IOException {

FileWriter out1=new FileWriter(this.filename); String name,num,birth,dep; do {

Scanner sca=new Scanner(System.in); name=sca.nextLine(); num=sca.nextLine(); this.filename=filename;

birth=sca.nextLine(); dep=sca.nextLine(); if(!name.equals(\"END\"))

{out1.write(\"姓名：\"+name+\"学号：\"+num+\"出生日期：\"+birth+\"

所属院系：\"+dep+\"\\");} }

实验结果：

}

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

StudentStream S1=new StudentStream(\"E:\\\\Student.txt\"); System.out.println(\"Student:\"); try

{S1.write();} catch(Exception e) { }

System.out.println(\"ERROR\"); }while(!name.equals(\"END\")); out1.close();

3、编程完成下列功能：建立两个文件myfiel.txt和myfile2.txt,对文件

myfile1.txt输入内容：“I am a student.”，并将其内容拷贝给myfile2.txt。源代码： package sy6;

import java.io.*; import java.util.Scanner;

public class Myfile {

private String filename; public Myfile(String filename) {

this.filename=filename; }

public String Getname() {

return this.filename; }

public void wite()throws IOException {

FileWriter w1=new FileWriter(this.filename);

BufferedWriter w2=new BufferedWriter(w1); Scanner sca=new Scanner(System.in); String str=sca.nextLine(); w2.write(str); w2.close(); w1.close();

}

public void copy(String filename2)throws IOException {

FileReader r1=new FileReader(this.filename); BufferedReader r2=new BufferedReader(r1); FileWriter w3=new FileWriter(filename2); BufferedWriter w4=new BufferedWriter(w3); String str; do {

str=r2.readLine(); if(str!=null) { }

w4.write(str);

}while(str!=null); r2.close(); r1.close(); w4.close(); w3.close();

}

public static void main(String a[]) {

Myfile m1=new Myfile(\"E:\\\\myfile1.txt\"); Myfile m2=new Myfile(\"E:\\\\myfile2.txt\"); try {

m1.wite();

m1.copy(m2.Getname());

}

catch (IOException e) {

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

} 实验结果：

4、从键盘输入一个整型数，一个双精度型和一个字符串，用

DataOutputStream将这些数据输出到文件中，然后用DataInputStream从文件中读出这些数据并打印到标准输出设备。源代码：

package sy6;

import java.io.*;

import java.util.Scanner;

public class Data { { }

public void fout()throws IOException {

static int num;

private String filename;

public Data(String filename)

this.filename=filename;

FileOutputStream f1=new FileOutputStream(this.filename); DataOutputStream d1=new DataOutputStream(f1); Scanner sca=new Scanner(System.in); int n1=sca.nextInt(); double n2=sca.nextDouble();

Scanner sca2=new Scanner(System.in); String n3=sca2.nextLine(); d1.writeInt(n1); d1.writeDouble(n2);

}

d1.writeChars(n3); num=n3.length()+1; d1.close(); f1.close();

public void sout()throws IOException { }

public static void main(String a[]) {

Data D=new Data(\"e:\\\\Data.txt\"); try {

D.fout();

FileInputStream f2=new FileInputStream(this.filename); DataInputStream d2=new DataInputStream(f2); while(true) { }

try { }

catch(EOFException e) { }

catch(IOException e) { }

d2.close(); f2.close();

System.out.println(e.toString()); break;

int n1=d2.readInt();

System.out.println(n1+\" \"); double n2=d2.readDouble(); System.out.println(n2+\" \"); for(int i=0;ichar n3=d2.readChar(); System.out.print(n3); }

} }

D.sout(); }

catch(Exception e) { }

实验结果：

5、编写一个Java应用程序，将已存在的扩展名为.txt的文本文件加密后存入另一个文本文件中。按模板要求，将【代码1】~【代码7】替换为Java程序代码。

package sy6;

import java.io.*;

public class SecretExample {

public static void main(String a[]) {

File fileone=new File(\"e:\\\\hello.txt\"); File filetwo=new File(\"E:\\\\hello.secret\"); char b[]=new char[100]; try{

FileReader in = new FileReader(fileone);//创建指向fileone的字符输入流

FileWriter out =new FileWriter(filetwo);//创建指向fileontwo的字符输出流

int n=-1;

{

}

System. FileReader 字符输入流 System. {

String System. }

System. {

{ String System. }

}

{

System..

while ( (n=in.read(b)) != -1 ) for (int i=0; iin2 = new FileReader(filetwo);//创建指向fileontwo的out.println(\"加密后的文件内容：\"); n=in2.read(b); while (n!=-1) str=new String(b,0,n); out.println(\"dfjakfjd\"+str); n=in2.read(b); in=new FileReader(filetwo); out.println(\"解密后的文件内容：\"); while ( (n=in.read(b))!=-1) for (int i=0; i.

} }

}

实验结果：

实验七使用TCP协议的Socket网络程序设计

一实验目的：理解Socket通信原理，掌握使用Socket和ServerSocket类进行TCP Socket通信的程序设计方法。二实验内容：

1、使用ServerSocket类和Socket类实现按如下协议通信的服务器端和客户端程序。服务器程序的处理规则如下： 1）向客户端程序发送Verifying Server!。

2）若读口令次数超过3次，则发送Illegal User!给客户端，程序退出。否则向下执行步骤3）。

3）读取客户端程序提供的口令。

4）若口令不正确，则发送PassWord Wrong!给客户端，并转步骤2），否则向下执行步骤5）。

5）发送Registration Successful!给客户端程序。客户端程序的处理规则如下： 1）读取服务器反馈信息。

2）若反馈信息不是Verifying Server!，则提示Server Wrong!，程序退出。否则向下执行步骤3）

3）提示输入PassWord并将输入的口令发送给服务器。 4）读取服务器反馈信息。

5）若反馈信息是Illegal User!，则提示Illegal User!，程序退出。否则向下执行步骤6）

6）若反馈信息是PassWord Wrong!，则提示PassWord Wrong!，并转步骤3），否则向下执行步骤。

7）输出Registration Successful!。实验代码：客户端： package sy7;

import java.io.BufferedReader; import java.io.IOException;

import java.io.InputStreamReader; import java.io.PrintStream; import java.net.Socket; import java.util.Scanner; public class client {

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

Socket s2=new Socket(\"127.0.0.1\ BufferedReader

in=new

BufferedReader(new

InputStreamReader(s2.getInputStream()));

PrintStream out=new PrintStream(s2.getOutputStream());

String str=in.readLine();

System.out.println(str);

int i=0; while(i<5) {

str=in.readLine();

System.out.println(str);

Scanner sca=new Scanner(System.in); String str3=sca.nextLine(); out.println(str3);

i++;

} in.close(); out.close(); s2.close();

} }

服务端： package sy7;

import java.io.*;

import java.net.ServerSocket; import java.net.Socket; public class Server {

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

ServerSocket s1=new ServerSocket(1227); Socket s2=s1.accept(); BufferedReader

in=new

BufferedReader(new

InputStreamReader(s2.getInputStream()));

PrintStream out=new PrintStream(s2.getOutputStream()); String str;

int i=0;//输入密码次数 out.println(\"Verifying Server!\"); out.println(\"please input password\");

while(i<4) {

str=in.readLine(); if(str.equals(\"1227\")) {

out.println(\"Registration Successful!\");

}

else if(!str.equals(\"1227\")) {

i++; if(i<=3)

{ } else { }

out.println(\"Illegal User!\"); in.close(); out.close(); s1.close(); return;

out.println(\"PassWord Wrong!\");

} }

in.close(); out.close(); s1.close();

}

实验结果：

}

2、使用套接字编写客户端-服务器程序，实现客户端-服务器交互计算。客户讲三角形3个边的长度发给服务器，服务器把计算出的三角形的面积返回给客

户。首先将服务器端的程序编译通过，并运行起来，等待客户的呼叫。运行效果如图7.1和图7.2所示。

实验代码：客户端： package sy7;

import java.awt.GridLayout;

import java.awt.HeadlessException; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import java.io.BufferedReader; import java.io.IOException;

import java.io.InputStreamReader; import java.io.PrintWriter; import java.net.InetAddress; import java.net.Socket;

import java.net.UnknownHostException;

import javax.swing.JButton; import javax.swing.JFrame; import javax.swing.JLabel; import javax.swing.JPanel; import javax.swing.JTextArea; import javax.swing.JTextField;

public class Sclient extends JFrame implements ActionListener { private Socket socket; private JTextArea tangle_area; private JTextField tangle_length1; private JTextField tangle_length2; private JTextField tangle_length3; private JPanel panel1,panel2,panel3,panel4; private JButton button_send,button_receive; private PrintWriter out; private String str; public Sclient(Socket socket)throws IOException { super(\"客户端\"+\" \"+InetAddress.getLocalHost()); this.setBounds(320,520,320,520); this.setDefaultCloseOperation(EXIT_ON_CLOSE); this.getContentPane().setLayout(new GridLayout(2,2)); panel1=new JPanel(new GridLayout(1,1));//第一个面板 button_send=new JButton(\"连接服务器\"); button_send.addActionListener(this);

panel1.add(button_send);

this.getContentPane().add(panel1); ////

panel2=new JPanel(new GridLayout(3,2));//第二个面板 JLabel lable1=new JLabel(\"输入边\"); tangle_length1=new JTextField(30); tangle_length1.addActionListener(this); panel2.add(lable1);

panel2.add(tangle_length1);

JLabel lable2=new JLabel(\"输入边\"); tangle_length2=new JTextField(30); tangle_length2.addActionListener(this); panel2.add(lable2);

panel2.add(tangle_length2);

JLabel lable3=new JLabel(\"输入边\"); tangle_length3=new JTextField(30); tangle_length3.addActionListener(this); panel2.add(lable3);

panel2.add(tangle_length3);

this.getContentPane().add(panel2); ///

panel3=new JPanel(new GridLayout(1,1)); //第三个面板 button_receive=new JButton(\"求三角形面积\"); button_receive.addActionListener(this); panel3.add(button_receive);

this.getContentPane().add(panel3);

panel4=new JPanel(new GridLayout(1,1)); //第四个面板 tangle_area=new JTextArea(); panel4.add(tangle_area); this.getContentPane().add(panel4);/// this.setVisible(true); this.socket=socket; this.out=new PrintWriter(socket.getOutputStream(),true); this.out.println(InetAddress.getLocalHost()); //发送的第一个字符，即ip地址 BufferedReader in=new BufferedReader(new InputStreamReader(socket.getInputStream())); str=in.readLine(); while(str==null)

{ out.close(); in.close(); socket.close(); } }

public Sclient(String host,int port)throws IOException { this(new Socket(host,port)); }

public void actionPerformed(ActionEvent e) {

if(e.getSource()==button_send) //发送按钮 { }

str=\"正在监听\"; this.out.println(str);

this.out.println(tangle_length1.getText()); this.out.println(tangle_length2.getText()); this.out.println(tangle_length3.getText());

if(e.getSource()==button_receive)//接收按钮 {

tangle_area.append(\"三角形的面积是：\"+\"\\n\"+str); button_send.setEnabled(false); button_receive.setEnabled(false); } } public static void main(String a[])throws IOException { new Sclient(\"127.0.0.1\ } }

服务端： package sy7;

import java.io.BufferedReader; import java.io.IOException;

import java.io.InputStreamReader; import java.io.PrintStream; import java.net.ServerSocket; import java.net.Socket;

public class Sserver { public static void main(String a[])throws IOException { ServerSocket s1=new ServerSocket(1227); Socket s2=s1.accept(); BufferedReader in=new BufferedReader(new InputStreamReader(s2.getInputStream())); PrintStream out=new PrintStream(s2.getOutputStream()); String str; str=in.readLine(); System.out.println(\"用户地址\"+str); //输出的第一个字符ip Double l1,l2,l3,l4,s; str=in.readLine(); System.out.println(str); str=in.readLine(); l1=Double.parseDouble(str); str=in.readLine(); l2=Double.parseDouble(str); str=in.readLine(); l3=Double.parseDouble(str); l4=(l1+l2+l3)/2; s=Math.sqrt(l4*(l4-l1)*(l4-l2)*(l4-l3)); str=String.valueOf(s); out.println(str); System.out.println(\"用户离开\"); in.close(); out.close(); s1.close(); } }

实验结果：

实验八数据库应用

实验目的：了解数据库系统、关系模型、客户-服务器模式等基本概念，掌握SQL的数据定义、数据操纵和数据查询等语句的语法；了解JDBC各种数据库驱动程序类型，熟悉JDBC提供的接口和类，掌握指定驱动类型、连接数据库、执行SQL语句、处理结果集等操作方法。实验内容：

1、配置ODBC数据源

1) 从开始菜单中，选择设置|控制面板。

2) 在控制面板中选择管理工具->数据源（ODBC）。

3) 双击“数据源ODBC”后，弹出卡片式对话框“ODBC数据源管理器”，上面一排有多个卡片标签，其中包括\"用户DSN\"、\"系统DSN\"、\"文件DSN\"等等。选择\"系统DSN\"。

4) 单击\"系统DSN\"中的\"添加…\"按钮，弹出一个对话框。

5) 在对话框中，列出了当前系统支持的ODBC数据源的驱动程序，选择\"Microsoft Access Driver\"，单击\"完成\"按钮，弹出一个对话框。

6) 在对话框中，向\"数据源\"文本框内输入数据源的名字，这个名字可以任取，在这个例子中，我们输入的名字是\"jvdb\"。然后，单击\"创建\"按钮。 7) 在对话框中，选择数据库存放的目录，然后向\"数据库名\"文本框内输入数据库的名字，这个名字可以任取，在这个例子中，我们输入的名字是\"jvdb\"。然后，单击\"确定\"按钮，会弹出显示\"数据库创建成功\"的对话框。 8) 依次单击\"确定\"按钮。

2、按照下表的结构建立\"student\"表并编写程序字段名 Name Sex Age

import java.sql.*; public class student {

Java数据类型 String String Int 宽度 10 2 3 SQL数据类型 Char(10) Char(2) Integer public static void main(String args[]) throws Exception {

Class.forName(\"com.mysql.jdbc.Driver\"); //指定MYSQL jdbc驱动程序

String

url=\"jdbc:mysql://localhost/studentinfo?user=153299&password=153299\"; Connection conn = DriverManager.getConnection(url); String sql;

Statement stmt = conn.createStatement();

sql = \"Create table Student ( Name char(10) NOT NULL,Sex char(2) DEFAULT NULL,Age Integer DEFAULT NULL)\";

stmt.execute(sql); conn.close(); }

}

3、编写程序，完成填写功能向\"student\"表中填入若干数据记录。

package student;

import java.sql.Connection; import java.sql.DriverManager; import java.sql.SQLException; import java.sql.Statement;

public class Insert {

public static void main(String[] args) {

//声明Connection对象 Connection con;

//创建字符串对象，用驱动程序名实例化此对象 String driver = \"com.mysql.jdbc.Driver\"; //创建字符串对象，用指向要访问的数据库url实例化 String url =

\"jdbc:mysql://localhost:3306/studentinfo?userUnicode=true&characterEncoding=UTF-8\";

//用MySQL配置时的用户名实例化字符串对象 String user = \"153299\";

//MySQL配置时的密码实例化字符串对象 String password = \"153299\";

//遍历查询结果集 try {

//加载mysql驱动程序 Class.forName(driver);

//getConnection()方法，连接MySQL数据库！！

con = DriverManager.getConnection(url,user,password); if(!con.isClosed())

System.out.println(\"已连接到MySql数据库。\"); //创建Statement类的对象，用来执行SQL语句！！ Statement statement = con.createStatement();

String sql1=\"insert into student(Name,Sex,Age) value('xiaoxu','男',20);\";

String sql2=\"insert into student(Name,Sex,Age) values('xiaozhao','男',17);\";

String sql3=\"insert into student(Name,Sex,Age) values('xiaoyang','男',12);\";

String sql4=\"insert into student(Name,Sex,Age) values('xiaozhang','女',25);\"; statement.execute(sql1); statement.execute(sql2); statement.execute(sql3); statement.execute(sql4); con.close(); }

catch(ClassNotFoundException e) { //数据库驱动类异常处理

System.out.println(\"没有驱动\"); e.printStackTrace(); } catch(SQLException e) { //数据库连接失败异常处理 e.printStackTrace(); }catch (Exception e) { // TODO: handle exception e.printStackTrace(); }finally{

System.out.println(\"数据库操作结束\"); } }

}

4、编写程序，完成查询功能。

在\"student\"表中分别查询所有记录以及满足条件\"age>18\"的记录。 1. 查询所有记录：

package student;

import java.sql.Connection; import java.sql.DriverManager; import java.sql.ResultSet; import java.sql.SQLException; import java.sql.Statement;

public class Selectall {

public static void main(String[] args) {

//声明Connection对象 Connection con;

//创建字符串对象，用驱动程序名实例化此对象 String driver = \"com.mysql.jdbc.Driver\"; //创建字符串对象，用指向要访问的数据库url实例化 String url =

\"jdbc:mysql://localhost:3306/studentinfo?userUnicode=true&characterEncoding=UTF-8\";

//用MySQL配置时的用户名实例化字符串对象 String user = \"153299\";

//MySQL配置时的密码实例化字符串对象 String password = \"153299\"; //遍历查询结果集 try {

//加载mysql驱动程序 Class.forName(driver);

//getConnection()方法，连接MySQL数据库！！

con = DriverManager.getConnection(url,user,password); if(!con.isClosed())

System.out.println(\"已连接到MySql数据库。\"); //创建Statement类的对象，用来执行SQL语句！！

Statement statement = con.createStatement(); //要执行的SQL语句实例化字符串对象 String sql = \"select * from student\";

//创建ResultSet类的对象，用来存放获取的结果集！！ ResultSet rs = statement.executeQuery(sql); System.out.println(\"-----------------\");

System.out.println(\"查询到的数据集如下:\"); System.out.println(\"-----------------\");

System.out.println(\"姓名\" + \"\\" + \"年龄\"+\"\\"+\"性别\"); System.out.println(\"-----------------\");

String name = null; String age = null; String sex =null;

//没有到数据库最后一条记录继续 while(rs.next()){ //获取uage字段数据 age= rs.getString(\"age\"); //获取uname字段数据

name = rs.getString(\"name\"); //获取usex字段数据

sex=rs.getString(\"sex\"); //输出结果 System.out.println(name + \"\\" + age+\"\\"+sex); } //

rs.close(); con.close();

} catch(ClassNotFoundException e) { //数据库驱动类异常处理

System.out.println(\"数据库操作结束\"); } } }

2. 查询age>18的记录：

package student;

import java.sql.Connection; import java.sql.DriverManager; import java.sql.ResultSet; import java.sql.SQLException; import java.sql.Statement;

public class Select {

public static void main(String[] args) {

//声明Connection对象 Connection con;

//创建字符串对象，用驱动程序名实例化此对象 String driver = \"com.mysql.jdbc.Driver\"; //创建字符串对象，用指向要访问的数据库url实例化 String url =

\"jdbc:mysql://localhost:3306/studentinfo?userUnicode=true&characterEncoding=UTF-8\";

//用MySQL配置时的用户名实例化字符串对象 String user = \"153299\";

//MySQL配置时的密码实例化字符串对象 String password = \"153299\"; //遍历查询结果集 try {

//加载mysql驱动程序 Class.forName(driver);

//getConnection()方法，连接MySQL数据库！！

con = DriverManager.getConnection(url,user,password); if(!con.isClosed())

System.out.println(\"已连接到MySql数据库。\"); //创建Statement类的对象，用来执行SQL语句！！ Statement statement = con.createStatement();

String sql=\"select * from student where Age>18;\"; ResultSet rs = statement.executeQuery(sql); System.out.println(\"-----------------\"); System.out.println(\"查询到的数据集如下:\"); System.out.println(\"-----------------\");

System.out.println(\"姓名\" + \"\\" + \"年龄\"+\"\\"+\"性别\"); System.out.println(\"-----------------\"); String name = null; String age = null; String sex =null;

//没有到数据库最后一条记录继续 while(rs.next()){ //获取uage字段数据 age= rs.getString(\"age\"); //获取uname字段数据

name = rs.getString(\"name\"); //获取usex字段数据

sex=rs.getString(\"sex\"); //输出结果 System.out.println(name + \"\\" + age+\"\\"+sex); }

rs.close(); con.close(); }

catch(ClassNotFoundException e) { //数据库驱动类异常处理

System.out.println(\"数据库操作结束\"); } } }

5、用户注册与登录。创建用户表，包括用户名和密码，设计用户注册与登录窗口，对输入的用户名进行注册或登录操作，用户名不能重复。实验代码：

import java.sql.*; import java.awt.*; import java.awt.event.*; import javax.swing.*;

class SJframe extends JFrame implements ActionListener{

/** * */

private static final long serialVersionUID = 1L; JLabel label1 = new JLabel(\"Name\"); JLabel label2 = new JLabel(\"Password\"); JLabel label3 = new JLabel(\"WELCOME\");

JLabel label4 = new JLabel(\"Note: UserName should be unique!\"); JLabel label5 = new JLabel(\" UserName or Password is wrong!\"); JTextField txt1 = new JTextField(); JTextField txt2 = new JTextField(); JButton btn1 = new JButton(\"Registe\"); JButton btn2 = new JButton(\"Sign In\"); JPanel panel1 = new JPanel(); JPanel panel2 = new JPanel(); JDialog dialog = new JDialog(); Query q = new Query(); public SJframe(){

super();

this.setBounds(300,240,250,150); this.setResizable(false); this.setVisible(true);

this.setDefaultCloseOperation(EXIT_ON_CLOSE); panel1.add(label3); panel1.add(label4);

panel1.setBackground(Color.lightGray); panel2.add(label1);

}

panel2.add(txt1); panel2.add(label2); panel2.add(txt2); panel2.add(btn1); panel2.add(btn2);

panel2.setLayout(new GridLayout(3,2)); this.add(panel1); this.add(panel2);

this.setLayout(new GridLayout(2,1)); dialog.setSize(250,100); dialog.add(label5);

dialog.setDefaultCloseOperation(HIDE_ON_CLOSE); btn1.addActionListener(this); btn2.addActionListener(this);

public void showerror(){ }

public void actionPerformed(ActionEvent e){ }

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

Class.forName(\"com.mysql.jdbc.Driver\"); //指定MYSQL jdbc驱动程序 try{ }

if(e.getSource() == btn2){ }

if(e.getSource() == btn1){ }

System.out.println(ee.toString());

String str = txt1.getText(); String pwd = txt2.getText(); if(q.find(str))

this.showerror(); q.insert(str,pwd); else

String str = txt1.getText(); String pwd = txt2.getText(); if(q.check(str,pwd))

System.out.println(\"Sign in Successfully!\"); this.showerror();

else

dialog.setLocation(350,290); dialog.setVisible(true);

} catch(Exception ee){

String

url=\"jdbc:mysql://localhost/user?user=153299&password=153299\"; Connection conn = DriverManager.getConnection(url); String sql;

Statement stmt = conn.createStatement();

sql = \"Create table registe ( Name char(10) primary key,password char(6) DEFAULT NULL)\";

stmt.execute(sql); stmt.close(); conn.close();

SJframe sj = new SJframe(); }

class Query{

public boolean find(String str) throws Exception{ }

public void insert(String str,String pwd) throws Exception{

Class.forName(\"com.mysql.jdbc.Driver\"); String url =

Connection con = DriverManager.getConnection(url); Statement sta = con.createStatement(); Class.forName(\"com.mysql.jdbc.Driver\"); String url =

Connection con = DriverManager.getConnection(url); Statement sta = con.createStatement();

String sql = \"SELECT * FROM registe WHERE name ='\"+str+\"'\"; ResultSet temp = sta.executeQuery(sql); String rst; try{ }

//System.out.println(rst); if (rst.equals(str)){ }

sta.close(); con.close(); return true;//have sta.close(); con.close(); return false;

rst = temp.getString(2); return false; }catch(Exception eee){ }

\"jdbc:mysql://localhost/user?user=153299&password=153299\";

}else{

\"jdbc:mysql://localhost/user?user=153299&password=153299\";

}

String sql = \"INSERT INTO registe(name,password) sta.execute(sql); sta.close(); con.close();

VALUES('\"+str+\"',\"+pwd+\")\";

public boolean check(String str,String pwd) throws Exception{ }

Class.forName(\"com.mysql.jdbc.Driver\"); String url =

Connection con = DriverManager.getConnection(url); Statement sta = con.createStatement();

String sql = \"SELECT * FROM registe WHERE name ='\"+str+\"'\"; ResultSet temp = sta.executeQuery(sql); String n = temp.getString(2); String p = temp.getString(3); //System.out.println(n+\"----\"+p); if (n.equals(str) && p.equals(pwd)){ }

sta.close(); con.close(); return true; sta.close(); con.close(); return false;

\"jdbc:mysql://localhost/user?user=153299&password=153299\";

}else{

运行结果：

6、学生成绩管理，设计学生成绩管理数据库应用程序，对课程表和学生成绩表进行数据插入、修改、删除、查询和成绩统计等操作，并从学生信息表中获得相

关数据。

1、建表

2、实验代码：

import java.sql.*; class Info{

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

Class.forName(\"com.mysql.jdbc.Driver\"); String url =

Connection con = DriverManager.getConnection(url); String course1 = \"INSERT INTO

\"jdbc:mysql://localhost/students?user=153299&password=153299\";

course(CourseName,CourseNumber,Teacher,StudentNumber) VALUES('Java',1,'lin',30)\";

String course2 = \"INSERT INTO

course(CourseName,CourseNumber,Teacher,StudentNumber) VALUES('Math',2,'zhang',20)\";

String course3 = \"INSERT INTO

course(CourseName,CourseNumber,Teacher,StudentNumber) VALUES('C',3,'yang',25)\";

String ss = \"INSERT INTO score(StudentName,Java,Math,C,Average) String sql = \"SELECT * FROM course\";

//String sc = \"DELETE FROM student WHERE(Name ='xiaoming')\"; Statement sta = con.createStatement(); int s=sta.executeUpdate(course1);

VALUES('小徐',95,98,92,95)\";

s=sta.executeUpdate(course2);

s=sta.executeUpdate(course3); s=sta.executeUpdate(ss); //s=sta.executeUpdate(sc);

ResultSet temp = sta.executeQuery(sql); while(temp.next())

System.out.println(\"CourseName\CourseNumber\Teacher\StudentNumber\");

System.out.println(temp.getString(\"CourseName\")+'\'+temp.getString(\"CourseNumber\")+'\'+temp.getString(\"Teacher\")+'\'+temp.getString(\"StudentNumber\")); }

3、运行结果：

}

sta.close(); con.close();

插入数据：

查询数据：

删除数据：

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

查看全文