第4章面向对象补充案例.docx

第4章面向对象补充案例.docx

《第4章面向对象补充案例.docx》由会员分享，可在线阅读，更多相关《第4章面向对象补充案例.docx（40页珍藏版）》请在冰豆网上搜索。

第4章面向对象补充案例

第四章补充案例

案例4-1类的继承

一、案例描述

1、考核知识点编号：

00104001名称：

类的继承

2、练习目标

了解类继承的意义和作用掌握如何实现类的继承

3、需求分析

在程序中，继承描述的是事物之间的所属关系，通过继承可以使多种事物之间形成一种关系体系。

为了让初学者熟悉类的继承，本案例将演示类的继承并编写测试类验证子类是否拥有父类的可继承成员。

4、设计思路（实现原理）

1）设计两个类Student和Teacher

2）抽取两个类共同的内容（如：

吃饭、睡觉）封装到一个类Person中，各自特有的部分保留在

各自类中。

3）让学生类继承Person类，老师类也继承Person。

4）编写测试类Example01，测试Student类和Teacher是否继承了Person类的成员。

、案例实现

1、抽取父类Person，实现继承关系，代码如下：

classPerson{

Stringname;//姓名

//吃饭的功能

voideat（）{

System.out.println（"

吃饭"）;

}

//睡觉的功能

voidsleep（）{

System.out.println（"

睡觉"）;

}

}

classStudentextendsPerson{

//学号intsid;

}

classTeacherextendsPerson{

//工号inttid;

//教课的功能voidteach（）{

System.out.println（"老师教课"）;}

}

2、定义测试类Example01，代码如下：

publicclassExample01{

publicstaticvoidmain（String[]args）{Students=newStudent（）;s.eat（）;

s.sleep（）;System.out.println（""）;

Teachert=newTeacher（）;t.eat（）;

t.sleep（）;t.teach（）;

}

}

运行结果如图4-1所示。

图4-1运行结果

三、案例总结

1、在Java中，多个类可以继承一个父类，但是一个类不能直接继承多个类，一个类只能有一个直接父类。

2、父类是由子类不断抽取而来的，不断地抽取就形成了体系结构，这个结构称为继承体系结构。

3、子类在继承父类的时候，会自动拥有父类所有的成员。

4、继承的好处是划分了类的层次性，实现了代码重用、扩展了程序功能。

案例4-2方法的重写

、案例描述

1、考核知识点

编号：

00104002

名称：

方法的重写

2、练习目标了解方法重写的意义和作用掌握如何进行方法重写

3、需求分析在继承关系中，子类会自动继承父类中定义的方法，但有时在子类中需要对继承的方法进行一些修改，即对父类的方法进行重写。

为了让初学者掌握方法的重写，本案例将编写一个类NewPhone，

该类继承Phone类并对Phone类的call（）方法进行重写。

4、设计思路（实现原理）

1）定义一个类Phone，编写方法call（），表示打电话功能

2）定义一个Phone的子类NewPhone，重写父类call（）方法，让它除了打电话功能外还具有开启语言和关闭语言功能。

3）编写一个测试类Example02，分别调用重写前和重写后的call（）方法

、案例实现

1、定义Phone及其子类NewPhone，子类对父类中的call（）方法重写，代码如下：

classPhone{

voidcall（）{

System.out.println（"打电话"）;

}

}

classNewPhoneextendsPhone{

voidcall（）{

System.out.println（"开启语音"）;

super.call（）;

System.out.println（"关闭语音"）;

}

}

2、定义测试类Example02，代码如下：

publicclassExample02{

publicstaticvoidmain（String[]args）{

System.out.println（"--重写前--"）;

Phonephone=newPhone（）;

phone.call（）;

System.out.println（"--重写后--"）;

PhonenewPhone=newNewPhone（）;newPhone.call（）;

}

}

运行结果如图4-2所示。

图4-2运行结果

三、案例总结

1、子类中需要对继承自父类的方法进行一些修改，这时就用到方法重写。

2、在子类中重写的方法需要和父类被重写的方法具有相同的方法名、参数列表以及返回值类型。

3、子类方法的访问修饰权限不能小于父类的。

4、重写的主要优点是能够定义子类特有的特征。

案例4-3super访问父类成员变量

一、案例描述

1、考核知识点编号：

00104003名称：

super关键字

2、练习目标

掌握使用super关键字访问父类成员变量

