JAVA上机题目.doc

一、 运行书中Helloworld程序
二、 编写一个计算器类，要求实现加、减、乘、除运算，注意在进行除法运算时，如果除数为0，那么就直接输出Error来
下面代码为判断是否为数字，如果是数字，那么返回是true，否则返回false，在使用下面代码前，要在程序头导入包：import java.util.regex.*;
public static boolean isNumeric(String str)
{
Pattern pattern = Ppile("[0-9]*");
Matcher isNum = pattern.matcher(str);
if( !isNum.matches() )
{
return false;
}
return true;
}
三、 编写Java程序，要求在运行的时候输入一个数字，表示行数，程序计算出相应行数的杨辉三角数据，并在屏幕上显示出来。
(1)、每行数字左右对称，由1开始逐渐变大，然后变小，回到1。
(2)、第n行的数字个数为n个。
(3)、第n行数字和为2n − 1。
(4)、每个数字等于上一行的左右两个数字之和。
(5)、将第2n+1行第1个数，跟第2n+2行第3个数、第2n+2行第5个数……连成一线，这些数的和是第2n个斐波那契数。将第2n行第2个数，跟第2n+1行第4个数、第2n+2行第6个数……这些数之和是第2n-1个斐波那契数。
(6)、第n行的第1个数为1，第二个数为1×(n-1)，第三个数为1×n×（n-1）/2，第四个数为1×n×（n-1）/2×（n-2）/3…依此类推。
通过main方法中的args获取用户附带的参数，例如用户输入app 10 （注意参数间有空格），那么args对应的值为：args[0]=10，然后通过Integer.parseInt(args[0])，即可得到int类型的数据。
四、 编写Java程序，Java中程序的结构，类的声明和定义
掌握面向对象的基本思想，抽象对象并定义类，类的继承结构，理解并能熟练运用类的多态性，抽象类和接口及它们的区别，理解并熟练运用抽象类和接口解决耦合问题。
1、构造一个抽象类Shape，它有两个抽象的方法area（）和perimeter（），分别表示求面积和周长，此外，它还有一个具体方法message（），能输出类的一些信息。
public abstract class Shape { //创建抽象类
public abstract void area(); //创建抽象方法
public abstract void perimeter(); //创建抽象方法
public void message(){ //创建具体方法
System.out.print("OY");
}
}
2、定义一个接口Graph，它有一个抽象的方法draw（），表示绘制Shape。
public interface Graph { //创建接口
public abstract void draw(); //创建抽象方法
}
3、构造Shape的两个子类Circle和Rectangle，分别表示圆和矩形，并且实现接口Graph。
//创建Circle类，继承Shape类，并实现接口Graph
public class Circle extends Shape implements Graph {

// 重写抽象类的抽象方法
public void area() {
}
// 重写抽象类的抽象方法
public void perimeter() {
}
// 重写接口的抽象方法
public void draw(){
};
}
//创建Rectangle类，继承Shape类，并实现接口Graph
public class Rectangle extends Shape implements Graph{
// 重写抽象类的抽象方法
public void area() {
// TODO Auto-generated method stub
}
// 重写抽象类的抽象方法
public void perimeter() {
// TODO Auto-generated method stub
}
// 重写接口的抽象方法
public void draw(){
};
}
4、构造测试类Test，其有方法getShapeData（Shape s），它输出s的面积和周长，构造矩形实例和圆实例，体会area方法和perimeter方法的多态性。
public class Test { //创建Test类
public static void getShapeData(Shape s){ //创建 方法
s.area();
s.perimeter();
}
public static void main(String[] args) {
getShapeData(new Circle()); //抽象类的多态
getShapeData(new Rectangle()); //抽象类的多态
}
}
5、类似上题，为Test添加方法drawGraph（Graph g），它“画出”Graph的图形----调用draw方法，构造矩形实例和圆实例，体会draw方法的多态性。

public class Test { //创建Test类

public void drawGraph(Graph g){ //创建 方法
g.draw();
}
public static void main(String[] args) {
Test t=new Test();
t.drawGraph(new Circle()); //接口的多态
t.drawGraph(new Rectangle()); //接口的多态
}
}
总结：
1、根据自己对实验的理解，说明一下在本实验中，抽象类Shape的作用是什么？
产生子类的同时给于子类一些特定的属性和方法
2、 分析说明抽象类和接口的异同？
抽象类可以给出一些成员的实现，接口却不包含成员的实现，抽象类的抽象成员可以被子类部分实现，接口的成员需要实现类完全实现，一个类只能继承一个抽象类，但可以实现多个接口。

