本科生实验报告
实验课程 Java语言程序设计
学院名称 信息科学与技术学院
专业名称 软件工程
学生姓名
学生学号
指导教师
实验地点 6A502
实验成绩
二〇##年一月八日
Java语言程序设计上机实验报告
摘要
本实验报告用于记录在Java语言程序设计课程开设的上机实验中记录上机实验过程，以激励自己学习进步并为将来的学习提供一系列参考资料。
关键字 Java语言；实验；编程；语法；算法
第1章 实验一
1.1 设计一个名为RegularPolygon的正n边形类
1.1.1 要求
一个名为n的int型私有数据域定义多边形的边数，默认值为3。
一个名为side的double型私有数据域存储边的长度，默认值为1。
一个名为x的double型私有数据域，它定义多边形中点的x坐标，默认值为0。
一个名为y的double型私有数据域，它定义多边形中点的y坐标，默认值为0。
一个创建带默认值的正多边形的无参构造方法。
一个能创建带指定边数和边长度、中心在(0,0)的正多边形的构造方法。
一个能创建带指定边数和边长度、中心在(x,y)的正多边形的构造方法。
所有数据域的get和set方法。
一个返回多边形周长的方法getPerimeter()。
一个返回多边形面积的方法getArea()。计算正多边形面积的公式是：面积=(n*side2)/(4*tan(180/n))
分别使用无参构造方法、 RegularPolygon (6,4)和RegularPolygon(10,4,5.6,7.8)创建三个RegularPolygon对象，并显示每个对象的周长和面积。
1.1.2 代码
2 //RegularPolygon.java
3
4 publicclass RegularPolygon {
5 privateint n = 3;//一个名为n的int型私有数据域定义多边形的边数，默认值为3。
6 privatedouble side = 1;//一个名为side的double型私有数据域存储边的长度，默认值为1。
7 privatedouble x = 0;//一个名为x的double型私有数据域，它定义多边形中点的x坐标，默认值为0。
8 privatedouble y = 0;//一个名为y的double型私有数据域，它定义多边形中点的y坐标，默认值为0。
9
10 //一个创建带默认值的正多边形的无参构造方法。
11 public RegularPolygon(){
12 this.setN(3);
13 setSide(1);
14 setX(0);
15 setY(0);
16 }
17
18 //一个能创建带指定边数和边长度、中心在(0,0)的正多边形的构造方法。
19 public RegularPolygon(int n, double side){
20 this.setN(n);
21 this.setSide(side);
22 setX(0);
23 setY(0);
24 }
25
26 //一个能创建带指定边数和边长度、中心在(x,y)的正多边形的构造方法。
27 public RegularPolygon(int n, double side, double x, double y){
28 this.setN(n);
29 this.setSide(side);
30 this.setX(x);
31 this.setY(y);
32 }
33
34 //所有数据域的get和set方法。
35 publicint getN() {
36 return n;
37 }
38
39 publicvoid setN(int n) {
40 this.n = n;
41 }
42
43 publicdouble getSide() {
44 return side;
45 }
46
47 publicvoid setSide(double side) {
48 this.side = side;
49 }
50
51 publicdouble getX() {
52 return x;
53 }
54
55 publicvoid setX(double x) {
56 this.x = x;
57 }
58
59 publicdouble getY() {
60 return y;
61 }
62
63 publicvoid setY(double y) {
64 this.y = y;
65 }
66
67 //一个返回多边形周长的方法getPerimeter()。
68 publicdouble getPerimeter(){
69 return n * side;
70 }
71
72 //一个返回多边形面积的方法getArea()。计算正多边形面积的公式是：面积=(n*side2)/(4*tan(180/n))
73 publicdouble getArea(){
74 return (n * side * side)/(4 * Math.tan(Math.PI/n));
75 }
76
77 }
//main
publicclass main {
publicstaticvoidmain (String[] args){
//使用无参方法构造一个对象
RegularPolygon r1 = new RegularPolygon();
//使用RegularPolygon(6, 4)方法构造一个对象
RegularPolygon r2 = new RegularPolygon(6, 4);
//使用RegularPolygon(10, 4, 5.6, 7.8)方法构造一个对象
RegularPolygon r3 = new RegularPolygon(10, 4, 5.6, 7.8);
//显示每个对象的周长和面积;
System.out.println("无参数多边形的面积是：\t" + r1.getArea() + "\t周长为：\t" + r1.getPerimeter());
System.out.println("两个参数多边形的面积是：\t" + r2.getArea() + "\t周长为：\t" + r2.getPerimeter());
System.out.println("四个参数多边形的面积是：\t" + r3.getArea() + "\t周长为：\t" + r3.getPerimeter());
}
}
1.2 设计一个名为Account的账户类
1.2.1 要求
n 一个名为id的int类型的私有账户数据域（默认值0）
n 一个名为balance的double类型的私有数据域存储余额（默认值0）
n 一个名为annualInterestRate的double类型的私有数据域存储当前利率（默认值0）。假设所有的账户都有相同的利率。
n 一个名为dateCreated的Date类型的私有数据域存储账户开户日期。(import java.util.Date)
n 一个能创建默认账户的无参构造方法。
n 一个能创建带特定id和初始余额的的账户的构造方法。
n id、balance和annualInterestRate的get和set方法
n dateCreated的get方法
n 一个名为getMonthlyInterestRate()的方法返回月利率。
n 一个名为withDraw的方法从账户提款。
n 一个名为deposit的方法向账户存款。
n 编写一个测试程序，创建一个账户id为123、余额为2000元、年利率为4.5%的Account对象。使用withDraw方法取款200元，使用deposit方法存款3000元，然后打印余额、月利息以及这个账户的开户日期。
1.2.2 代码
//Account.java
package Account;
import java.util.Date;
publicclass Account {
//一个名为id的int类型的私有账户数据域（默认值0）
privateint id = 0;
//一个名为balance的double类型的私有数据域存储余额（默认值0）
privatedouble balance = 0;
//一个名为annualInterestRate的double类型的私有数据域存储当前利率（默认值0）。
privatedouble annualInterestRate = 0;
//一个名为dateCreated的Date类型的私有数据域存储账户开户日期。
private Date dateCreated;
//一个能创建默认账户的无参构造方法。
public Account(){
this.setId(0);
this.setBalance(0);
dateCreated = new Date();
}
//一个能创建带特定id和初始余额的的账户的构造方法。
public Account(int id, double balance){
this.setId(id);
this.setBalance(balance);
dateCreated = new Date();
}
//id、balance和annualInterestRate的get和set方法
publicint getId() {
return id;
}
publicvoid setId(int id) {
this.id = id;
}
publicdouble getBalance() {
return balance;
}
publicvoid setBalance(double balance) {
this.balance = balance;
}
publicdouble getAnnualInterestRate() {
return annualInterestRate;
}
publicvoid setAnnualInterestRate(double annualInterestRate) {
this.annualInterestRate = annualInterestRate;
}
//dateCreated的get方法
public Date getDateCreated() {
return dateCreated;
}
//一个名为getMonthlyInterestRate()的方法返回月利率
publicdouble getMonthlyInterestRate(){
return getAnnualInterestRate()/12;
}
//一个名为withDraw的方法从账户提款。
publicdouble withDraw(double draw){
if(draw <= getBalance()){
setBalance(getBalance() - draw);
return draw;
}else{
return 0;
}
}
//一个名为deposit的方法向账户存款。
publicdouble deposit(double deposit){
setBalance(getBalance() + deposit);
return deposit;
}
}
//main
package Account;
publicclass Main {
publicstaticvoid main(String[] args){
//创建一个账户id为123、余额为2000元、年利率为4.5%的Account对象。
Account account = new Account(123, 2000);
account.setAnnualInterestRate(0.045);
//使用withDraw方法取款200元
account.withDraw(200);
//使用deposit方法存款3000元
account.deposit(3000);
//然后打印余额、月利息以及这个账户的开户日期。
System.out.println("账户 "+account.getId()+" 的余额为：\t" + account.getBalance());
System.out.println("月利息为：\t" + account.getMonthlyInterestRate() * account.getBalance());
System.out.println("开户日期：\t" + account.getDateCreated());
}
}
第2章 实验二
2.1三角形类Triangle
2.1.1 要求
v 设计一个三角形类Triangle来扩展Geometricobject类，该类包括：
v 三个名为side1， side2和side3的double数据域表示这个三角形的三条边，它们的默认值是1.0
v 一个无参构造方法创建默认的三角形
v 一个能创建指定side1， side2和side3的三角形的构造方法
v 所有三个数据域的get方法
v 一个名为getArea()的方法返回这个三角形的面积 ,计算公式为s=(side1+ side2+ side3)/2
v 一个名为getPerimeter()的方法返回这个三角形的周长
v 编写测试程序，创建边长为1、1.5和1，颜色为yellow，filled为true的Triangle对象，然后显示它的面积、周长、颜色以及是否被填充
v 显示以该对象创建的具有三角形底的Pillar类对象的体积。
2.1.2 代码
//Geometricobject.java
package Geometricobject;
publicabstractclass Geometricobject {
private String color = "White";
private String filled = "false";
publicabstractdouble getArea();
publicabstractdouble getPerimeter();
public String getColor() {
return color;
}
publicvoid setColor(String color) {
this.color = color;
}
public String getFilled() {
return filled;
}
publicvoid setFilled(String filled) {
this.filled = filled;
}
}
//Pillar.java
package Geometricobject;
publicclass Pillar {
private Geometricobject geometricobject;
privatedouble height;
public Pillar(Geometricobject geometricobject, double height){
this.geometricobject = geometricobject;
this.height = height;
}
publicdouble getVolume(){
return height * geometricobject.getArea();
}
}
//Triangle
package Geometricobject;
//设计一个三角形类Triangle来扩展Geometricobject
publicclass Triangle extends Geometricobject{
//三个名为side1， side2和side3的double数据域表示这个三角形的三条边，它们的默认值1.0
privatedouble side1 = 1.0;
privatedouble side2 = 1.0;
privatedouble side3 = 1.0;
//一个无参构造方法创建默认的三角形
public Triangle(){}
//一个能创建指定side1， side2和side3的三角形的构造方法
public Triangle(double side1, double side2, double side3){
this.side1 = side1;
this.side2 = side2;
this.side3 = side3;
}
//所有三个数据域的get方法
publicdouble getSide1() {
return side1;
}
publicdouble getSide2() {
return side2;
}
publicdouble getSide3() {
return side3;
}
//一个名为getArea()的方法返回这个三角形的面积 ,计算公式为s=(side1+ side2+ side3)/2
publicdouble getArea(){
return (this.side1 + this.side2 + this.side3)/2;
}
//一个名为getPerimeter()的方法返回这个三角形的周长
publicdouble getPerimeter(){
returnthis.side1 + this.side2 + this.side3;
}
};
//main.java
package Main;
import Geometricobject.*;
publicclass Main {
publicstaticvoid main(String[] argv){
Triangle triangle = new Triangle(1, 1.5, 1);
triangle.setColor("yellow");
triangle.setFilled("true");
System.out.println("面积\t" + triangle.getArea());
System.out.println("周长\t" + triangle.getPerimeter());
System.out.println("颜色\t" + triangle.getColor());
System.out.println("是否填充\t" + triangle.getFilled());
Pillar pillar = new Pillar(triangle, 2);
System.out.println("Pillar类的对象体积\t" + pillar.getVolume());
}
}
2.2设计一个名为Person的类和它的两个名为Student和Employee的子类
2.2.1 要求
v Employee类又有子类：教员类Faculty和职员类Staff。
v 每个人都有姓名、地址、电话号码
v 学生有班级号
v 教员有级别
v 职员有职务称号
v 覆盖每个类的toString方法，显示相应的类名和人名
v 编写测试程序，创建Person、 Student、Employee Faculty和Staff，并调用它们的toString方法
2.2.2 代码
//Employee.java
package Class;
//Person的子类Employee
publicclass Employee extends Person {
public Employee(String name, String address, String phonenumber){
super(name, address, phonenumber);
}
}
//Faculty.java
package Class;
//Employee的子类Faculty
publicclass Faculty extends Employee {
//教员有级别
private String level;
public Faculty(String name, String address, String phonenumber, String level){
super(name, address, phonenumber);
this.level = level;
}
}
//Person.java
package Class;
//设计一个名为Person的类
publicclass Person {
private String name;
private String address;
private String phonenumber;
public Person(String name, String address, String phonenumber){
this.name = name;
this.address = address;
this.phonenumber = phonenumber;
}
//覆盖每个类的toString方法，显示相应的类名和人名
public String toString(){
returnthis.getClass().getName() + "\t姓名 :" + name;
}
}
//Staff.java
package Class;
//Employee的子类Staff
publicclass Staff extends Employee {
//职员有职务称号
private String professionaltitle;
public Staff(String name, String address, String phonenumber, String professionaltitle){
super(name, address, phonenumber);
this.professionaltitle = professionaltitle;
}
}
//Student.java
package Class;
//Person的子类Student
publicclass Student extends Person{
//学生有班级号
privateintclassnumber;
public Student(String name, String address, String phonenumber, int classnumber){
super(name, address, phonenumber);
this.classnumber = classnumber;
}
}
//Main.java
package Main;
import Class.*;
publicclass Main {
publicstaticvoid main(String[] args) {
//创建Person、 Student、Employee Faculty和Staff
Person person = new Person("Person", "ddd", "222");
Student student = new Student("Student", "ddd", "2", 5);
Employee employee = new Employee("Employee", "ddd", "33");
Faculty faculty = new Faculty("Factuly", "ddd", "22", "level");
Staff staff = new Staff("Staff", "ddd", "222", "professionaltitle");
System.out.println(person.toString());
System.out.println(student.toString());
System.out.println(employee.toString());
System.out.println(faculty.toString());
System.out.println(staff.toString());
}
}
第3章 实验三
3.1求几何对象的面积之和
3.1.1 要求
v 编写一个方法，求参数列表中所有几何对象的面积之和。方法签名如下：
v public static double sumArea(GeometricObject… a)
v 编写测试程序，创建4个对象（2个矩形，2个三角形），然后使用sumArea方法求它们的总面积。
v 可变参数用法参考书58页，同时请大家使用增强的for语句编程。
3.1.2 代码
publicstaticdouble sumArea(Geometricobject...list){
double sum = 0;
for(Geometricobject param:list){
sum += param.getArea();
}
return sum;
}
3.2实现可比较大小的RegularPolygon类和 Triangle类
3.2.1 要求
v 扩展实验一中的RegularPolygon 类和实验二中的Triangle类，使之都实现Comparable接口。
v 编写测试程序，测试新的RegularPolygon 类和Triangle类
3.2.2 代码
//ComparableGeometricobject.java
package Geometricobject;
publicabstractclass ComparableGeometricobject extends Geometricobject implements
Comparable<ComparableGeometricobject> {
publicint compareTo(ComparableGeometricobject o){
if(getArea() > (o.getArea()))
return 1;
elseif ((getArea()) < (o.getArea()))
return -1;
else
return 0;
}
}
//ComparableRegularPolygon.java
package Geometricobject;
publicclass ComparableRegularPolygon extends ComparableGeometricobject {
privateint n = 3;
privatedouble side = 1;
privatedouble x = 0;
privatedouble y = 0;
public ComparableRegularPolygon(){
this.setN(3);
setSide(1);
setX(0);
setY(0);
}
public ComparableRegularPolygon(int n, double side){
this.setN(n);
this.setSide(side);
setX(0);
setY(0);
}
public ComparableRegularPolygon(int n, double side, double x, double y){
this.setN(n);
this.setSide(side);
this.setX(x);
this.setY(y);
}
publicint getN() {
return n;
}
publicvoid setN(int n) {
this.n = n;
}
publicdouble getSide() {
return side;
}
publicvoid setSide(double side) {
this.side = side;
}
publicdouble getX() {
return x;
}
publicvoid setX(double x) {
this.x = x;
}
publicdouble getY() {
return y;
}
publicvoid setY(double y) {
this.y = y;
}
publicdouble getPerimeter(){
return n * side;
}
publicdouble getArea(){
return (n * side * side)/(4 * Math.tan(Math.PI/n));
}
}
//ComparableRectangle.java
package Geometricobject;
publicclass ComparableRectangle extends ComparableGeometricobject{
privatedouble width = 1.0;
privatedouble height = 1.0;
public ComparableRectangle(){}
public ComparableRectangle(double width, double height){
this.width = width;
this.height = height;
}
publicdouble getArea(){ return width * height;}
publicdouble getPerimeter(){ return width + width + height +height;}
publicdouble getWidth(){ returnthis.width;}
publicdouble getHeight(){ returnthis.height;}
}
//ComparableTriangle.java
package Geometricobject;
publicclass ComparableTriangle extends ComparableGeometricobject{
privatedouble side1 = 1.0;
privatedouble side2 = 1.0;
privatedouble side3 = 1.0;
public ComparableTriangle(){}
public ComparableTriangle(double side1, double side2, double side3){
this.side1 = side1;
this.side2 = side2;
this.side3 = side3;
}
publicdouble getSide1() {
return side1;
}
publicdouble getSide2() {
return side2;
}
publicdouble getSide3() {
return side3;
}
publicdouble getArea(){
return (this.side1 + this.side2 + this.side3)/2;
}
publicdouble getPerimeter(){
returnthis.side1 + this.side2 + this.side3;
}
}
3.3找出最大的对象
3.3.1 要求
v 编写一个方法，返回对象列表中最大的对象。
v 方法签名：
Public static Object max(Comparable…a)
v 编写测试程序，创建2个RegularPolygon 类和2个Triangle类对象，找出面积最大的对象。
3.3.2 代码
publicstatic ComparableGeometricobject max(ComparableGeometricobject...list){
ComparableGeometricobject o = list[0];
for(ComparableGeometricobject param:list){
if(o.getArea() < param.getArea()){
o = param;
}
}
return o;
}
第4章 实验四
4.1求几何对象的面积排序
4.1.1 要求
v 编写一个方法，求参数中几何对象数组的面积排序（冒泡法）。方法签名如下：
v public static void bubbleSort(GeometricObject[] a)
v 编写测试程序，创建4个对象（4个矩形或4个三角形）的数组，然后使用bubbleSort方法对它们的面积进行冒泡法排序。
v 排序时，请使用实验3中的max方法比较面积大小。
4.1.2 代码
publicstaticvoid bubbleSort(ArrayList<ComparableGeometricobject> list, ArrayList<ComparableGeometricobject> r){
ComparableGeometricobject temp;
while(list.size() > 0){
temp = list.get(0);
for(int j=0; j<list.size(); j++){
temp = max(temp, list.get(j));
}
list.remove(temp);
r.add(temp);
}
}
4.2修改后的Account类
4.2.1 要求
v 在实验一Account类的基础上做如下修改：
v 添加一个String型的数据域name存储客户名字
v 添加一个新的构造方法，该方法创建一个带指定名字、id和初始余额的账户
v 添加一个名为transactions的数据域，类型为ArrayList，可以为账户存储交易。每笔交易都是一个名为Transaction类的实例
v 修改withDraw和deposit方法，向transactions线性表添加一笔交易。
4.2.2 代码
//account.java
package Account;
import java.util.ArrayList;
import java.util.Date;
public class Account {
//添加一个名为transactions的数据域，类型为ArrayList，可以为账户存储交易。每笔交易都是一个名为Transaction类的实例
public ArrayList<Transaction> transactions;
//添加一个String型的数据域name存储客户名字
private String name;
private int id = 0;
private double balance = 0;
private double annualInterestRate = 0;
private Date dateCreated;
public Account(){
this.setId(0);
this.setBalance(0);
dateCreated = new Date();
transactions = new ArrayList<Transaction>();
}
public Account(int id, double balance){
this.setId(id);
this.setBalance(balance);
dateCreated = new Date();
transactions = new ArrayList<Transaction>();
}
//添加一个新的构造方法，该方法创建一个带指定名字、id和初始余额的账户
public Account(int id, String name, double balance){
this.setId(id);
this.setName(name);
this.setBalance(balance);
dateCreated = new Date();
transactions = new ArrayList<Transaction>();
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public double getBalance() {
return balance;
}
public void setBalance(double balance) {
this.balance = balance;
}
public double getAnnualInterestRate() {
return annualInterestRate;
}
public void setAnnualInterestRate(double annualInterestRate) {
this.annualInterestRate = annualInterestRate;
}
public Date getDateCreated() {
return dateCreated;
}
public double getMonthlyInterestRate(){
return getAnnualInterestRate()/12;
}
public double withDraw(double draw){
if(draw <= getBalance()){
setBalance(getBalance() - draw);
Transaction t = new Transaction('w', draw, getBalance(), "取钱");
this.transactions.add(t);
return draw;
}else{
return 0;
}
}
public double deposit(double deposit){
setBalance(getBalance() + deposit);
Transaction t = new Transaction('d', deposit, getBalance(), "存钱");
this.transactions.add(t);
return deposit;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
4.3Transaction类
4.3.1 要求
v 一个名为date的Date类型数据域表示交易日期
v 一个名为type的char型数据域表示交易类型，例如： ‘w’表示取钱 ‘D’表示存钱
v 一个名为amount的double型数据域表示交易额
v 一个名为balance的double型数据域表示交易后的新余额
v 一个名为description的String型数据域描述交易
v 一个能创建指定type、amount、balance和description对象的构造方法
v 编写一个测试程序，创建一个年利率1.5%、余额1000、id为112、名字为zhao的Account对象。使用withDraw方法取款20，150，10，使用deposit方法存款300,10,5，然后打印账户清单，显示用户名字，利率，余额和所有交易。
4.3.2 代码
//Transaction.java
package Account;
import java.util.Date;
publicclass Transaction {
//一个名为date的Date类型数据域表示交易日期
private Date date;
//一个名为type的char型数据域表示交易类型，例如： ‘w’表示取钱 ‘D’表示存钱
privatechar type;
//一个名为amount的double型数据域表示交易额
privatedouble amount;
//一个名为balance的double型数据域表示交易后的新余额
privatedouble balance;
//一个名为description的String型数据域描述交易
private String description;
//一个能创建指定type、amount、balance和description对象的构造方法
public Transaction(char type, double amount, double balance, String description){
this.type = type;
this.amount = amount;
this.balance = balance;
this.description = description;
date = new Date();
}
public Date getDate() {
return date;
}
publicchar getType() {
return type;
}
publicdouble getAmount() {
return amount;
}
publicdouble getBalance() {
return balance;
}
public String getDescription() {
return description;
}
}
//Main.java
package Main;
import Account.*;
publicclass Main {
publicstaticvoid main(String[] args) {
// TODO Auto-generated method stub
//创建一个年利率1.5%、余额1000、id为112、名字为zhao的Account对象。
Account account = new Account(112, "Zhao", 1000);
account.setAnnualInterestRate(0.015);
account.withDraw(20);
account.withDraw(150);
account.withDraw(10);
account.deposit(300);
account.deposit(10);
account.deposit(5);
for(int i=0; i<account.transactions.size(); i++){
System.out.println(account.transactions.get(i));
}
}
}
第5章 实验五
5.1 ArrayIndexOutBoundException异常
5.1.1 要求
v 创建一个满足下列要求的程序：
v 创建一个由20个随机整数构成的数组。
v 提示用户输入数组的下标，然后显示对应的元素值。
v 如果指定的下标越界，就显示消息out of bounds
5.1.2 代码
//Main.java
package Main;
import java.util.Scanner;
publicclass Main {
publicstaticintnumber[] = newint[20];
publicstaticvoid main(String[] args) {
// TODO Auto-generated method stub
for (int i =0 ; i<20; i++){
number[i] = (int)Math.random();
}
@SuppressWarnings("resource")
Scanner reader = new Scanner(System.in);
int n;
while(true){
try{
n = reader.nextInt();
System.out.println(n + '\t' + number[n]);
}catch(Exception e){
System.out.println("数组越界");
}
}
}
}
5.2 修改实验三的Account类
5.2.1 要求
v 如果创建Account对象时，账户余额或利率小于或等于0，则抛出IllegalArgumentException异常。
v 创建一个IllegalWithDrawException类，如果withDraw方法中，取款金额超过账户余额，则抛出IllegalWithDrawException异常
v 编写测试程序
5.2.2 代码
//IllegalArgumentException.java
package Account;
@SuppressWarnings("serial")
publicclass IllegalArgumentException extends Exception {
String message;
public IllegalArgumentException(){
message = "年利率小于或等于0";
}
public String warnMess(){
return message;
}
}
//IllegalWithDrawException.java
package Account;
@SuppressWarnings("serial")
publicclass IllegalWithDrawException extends Exception {
String message;
public IllegalWithDrawException(double m, double n){
message = "取出金额" + m + "超出账户余额" + "n" + "\n";
}
public String warnMess(){
return message;
}
}
5.3 定义带三条边的Triangle类
5.3.1 要求
v Triangle类扩展自GeometricObject类。在三角形中，任意两边之和总大于第三边，Triangle类必须遵从这一规则。创建一个IllegalTriangleException类，如果创建的三角形的边违反了这一规则，抛出一个IllegalTriangleException对象。
v 编写测试程序
5.3.2 代码
//IllegalTriangleException.java
package Geometricobject;
@SuppressWarnings("serial")
publicclass IllegalTriangleException extends Exception {
String message;
public IllegalTriangleException(){
message = "三角形变长不合法";
}
public String warnMess(){
return message;
}
}
//Trianle.java
package Geometricobject;
publicclass Triangle extends Geometricobject{
privatedouble side1 = 1.0;
privatedouble side2 = 1.0;
privatedouble side3 = 1.0;
public Triangle(){}
privateboolean check(){
if( side1 + side2 < side3 || side1 + side3 < side2 || side3 + side2 < side1){
returnfalse;
}else{
returntrue;
}
}
public Triangle(double side1, double side2, double side3){
try{
this.side1 = side1;
this.side2 = side2;
this.side3 = side3;
if(!check())
thrownew IllegalTriangleException();
}catch(IllegalTriangleException e){
System.out.println(e.warnMess());
}
}
publicdouble getSide1() {
return side1;
}
publicdouble getSide2() {
return side2;
}
publicdouble getSide3() {
return side3;
}
publicdouble getArea(){
return (this.side1 + this.side2 + this.side3)/2;
}
publicdouble getPerimeter(){
returnthis.side1 + this.side2 + this.side3;
}
};
第6章 实验六
6.1 检测回文串
6.1.1 要求
v 如果一个字符串从前向后读和从后向前读都是同一个字符串，则称为回文串。
v 例如：“mom”和“dad”都是回文串
v 编写一个程序，提示用户输入一个字符串，忽略该字符串中的非字母和非数字字符，然后判断是否是回文串。
v 可使用Character类的静态方法
isLetterOrDigit(char ch)来判断字符类型。
6.1.2 代码
//Main.java
package Main;
import java.util.Scanner;
publicclass Main {
publicstaticvoid main(String[] args) {
String string;
@SuppressWarnings("resource")
Scanner reader = new Scanner(System.in);
string = reader.nextLine();
int size = string.length();
int n = size/2 ;
int i;
for(i = 0; i <= n; i++){
if(string.charAt(i) != string.charAt(size - 1 - i)){
break;
}
}
if(i != n+1){
System.out.println("wrong");
}else{
System.out.println("right");
}
}
}
6.2 检验密码
6.2.1 要求
v 一些网站设定了一些制定密码的规则。编写一个方法，检验一个字符串是否是合法的密码。假设密码规则如下：
? 密码必须至少有8个字符
? 密码只能包括字母和数字
? 密码必须至少有2个数字
v 编写一个程序，提示用户输入密码，并判断是否是合法的密码。
6.2.2 代码
//Main.java
package Main;
import java.util.Scanner;
publicclass Main {
publicstaticvoid main(String[] args) {
// TODO Auto-generated method stub
String regex = "^(\\w*[0-9]\\w*[0-9]\\w*)$";
@SuppressWarnings("resource")
Scanner reader = new Scanner(System.in);
String string = reader.nextLine();
if(string.matches(regex) && string.length() >= 8){
System.out.println("ok");
}else{
System.out.println("wrong");
}
}
}
6.3 在字符串中每个数字出现的次数
6.3.1 要求
v 使用下面的方法头编写一个方法，统计每个数字在字符串中出现的次数：
public static int[] count(String s)
v 这个方法统计每个数字在字符串中出现的次数。返回值是一个10个元素的数组，每个元素存储的是一个数字出现的次数。
v 例如：执行完 int[] counts = count(“0112ab”);后，counts[0] = 1, counts[1] = 2, counts[2] = 1
6.3.2 代码
//Main.java
package Main;
publicclass Main {
publicstaticvoid main(String[] args) {
// TODO Auto-generated method stub
}
publicstaticint[] count(String s){
int counts[] = newint[10];
int size = s.length();
for(int i=0; i<10; i++){
counts[i] = 0;
}
int temp;
for(int i=0; i<size; i++){
temp = (int)(s.charAt(i) - '0');
if(temp>=0 && temp <= 9){
counts[temp]++;
}
}
return counts;
}
}
6.4 刽子手游戏
6.4.1 要求
v 随机产生一个单词，单词中的字母都以星号显示。然后提示用户一次猜测一个字母，当用户才猜测准确时，就显示实际的字母。当用户完成了一个单词，就显示猜错的次数，然后询问用户是否继续猜测另一个单词。
v 声明一个数组来存储这些单词，例如：
String[] words = {“program”,”hello”,…….};
6.4.2 代码
//Main.java
package Main;
import java.util.Scanner;
publicclass Main {
static String[] words = {"program","hello","you", "he", "I"};
static String replace(String str, char n, int index){
if(index > str.length() - 1){
thrownew ArrayIndexOutOfBoundsException("越界");
}
String pre = str.substring(0, index);
String sub = str.substring(index + 1);
return pre + n + sub;
}
staticboolean unknown(String s){
for(int i=0; i<s.length(); i++){
if(s.charAt(i) == '*'){
returntrue;
}
}
returnfalse;
}
static String update(String key, String answer, char n){
for(int i=0; i<answer.length(); i++){
if(answer.charAt(i) == n){
key = replace(key, n, i);
}
}
return key;
}
publicstaticvoid main(String[] args) {
// TODO Auto-generated method stub
@SuppressWarnings("resource")
Scanner reader = new Scanner(System.in);
String answer = words[((int)Math.random())%words.length];
String key = "";
String in;
int size = answer.length();
for(int i=0; i<size; i++){
key += '*';
}
while(unknown(key)){
System.out.println(key);
in = reader.next();
key = update(key, answer, in.charAt(0));
}
System.out.println(key);
}
}
第7章 实验七
7.1在实验四Account类的基础上做如下修改
7.1.1 要求
v 打印账户清单时，显示用户名字，开户日期（格式为年-月-日，例如20##-11-19），利率（格式化为百分数），余额（格式化为货币值，例如：1,234,567￥）和所有交易。
v 增加balanceInterest方法，计算当前存款的利息(按存款存入的天数计算，如果有多笔存款，发生取款交易时，按存入顺序取款)
7.1.2 代码
publicdouble balanceInterest(){
double sum = 0;
ArrayList<Double> s = new ArrayList<Double>();
double temp = 0;
double amount;
for(int j=0; j<transactions.size(); j++){
for(int k=1; k<s.size(); k++){
sum += s.get(j) * getAnnualInterestRate() * (transactions.get(j).getDate().getYear() + - transactions.get(j-1).getDate().getYear());
}
if(transactions.get(j).getDescription().compareTo("存钱") == 0){
s.add(transactions.get(j).getAmount());
}elseif(transactions.get(j).getDescription().compareTo("取钱") == 0){
amount = transactions.get(j).getAmount();
int i=0;
while(amount > 0 ){
temp = s.get(i);
temp -= amount;
if(temp < 0){
temp = 0;
amount -= s.get(i);
}else{
temp -= amount;
}
s.set(i, temp);
}
}
}
return sum;
}
第8章 实验八
8.1 4个小伙伴唱歌
8.1.1 要求
v 编写代码模拟他们唱歌的全过程，要求如下：
v （1）话筒只有一个，大家轮流随机唱 ~
v （2）每个人都可以不被打断地唱三句歌词：1、我是x（x=1,2,3,4）；2、我最喜欢唱歌；3、大家都爱听我唱歌！
v （3）每个人都只能唱10次，次数到了，就只有旁观了~
8.1.2 代码
//Tool
package Tools;
publicclass Tool implements Runnable{
privateint friend[];
public Tool(){
friend = newint[5];
friend[1] = 0;
friend[2] = 0;
friend[3] = 0;
friend[4] = 0;
}
publicvoid run(){
int singer = Thread.currentThread().getName().charAt(0) - '0';
int temp = friend[singer];
while(true){
if(temp < 10){
sing(temp);
temp ++;
try{
Thread.sleep(1);
}catch(InterruptedException e){
}
}else{
return;
}
friend[singer] = temp;
}
}
publicsynchronizedvoid sing(int temp){
System.out.print("我是" + Thread.currentThread().getName() + ",");
System.out.print("我最喜欢唱歌,");
System.out.print("大家都爱听我唱歌.");
System.out.print(temp + 1 + "\n");
}
}
//Main.java
package Main;
import Tools.*;
publicclass Main {
publicstaticvoid main(String[] args) {
// TODO Auto-generated method stub
Tool tool = new Tool();
Thread f1 = new Thread(tool);
Thread f2 = new Thread(tool);
Thread f3 = new Thread(tool);
Thread f4 = new Thread(tool);
f1.setName("1");
f2.setName("2");
f3.setName("3");
f4.setName("4");
f1.start();
f2.start();
f3.start();
f4.start();
}
}
8.2说悄悄话的一对情侣
8.2.1 要求
v 一对情侣要说悄悄话，他们不希望被人听到，要求如下：
v （1）轮流让情侣说话，可以分为男方和女方，悄悄话是用户的输入字符串
v （2）女方能听懂男方的每句话，同时女方的每一句话都进行了加密，加密方式：倒着说：例如把"我爱你"加密成"你爱我"，"abc"加密为"cba"
v （3）男方能够翻译女方的每一句话，同时男方的每一句话也被进行了加密，加密方式是：对每一句话都根据加密密码“无敌小情侣"进行加密！
8.2.2 代码
//Message.java
package Runnable;
import java.util.Scanner;
publicclass Message implements Runnable{
public Message(){
t = "Girl";
}
private String t;
privatechar[] key = "FFF".toCharArray();
publicvoid run(){
while(true){
String speaker = Thread.currentThread().getName();
if(speaker.compareTo(t) == 0){
speak(t);
}else{
try {
Thread.sleep(1);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
publicsynchronizedvoid speak(String speaker){
Scanner s = new Scanner(System.in);
String temp = s.nextLine();
if(speaker.compareTo("Girl") == 0){
System.out.print("Gril:\t");
for(int i=temp.length() - 1; i >=0; i--){
System.out.print(temp.charAt(i));
}
System.out.print("\n");
this.t = "Boy";
}
elseif(speaker.compareTo("Boy") == 0){
System.out.print("Boy:\t");
char [] c = temp.toCharArray();
int k = key.length;
int n = c.length;
for(int i=0; i < n; i++){
int mima = c[i] + key[i%k];
c[i] = (char) mima;
System.out.println(c[i]);
}
System.out.print("\n");
this.t = "Girl";
}
}
}
//Main.java
package Main;
import Runnable.Message;
publicclass Main {
publicstaticvoid main(String[] args) {
Message m = new Message();
Thread g = new Thread(m);
Thread b = new Thread(m);
g.setName("Girl");
b.setName("Boy");
g.start();
b.start();
}
}
