java课后习题
发布时间：2014-02-28 16:21:50
8.7 设计一个名为Account类，它包括：
一个名为id的int类型私有帐户数据域（默认值0）。
一个名为balance的double类型私有帐户数据域（默认值0）。
一个名为annualInterestRate的double类型私有数据域存储当前利率（默认值0）。假设所以的帐户都有相同的利率。
一个名为dateCreated的Date类型私有数据域存储帐户的开户日期。
一个能创建默认帐户的无参构造方法。
一个能创建带特定id和初始余额的帐户的构造方法。
Id balance annualInterstRate的访问器和修改器。
dateCreated的访问器。一个名为getMonthlyInterestRate()的方法返回月利率。
一个名为withDraw的方法从帐户提取特定数额。
一个名deposit的方法向帐户存储特定的数额。
画出该类的UML图。实现这个类。编写一个测试程序，创建一个帐户ID为1122，余额为20000美元，年利率为4.5%的Account对象。使用withdraw方法取款2500美元，使用deposit方法存款3000美元，然后打印余额，月利息以及这个帐户的开户日期。
源程序：
public class Account {
private int id; //账户号码
private double balance; //账户余额
private double annualInterestRate; //当前利率
private java.util.Date dateCreated = new java.util.Date(); //开户日期
public Account()
{
this.id = 0;
this.balance = 0;
this.annualInterestRate = 0;
}
public Account(int id,int balance)
{
this.id = id;
this.balance =balance;
}
public int getId()
{
return this.id;
}
public void steId(int id)
{
this.id = id;
}
public double getBalance()
{
return this.balance;
}
public void setBalance(double balance)
{
this.balance = balance;
}
public double getannualInterestRate()
{
return this.annualInterestRate;
}
public void setAnnualInterestRate(double annualInterestRate)
{
this.annualInterestRate = annualInterestRate;
}
public java.util.Date getDateCreated()
{
return this.dateCreated;
}
public double getMonthlyInterestRate()
{
return this.annualInterestRate/12;
}
public double withDraw(double count)
{
this.balance -= count;
return this.balance;
}
public double deposit(double count)
{
this.balance += count;
return this.balance;
}
public static void main(String[] args)
{
Account account = new Account(1122,20000);
account.setAnnualInterestRate(0.045);
account.withDraw(2500);
account.deposit(3000);
System.out.println("余额："+account.getBalance());
System.out.println("月利息："
+account.getMonthlyInterestRate()*account.getBalance());
System.out.println("开户日期："+account.getDateCreated().toString());
}
}
运行结果：
余额：20500.0
月利息：76.875
开户日期：Mon Apr 16 20:54:13 CST 2012
8.8 设计一个名为Fan的类来表示一个风扇。这个类包括：
三个名为SLOW、MEDIUM和FAST而值是1、2和3的常量表示风扇的速度。
一个名为speed的int类型私有数据域表示风扇的速度（默认值SLOW）。
一个人名为on的boolean类型私有数据域表示风扇是否打开（默认值为false）。
一个名为radius的double类型私有数据域表示风扇的半径（默认值5）。
一个名为color的string类型数据域表示风扇的颜色（默认值为blue）。
这四个数据域的访问器和修改器。
一个创建默认风扇的无参构造方法。
一个名为toString()方法返回描述风扇的字符串。如果风扇是打开的，那么该方法在一个组合的字符串中返回风扇的速度、颜色和半径。如果风扇没有打开，该方法就会返回一个由“fan is off”和风扇颜色及半径组合成的字符串。
画出该类的UML图。实现这个类。编写一个测试程序，创建两个Fan对象。将第一个对象设置为最大速度、半径10、颜色为yellow、状态为打开。将第二个对象设置为中等速度、半径为5、颜色为blue、状态为关闭。通过调用它们的toSrting方法显示这些对象。
源程序：
public class Fan {
final static int SLOW = 1;
final static int MEDIUM = 2;
final static int FAST = 3;
private int speed = SLOW;
private boolean on = false;
private double radius = 5;
private String color = "blue";
public int getSpeed() {
return speed;
}
public void setSpeed(int speed) {
this.speed = speed;
}
public boolean isOn() {
return on;
}
public void setOn(boolean on) {
this.on = on;
}
public double getRadius() {
return radius;
}
public void setRadius(double radius) {
this.radius = radius;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public Fan()
{
}
public String toString()
{
if(on==true)
return "风扇速度："+this.getSpeed()+"\n"
+"风扇半径："+this.getRadius()+"\n"
+"风扇颜色："+this.getColor()+"\n";
else
return "fan is off"+"\n"+"风扇半径："+this.getRadius()+"\n"
+"风扇颜色："+this.getColor()+"\n";
}
public static void main(String[] args)
{
Fan fan = new Fan();
fan.setColor("yello");
fan.setRadius(10.0);
fan.setSpeed(FAST);
fan.setOn(true);
Fan fan1 = new Fan();
fan1.setColor("bule");
fan1.setOn(false);
fan1.setRadius(5.0);
System.out.println(fan.toString());
System.out.println(fan1.toString());
}
}
运行结果：
风扇速度：3
风扇半径：10.0
风扇颜色：yello
fan is off
风扇半径：5.0
风扇颜色：bule
8.9 在一个正n边形中，所以边的长度都相同，且所有角的度数都相同（即这个多边形是等边等角的）。设计一个名为RegularPolygon的类，该类包括：
一个名为int型的私有数据域定义多边形的边数，默认值3。
一个名为side的double型私有数据域存储边的长度，默认值1。
一个名为x的double型私有数据域，它定义多边形中点的x坐标，默认值0。
一个名为y的double型私有数据域，它定义多边形中点的y坐标，默认值0。
一个创建带默认值的正多边形的无参构造方法。
一个能创建带指定边数和边长度、中心在（0,0）的正多边形的构造方法。
一个能创建带指定边数和边长度、中心在（x,y）的正多边形的构造方法。
所有数据域的访问器和修改器。
一个返回多边形周长的方法getPerimeter（）。
一个返回多边形面积的方法getArea().计算多边形面积的公式是：
面积=(n*s*s)/(4*tan(p/n))
画出该类的UML图。实现这个类。编写一个测试程序，分别使用无参构造方法、RegularPolygon（6,4）和RegularPolygon（10,4,5.6,7.8）创建三个RegularPolygon对象。显示每个对象的周长和面积。
源程序：
public class RegularPolygon {
private int n = 3;
private double side = 1;
private double x = 0;
private double y = 0;
public RegularPolygon()
{
}
public RegularPolygon(int n,double side)
{
this.n = n;
this.side = side;
}
public RegularPolygon(int n,double side,double x,double y)
{
this(n,side);
this.x = x;
this.y = y;
}
public int getN() {
return n;
}
public void setN(int n) {
this.n = n;
}
public double getSide() {
return side;
}
public void setSide(double side) {
this.side = side;
}
public double getX() {
return x;
}
public void setX(double x) {
this.x = x;
}
public double getY() {
return y;
}
public void setY(double y) {
this.y = y;
}
public double getPerimeter()
{
return n*side;
}
public double getArea()
{
return ((n*side*side)/(4*Math.tan(Math.PI/n)));
}
public static void main(String[] args) {
RegularPolygon reg1 = new RegularPolygon();
System.out.println("reg1的周长为："+reg1.getPerimeter()+" "+
"reg1的面积为："+reg1.getArea());
RegularPolygon reg2 = new RegularPolygon(6,4);
System.out.println("reg1的周长为："+reg2.getPerimeter()+
" "+"reg2的面积为："+reg2.getArea());
RegularPolygon reg3 = new RegularPolygon(10,4,5.6,7.8);
System.out.println("reg3的周长为："+reg3.getPerimeter()+
" "+"reg3的面积为："+reg3.getArea());
}
}
运行结果：
reg1的周长为：3.0 reg1的面积为：0.43301270189221946
reg1的周长为：24.0 reg2的面积为：41.569219381653056
reg3的周长为：40.0 reg3的面积为：123.10734148701015
8.11为二次方程式ax2+bx+c=0设计一个名为QuadraticEquation的类。
这个类包括：
代表三个系数的私有数据域a、b、c。
一个参数为a、b和c的构造方法。
a、b、c的三个get方法。
一个名为getDiscriminant（）的方法返回判别式，b2-4ac。
一个名为getRoot1()和getRoot2()的方法返回登时的两个根：
r1=(-b+sqr(b2-4ac))/2a and r2=(-b-sqr(b2-4ac))/2a
这些方法只有在判别式为非负数时才有用。如果判别式为负，这些方法返回0.
画出该类的UML图。实现这个类。编写一个测试程序，提示用户输入a、b和c的值，然后显示判别式的结果。如果判别式为正数，显示俩个根；如果判别式为0，显示一个根；否则，显示“The equation has no roots.”（这个方程无根）。参见练习题的3.1运行示例。
源程序：
import java.util.Scanner;
public class QuadraticEquation {
private double a;
private double b;
private double c;
public QuadraticEquation(double a,double b,double c)
{
this.a = a;
this.b = b;
this.c = c;
}
public double getA() {
return a;
}
public double getB() {
return b;
}
public double getC() {
return c;
}
public double getDiscriminant()
{
return (b*b-4*a*c);
}
public double getRoot1()
{
if(this.getDiscriminant()>=0)
return ((-b+Math.pow(this.getDiscriminant(), 0.5))/(2*a));
else
return 0;
}
public double getRoot2()
{
if(this.getDiscriminant()>=0)
return ((-b-Math.pow(this.getDiscriminant(), 0.5))/(2*a));
else
return 0;
}
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
double x,y,z;
x = input.nextDouble();
y = input.nextDouble();
z = input.nextDouble();
QuadraticEquation qua = new QuadraticEquation(x,y,z);
System.out.println("该方程的两个根分别为："+qua.getRoot1()+
" "+qua.getRoot2());
}
}
运行结果：
1 -2 1
该方程的两个根分别为：1.0 1.0
9.3 （检验密码）一些网站设定了一些制定密码的规则。编写一个方法，检验一个字符串是否是合法的密码。假设密码规则如下：
1、 密码必须至少有8个字符
2、 密码职能包括字母和数字
3、 密码必须至少有2个数字
编写一个程序，提示用户输入密码，如果该密码符合规则就显示“Valid Password”，否则显示“Invilid Password”。
源程序：
import java.util.Scanner;
public class TestPassword {
public static int numbersOfcount(String s1)
{
int count = 0;
for(int i=0;i
{
if(Character.isDigit(s1.charAt(i)))
count++;
}
return count;
}
public static boolean testword(String s2)
{
boolean b = false;
for(int i=0;i
{
if(Character.isDigit(s2.charAt(i))||
Character.isLetter(s2.charAt(i)))
b = true;
else
b = false;
}
return b;
}
public static void testPassword(String s)
{
if(numbersOfcount(s)>=2&&s.length()>=8&&testword(s))
System.out.println("Valid Password!");
else
System.out.println("Invalid Password!");
}
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.println("Enter your password" +
"(including words and numbers)");
String password = input.nextLine();
testPassword(password);
}
}
运行结果：
Enter your password(including words and numbers)
12abcddde
Valid Password!
Enter your password(including words and numbers)
12332123
Valid Password!
9.5 使用下面的方法头编写一个方法，统计每个数字在字符串中出现的次数：
public static void main(String[] args)
这个方法统计每个数字在字符串中出现的次数。返回值是10个元素构成的数组，每个元素存储的是一个数字出现的的次数。例如，在执行完int[] count(“12203AB3”)之后，count[0]为1，count[1]为1，count[2]为2，count[3]为2.
编写一个测试程序，提示用户输入一个字符串，然后显示每个数字在字符串中出现的次数。
源程序：
import java.util.Scanner;
public class TestNumbersOfCount {
public static int[] count(String s)
{
int []count = new int[10];
for(int i=0;i
{
if(Character.isDigit(s.charAt(i)))
count[s.charAt(i)-'0']++;
}
return count;
}
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.println("Enter a String:");
String s1 = input.nextLine();
int []count = new int[10];
count = count(s1);
for(int i=0;i
System.out.print("count["+i+"]= "+count[i]+" ");
}
}
运行结果：
Enter a String:
19921202abc
count[0]= 1 count[1]= 2 count[2]= 3 count[3]= 0 count[4]= 0 count[5]= 0 count[6]= 0 count[7]= 0 count[8]= 0 count[9]= 2
9.12 编写一个方法，检测两个单词是否互为变位词。如果在不记顺序的情况下两个单词包含完全相同的字母，则称这两个单词互为变位词（anagram）。例如，“silent”和“listen”互为变位词。该方法的方法头如下所示：
Public static boolean isAnagram（String s1，String s2）
编写一个测试程序，提示用户输入两个字符串，如果它们是变位词，则显示“anagram”，否则显示“not anagram”。
源程序：
import java.util.*;
public class TestAnagram {
public static boolean isAnagram(String s1,String s2)
{
boolean b =true;
char[] ch = s1.toChar();
char[] ch1 = s2.toChar();
if(ch.length==ch1.length)
{
for(int i=0;i
{
for(int j=0;j
if(ch[i]!=ch[j]) b = false;
}
}
return b;
}
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.println("Enter a word");
String str1 = input.next();
String str2 = input.next();
System.out.println(isAnagram(str1,str2));
}
}
运行结果：
please input one word:
silent
please input the other word:
islten
Anagram
补充题：用一个数组存储不同的对象
源程序：
public class Tests {
public static void main(String[] args) {
s []arrays = new s[10];
for(int i=0;i
{
switch(i%4){
case 0:
arrays[i] = new Rengtange();
break;
case 1:
arrays[i] = new Circle();
break;
case 2:
arrays[i] = new MyDouble();
break;
case 3:
arrays[i] = new MyIntenger();
break;
}
}
for(int i=0;i
arrays[i].shape();
}
}
abstract class s{
public abstract void shape();
}
class Rengtange extends s{
public void shape()
{
System.out.println("这是一个矩形。");
}
}
class Circle extends s{
public void shape()
{
System.out.println("这是一个圆。");
}
}
class MyDouble extends s{
public void shape()
{
System.out.println("这是一个双精度浮点数。");
}
}
class MyIntenger extends s{
public void shape()
{
System.out.println("这是一个整数。");
}
}
运行结果:
这是一个矩形。
这是一个圆。
这是一个双精度浮点数。
这是一个整数。
这是一个矩形。
这是一个圆。
这是一个双精度浮点数。
这是一个整数。
这是一个矩形。
这是一个圆。
9.14 （求整数的和）编写两个程序，第一个程序给main方法传入个数不定的整数，每个整数都是一个独立的字符串，然后显示它们的和。第二个程序给main方法传入个数不定的整数构成的同一字符串，数字之间被空格分隔，然后显示它们的和。
源程序：
import java.util.*;
public class Exerce9_14 {
public static int add(String s)
{
int sum = 0;
String [] ch = s.split(" ");
int[] a = new int[ch.length];
for(int i=0;i
{
a[i] = Integer.parseInt(ch[i]);
sum+=a[i];
}
return sum;
}
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.println("输入一串数字（以空格隔开）：");
String str1 = input.nextLine();
System.out.println(add(str1));
}
}
运行结果：
输入一串数字（以空格隔开）：
1 2 3
The total is:6
源程序：
public class Exercise9_14b {
public static void main(String[] args) {
int sum = 0;
if (args[0] == null)
System.out.println("请传个main方法一个参数！");
else{
String [] s = args[0].split(" ");
for (int i = 0; i < s.length; i++){
int[] count = new int[s.length];
count[i]=Integer.parseInt(s[i]);
sum += count[i];
}
}
System.out.println("the total is :"+sum);
}
}
运行结果：
Exercise9_14b
" 1 2 3 4 5"
The total is 15
11.1设计一个名为Triangle的类来扩展GeometricObject类。该类包括：
1) 三个名为side1、side2和side3的double数据域表示这个三角形的三条边，它们的默认值是1.0。
2) 一个无参构造方法创建默认的三角形。
3) 一个能创建带指定side1、side2、和side3的三角形构造方法。
4) 一个名为getArea（）的方法返回这个三角形的面积。
5) 一个名为getPerimeter（）的方法返回这个三角形的周长。
6) 一个名为toString（）的方法返回这个三角形的字符串描述。
计算三角形的面积的公式为：
![](https://wkrtcs.bdimg.com/rtcs/image?w=235.8&md5sum=5cad61a1a42ba154d4fb2556a6a157d2&sign=7d7502bb54&rtcs_flag=1&rtcs_ver=3.1&l=webapp&bucketNum=41&ipr={"t":"img","w":"235.8","h":"21.533333333333","dataType":"gif","c":"word/media/image1.png"})
![](https://wkrtcs.bdimg.com/rtcs/image?w=333.33333333333&md5sum=5cad61a1a42ba154d4fb2556a6a157d2&sign=7d7502bb54&rtcs_flag=1&rtcs_ver=3.1&l=webapp&bucketNum=41&ipr={"t":"img","w":"333.33333333333","h":"26.866666666667","dataType":"gif","c":"word/media/image2.png"})
toString（）方法的实现如下所示：
return“Triangle:side1=”+side1+“ side2=”+side2+“ side3=”+side3；
实现这个类。编写一个测试，创建边长为1,1.5,1，颜色为yellow，filled为true的Triangle对象，然后显示他的面积、周长、颜色以及是否被填充。
源程序：
import java.util.Date;
class GeometricObject{
private String color = "white";
private boolean filled;
private java.util.Date dataCreated;
public GeometricObject()
{
dataCreated = new java.util.Date();
}
public GeometricObject(String color,boolean filled)
{
dataCreated = new java.util.Date();
this.color = color;
this.filled = filled;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public boolean isFilled() {
return filled;
}
public void setFilled(boolean filled) {
this.filled = filled;
}
public java.util.Date getDataCreated() {
return dataCreated;
}
public String toString()
{
return "created on"+dataCreated+"\ncolor:"+color+
"and filled:"+filled;
}
}
class Triangle extends GeometricObject{
private double side1 = 1.0,side2 = 1.0,side3 = 1.0;
public Triangle()
{
}
public Triangle(double side1,double side2,double side3,String color,boolean filled)
{
super.setColor(color);
super.setFilled(filled);
this.side1 = side1;
this.side2 = side2;
this.side3 = side3;
}
public double getSide1() {
return side1;
}
public double getSide2() {
return side2;
}
public double getSide3() {
return side3;
}
public double getArea()
{
return Math.pow(this.getPerimimeter()*(this.getPerimimeter()-this.side1)*(this.getPerimimeter()-this.side2)*(this.getPerimimeter()-this.side3), 0.5);
}
public double getPerimimeter()
{
return side1+side2+side3;
}
public String toString()
{
return "Triangle:side1="+side1+"side2="+side2+"side3="+side3;
}
}
public class TestTriangle {
public static void main(String[] args) {
Triangle tri = new Triangle(1,1.5,1,"yellow",true);
System.out.println("周长为："+tri.getPerimimeter());
System.out.println("面积为："+tri.getArea());
System.out.println("颜色为："+tri.getColor());
System.out.println("是否被填充？"+tri.isFilled());
}
}
运行结果：
周长为：3.5
面积为：6.614378277661476
颜色为：yellow
是否被填充？true
11.2 设计一个名为Person的类和它的两个名为Student和Employee子类。Employee又有子类：教员Faculty和职员类Staff。每个人都有姓名、地址、电话号码和电子邮件地址。学生有班级状态（大一、大二、大三和大四）。将这些状态定义为常量。一个雇员有办公室、工资、和受聘日期。定义一个MyDate的类，包含数据域year、month、day。教员有办公时间和级别。职员有职务称号。覆盖每个类中的toString方法，显示相应的类名和人名。
实现这些类。编写一个测试程序，创建Person、Student、Employee、Faculty和Staff，并调用他们的toString方法。
源程序：
public class TestPerson {
public static void main(String[] args) {
Person person = new Person("张三","坞城路1号","133********","123@22.com");
Student stu = new Student("李四", "坞城路2号", "12344332234", "122@qq.com",Student.FIRST);
Employee emp = new Employee("王五", "坞城路3号", "1234562234","办公楼1号","102@qq.com", 4000, new MyData(2012,12,2));
Faculty fac = new Faculty(5000, "赵六", "坞城路4号", "1234562934", "102@qq.com", new MyData(2012,1,2),"教授");
Staff sta = new Staff("张七", "坞城路4号", "1234562934", "102@qq.com", "办公楼2号",3000, new MyData(2012,1,2), "标兵");
System.out.println("类名："+person.getClass().getName()+" "+person.tostring());
System.out.println("类名："+stu.getClass().getName()+" "+stu.tostring());
System.out.println("类名："+emp.getClass().getName()+" "+emp.tostring());
System.out.println("类名："+fac.getClass().getName()+" "+fac.tostring());
System.out.println("类名："+sta.getClass().getName()+" "+sta.tostring());
}
}
class Person{
private String name,address,telephone,email;
public Person(String name,String address,String telephone,String email)
{
this.name = name;
this.address = address;
this.telephone = telephone;
this.email = email;
}
public String getName() {
return name;
}
public String getAddress() {
return address;
}
public String getTelephone() {
return telephone;
}
public String getEmail() {
return email;
}
public String tostring()
{
return "人名："+this.getName();
}
}
class Student extends Person{
private String grade;
final static String FIRST = "fisherman";
final static String SECOND = "sophmore";
final static String THIRD = "senior";
final static String FOURTH = "junior";
public Student(String name, String address,
String telephone, String email,String grade) {
super(name, address, telephone, email);
this.grade = grade;
}
public String tostring()
{
return "人名："+this.getName();
}
}
class Employee extends Person{
private String officer;
protected double salarity;
private MyData data;
public String getOfficer() {
return officer;
}
public double getSalarity() {
return salarity;
}
public MyData getData() {
return data;
}
public Employee(String name, String address, String telephone,
String email,String officer,double salarity,MyData data) {
super(name, address, telephone, email);
this.officer = officer;
this.salarity = salarity;
this.data = data;
}
public String tostring()
{
return "人名："+this.getName();
}
}
class Faculty extends Employee{
private MyData data1;
private String level;
public Faculty(double salarity,String name, String address,
String telephone, String email,MyData data1,String level) {
super(name, address, telephone, email, level, salarity, data1);
this.level = level;
}
public String tostring()
{
return "人名："+this.getName();
}
}
class Staff extends Employee{
private String call;
public Staff(String name, String address, String telephone,String email,String officer, double salarity, MyData data,String call) {
super(name, address, telephone, email, officer, salarity, data);
this.call = call;
}
public String tostring()
{
return "人名："+this.getName();
}
}
class MyData{
private int year;
private int month;
private int day;
public MyData(int year,int month,int day)
{
this.year = year;
this.month = month;
this.day = day;
}
}
运行结果：
类名：Student 人名：李四
类名：Employee 人名：王五
类名：Faculty 人名：赵六
类名：Staff 人名：张七
13.2 编写一个程序，提示用户读取两个整数，然后显示它们的和。程序应该在输入不正确时提示用户再次读取数字”Incorrect input and re-enter two integers:”。
源程序：
import java.util.InputMismatchException;
import java.util.Scanner;
public class TestAddException {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.println("Please Enter two Interger number:");
boolean flag = true;
do{
try
{
int a = input.nextInt();
int b = input.nextInt();
System.out.println("The result is "+(a+b));
flag = false;
}
catch(InputMismatchException ex)
{
System.out.println("Incorrect input and re-enter two integers:");
input.nextLine();
}
}while(flag);
}
}
运行结果：
Please Enter two Interger number:
1 1.2
Incorrect input and re-enter two integers:
1 3
The result is 4
13.5 （IllegalTriangleException异常）练习题11.1定义了带三条边的Triangle类。在三角形中，任意两边之和总大于第三边，三角形类Triangle必须遵从这一规则。创建一个IllegalTriangleException类，然后修改Triangle类的构造方法，如果创建的三角形的边违反了这一规则，抛出一个IllegalTriangleException对象，如下所示：
/**Construct a triangle with the specified sides*/
Public Triangle(double side1,double side2,double side3)
Throws IllegalTriangleException{
// Implement it
}
源程序：
class IlleagalTriangleException extends Exception{
private double s1,s2,s3;
public IlleagalTriangleException(double s1,double s2,double s3)
{
super("三边不合法：三角形任意两边之和应大于第三边。");
this.s1 = s2;
this.s2 = s2;
this.s3 = s3;
}
}
public class TriangleSideException{
private double side1,side2,side3;
public TriangleSideException(double side1,double side2,double side3) throws IlleagalTriangleException
{
if((side1+side2)>side3&&(side1+side3)>side2&&(side3+side2)>side1)
{
this.side1 = side1;
this.side2 = side2;
this.side3 = side3;
}
else
throw new IlleagalTriangleException(side1,side2,side3);
}
public String tostring()
{
return "三角形的三边为："+"side1:"+side1+" "+"side2:"+side2+" "+"side3:"+side3;
}
public static void main(String[] args) {
double ss1 = 1.5;
double ss2 = 0.1;
double ss3 = 1.2;
try{
TriangleSideException tri = new TriangleSideException(ss1,ss2,ss3);
System.out.println(tri.tostring());
}
catch(IlleagalTriangleException ex){
System.out.println(ex.toString());
}
}
}
运行结果：
IlleagalTriangleException: 三边不合法：三角形任意两边之和应大于第三边。
13.6 （IllegalTriangleException异常）程序清单9-2实现了hexToDecimal(String hexString)方法，它将一个十六进制字符串转换为一个十进制数。实现这个hexToDecimal方法，在字符串不是一个十六进制字符串时抛出NumberFormatException异常。
源程序：
import java.util.*;
public class HexToDecimalConversion {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.println("输入一个十六进制数：");
try{
String hex = input.nextLine();
System.out.println("这个十六进制数"+hex+"所对应的十进制数为："
+hexToDecimal(hex.toUpperCase()));
}
catch(NumberFormatException ex){
System.out.println(ex.toString());
}
}
public static int hexToDecimal(String hex)
throws NumberFormatException
{
int decimalValue = 0;
for(int i=0;i
char hexChar = hex.charAt(i);
if((hexChar>='A'&&hexChar<='F')||(hexChar>='a'&&hexChar<='9')
||(hexChar>='0'&&hexChar<='9')){
decimalValue = decimalValue *16+hexCharToDecimal(hexChar);
}
else
throw new NumberFormatException("输入必为数字0~9或者字母a~f" +"(不分大小写)。");
}
return decimalValue;
}
public static int hexCharToDecimal(char ch)
{
if(ch>='A'&&ch<='F')
return 10+ch-'A';
else
return ch-'0';
}
}
运行结果：
输入一个十六进制数：
1a3b
这个十六进制数1a3b所对应的十进制数为：6715
相关推荐
愚公移山新编作文
计算机专业毕业生自荐信
煤炭运销部职能职责
张伯行观后感 - 心得体会
优质物业服务到底包含哪些服务项目和标准
收入效应与替代效应
手卫生培训记录
深圳盐港中学2021初三化学中考最后一次模拟压题试题和答案
《正方体的认识》教学反思
周末时间计划表