1. 类是对对象的抽象；抽象是对类的抽象；接口是对行为的抽象。
2. 如果行为跨越不同的对象，可使用 ；对于一些相似的类对象，用继承抽象类。
3. 抽象类是从子类发现公共的东西，泛化出父类，然后子类继承父类；而接口是根本不知子类的存在，方法如何实现还不确定，预先定义。
五、 熟悉Java中程序的结构，接口的定义和使用
学校中有教师和学生两类人，而在职研究生既是教师又是学生。设计两个接口studentinterface和teacherinterface。其中，studentinterface接口包含setFee()getFee()方法，分别用于设置和获取学生的学费；teacherinterface接口包含setPay()和getPay()方法，分别用于设置和获取教师的工资。
定义一个研究生类graduate，实现studentinterface接口和teacherinterface接口，它的成员变量有name，sex，age，fee，pay。
创建一个姓名为“zhangsan”的研究生，统计他的年收入和学费，如果收入减去学费不足2000元，则输出“provide a loan”（需要贷款）信息。
要求：在graduate中实现各个接口定义的抽象方法。
实验代码：
定义接口IStudentinterface
public interface IStudentinterface //创建学生接口
{
public void setFee(float fee); //抽象(设置学生的学费)方法
public float getFee(); //抽象(获取学生的学费)方法
}
定义接口ITeacherinterface
public interface ITeacherinterface //创建教师接口
{
public void setPay(float pay); //抽象(设置教师工资)方法
public float getPay(); //抽象(获取教师工资)方法
}
定义研究生类Graduate
public class Graduate implements IStudentinterface, ITeacherinterface {

String name,sex;
int age;
float fee,pay;

public Graduate(String name,String sex,int age) //定义构造函数设置姓名,性别及年龄
{ this.name = name;
this.sex = sex;
this.age = age;
}

@Override
public float getFee() { //实现返回学费数据的方法
// TODO Auto-generated method stub
return fee;
}

@Override
public void setFee(float fee) { //实现设置学费数据的方法
// TODO Auto-generated method stub
this.fee = fee ;
}

@Override
public float getPay() { //实现返回工资数据的方法
// TODO Auto-generated method stub
return pay;
}

@Override
public void setPay(float pay) { //实现设置工资数据的方法
// TODO Auto-generated method stub
this.pay = pay;
}

}
定义测试类Test实例化方法

public class Test {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Graduate zs = new Graduate("zhangsan","男",26);
zs.setFee(1500); //设置学生学费
zs.setPay(2000); //设置教师工资
float zsf = zs.getFee();
float zsp = zs.getPay();
float zst = zsp - zsf;
if(zst<2000){
System.out.print("provide a loan");
}
}
}
六、 掌握Java高效类的特征，Java中如何设计高效的低耦合高聚合类，掌握接口在类的耦合性中的作用
1、设计一个学生信息管理系统，要求能对学生的信息进行增删改查的操作，在设计中要求能充分合理使用低耦合和高聚合的特征。注意，在对数据库的操作语句不需要完成，只需要进行相应的提示即可。

实验代码如下：
//创建学生基类 Students
public class Students {
private String Name;
private String Sex;
private int Age;
public Students (String strName, String strSex, int iAge) //设置学生信息的构造方法
{
this. Name = StrName;
this. Sex = StrSex;
this. Age = IAge;
}
public String GetStudnetName(String strName)
{
this. Name = StrName;
}
public String GetStudnetName()
{
return Name;
}
public String GetStudentSex()
{
return Sex;
}
public int GetStudentAge()
{
return Age;
}
}
//创建Manager类针对实现学生信息操作的具体方法实现
public class Manager {

public Student AddStudent(String strName, String strSex, int iAge)
{
Student S1 = new Student (strName, strSex, iAge);

String strSql = "添加学生信息"
+" 姓名: " + S1.GetStudnetName()
+" 性别: " + S1.GetStudentSex()
+" 年龄: " + S1.GetStudentAge();
System.out.println(str_Sql);
return S1;
}//提供添加学生信息的方法

public void DeleteStudent(Student s1)
{
String strSql = "删除学生信息"
+ " 姓名: " + S1.GetStudnetName();
System.out.println(strSql);
}//提供删除学生信息的方法

public void DeleteStudent(String strName)
{
String strSql = "修改学生信息"
+ " 姓名: " + S1.GetStudnetName();
System.out.println(strSql);
}//提供修改学生信息的方法

public void SelectStudnet(Student S1)
{
String strSql = "查找结果:\n "
+ "姓名: " + S1.GetStudnetName()
+ "性别: " + S1.GetStudentSex()
+ "年龄: " + S1.GetStudentAge();
System.out.println(strSql);
}//提供查找学生信息的方法
}