3、需求分析子类可以继承父类的非私有成员变量，如果在子类中修改了继承自父类的成员变量的值，再想要

访问父类的该成员变量时，可以通过super.成员变量来实现。

为了让初学者熟悉super关键字的用法，

本案例将分别设计Fu类及其子类Zi，并在Zi类的方法中使用super关键字访问Fu类的成员变量。

4、设计思路（实现原理）

1）编写一个Fu类，在类中定义无参构造和一个初始值为20的num成员变量。

2）Zi类继承Fu类，在子类中对num值进行了修改，同时在子类中定义无参构造和一个无返回值的method（）方法，method（）方法中使用super关键字调用了Fu类的num成员变量。

3）定义测试类Example03。

、案例实现

1、编写Fu类及其子类Zi，在Zi类中使用super关键字调用Fu类成员变量，代码如下classFu{

Fu（）{}

intnum=20;

}

classZiextendsFu{

Zi（）{}

intnum=30;//修改num的值

voidmethod（）{

System.out.println（"method"）;

//super关键字调用父类成员变量

System.out.println（"Fu类中num值为：

"+super.num）;System.out.println（"Zi类中num值为：

"+num）;

}

}

2、定义测试类Example03，代码如下：

classExample03{

publicstaticvoidmain（String[]args）{

Ziz=newZi（）;

z.method（）;

}

}运行结果如图4-3所示。

图4-3运行结果

三、案例总结

1、使用super关键字调用父类的成员方法。

具体格式如下：

super.成员变量

2、被调用的父类成员变量，必须是非private的。

案例4-4super访问父类成员方法

、案例描述

1、考核知识点编号：

00104003名称：

super关键字

2、练习目标掌握使用super关键字访问父类成员方法

3、需求分析子类重写父类的方法后，子类对象将无法访问父类被重写的方法，为了解决这个问题，在Java中专门提供了一个super关键字用于访问父类的成员。

为了让初学者熟悉super关键字的用法，本案例将分别设计Fu类及其子类Zi，在Zi类的方法中使用super关键字访问Fu类的成员方法。

4、设计思路（实现原理）

1）编写一个Fu类，在类中定义无参构造和一个无返回值的show（）方法。

2）Zi类继承Fu类，子类中定义无参构造和一个无返回值的method（）方法，method（）方法中使用

super关键字调用了Fu类的show（）方法。

3）定义测试类Example04。

、案例实现

1、编写Fu类及其子类Zi，在Zi类中使用super关键字调用Fu类成员方法，代码如下：

classFu{

Fu（）{}voidshow（）{

System.out.println（"Fushow"）;

}

}classZiextendsFu{

Zi（）{}voidmethod（）{System.out.println（"Zimethod"）;//super关键字调用父类成员方法super.show（）;

}

}

2、定义测试类Example04，代码如下：

classExample04{

publicstaticvoidmain（String[]args）{

Ziz=newZi（）;z.method（）;

}

}

运行结果如图4-4所示。

图4-4运行结果

三、案例总结

1、使用super关键字调用父类的成员方法。

具体格式如下：

super.成员方法（［参数1,参数2⋯］）

2、被调用的父类成员方法，必须是非private的。

案例4-5super访问父类构造方法

一、案例描述

1、考核知识点编号：

00104003名称：

super关键字

2、练习目标掌握如何在子类构造方法中使用super关键字访问父类构造方法

3、需求分析在子类的构造方法中一定会调用父类的某个构造方法，如果想指定调用类父类中的哪个构造方法，可以使用super关键字来实现。

为了让初学者掌握super关键字的用法，本案例将分别设计Fu类及其

子类Zi，在Zi类的构造方法中使用super关键字访问Fu类的构造方法。

4、设计思路（实现原理）

1）编写一个Fu类，在类中定义无参构造。

2）Zi类继承Fu类，子类中也定义无参构造方法，在构造方法中使用super关键字调用Fu类的构

造方法。

3）定义测试类Example05。

二、案例实现

1、编写Fu类及其子类Zi，在Zi类构造中使用super关键字调用Fu类构造方法，代码如下：

classFu{

Fu（）{System.out.println（"Fu类构造方法!

"）;

}

}classZiextendsFu{

Zi（）{super（）;//在子类构造中调用父类构造System.out.println（"Zi类构造方法!

"）;

}}

2、定义测试类Example05，代码如下：

publicclassExample05{

publicstaticvoidmain（String[]args）{

Zizi=newZi（）;

}}运行结果如图4-5所示。

