实验一 条件语句、循环语句的使用
实验目的
1、掌握if条件语句的语法格式，了解if条件语句的执行流程。
2、熟悉switch条件语句的语法格式，了解switch条件语句的特点。
3、掌握while循环语句的语法格式和使用， 了解while循环语句的特点。
4、掌握for循环语句的语法格式和使用，了解for循环语句的特点。
5、掌握循环嵌套的使用和执行顺序。
实验过程
项目1、使用if…else if…else语句实现判断某月是哪个季节的功能
1）编写一个类Example11
2）定义一个变量month用于存储月份。
3）用if条件语句，判断这个月份在哪一个季节并输出结果，如：春季是3、4、5月，夏季是6、7、8月，秋季是9、10、11月，冬季是12、1、2月
4）由于一年只有12个月，所以要过滤除1-12以外的月份值
源代码：
package cn.edu.hbuas.dierzu;
import java.util.Scanner;
public class Example11 {
public static void main(String[] args) {
System.out.println("请输入月份，系统为您判断此时的季节");
Scanner scan=new Scanner(System.in);
int month=scan.nextInt();
if (month == 3 || month == 4 || month == 5) {
//3月、4月、5月，输出结果为春季
System.out.println(month + "月是春季");
} else if (month == 6 || month == 7 || month == 8) {
//6月、7月、8月，输出结果为夏季
System.out.println(month + "月是夏季");
} else if (month == 9 || month == 10 || month == 11) {
//9月、10月、11月，输出结果为秋季
System.out.println(month + "月是秋季");
} else if (month == 12 || month == 1 || month == 2) {
//12月、1月、2月，输出结果为冬季
System.out.println(month + "月是冬季");
} else {
//一年只有12个月，范围不在1-12间的需要过滤掉
System.out.println("没有这个月份，请重新输入");
}
}
}
代码执行结果：
项目2、使用switch 条件语句实现判断选择题对错的功能
1）编写一个类Example12
2）定义一个变量answer用于存储答案选项
3）用switch条件语句判断如果变量answer为B则正确，其它则错误
4）如果变量answer不等于ABCD四个选择则打印“不存在此选项”
源代码：
package cn.edu.hbuas.dierzu;
import java.util.Scanner;
public class Example12 {
public static void main(String[] args) {
System.out.println("请输入你想到答案，系统会为您判断对错");
Scanner scan=new Scanner(System.in);
String answer=scan.next();
switch(answer)
{
case "A":
System.out.println("A错误");//答案为A错误
break;
case "B":
System.out.println("B正确");//答案为B正确
break;
case "C":
System.out.println("C错误");//答案为C错误
break;
case "D":
System.out.println("D错误");//答案为D错误
break;
default:
System.out.println("该选项不存在");//输入范围不合适
}
}
}
代码执行结果：
项目3、使用while语句实现统计1-10以内奇数的个数的功能
1）编写一个类Example13
2）定义一个变量x为1，用while语句循环条件为x<=10
3）在while循环中，使用表达式x%2判断是否为奇数，如果为奇数，则变量count的值加1。
源代码：
package cn.edu.hbuas.dierzu;
public class Example13 {
public static void main(String[] args) {
int x=1;
int count;
count=0;
while(x<=10)
{
if(x%2==1){
count++;//如果为奇数，则变量count+1
System.out.println(x);
}
x++;
}
System.out.println("count="+count);
}
}
代码执行结果：
项目4、使用for循环语句计算1+2+3+4+5...+100表达式的结果
1）编写一个类Example14
2）在该类中定义一个变量sum来存储每次循环整数相加的和。
3）在for循环语句中定义变量x,循环条件为x<=100
源代码：
package cn.edu.hbuas.dierzu;
public class Example14 {
public static void main(String[] args) {
int sum=0;
for(int x=1;x<=100;x++)
{
sum=sum+x;
}
System.out.println("sum="+sum);//输出总和
}
}
代码执行结果：
项目5、用for循环嵌套打印由“*”组成的直角三角形。具体要求如下：
第一个三角形为倒直角三角形，共5行，第一行5个 “*”，一行减少一个，第5行一个“*”
将倒直角三角形上下翻转为正直角三角形，第一行1一个“*”，第5行5个“*”
1） 分析第一个三角形的打印，外层for循环控制行数，初始化表达式从0开始，循环条件为小于5；第一行是5个“*”所以应该内层循环打印5次，初始化表达式从0开始，循环条件为小于5。同理，内层的循环初始化和条件如下所示：
0 1 2 3 4
1 2 3 4
2 3 4
3 4
4
由此可见内层循环的初始化表达式y 与外层的x是相等的，循环条件都是小于5。
2） 分析第二个三角形的打印，第一行1个“*”，第二行2个“*”...由此可见，内层循环的循环次数与行数是相等的，所以内层循环的y小于或等于外层的x。
源代码：
package cn.edu.hbuas.dierzu;
public class Example15 {
public static void main(String[] args) {
for(int x=0;x<5;x++)
{
for(int y=x;y<5;y++)
{
System.out.print("*");
}
System.out.println();
}//输出倒三角形
System.out.println("————————————————");
for(int x=0;x<5;x++)
{
for(int y=0;y<=x;y++)
{
System.out.print("*");
}
System.out.println();//输出三角形
}
}
}
代码执行结果：
实验反思
通过本次实验学习到了一下几点：
1、if…else if…else语句用于对多个条件进行判断，进行多种不同的处理。
2、switch 条件语句也是一种很常用的选择语句，和if条件语句不同，它只能针对某个表达式的值作出判断，从而决定程序执行哪一段代码。
3、while语句会反复地进行条件判断，只要条件成立，{}内的执行语句就会执行，直到条件不成立，while循环才会结束。
4、continue语句和break语句的区别在于，break结束循环，continue只是跳过后面的语句继续循环。
5、做任何判断都要考虑其它因素，考虑对用户的友好性，在出了超出范围、输入方式不对等情况时，给予提示。
实验二 方法的定义、重载；数组的应用
实验目的
1、掌握方法的定义。
2、了解重载的定义，掌握方法重载的用法。
3、掌握一维数组的定义。
4、掌握如何获取一维数组的最值。
5、掌握一维数组中元素的排序。
实验过程
项目1、定义一个方法，并且该方法能够实现四则运算的功能。
1）编写一个类Example21
2）定义一个方法siZe，设置三个参数，两个数字为int型，一个符号为char型
3）在方法中，用if选择语句根据传入的符号参数进行不同的运算
4）如果传入的符号不包含在加减乘除四个符号中则输出“符号错误”
5）在main方法中调用方法计算3*0的结果，测试方法是否成功运算出正确结果
源代码：
package cn.edu.hbuas.dierzu;
import java.util.Scanner;
public class Example21 {
public static void siZe(String[] args) {
Scanner scan=new Scanner( System.in);//创建一个scan对象获取输入的值,从键盘键入值
System.out.println("请输入第一个数值");
int a=scan.nextInt();//从键盘键入第一个值
System.out.println("请输入第二个数值");
int b=scan.nextInt();//从键盘键入第二个值
System.out.println("请输入运算符");
String c=scan.next();//从键盘键入符号
float d;
if(c.equals("+")){
d=a+b;
System.out.println(a+"+"+b+"="+d+"");}//equals是判断字符是否相等
else if(c.equals("-")){
d=a-b;
System.out.print(+a+"-"+b+"="+d+"");}
else if(c.equals("*")){
d=a*b;
System.out.print(+a+"*"+b+"="+d+"");}
else if(c.equals("÷")){
d=a/b;
System.out.print(+a+"÷"+b+"="+d+"");}
else
System.out.println("符号错误");}//如果输出的符号不等同于前四个，则提示输出符号错误。
public static void main(String[] args) {
Example21 st=new Example21();
st.siZe(args);}
}
代码执行结果：
项目2、通过方法重载的方式实现九九乘法表的打印。
1）编写一个类Example22
2）在Example22中定义一个带参数的方法print99，该参数用于指定乘法表打印的行数
3）在Example22中定义一个方法print99，此方法没有参数。
4）在main方法中分别调用无参方法print99()和有参方法print99(6)，测试两个重载的方法print99能否成功打印出符合要求的乘法表。
源代码：
package cn.edu.hbuas.dierzu;
public class Example22 {
public static void main(String[] args) {
print99();//调用对象方法
print99(6);//调用对象方法
}
private static void print99(int x){
for(int i=1;i<=x;i++){ //控制行
for(int j=1;j<=i;j++){ //控制一行多少
int n=i*j;
System.out.print(i+"*"+j+"="+n+" ");//按照格式输出
}
System.out.println("");
}
System.out.println("——————————————————————————————————————————————————————————————");
}
private static void print99(){
print99(9);//调用对象方法
}
}
代码执行结果：
项目3、定义一个数组，将序列{0,1,2,3,4}赋值给数组，并写一个方法用来访问数据的每一个元素。
1）定义一个数组，在初始化数组时有一种方式叫做静态初始化，就是在定义数组的同时就为数组的每个元素赋值。可以在定义数组时将序列{0,1,2,3,4}赋值给数组。
2）定义一个方法printArr()输出数组的元素，可以用for循环语句依次输出数组的元素，各元素用“，”间隔可以更清楚的输出元素。
3）在最后一个元素输出时，后面就不需要加“，”了，所以循环到length-1时不打印“，”。
源代码：
package cn.edu.hbuas.dierzu;
public class Example23 {
public static void printArr (String[] args){//定义一个printArr方法
int[] x={0,1,2,3,4};
System.out.print("[");
for (int i=0;i<x.length-1;i++){//循环输出数组值到数组的最后一个元素前结束
System.out.print(x[i]);
System.out.print(",");
}
System.out.print(x[x.length-1]);//输出最后一个元素
System.out.println("]");
}
public static void main(String[] args){
Example23 st=new Example23();
st.printArr(args);//调用printArr方法
}
}
代码执行结果：
项目4、定义一个数组，并获取该数组中值最小的元素
1）定义一个数组。
2）定义一个方法，用来获取最小值。该方法应返回一个int型的数值，参数为数组类型。在方法中，定义一个临时变量min，用于记住数组的最小值。首先假设数组中第一个元素arr[0]为最小值，然后使用for循环对数组进行遍历，在遍历的过程中只要遇到比min值还小的元素，就将该元素赋值给min。这样一来，变量min就能够在循环结束时记住数组中的最小值。
3）在main方法中调用该方法，将定义的数组作为参数传给方法，获取该数组的最小值。
源代码：
package cn.edu.hbuas.dierzu;
public class Example24 {
public static void main(String[] args){
int[] arr={66,55,44,11,22};
int x=minx(arr); //调用对象方法
System.out.println("最小值为"+x);
}
private static int minx(int[] arr){
int min=arr[0]; //第一个元素设置成最小值
int lenth=arr.length; //for循环结束条件
for(int i=1;i<=lenth-1;i++){
if(min>arr[i]){
min=arr[i]; //数组的元素找出最小值
}
}
return min;
}
}
代码执行结果：
项目5、对数组元素进行选择排序
1）定义排序方法，在方法中，用for循环嵌套实现排序。第一层循环是从数组的第一个元素开始循环。第二层循环用于与第一层循环中的元素比较找出最值，并将最小值的下标跟第一个元素的下标进行互换。
2）为了方便观察排序结果，将第3题中的printArr()方法复制到类中，输出排序前和排序后的数组元素。
源代码：
package cn.edu.hbuas.dierzu;
public class Example25 {
public static void main(String[] args){
int[] arr={9,4,7,8,5,6,1,3,2};//静态初始化，随机给出一组数据
System.out.print("您事先输入好的数组排序前为");
printArray(arr);//打印数组元素
selectSort(arr);//选择调用顺序方法
System.out.print("您事先输入好的数组排序后为");
printArray(arr);//打印数组元素
}//定义打印数组元素的方法
public static void selectSort(int[] arr){
for (int x=0;x<arr.length-1;x++){// 循环遍历数组的元素
for (int y=x+1;y<arr.length;y++){
if(arr[y]<arr[x]){//比较相邻元素，然后调换顺序
int temp=arr[x];
arr[x]=arr[y];
arr[y]=temp;
}
}
}
}
public static void printArray(int[] arr){
System.out.print("[");
for(int x=0;x<arr.length;x++){
if(x==(arr.length-1)){
System.out.print(arr[x]);
}
else{
System.out.print(arr[x] + ",");
}
}
System.out.println("]");
}
}
代码执行结果：
实验反思
数组：
1、 数组的好处：数组里的每个元素都有编号，编号从0开始，并且一次递增，方便操作其中的元素。
2、 要在程序中使用数组，就必须要声明数组，再给数组分配内存。
3、 数组对应在内存中一段连续空间。
4、 数组元素必须是相同数据类型，可以是引用数据类型，但是同一个数组中的元素必须 是同一类数据类型。
方法：
1、java方法是语句的集合，它们在一起执行一个功能。
2、方法是解决一类问题的步骤的有序组合。
3、方法包含于类或对象中。
4、方法在程序中被创建，在其他地方被引用。
总结：
数组不是集合，它只能保存同种类型的多个原始类型或者对象的引用。数组保存的仅仅是对象的引用，而不是对象本身。
数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的。
实验三 类的定义、封装；构造方法的定义、重载
实验目的
1、掌握类定义的方式，掌握如何在类中定义成员变量和成员方法。
2、掌握如何创建类的对象，掌握如何使用两个或者多个变量引用同一个实例对象。
3、了解为什么要对类进行封装，了解如何实现类的封装。
4、掌握有参构造方法的定义方式，理解系统会自动分配无参构造方法的情况。
5、掌握如何在类中定义重载的构造方法。
实验过程
项目1、设计一个表示学生的类，该类具有表示姓名的属性name和表示年龄的属性age，同时还具有表示说话行为的方法speak()，用于输出学生的姓名和年龄。
1）使用class关键字定义一个表示学生类型的类，类名为Student。
2）在Student类中定义两个成员变量name和age，分别用来表示姓名和年龄。其中，name的数据类型为String，变量age的数据类型为int。
3）在Student类中定义一个表示说话行为的speak()方法，用于输出学生的姓名和年龄。
源代码：
package cn.edu.hbuas.dier;
public class Student {
private String name;
private int age;
public Student(String s,int a){
this.name=s;
this.age=a;
}
public void speak(){
System.out.println("我的名字是"+this.name+"，我今年"+this.age+"岁了。");
}
}
代码执行结果：
项目2、基于上一题，创建三个学生对象，它们的引用变量分别是s1、s2和s3，首先分别使用s1和s2引用，为name和age赋值，然后调用speak()方法，最后将s2变量赋值给s3， s3也调用speak()方法。
1）编写Example32类
2）在main()方法中，创建Student类的第一个对象，其引用变量为s1，使用s1调用name和age变量分别为它们赋值为“张三”和“19”，然后调用speak()方法。
3）创建Student类的第二个对象，其引用变量为s2，使用s2分别为name和age赋值为“李四”和“20”，然后调用speak()方法。
4）创建Student类的第三个对象，其引用变量为s3，将s2的值赋给s3，然后使用s3调用speak()方法。
源代码：
package cn.edu.hbuas.dier;
public class Example32 {
public static void main(String[] args) {
Student s1=new Student("张三",19);
Student s2=new Student("李四",20);
Student s3=s2;
s3.speak();
}
}
代码执行结果：
项目3、使用private关键字对成员变量name和age进行私有化，同时分别提供一个setName(String n)和setAge(int a)方法用于外界的访问，其中setAge(int a)中需要对age进行判断。
1） 编写测试类Example33，将属性age的值设为-30，演示不合理现象。
2） 对Student类进行修改，将name和age属性使用private修饰，然后定义getName()、setName(String n)、getAge()和setAge(int a)四个对外访问name和age的方法。
3） 在setAge(int a)方法中对传入的参数进行检查，如果输入值为负数，则打印出“设置的年龄不合法”，如果不为负数，才将其设置为age属性的值。
4）对Example33类进行修改，在main()方法中创建Student类的实例对象，通过调用对象的setName(String n)和setAge(int a)方法来设置的name属性和age属性值，并调用speak()方法。
源代码：
Student类
package cn.edu.hbuas.dier;
public class Student {
private String name;
private int age;
public void setName(String n) {
this.name = n;
}
public void setAge(int a) {
if(a > 0)
this.age = a;
else
System.out.println("设置的年龄不合法");
}
public int getAge() {
return age;
}
public String getName() {
return name;
}
public void speak(){
System.out.println("我的名字是"+this.name+"，我今年"+this.age+"岁了。");
}
}
Example33类
package cn.edu.hbuas.dier;
public class Example33{
public static void main(String[] args) {
Student s1 = new Student();
s1.setAge(-30);
s1.setName("张三");
Student s2 = new Student();
s2.setAge(20);
s2.setName("李四");
Student s3 = s2;
s3.speak();
}
}
代码执行结果：
项目4、演示如何使用有参构造方法完成对象属性的初始化。
1） 定义一个Student类，该类有一个age属性，在类中定义一个有参数的构造方法，该参数用于为age属性赋值。
2） 编写一个测试类Example34，在main()方法中通过有参构造方法创建一个对象。
3） 打印该对象age属性的值。
源代码：
Student类
package cn.edu.hbuas.dier;
public class Student {
private String name;
private int age;
public Student(String s,int a){
this.name = s;
this.age = a;
}
public int getAge() {
return age;
}
}
Example34类
package cn.edu.hbuas.dier;
public class Example34 {
public static void main(String[] args) {
Student s1 = new Student("张三",19);
System.out.println("我的年龄是："+s1.getAge());
}
}
代码执行结果：
项目5、通过创建对象的方式演示不同构造方法的使用方式，并根据构造方法的输出结果对构造方法的重载进行学习。
1）对Student类进行修改，在类中定义三个重载的构造方法，包括无参的构造方法，接收一个String类型参数的构造方法，接收String类型和int类型两个参数的构造方法。
2）编写测试类Example35，在main()方法中，分别使用三个重载的构造方法创建三个Student对象。
源代码：
Student类
package cn.edu.hbuas.dier;
public class Student {
private String name;
private int age;
public Student(){}
public Student(String s){
this.name = s;
}
public Student(String s,int a){
this.name = s;
this.age = a;
}
public void speak(){
System.out.println("我的名字是"+this.name+"，我今年"+this.age+"岁了。");
}
}
Example35类
package cn.edu.hbuas.dier;
public class Example35 {
public static void main(String[] args) {
Student s1 = new Student("王五",18);
Student s2 = new Student("张三",19);
Student s3 = new Student("李四",20);
s1.speak();
s2.speak();
s3.speak();
}
}
代码执行结果：
实验反思
1、Java语言严格区分大小写，class和Class是不同的，在定义类时只能使用class关键字
2、在Student类中，成员变量name是String类型，String表示一个字符串
3、和普通方法一样，构造方法中同样可以接收多个参数，只要在使用new关键字创建对象时，传入数量相同和类型一致的参数，就可以自动地调用对应的构造方法。
4、一个类中如果没有定义构造方法，系统会默认为其分配一个方法体为空的无参构造方法，而一旦定义了构造方法，系统就不再提供默认的构造方法。
5、一个类中可以定义多个重载的构造方法，在创建对象时，根据传入参数的不同会调用相应的构造方法。
6、只要实现了封装就能对外界的访问进行控制，避免对私有变量随意修改而引发问题。
实验四 静态方法、静态内部类的使用
实验目的
1、了解在静态方法中只能访问类的静态成员，而不能访问非静态成员。
2、理解在静态内部类中可以定义静态成员和非静态成员，掌握访问静态内部类中静态成员和非静态成员的方式。
3、掌握方法内部类中访问的局部变量需要使用final关键字修饰。
实验过程
项目1、编写一个测试类，在类中定义若干个静态方法和非静态方法，通过方法之间的相互调用，演示静态方法和非静态方法的调用情况。
1）编写Example41类，在类中定义两个静态方法staticMethod1()、staticMethod2()，两个非静态方法nonStaticMethod1()、nonStaticMethod2()
2）在Example41类中，针对定义的四个方法进行互相调用，观察调用情况。
源代码：
package cn.edu.hbuas.dier;
public class Example41 {
public static void staticMethod1(){
System.out.println("调用了staticMethod1方法。");
// nonStaticMethod1();
}
public static void staticMethod2(){
System.out.println("调用了staticMethod2方法。");
}
public void nonStaticMethod1(){
System.out.println("调用了nonStaticMethod1方法。");
staticMethod1();
nonStaticMethod2();
}
public void nonStaticMethod2(){
System.out.println("调用了nonStaticMethod2方法。");
}
public static void main(String[] args) {
System.out.println("调用了main方法。");
Example41 e = new Example41();
e.nonStaticMethod1();
}
}
代码执行结果：
项目2、设计一个静态内部类，并编写测试类演示如何访问静态内部类中的静态成员和非静态成员。
1）定义外部类Outer，在Outer类中定义一个静态内部类Inner。
2）在Inner中定义两个String类型变量，一个静态变量staticField，其值为“静态内部类的静态变量”，一个非静态变量nonStaticField，其值为“静态内部类的非静态变量”。定义两个方法，一个静态方法staticMethod()打印“静态内部类的静态方法”，一个非静态方法nonStaticMethod()打印“静态内部类的非静态方法”。
3）编写Example42类，在类的main()方法中调用Inner类中的变量和方法。
源代码：
package cn.edu.hbuas.dier;
import org.w3c.dom.ls.LSOutput;
class Outer{
static class Inner{
static String staticField = "静态内部类的静态变量";
String nonStaticField = "静态内部类的非静态变量";
static void staticMethod(){
System.out.println("静态内部类的静态方法");
}
void nonStaticMethod(){
System.out.println("静态内部类的非静态方法");
}
}
}
public class Example42{
public static void main(String[] args){
Outer.Inner inner = new Outer.Inner();
System.out.println(inner.nonStaticField);
inner.nonStaticMethod();
}
}
代码执行结果：
项目3、编写一个方法内部类，演示如何在方法内部类中访问局部变量。
1）编写Example43类，在类中定义一个test()方法，test()方法中定义一个int类型的局部变量num，其值为5。
2）在test()方法中定义一个方法内部类Inner，在Inner类中定义一个show()方法，方法中访问局部变量num。在test()方法中创建内部类Inner的实例对象，调用其show()方法。
3）在Example43的main()方法中，创建Example43的实例对象，使用变量e引用该对象，通过变量e调用test()方法。
源代码：
package cn.edu.hbuas.dier;
public class Example43 {
void test() {
int num = 5;
class Inner {
void show() {
System.out.println("局部变量num的值为" + num);
};
}
Inner inner = new Inner();
inner.show();
}
public static void main(String[] args) {
Example43 e = new Example43();
e.test();
}
}
代码执行结果：
实验反思
1、在静态方法中只能访问静态方法，在非静态方法中可以访问静态方法和非静态方法。
2、非静态变量只能通过对象或者对象的引用变量访问，而静态方法在创建对象之前就可以通过类名直接访问，因此在静态方法中不能访问非静态变量，只能访问静态变量。
3、静态内部类中可以定义静态成员和非静态成员，如果要访问非静态成员，必须通过静态内部类的对象或者对象的引用变量。如果要访问静态成员，则可以直接通过“外部类.静态内部类.静态成员”的方式，不需要创建静态内部类的实例对象。
4、方法内部中访问的局部变量必须使用final关键字修饰，否则程序在编译时会发生错误。
实验五 类的继承
实验目的
1、了解类继承的意义和作用，掌握如何实现类的继承。
实验过程
项目1、编写程序演示类的继承并编写测试类验证子类是否拥有父类的可继承成员。
1）设计两个类Student和Teacher
2）抽取两个类共同的内容（如：吃饭、睡觉）封装到一个类Person中，各自特有的部分保留在各自类中。
3）让学生类继承Person类，老师类也继承Person。
4）编写测试类Example51，测试Student类和Teacher是否继承了Person类的成员。
源代码：
Person类
package cn.edu.hbuas.dier;
public class Person {
String name;
int age;
public void eat(){
System.out.println(name + "在吃饭");
}
public void sleep(){
System.out.println(name + "在睡觉");
}
}
Student类
package cn.edu.hbuas.dier;
class Student extends Person{
public Student(String name,int age){
this.name = name;
this.age = age;
}
public void speak(){
System.out.println("我叫"+this.name+"我今年"+age+"岁了，我是一个学生。");
}
}
Teacher类
package cn.edu.hbuas.dier;
class Teachar extends Person{
public Teachar(String name,int age){
this.name = name;
this.age = age;
}
public void speak(){
System.out.println("我叫"+this.name+"我今年"+age+"岁了，我是一个老师。");
}
}
Example51类
package cn.edu.hbuas.dier;
public class Example51 {
public static void main(String[] args) {
Student s = new Student("红果果",15);
Teachar t = new Teachar("绿泡泡",25);
s.speak();
s.eat();
s.sleep();
t.speak();
t.eat();
t.sleep();
}
}
代码执行结果：
实验反思
1、在Java中，多个类可以继承一个父类，但是一个类不能直接继承多个类，一个类只能有一个直接父类。
2、父类是由子类不断抽取而来的，不断地抽取就形成了体系结构，这个结构称为继承体系结构。
3、子类在继承父类的时候，会自动拥有父类所有的成员。
4、继承的好处是划分了类的层次性，实现了代码重用、扩展了程序功能。
来源地址：https://blog.csdn.net/FengleYiMan/article/details/131223612