书写测试类完成实际操作：
public class Test {
public static void main(String[] args) {
Manager M1 = new Manager ();
Student S1 = Manager.AddStudent("张三","男",22);
M1.UpdateStudent (S1,”李四”);
M1.SelectStudnet (S1);
M1.DeleteStudent (S1);
}
}
七、 掌握Java高效类的特征，Java中成员函数的设计，Java中常用的从Object中继承的方法的作用，成员函数的重写
设计一个软件，实现以下功能：
1、 设计一个成绩类，具有课程编号、课程名称、分数
2、 设计一个学生信息类，具有学号、姓名、性别、成绩
3、 要求学生信息类能完成对象的克隆(Clone)、比较（Equals）、学号输出(HashCode)、信息输出(ToString)等相关功能。
4、 克隆的时候，要求对新对象中成绩的修改不影响到旧对象的成绩
5、 比较的时候，只需要对对象中的学号进行比较，如果学号相等，那么就返回为真，否则为假
6、 当运行对象的HashCode方法时，输出此对象的学号
7、 当执行对象的toString方法时，要求按照下面的格式输出数据
0001 张三 男 80 87 90 81
成绩类：
package com.stu.info;
public class Score {
public Score(String courseID, String courseName, int courseScore) {
super();
this.courseID = courseID;
this.courseName = courseName;
this.courseScore = courseScore;
}
private String courseID;
public String getCourseID() {
return courseID;
}
public void setCourseID(String courseID) {
this.courseID = courseID;
}
private String courseName;
public String getCourseName() {
return courseName;
}
public void setCourseName(String courseName) {
this.courseName = courseName;
}

private int courseScore;
public int getCourseScore() {
return courseScore;
}
public void setCourseScore(int courseScore) {
this.courseScore = courseScore;
}
}
学生信息类：
package com.stu.info;

public class Student implements Cloneable{

public Student(String stuNo, String stuName, String stuSex, Score[] stuScore) {
super();
this.stuNo = stuNo;
this.stuName = stuName;
this.stuSex = stuSex;
this.stuScore = stuScore;
}

private String stuNo;

public String getStuNo() {
return stuNo;
}
public void setStuNo(String stuNo) {
this.stuNo = stuNo;
}

private String stuName;

public String getStuName() {
return stuName;
}
public void setStuName(String stuName) {
this.stuName = stuName;
}

private String stuSex;

public String getStuSex() {
return stuSex;
}
public void setStuSex(String stuSex) {
this.stuSex = stuSex;
}

private Score[] stuScore;

public Score[] getStuScore() {
return stuScore;
}
public void setStuScore(Score[] stuScore) {
this.stuScore = stuScore;
}
public int hashCode() {

return Integer.parseInt(this.stuNo);
}

public boolean equals(Object obj) {

if(this.stuNo== (String) obj )
{
return true;
}
return false;
}

@Override
public String toString() {

String strTemp = this.stuNo+"\t"+this.stuName+"\t"+this.stuSex+"\t";

for(int i=0;i<stuScore.length;i++)
{
strTemp+=this.stuScore[i].getCourseScore()+"\t";
}

return strTemp;
}

protected Object clone() throws CloneNotSupportedException {
Student stu=(Student)(super.clone());
stu.stuScore=this.stuScore;
return stu;
}
}
测试类：
package com.stu.info;

public class Test {

/**
* @param args
*/
public static void main(String[] args) throws CloneNotSupportedException {
// TODO Auto-generated method stub

Score sc=new Score("EN001","英语1",80);
Score sc1=new Score("EN001","英语1",87);
Score sc2=new Score("EN001","英语1",90);
Score sc3=new Score("EN001","英语1",81);

Score[] score=new Score[4];
score[0]=sc;
score[1]=sc1;
score[2]=sc2;
score[3]=sc3;

Student stu=new Student("10001","张三","男",score);

stu.setStuScore(score);

System.out.println("该对象的学号是："+stu.hashCode());

if(stu.equals("10001"))
{
System.out.println("10001 与 对象学号："+stu.getStuNo()+" 相同啦");
}
else
{
System.out.println("10001 与 对象学号： "+stu.getStuNo()+" 不同啦");
}

Student stu1=(Student)stu.clone();
System.out.println("克隆对象后的学号是："+stu1.hashCode());

Score sco=new Score("EN001","英语1",90);
Score sco1=new Score("EN001","英语1",97);
Score sco2=new Score("EN001","英语1",100);
Score sco3=new Score("EN001","英语1",91);

Score[] score1=new Score[4];
score1[0]=sco;
score1[1]=sco1;
score1[2]=sco2;
score1[3]=sco3;
stu1.setStuScore(score1);

System.out.println(stu.toString());
System.out.println(stu1.toString());
System.out.println(stu.toString());
}

}
程序结果：

