实验4 包与异常处理
一、实验目的
理解Java包机制的作用，掌握Java中的四种访问控制级别；理解异常处理机制，掌握Java异常处理的基本方法。
二、实验内容
1.程序理解：
1)包的定义和引入
在包Com.tsinghua.p1中定义了一个ClassA类，里面定义的四个不同修饰符的变量和方法，在方法中分别打印出对应修饰符变量的值。在该类的main()方法中尝试通过该类的实例对象调用了四个变量和四个方法。说明了四个修饰符号在同一个类中是可调用的。
package com.tsinghua.p1;
public class ClassA{
private String s_pri = "classA private str";
String s_fri = "classA friendly str";
protected String s_pro = "classA protected str";
public String s_pub = "classA public str";
private void printPriStr(){
System.out.println(" ClassA s_pri :"+this.s_pri);
}
void printFriStr(){
System.out.println(" ClassA s_fri :"+this.s_fri);
}
protected void printProStr(){
System.out.println(" ClassA s_pro :"+this.s_pro);
}
public void printPubStr(){
System.out.println(" ClassA s_pub :"+this.s_pub);
}
public static void main(String[] args){
ClassA a = new ClassA();
a.printPriStr();
a.printFriStr();
a.printProStr();
a.printPubStr();
System.out.println(a.s_pri);
System.out.println(a.s_fri);
System.out.println(a.s_pro);
System.out.println(a.s_pub);
}
}
在同一个包中继承ClassA类创建子类ClassBA，然后实例了该类的一个对象，然后调用了父类中的方法和变量。私有变量和私有方法都不能在继承类中使用，不论是同类中的还是非同类中的。
package com.tsinghua.p1;
public class ClassBA extends ClassA{
public static void main(String[] args){
ClassBA ba = new ClassBA();
ba.printFriStr();
ba.printProStr();
ba.printPubStr();
//私有变量不能访问
// System.out.println(ba.s_pri);
System.out.println(ba.s_fri);
System.out.println(ba.s_pro);
System.out.println(ba.s_pub);
ClassA a = new ClassA();
//私有方法不能调用
// a.printPriStr();
a.printFriStr();
a.printProStr();
a.printPubStr();
//私有变量不能访问
// System.out.println(a.s_pri);
System.out.println(a.s_fri);
System.out.println(a.s_pro);
System.out.println(a.s_pub);
}
}
在同一个包中创建一个新的类，然后在新类中实例化一个ClassA的对象，然后尝试调用ClassA中定义的变量和方法。
注意：除了私有变量和私有方法外，其他的在同一个包中的不同类中都可以调用。
package com.tsinghua.p1;
public class ClassB {
public static void main(String[] args){
ClassA a = new ClassA();
// a.printPriStr(); 私有变量不可调用
a.printProStr();
a.printFriStr();
a.printPubStr();
// System.out.println(a.s_pri); 私有方法不可调用
System.out.println(a.s_pro);
System.out.println(a.s_fri);
System.out.println(a.s_pub);
}
}
在另一个包Com.tsinghua.p2中创建一个新的类ClassCA并继承ClassA，然后在该类中实例化该类的一个对象，然后调用父类中的变量和方法。
注意：
不同包中的子类，只能调用父类中protected和public定义的方法或变量。
package com.tsinghua.p2;
import com.tsinghua.p1.ClassA; //引入com.tsinghua.p1包中的ClassA类。
public class ClassCA extends ClassA{
public static void main(String[] args){
ClassCA ca = new ClassCA();
// ca.printPriStr();
// ca.printFriStr();
ca.printProStr();
ca.printPubStr();
// System.out.println(ca.s_pri);
// System.out.println(ca.s_fri);
System.out.println(ca.s_pro);
System.out.println(ca.s_pub);
ClassA a = new ClassA();
// a.printPriStr();
// a.printProStr();
// a.printFriStr();
a.printPubStr();
// System.out.println(a.s_pri);
// System.out.println(a.s_pro);
// System.out.println(a.s_fri);
System.out.println(a.s_pub);
}
}
2）程序无法预见的异常必须进行异常处理（try-catch）
系统已定义异常类的处理：NumberFormatException
package com.tsinghua.p2;
import java.io.*;//通过数据流、序列化和文件系统提供系统输入和输出。
public class IntTransfer {
public static void main(String[] args) {
// 从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。
BufferedReader re = new BufferedReader(new InputStreamReader(System.in));
String str = "";
System.out.println("请输入整数字符串：");
while (true) {
try {
str = re.readLine();// 读取一个文本行。通过下列字符之一即可认为某行已终止：换行 (‘\n‘)、回车
// (‘\r‘) 或回车后直接跟着换行
int i = Integer.parseInt(str);// 将字符串参数作为有符号的十进制整数进行解析。
System.out.println("输入的整数为：" + i);
break;
} catch (NumberFormatException e) {// 当应用程序试图将字符串转换成一种数值类型，但该字符串不能转换为适当格式时，抛出该异常。
System.out.println("输入的整数格式不对，请重新输入：");
} catch (Exception e) {
e.printStackTrace();
}
}
}
}2.编程题
（1）1) 设计一个类，类成员和方法分别用public、private、protected以及“default”访问权限。在本类的main方法中创建属于这个类的一个对象，并观察在试图访问所有类成员时会获得哪种类型的编译器错误提示。（为什么？）设计一个新类，并在新类的main方法中创建属于这个类的一个对象，并观察在试图访问所有类成员时会获得哪种类型的编译器错误提示。（注意同一个目录内的类属于“默认”包的一部分）（为什么？）
2) 用protected数据成员创建一个类，在相同的文件里创建第二个类，用一个方法操纵第一个类里的protected权限的数据成员，观察能否操纵？
（2）写一个类MikeOne，包括一个方法：methodA()打印出类名,放入包mypack.one中，写一个类MikeTwo，包括一个方法：methodB()打印出类名,放入包mypack.two中。定义一个类Cmain,要求在其中可以访问到前面的两个类中的方法。（提示，导入所需包中的类后再访问，获取对象的类名，可以通过对象.getClass().getName()来实现）
（3）在实验3的复数类中增加一个构造方法，该构造方法有两个字符串类型的参数，分别为复数的实部和虚部赋值。在构造方法里先将字符串参数转换为浮点数再赋值给实部或虚部。当字符串的内容不能转化为浮点数时，抛出数值格式异常NumberFormatException。在main函数中处理该异常，并进行测试。
（提示：请参照程序理解的第2题来完成本程序；字符串转换为浮点数调用Double类提供的静态方法parseDouble，转换失败时会抛出数值格式异常NumberFormatException，在main函数中处理此异常）。
（4）自定义非法年龄类IllegalAgeException，定义一个Person类，包含年龄，姓名，性别等属性，编写属性设置和读取函数，在设置年龄函数中，判断参数是否符合要求（1~150），如果不符合则抛出异常，编写main函数进行测试。
三、实验结果和分析
(1)程序1运行结果
1）
分析：设计一个类，类成员和方法分别用public、private、protected以及“default”访问权限。在本类的main方法中创建属于这个类的一个对象，从结果可以看出，private，default，protected，public这四种权限都可以在本类中访问。
分析：设计一个新类，并在新类的main方法中创建属于这个类的一个对象，并观察在试图访问所有类成员时，从结果可以看出：private权限的成员变量和成员函数都不能被访问，说明如果类的成员被private访问控制符来修饰，则这个成员只能被该类的其他成员访问，其他类无法直接访问。
2）
分析：用protected数据成员创建一个类，在同一个包里创建第二个类，在第二个类里创建第一个类的对象，访问protected权限的数据成员，从结果可以看出，如果一个类的成员被protected访问控制符修饰，那么这个成员既能被同一包下的其他类访问，也能被不同包下该类的子类访问。
(2)程序2运行结果
分析：写一个类MikeOne，包括一个方法：methodA()打印出类名,放入包mypack.one中，写一个类MikeTwo，包括一个方法：methodB()打印出类名,放入包mypack.two中。在mypack.two包下定义一个类Cmain,导入所需mypack.one，创建对象，访问前两个类中的方法，（可通过getClass().getName()获取对象的类名，可以通过对象.来实现）
(3)程序3运行结果
分析：自定义一个异常类NumberFormatException继承自Exception，在实验3的复数Complex类中增加一个构造方法，该构造方法有两个字符串类型的参数，分别为复数的实部和虚部赋值，在构造方法里先用 Double.parseDouble()，将字符串参数转换为浮点数，再赋值给实部或虚部。当字符串的内容不能转化为浮点数时，抛出数值格式异常NumberFormatException。在main函数中用try….catch…处理该异常.
(4)程序4运行结果
分析：自定义非法年龄类IllegalAgeException，定义一个Person类，包含年龄，姓名，性别等属性，编写属性设置和读取函数，在设置年龄函数中，判断参数是否符合要求（1~150），如果不符合则抛出异常，编写main函数进行测试。在main()方法中，定义了一个try….catch语句用于捕获setAge()方法跑出的异常，在调用setAge()方法时由于传入的年龄在1-150之间，否则就会抛出一个自定义异常IllegalAgeException，该异常被扑火后最终被catch代码块处理，并打印出异常信息。
四、实验源代码
(1)程序1源代码
1）
package example1;
//定义访问权限测试PermissionTest类
public class PermissionTest1 {
// 定义各种权限的成员变量
private String apri = "私有成员变量被访问鸟~";
String adef = "缺省成员变量被访问鸟~";
protected String apro = "保护成员变量被访问鸟~";
public String apub = "公有成员变量被访问鸟~";
// 定义各种权限的成员函数
private void bpri() {
System.out.println("私有成员函数被访问鸟~");
}
void bdef() {
System.out.println("缺省成员函数被访问鸟~");
}
protected void bpro() {
System.out.println("保护成员函数被访问鸟~");
}
public void bpub() {
System.out.println("公有成员函数被访问鸟~");
}
public static void main(String[] args) {
// 创建类对象
PermissionTest1 p1 = new PermissionTest1();
// 访问所有类成员
System.out.println("在本类的main方法中访问所有类成员的结果为：\n");
System.out.println(p1.apri);
System.out.println(p1.adef);
System.out.println(p1.apro);
System.out.println(p1.apub + "\n");
p1.bpri();
p1.bdef();
p1.bpro();
p1.bpub();
}
}
package example1;
public class PermissionTest2 {
public static void main(String[] args) {
// 创建类对象
PermissionTest1 p2 = new PermissionTest1();
// 访问所有类成员
System.out.println("在新类的main方法中访问所有类成员的结果为：\n");
// System.out.println(p2.apri);
System.out.println("私有成员变量无法访问！");
System.out.println(p2.adef);
System.out.println(p2.apro);
System.out.println(p2.apub + "\n");
// p2.bpri();
System.out.println("私有成员函数无法访问！");
p2.bdef();
p2.bpro();
p2.bpub();
}
}
2）
package example1;
public class PermissionTest3 {
// 定义一个protected成员变量
protected String cpro = "保护成员变量被访问了鸟~";
}
package example1;
public class PermissionTest4 {
public static void main(String[] args) {
PermissionTest3 p4 = new PermissionTest3();
System.out.println(p4.cpro);
}
}
(2)程序2源代码
package mypack.one;
//定义一个类 MikeOne
public class MikeOne {
// 定义一个方法,打印出类名
public void methodA() {
System.out.println(getClass().getName());
}
}
package mypack.two;
//定义一个类 MikeOne
public class MikeTwo {
// 定义一个方法,打印出类名
public void methodB() {
System.out.println(getClass().getName());
}
}
package mypack.two;
//导入mypack.one.MikeOne包
import mypack.one.MikeOne;
public class Cmain {
public static void main(String[] args) {
// 创建对象
MikeOne m1 = new MikeOne();
MikeTwo m2 = new MikeTwo();
// 调用方法
m1.methodA();
m2.methodB();
}
}
(3)程序3源代码
package com.tsinghua.p2;
package com.tsinghua.p2;
import java.io.*;//通过数据流、序列化和文件系统提供系统输入和输出。
//定义一个复数Complex类
public class Complex {
double real;
double im;
// 定义实部和虚部构造方法
public Complex(String real, String im) {
this.real = Double.parseDouble(real);
this.im = Double.parseDouble(im);
}
// 字符串描述（重写Object的toString方法，输出a+bi的形式）
public String toString() {
if (im < 0)
return real + "" + im + "i";
else
return real + "+" + im + "i";
}
public static void main(String[] args) {
// 从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。
BufferedReader re = new BufferedReader(new InputStreamReader(System.in));
// 初始化
String str1 = "";
String str2 = "";
System.out.println("请输入复数的实部和虚部：");
while (true) {
try {
str1 = re.readLine();// 读取一个文本行。通过下列字符之一即可认为某行已终止：换行 (‘\n‘)、回车
str2 = re.readLine(); // (‘\r‘) 或回车后直接跟着换行
Complex c1 = new Complex(str1, str2);// 创建Complex对象
System.out.println("输入的复数为" + c1.toString());
break;
} catch (NumberFormatException e) {// 当应用程序试图将字符串转换成一种数值类型，但该字符串不能转换为适当格式时，抛出该异常。
System.out.println("输入的浮点数格式不对，请重新输入：");
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
(4)程序4源代码
//下面的代码是自定义一个异常类继承自Exception
public class IllegalAgeException extends Exception {
public IllegalAgeException() {
super(); // 调用Exception无参的构造方法
}
public IllegalAgeException(String message) {
super(message); // 调用Exception有参的构造方法
}
}
package com.tsinghua.p2;
import java.util.Scanner;
//定义一个Person类
public class Person {
// 定义年龄，姓名，性别成员变量
private int age;
private String name;
private String sax;
// 编写属性设置和读取函数
void SetAge(int age) throws IllegalAgeException {
if (age >= 150 || age < 0) {
throw new IllegalAgeException("年龄不合法");// 使用throw关键字声明异常对象
}
this.age = age;
}
void SetName(String name) {
this.name = name;
}
void SetSax(String sax) {
this.sax = sax;
}
int GetAge() {
return age;
}
String GetName() {
return name;
}
String GetSax() {
return sax;
}
public static void main(String[] args) {
while (true) {
try {
// 创建对象
Person p = new Person();
Scanner sc = new Scanner(System.in);
System.out.println("请输入姓名，年龄，性别：");
String str1 = sc.next();
int a = sc.nextInt();
String str2 = sc.next();
// 调用属性设置和读取函数的方法
p.SetName(str1);
p.SetAge(a);
p.SetSax(str2);
System.out.println("姓名：" + p.GetName());
System.out.println("年龄：" + p.GetAge());
System.out.println("性别：" + p.GetSax());
break;
} catch (IllegalAgeException e) { // 对捕获到的异常进行处理
System.out.println(e.getMessage()); // 打印捕获的异常信息
}
}
}
}