图4-5运行结果

三、案例总结

1、通过super调用父类构造方法的代码必须位于子类构造方法的第一行，并且只能出现一次。

2、在子类的构造方法中通过super指定调用父类的哪个构造方法，如果没有指定，在实例化子类对象时，会自动调用父类无参的构造方法。

3、被调用的父类构造方法，必须是非private的。

案例4-6final修饰类

、案例描述

1、考核知识点

编号：

00104004

名称：

final关键字

2、练习目标

了解final关键字修饰类的特点

掌握final关键字修饰类的用法

3、需求分析

Java中的类被final关键字修饰后，该类将不可以被继承，也就是不能够派生子类。

为了让初学者熟悉final关键字修饰类的用法，本案例将分别设计两个类，一个是使用final关键字修饰的Fu类，另一个是继承Fu类的Zi类，验证final关键字修饰的类是否能被继承。

4、设计思路（实现原理）

1）编写一个final关键字修饰的Fu类，类体可以为空

2）编写Zi类，Zi类继承于Fu类，类体可以为空

3）定义测试类Example06。

、案例实现

1、编写final修饰的Fu类，Zi类继承Fu类，代码如下：

finalclassFu{

//类体为空代码

}

//Zi类继承final修饰的Fu类classZiextendsFu{

//类体为空代码

}

2、定义测试类Example06，代码如下：

publicclassExample06{

publicstaticvoidmain（String[]args）{

Zizi=newZi（）;

}

}运行结果如图4-6所示。

图4-6运行结果

三、案例总结

在Java中，被final关键字修饰的类为最终类，不能被其它类继承。

案例4-7final修饰方法

、案例描述

1、考核知识点编号：

00104004名称：

final关键字

2、练习目标

掌握使用final关键字修饰方法

3、需求分析子类可以继承父类的成员方法，并在必要时对方法进行重写，增加了方法的扩展的同时也打破了

方法的封装，如果我们希望父类中的某些方法不能被重写，这时就可以使用final关键字来修饰。

为了让初学者掌握使用final关键字修饰方法，本案例将分别设计两个类，一个是Fu类，其中定义了final修饰的show（）方法，另一个是继承Fu类的Zi类，在Zi类中对show（）方法进行重写。

4、设计思路（实现原理）

1）编写一个Fu类，类中定义final修饰的show（）方法。

2）编写Zi类，Zi类继承于Fu类，在Zi类中对show（）方法进行重写

3）定义测试类Example07，创建Zi类对象，并调用Zi类show（）方法。

、案例实现

1、编写Fu类及其子类Zi类，在Zi类中对show（）方法重写，代码如下：

classFu{

//final关键字修饰的方法

publicfinalvoidshow（）{

System.out.println（"这是绝密资源"）;

}

}

classZiextendsFu{

//重写父类中final修饰的方法

publicvoidshow（）{

System.out.println（"这是一堆垃圾，给处理了"）;

}

}

2、定义测试类Example07，代码如下：

publicclassExample07{

publicstaticvoidmain（String[]args）{

Ziz=newZi（）;

z.show（）;

}

}运行结果如图4-7所示。

图4-7运行结果

三、案例总结

当一个类的方法被final关键字修饰后，这个类的子类将不能重写该方法。

案例4-8final修饰局部变量

一、案例描述

1、考核知识点

编号：

00104004

名称：

final关键字

2、练习目标

掌握使用final关键字修饰局部变量

3、需求分析

Java中被final修饰的变量为常量，它只能被赋值一次，也就是说final修饰的变量一旦被赋值，其值不能改变。

为了让初学者掌握使用final关键字修饰局部变量，本案例将在类的方法中定义一个final修饰的局部变量，并试着对该变量重新赋值。

4、设计思路（实现原理）

1）编写一个Example08类，类中定义类一个final修饰的局部变量age，为其赋初始值为18。

2）为age重新赋值为20。

、案例实现