八、 掌握Java如何实现多线程程序的设计，Java中实现多线程的方法
参考书本多线程的代码，设计具有以下功能的程序
l 总共有1000张火车票
l 有四个售票点来销售（用四个线程来模拟实现）
l 当线程销售出去一张票时，显示线程销售的提示信息
（一）public class DuoThreah implements Runnable {
@Override
public void run() {
// TODO Auto-generated method stub
int nonSharedValue = 100;
nonSharedValue += 100;
System.out.println("Value:"+ nonSharedValue);

}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
DuoThreah ts = new DuoThreah();
Thread t1 = new Thread(ts);
Thread t2 = new Thread(ts);
t1.start();
t2.start();
}
}

（二）、
public class DuoThreah implements Runnable {
int SharedValue=100;
@Override
public void run() {
// TODO Auto-generated method stub

SharedValue += 100;
System.out.println("Value:"+ SharedValue);
}

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
DuoThreah ts = new DuoThreah();
Thread t1 = new Thread(ts);
Thread t2 = new Thread(ts);
t1.start();
t2.start();
}
}

（三）、
public class DuoThreah implements Runnable {
int SharedValue=0;
@Override
public void run() {
// TODO Auto-generated method stub
SharedValue += 1;
System.out.println("卖出票数为:"+ SharedValue+"张");
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
DuoThreah ts = new DuoThreah();
Thread t1 = new Thread(ts);
Thread t2 = new Thread(ts);
Thread t3 = new Thread(ts);
Thread t4 = new Thread(ts);
t1.start();
t2.start();
t3.start();
t4.start();
}

}

（四）、
public class DuoThreah implements Runnable {

int SharedValue=0;
int SurplusValue=1000;
@Override
public void run() {
// TODO Auto-generated method stub
while(SurplusValue!=0)
{
SharedValue +=1;
SurplusValue -= 1;
System.out.println("卖出票数为:"+ SharedValue+"张"+","+"剩余票数为:"+ SurplusValue+"张"+";");
}
}

/**
* @param args
*/
public static void main(String[] args)
{
// TODO Auto-generated method stub

DuoThreah ts = new DuoThreah();

Thread t1 = new Thread(ts);
Thread t2 = new Thread(ts);
Thread t3 = new Thread(ts);
Thread t4 = new Thread(ts);
t1.start();
t2.start();
t3.start();
t4.start();

}

}

九、 掌握Java如何实现多线程程序的设计，Java中实现多线程的方法，线程的启动、挂起、退出等相关操作
参考书本P101至P132多线程的代码，设计一个多线程下载程序
a) 能够输入下载地址
b) 能够控制下载动作
c) 要求使用多线程来下载，下载时要能响应其它用户操作。
d) 要能够显示下载的进度

十、 掌握Java集合的使用方法，Java中方法的重写步骤，面向对象程序设计的方法
设计一个Java程序，要求能完成以下功能：
1、程序要能够存储任意多个学生的信息。
2、学生的信息有：学号、姓名、性别、年龄等相关字段。
3、可以增加学生的信息，如果学号相同就不能添加
4、根据用户输入的学号信息，可以删除掉相应的学生信息
5、如果用户输入学号和其它信息，那么可以更改相应学生的信息
6、在测试类里面进行相应的操作，可以完成上面的任务。

Student类：

public class Student { //定义学生类

private int StuID;
private String StuName;
private String StuSex;
private int StuAge;
//定义学生类信息
public Student(int id,String name,String sex,int age) {
this.StuID = id;
this.StuName = name;
this.StuSex = sex;
this.StuAge = age;
}
//定义设置,获取学生信息的方法
public int getId() {
return StuID;
}
public void setId(int id) {
this.StuID = id;
}
public String getName() {
return StuName;
}
public void setName(String name) {
this.StuName = name;
}
public String getSex() {
return StuSex;
}
public void setSex(String sex) {
this.StuSex = sex;
}
public int getAge() {
return StuAge;
}
public void setAge(int age) {
this.StuAge = age;
}
//重载equals函数,是学号属于学生类的学生在学好重复的情况下无法添加
public boolean equals(Object o) {
if(o instanceof Student) {
Student stu = (Student)o;
if(this.StuID == stu.getId())
return true;
else
return false;
}
return false;
}
//重载hashCode函数,确保学号不重复
public int hashCode() {
return StuID;
}

}
StuOP类:

import java.util.HashSet;
import java.util.Set;

public class StuOP { //定义学生信息操作类

private Set<Student> students;
//定义添加学生信息的方法
public StuOP() {
students = new HashSet<Student>();
}
//定义添加学生信息的方法
public void Add(Student stu) {
students.add(stu);
}
//定义删除学生信息的方法
public void Delete(int id) {
for(Student stu : stude