1、编写类Example08，代码如下publicclassExample08{

publicstaticvoidmain（String[]args）{

finalintage=18;//第一次可以赋值

age=20;//再次赋值会报错}

}

编译错误，如图4-8所示。

图4-8错误提示

三、案例总结

final修饰的变量表示常量，一经定义就不能重新赋值。

案例4-9final修饰成员变量

、案例描述

1、考核知识点

编号：

00104004

名称：

final关键字

2、练习目标

掌握使用final关键字修饰成员变量

3、需求分析

final修饰

在Java中，final修饰的变量表示常量，一经定义就不能重新赋值。

为了让初学者熟悉变量的情况，本案例将使用final关键字修饰成员变量，观察其是否能够再次赋值。

4、设计思路（实现原理）

1）编写一个Fu类，父类中定义一个变量X，并用final关键字修饰变量。

2）编写Zi类，Zi类继承于Fu类，在子类中对常量再赋新值。

3）定义测试类Example09，观察运行结果。

、案例实现

1、编写Fu类及其子类Zi类，在Zi类中对X再赋值，代码如下：

classFu{

//final修饰的变量，也就是常量

publicfinalintX=10;

}

classZiextendsFu{

X=20;//在子类中对常量再赋新值publicvoidmethod（）{

System.out.println（X）;

}

}

2、定义测试类Example09，代码如下：

publicclassExample09{

publicstaticvoidmain（String[]args）{

Ziz=newZi（）;

z.method（）;

}

}

编译错误，结果如图4-9所示。

图4-9错误提示

三、案例总结

在本案例中Zi类中对变量X再次赋值，运行结果报错。

这是因为Java中被final修饰的变量为常量，它只能被赋值一次，也就是说final修饰的变量一旦被赋值，其值不能改变。

如果再次对该变量进行赋值，则程序会在编译时报错。

案例4-10接口的实现

、案例描述

1、考核知识点

编号：

00104006

名称：

接口

2、练习目标掌握如何实现接口

3、需求分析由于接口中的方法都是抽象方法，因此不能通过实例化对象的方式来调用接口中的方法。

此时需要定义一个类，并使用implements关键字实现接口中所有的方法。

为了上初学者掌握如何实现接口，本案例将设计一个类，使用关键字implements实现Inter接口中的方法。

4、设计思路（实现原理）

1）设计名为Inter的接口，接口中定义一个初始值为20的num常量和method（）抽象方法。

2）编写Inter接口的实现类InterImpl，使用implements关键字实现接口中的方法。

3）编写测试类Example10，测试类中对接口的实现类进行实例化，并调用接口中的方法。

、案例实现

1、编写接口Inter，InterImpl类使用implements实现了接口，代码如下：

//定义一个接口interfaceInter{

intnum=20;voidmethod（）;

}

//使用implements关键字实现接口classInterImplimplementsInter{voidshow（）{

System.out.println（num）;

}

publicvoidmethod（）{

System.out.println（"InterImplmethod"）;}

}

2、定义测试类Example10，代码如下：

classExample10{

publicstaticvoidmain（String[]args）{//通过实现类实例化InterImplii=newInterImpl（）;ii.show（）;ii.method（）;

}

}运行结果如图4-10所示。

图4-10运行结果

三、案例总结

1、接口使用interface关键字来定义。

2、接口没有构造方法，接口中的变量缺省都是使用publicstaticfinal修饰的，即全局常量，接口中的

方法都是publicabstract修饰的，即抽象方法。

3、定义一个类，并使用implements关键字实现接口中的方法，一个类可以实现多个接口。

4、由于接口中的方法都是抽象方法，因此不能直接通过实例化对象的方式来调用接口中的方法，需要在类实现接口后借助类来间接实例化。

案例4-11接口的继承

一、案例描述

1、考核知识点编号：

00104007

名称：

接口的继承与多实现

2、练习目标掌握接口继承的方式及其特点

3、需求分析

在程序中，可以定义一个接口使用extends关键字去继承另一个接口。

为了加深初学者对结果的理解，本案例将演示接口与接口、类与接口的继承和实现关系。

4、设计思路（实现原理）

1）设计接口Phone代表传统手机，在接口中定义receiveMessages（）和call（）抽象方法。

2）设计接口SmartPhone代表智能手机，在接口中定义faceTime（）方法，并使用extends关键字继承Phone接口，使其具有Phone接口的所有功能。

3）设计类MIPhone表示小米手机，类中定义useMIUI（）方法，并实现SmartPhone接口的所有方法。

4）编写测试类Example11，测试类中对MIPhone进行实例化，并访问小米手机具有的各种功能。

、案例实现

1、编写接口Phone和SmartPhone、类MIPhone。

代码如下：

interfacePhone{

voidreceiveMessages（）;

voidcall（）;

}

interfaceSmartPhoneextendsPhone{

voidfaceTime（）;

}

classMIPhoneimplementsSmartPhone{publicvoidreceiveMessages（）{

System.out.println（"接收短息"）;