面向对象编程（进阶）（上）
下篇链接见：面向对象编程（进阶）（下）
文章目录
- 一. 关键字：this
-
- 1.1 this是什么？
- 1.2 什么时候使用this
-
- 1.2.1 实例方法或构造器中使用当前对象的成员
- 1.2.2 同一个类中构造器互相调用
- 1.3 练习
- 二. 面向对象特征二：继承(Inheritance)
-
- 2.1 继承的概述
-
- 2.1.1 生活中的继承
- 2.1.2 Java中的继承
- 2.1.3 继承的好处
- 2.2 继承的语法
-
- 2.2.1 继承中的语法格式
- 2.2.2 继承中的基本概念
- 2.3 代码举例
- 2.4 继承性的细节说明
- 2.5 练习
- 三. 方法的重写（override/overwrite）
-
- 3.1 方法重写举例
- 3.2 方法重写的要求
- 3.3 小结：方法的重载与重写
- 3.4 练习
- 四. 再谈封装性中的4种权限修饰
- 五. 关键字：super
-
- 5.1 super的理解
- 5.2 super的使用场景
-
- 5.2.1 子类中调用父类被重写的方法
- 5.2.2 子类中调用父类中同名的成员变量
- 5.2.3 子类构造器中调用父类构造器
- 5.3 小结：this与super
- 5.4 练习
一. 关键字：this
1.1 this是什么？
-
在Java中，this关键字不算难理解，它的作用和其词义很接近。
- 它在方法（准确的说是实例方法或非static的方法）内部使用，表示调用该方法的对象
- 它在构造器内部使用，表示该构造器正在初始化的对象。
-
this可以调用的结构：成员变量、方法和构造器
1.2 什么时候使用this
1.2.1 实例方法或构造器中使用当前对象的成员
在实例方法或构造器中，如果使用当前类的成员变量或成员方法可以在其前面添加this，增强程序的可读性。不过，通常我们都习惯省略this。
但是，当形参与成员变量同名时，如果在方法内或构造器内需要使用成员变量，必须添加this来表明该变量是类的成员变量。即：我们可以用this来区分成员变量和局部变量。比如：
另外，使用this访问属性和方法时，如果在本类中未找到，会从父类中查找。
举例1：
class Person{ // 定义Person类
private String name ;
private int age ;
public Person(String name,int age){
this.name = name ;
this.age = age ;
}
public void setName(String name){
this.name = name;
}
public void setAge(int age){
this.age = age;
}
public void getInfo(){
System.out.println("姓名：" + name) ;
this.speak();
}
public void speak(){
System.out.println(“年龄：” + this.age);
}
}
举例2：
public class Rectangle {
int length;
int width;
public int area() {
return this.length * this.width;
}
public int perimeter(){
return 2 * (this.length + this.width);
}
public void print(char sign) {
for (int i = 1; i <= this.width; i++) {
for (int j = 1; j <= this.length; j++) {
System.out.print(sign);
}
System.out.println();
}
}
public String getInfo(){
return "长：" + this.length + "，宽：" + this.width +"，面积：" + this.area() +"，周长：" + this.perimeter();
}
}
测试类：
public class TestRectangle {
public static void main(String[] args) {
Rectangle r1 = new Rectangle();
Rectangle r2 = new Rectangle();
System.out.println("r1对象：" + r1.getInfo());
System.out.println("r2对象：" + r2.getInfo());
r1.length = 10;
r1.width = 2;
System.out.println("r1对象：" + r1.getInfo());
System.out.println("r2对象：" + r2.getInfo());
r1.print('#');
System.out.println("---------------------");
r1.print('&');
System.out.println("---------------------");
r2.print('#');
System.out.println("---------------------");
r2.print('%');
}
}
1.2.2 同一个类中构造器互相调用
this可以作为一个类中构造器相互调用的特殊格式。
- this()：调用本类的无参构造器
- this(实参列表)：调用本类的有参构造器
public class Student {
private String name;
private int age;
// 无参构造
public Student() {
// this("",18);//调用本类有参构造器
}
// 有参构造
public Student(String name) {
this();//调用本类无参构造器
this.name = name;
}
// 有参构造
public Student(String name,int age){
this(name);//调用本类中有一个String参数的构造器
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getInfo(){
return "姓名：" + name +"，年龄：" + age;
}
}
注意：
- 不能出现递归调用。比如，调用自身构造器。
- 推论：如果一个类中声明了n个构造器，则最多有 n - 1个构造器中使用了"this(形参列表)"
- this()和this(实参列表)只能声明在构造器首行。
- 推论：在类的一个构造器中，最多只能声明一个"this(参数列表)"
1.3 练习
练习1：添加必要的构造器，综合应用构造器的重载，this关键字。
练习2：
（1）按照如下的UML类图，创建相应的类，提供必要的结构：
在提款方法withdraw()中，需要判断用户余额是否能够满足提款数额的要求，如果不能，应给出提示。deposit()方法表示存款。
（2）按照如下的UML类图，创建相应的类，提供必要的结构
（3）按照如下的UML类图，创建相应的类，提供必要的结构
-
addCustomer 方法必须依照参数（姓，名）构造一个新的 Customer对象，然后把它放到 customer 数组中。还必须把 numberOfCustomer 属性的值加 1。
-
getNumOfCustomers 方法返回 numberofCustomers 属性值。
-
getCustomer方法返回与给出的index参数相关的客户。
（4）创建BankTest类，进行测试。
内存解析图：
二. 面向对象特征二：继承(Inheritance)
2.1 继承的概述
2.1.1 生活中的继承
- 财产继承：
- 绿化：前人栽树，后人乘凉
“绿水青山，就是金山银山”
-
样貌：
-
继承之外，是不是还可以"
进化"：
继承有延续（下一代延续上一代的基因、财富）、扩展（下一代和上一代又有所不同）的意思。
2.1.2 Java中的继承
角度一：从上而下
为描述和处理个人信息，定义类Person：
为描述和处理学生信息，定义类Student：
通过继承，简化Student类的定义：
说明：Student类继承了父类Person的所有属性和方法，并增加了一个属性school。Person中的属性和方法，Student都可以使用。
角度二：从下而上
多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类中无需再定义这些属性和行为，只需要和抽取出来的类构成继承关系。如图所示：
再举例：
2.1.3 继承的好处
-
继承的出现减少了代码冗余，提高了代码的复用性。
-
继承的出现，更有利于功能的扩展。
-
继承的出现让类与类之间产生了
is-a的关系，为多态的使用提供了前提。- 继承描述事物之间的所属关系，这种关系是：
is-a的关系。可见，父类更通用、更一般，子类更具体。
- 继承描述事物之间的所属关系，这种关系是：
注意：不要仅为了获取其他类中某个功能而去继承！
2.2 继承的语法
2.2.1 继承中的语法格式
通过 extends 关键字，可以声明一个类B继承另外一个类A，定义格式如下：
[修饰符] class 类A {
...
}
[修饰符] class 类B extends 类A {
...
}
2.2.2 继承中的基本概念
类B，称为子类、派生类(derived class)、SubClass
类A，称为父类、超类、基类(base class)、SuperClass
2.3 代码举例
1、父类
package com.atguigu.inherited.grammar;
/*
* 定义动物类Animal，做为父类
*/
public class Animal {
// 定义name属性
String name;
// 定义age属性
int age;
// 定义动物的吃东西方法
public void eat() {
System.out.println(age + "岁的"
+ name + "在吃东西");
}
}
2、子类
package com.atguigu.inherited.grammar;
/*
* 定义猫类Cat 继承 动物类Animal
*/
public class Cat extends Animal {
int count;//记录每只猫抓的老鼠数量
// 定义一个猫抓老鼠的方法catchMouse
public void catchMouse() {
count++;
System.out.println("抓老鼠，已经抓了"
+ count + "只老鼠");
}
}
3、测试类
package com.atguigu.inherited.grammar;
public class TestCat {
public static void main(String[] args) {
// 创建一个猫类对象
Cat cat = new Cat();
// 为该猫类对象的name属性进行赋值
cat.name = "Tom";
// 为该猫类对象的age属性进行赋值
cat.age = 2;
// 调用该猫继承来的eat()方法
cat.eat();
// 调用该猫的catchMouse()方法
cat.catchMouse();
cat.catchMouse();
cat.catchMouse();
}
}
2.4 继承性的细节说明
1、子类会继承父类所有的实例变量和实例方法
从类的定义来看，类是一类具有相同特性的事物的抽象描述。父类是所有子类共同特征的抽象描述。而实例变量和实例方法就是事物的特征，那么父类中声明的实例变量和实例方法代表子类事物也有这个特征。
- 当子类对象被创建时，在堆中给对象申请内存时，就要看子类和父类都声明了什么实例变量，这些实例变量都要分配内存。
- 当子类对象调用方法时，编译器会先在子类模板中看该类是否有这个方法，如果没找到，会看它的父类甚至父类的父类是否声明了这个方法，遵循
从下往上找的顺序，找到了就停止，一直到根父类都没有找到，就会报编译错误。
所以继承意味着子类的对象除了看子类的类模板还要看父类的类模板。
2、子类不能直接访问父类中私有的(private)的成员变量和方法
子类虽会继承父类私有(private)的成员变量，但子类不能对继承的私有成员变量直接进行访问，可通过继承的get/set方法进行访问。如图所示：
3、在Java 中，继承的关键字用的是“extends”，即子类不是父类的子集，而是对父类的“扩展”
子类在继承父类以后，还可以定义自己特有的方法，这就可以看做是对父类功能上的扩展。
4、Java支持多层继承(继承体系)
class A{}
class B extends A{}
class C extends B{}
说明：
子类和父类是一种相对的概念
顶层父类是Object类。所有的类默认继承Object，作为父类。
5、一个父类可以同时拥有多个子类
class A{}
class B extends A{}
class D extends A{}
class E extends A{}
6、Java只支持单继承，不支持多重继承
public class A{}
class B extends A{}
//一个类只能有一个父类，不可以有多个直接父类。
class C extends B{} //ok
class C extends A,B... //error
2.5 练习
练习1：定义一个学生类Student，它继承自Person类
练习2：
(1)定义一个ManKind类，包括
-
成员变量int sex和int salary；
-
方法void manOrWoman()：根据sex的值显示“man”(sex==1)或者“woman”(sex==0)；
-
方法void employeed()：根据salary的值显示“no job”(salary==0)或者“ job”(salary!=0)。
(2)定义类Kids继承ManKind，并包括
- 成员变量int yearsOld；
- 方法printAge()打印yearsOld的值。
(3)定义类KidsTest，在类的main方法中实例化Kids的对象someKid，用该对象访问其父类的成员变量及方法。
练习3：根据下图实现类。在CylinderTest类中创建Cylinder类的对象，设置圆柱的底面半径和高，并输出圆柱的体积。
三. 方法的重写（override/overwrite）
父类的所有方法子类都会继承，但是当某个方法被继承到子类之后，子类觉得父类原来的实现不适合于自己当前的类，该怎么办呢？子类可以对从父类中继承来的方法进行改造，我们称为方法的重写 (override、overwrite)。也称为方法的重置、覆盖。
在程序执行时，子类的方法将覆盖父类的方法。
3.1 方法重写举例
比如新的手机增加来电显示头像的功能，代码如下：
package com.atguigu.inherited.method;
public class Phone {
public void sendMessage(){
System.out.println("发短信");
}
public void call(){
System.out.println("打电话");
}
public void showNum(){
System.out.println("来电显示号码");
}
}
package com.atguigu.inherited.method;
//SmartPhone：智能手机
public class SmartPhone extends Phone{
//重写父类的来电显示功能的方法
@Override
public void showNum(){
//来电显示姓名和图片功能
System.out.println("显示来电姓名");
System.out.println("显示头像");
}
//重写父类的通话功能的方法
@Override
public void call() {
System.out.println("语音通话 或 视频通话");
}
}
package com.atguigu.inherited.method;
public class TestOverride {
public static void main(String[] args) {
// 创建子类对象
SmartPhone sp = new SmartPhone();
// 调用父类继承而来的方法
sp.call();
// 调用子类重写的方法
sp.showNum();
}
}
@Override使用说明：
写在方法上面，用来检测是不是满足重写方法的要求。这个注解就算不写，只要满足要求，也是正确的方法覆盖重写。建议保留，这样编译器可以帮助我们检查格式，另外也可以让阅读源代码的程序员清晰的知道这是一个重写的方法。
3.2 方法重写的要求
-
子类重写的方法
必须和父类被重写的方法具有相同的方法名称、参数列表。 -
子类重写的方法的返回值类型
不能大于父类被重写的方法的返回值类型。（例如：Student < Person）。
注意：如果返回值类型是基本数据类型和void，那么必须是相同
- 子类重写的方法使用的访问权限
不能小于父类被重写的方法的访问权限。（public > protected > 缺省 > private）
注意：① 父类私有方法不能重写 ② 跨包的父类缺省的方法也不能重写
- 子类方法抛出的异常不能大于父类被重写方法的异常
此外，子类与父类中同名同参数的方法必须同时声明为非static的(即为重写)，或者同时声明为static的（不是重写）。因为static方法是属于类的，子类无法覆盖父类的方法。
3.3 小结：方法的重载与重写
方法的重载：方法名相同，形参列表不同。不看返回值类型。
方法的重写：见上面。
（1）同一个类中
package com.atguigu.inherited.method;
public class TestOverload {
public int max(int a, int b){
return a > b ? a : b;
}
public double max(double a, double b){
return a > b ? a : b;
}
public int max(int a, int b,int c){
return max(max(a,b),c);
}
}
（2）父子类中
package com.atguigu.inherited.method;
public class TestOverloadOverride {
public static void main(String[] args) {
Son s = new Son();
s.method(1);//只有一个形式的method方法
Daughter d = new Daughter();
d.method(1);
d.method(1,2);//有两个形式的method方法
}
}
class Father{
public void method(int i){
System.out.println("Father.method");
}
}
class Son extends Father{
public void method(int i){//重写
System.out.println("Son.method");
}
}
class Daughter extends Father{
public void method(int i,int j){//重载
System.out.println("Daughter.method");
}
}
3.4 练习
练习1：如果现在父类的一个方法定义成private访问权限，在子类中将此方法声明为default访问权限，那么这样还叫重写吗？ (NO)
练习2：修改继承内容的练习2中定义的类Kids，在Kids中重新定义employeed()方法，覆盖父类ManKind中定义的employeed()方法，输出“Kids should study and no job.”
四. 再谈封装性中的4种权限修饰
权限修饰符：public,protected,缺省,private
| 修饰符 | 本类 | 本包 | 其他包子类 | 其他包非子类 |
|---|---|---|---|---|
| private | √ | × | × | × |
| 缺省 | √ | √（本包子类非子类都可见） | × | × |
| protected | √ | √（本包子类非子类都可见） | √（其他包仅限于子类中可见） | × |
| public | √ | √ | √ | √ |
外部类：public和缺省
成员变量、成员方法等：public,protected,缺省,private
1、外部类要跨包使用必须是public，否则仅限于本包使用
（1）外部类的权限修饰符如果缺省，本包使用没问题
（2）外部类的权限修饰符如果缺省，跨包使用有问题
2、成员的权限修饰符问题
（1）本包下使用：成员的权限修饰符可以是public、protected、缺省
（2）跨包下使用：要求严格
（3）跨包使用时，如果类的权限修饰符缺省，成员权限修饰符>类的权限修饰符也没有意义
五. 关键字：super
5.1 super的理解
在Java类中使用super来调用父类中的指定操作：
- super可用于访问父类中定义的属性
- super可用于调用父类中定义的成员方法
- super可用于在子类构造器中调用父类的构造器
注意：
- 尤其当子父类出现同名成员时，可以用super表明调用的是父类中的成员
- super的追溯不仅限于直接父类
- super和this的用法相像，this代表本类对象的引用，super代表父类的内存空间的标识
5.2 super的使用场景
5.2.1 子类中调用父类被重写的方法
- 如果子类没有重写父类的方法，只要权限修饰符允许，在子类中完全可以直接调用父类的方法；
- 如果子类重写了父类的方法，在子类中需要通过
super.才能调用父类被重写的方法，否则默认调用的子类重写的方法
举例：
package com.atguigu.inherited.method;
public class Phone {
public void sendMessage(){
System.out.println("发短信");
}
public void call(){
System.out.println("打电话");
}
public void showNum(){
System.out.println("来电显示号码");
}
}
//smartphone：智能手机
public class SmartPhone extends Phone{
//重写父类的来电显示功能的方法
public void showNum(){
//来电显示姓名和图片功能
System.out.println("显示来电姓名");
System.out.println("显示头像");
//保留父类来电显示号码的功能
super.showNum();//此处必须加super.，否则就是无限递归，那么就会栈内存溢出
}
}
总结：
-
方法前面没有super.和this.
- 先从子类找匹配方法，如果没有，再从直接父类找，再没有，继续往上追溯
-
方法前面有this.
- 先从子类找匹配方法，如果没有，再从直接父类找，再没有，继续往上追溯
-
方法前面有super.
- 从当前子类的直接父类找，如果没有，继续往上追溯
5.2.2 子类中调用父类中同名的成员变量
- 如果实例变量与局部变量重名，可以在实例变量前面加this.进行区别
- 如果子类实例变量和父类实例变量重名，并且父类的该实例变量在子类仍然可见，在子类中要访问父类声明的实例变量需要在父类实例变量前加super.，否则默认访问的是子类自己声明的实例变量
- 如果父子类实例变量没有重名，只要权限修饰符允许，在子类中完全可以直接访问父类中声明的实例变量，也可以用this.实例访问，也可以用super.实例变量访问
举例：
class Father{
int a = 10;
int b = 11;
}
class Son extends Father{
int a = 20;
public void test(){
//子类与父类的属性同名，子类对象中就有两个a
System.out.println("子类的a：" + a);//20 先找局部变量找，没有再从本类成员变量找
System.out.println("子类的a：" + this.a);//20 先从本类成员变量找
System.out.println("父类的a：" + super.a);//10 直接从父类成员变量找
//子类与父类的属性不同名，是同一个b
System.out.println("b = " + b);//11 先找局部变量找，没有再从本类成员变量找，没有再从父类找
System.out.println("b = " + this.b);//11 先从本类成员变量找，没有再从父类找
System.out.println("b = " + super.b);//11 直接从父类局部变量找
}
public void method(int a, int b){
//子类与父类的属性同名，子类对象中就有两个成员变量a，此时方法中还有一个局部变量a
System.out.println("局部变量的a：" + a);//30 先找局部变量
System.out.println("子类的a：" + this.a);//20 先从本类成员变量找
System.out.println("父类的a：" + super.a);//10 直接从父类成员变量找
System.out.println("b = " + b);//13 先找局部变量
System.out.println("b = " + this.b);//11 先从本类成员变量找
System.out.println("b = " + super.b);//11 直接从父类局部变量找
}
}
class Test{
public static void main(String[] args){
Son son = new Son();
son.test();
son.method(30,13);
}
}
总结：起点不同（就近原则）
-
变量前面没有super.和this.
- 在构造器、代码块、方法中如果出现使用某个变量，先查看是否是当前块声明的
局部变量， - 如果不是局部变量，先从当前执行代码的
本类去找成员变量 - 如果从当前执行代码的本类中没有找到，会往上找
父类声明的成员变量（权限修饰符允许在子类中访问的）
- 在构造器、代码块、方法中如果出现使用某个变量，先查看是否是当前块声明的
-
变量前面有this.
- 通过this找成员变量时，先从当前执行代码的本类去找成员变量
- 如果从当前执行代码的本类中没有找到，会往上找==父类声明的成员变量（==权限修饰符允许在子类中访问的）
-
变量前面super.
- 通过super找成员变量，直接从当前执行代码的直接父类去找成员变量（权限修饰符允许在子类中访问的）
- 如果直接父类没有，就去父类的父类中找（权限修饰符允许在子类中访问的）
特别说明：应该避免子类声明和父类重名的成员变量
在阿里的开发规范等文档中都做出明确说明：
阿里巴巴Java开发手册-1.7.1-黄山版
5.2.3 子类构造器中调用父类构造器
① 子类继承父类时，不会继承父类的构造器。只能通过“super(形参列表)”的方式调用父类指定的构造器。
② 规定：“super(形参列表)”，必须声明在构造器的首行。
③ 我们前面讲过，在构造器的首行可以使用"this(形参列表)"，调用本类中重载的构造器，
结合②，结论：在构造器的首行，“this(形参列表)” 和 "super(形参列表)"只能二选一。
④ 如果在子类构造器的首行既没有显示调用"this(形参列表)“，也没有显式调用"super(形参列表)”，
则子类此构造器默认调用"super()"，即调用父类中空参的构造器。
⑤ 由③和④得到结论：子类的任何一个构造器中，要么会调用本类中重载的构造器，要么会调用父类的构造器。
只能是这两种情况之一。
⑥ 由⑤得到：一个类中声明有n个构造器，最多有n-1个构造器中使用了"this(形参列表)“，则剩下的那个一定使用"super(形参列表)”。
开发中常见错误：
如果子类构造器中既未显式调用父类或本类的构造器，且父类中又没有空参的构造器，则
编译出错。
情景举例1：
class A{
}
class B extends A{
}
class Test{
public static void main(String[] args){
B b = new B();
//A类和B类都是默认有一个无参构造，B类的默认无参构造中还会默认调用A类的默认无参构造
//但是因为都是默认的，没有打印语句，看不出来
}
}
情景举例2：
class A{
A(){
System.out.println("A类无参构造器");
}
}
class B extends A{
}
class Test{
public static void main(String[] args){
B b = new B();
//A类显示声明一个无参构造，
//B类默认有一个无参构造，
//B类的默认无参构造中会默认调用A类的无参构造
//可以看到会输出“A类无参构造器"
}
}
情景举例3：
class A{
A(){
System.out.println("A类无参构造器");
}
}
class B extends A{
B(){
System.out.println("B类无参构造器");
}
}
class Test{
public static void main(String[] args){
B b = new B();
//A类显示声明一个无参构造，
//B类显示声明一个无参构造，
//B类的无参构造中虽然没有写super()，但是仍然会默认调用A类的无参构造
//可以看到会输出“A类无参构造器"和"B类无参构造器")
}
}
情景举例4：
class A{
A(){
System.out.println("A类无参构造器");
}
}
class B extends A{
B(){
super();
System.out.println("B类无参构造器");
}
}
class Test{
public static void main(String[] args){
B b = new B();
//A类显示声明一个无参构造，
//B类显示声明一个无参构造，
//B类的无参构造中明确写了super()，表示调用A类的无参构造
//可以看到会输出“A类无参构造器"和"B类无参构造器")
}
}
情景举例5：
class A{
A(int a){
System.out.println("A类有参构造器");
}
}
class B extends A{
B(){
System.out.println("B类无参构造器");
}
}
class Test05{
public static void main(String[] args){
B b = new B();
//A类显示声明一个有参构造，没有写无参构造，那么A类就没有无参构造了
//B类显示声明一个无参构造，
//B类的无参构造没有写super(...)，表示默认调用A类的无参构造
//编译报错，因为A类没有无参构造
}
}
情景举例6：
class A{
A(int a){
System.out.println("A类有参构造器");
}
}
class B extends A{
B(){
super();
System.out.println("B类无参构造器");
}
}
class Test06{
public static void main(String[] args){
B b = new B();
//A类显示声明一个有参构造，没有写无参构造，那么A类就没有无参构造了
//B类显示声明一个无参构造，
//B类的无参构造明确写super()，表示调用A类的无参构造
//编译报错，因为A类没有无参构造
}
}
情景举例7：
class A{
A(int a){
System.out.println("A类有参构造器");
}
}
class B extends A{
B(int a){
super(a);
System.out.println("B类有参构造器");
}
}
class Test07{
public static void main(String[] args){
B b = new B(10);
//A类显示声明一个有参构造，没有写无参构造，那么A类就没有无参构造了
//B类显示声明一个有参构造，
//B类的有参构造明确写super(a)，表示调用A类的有参构造
//会打印“A类有参构造器"和"B类有参构造器"
}
}
情景举例8：
class A{
A(){
System.out.println("A类无参构造器");
}
A(int a){
System.out.println("A类有参构造器");
}
}
class B extends A{
B(){
super();//可以省略，调用父类的无参构造
System.out.println("B类无参构造器");
}
B(int a){
super(a);//调用父类有参构造
System.out.println("B类有参构造器");
}
}
class Test8{
public static void main(String[] args){
B b1 = new B();
B b2 = new B(10);
}
}
5.3 小结：this与super
1、this和super的意义
this：当前对象
- 在构造器和非静态代码块中，表示正在new的对象
- 在实例方法中，表示调用当前方法的对象
super：引用父类声明的成员
2、this和super的使用格式
- this
- this.成员变量：表示当前对象的某个成员变量，而不是局部变量
- this.成员方法：表示当前对象的某个成员方法，完全可以省略this.
- this()或this(实参列表)：调用另一个构造器协助当前对象的实例化，只能在构造器首行，只会找本类的构造器，找不到就报错
- super
- super.成员变量：表示当前对象的某个成员变量，该成员变量在父类中声明的
- super.成员方法：表示当前对象的某个成员方法，该成员方法在父类中声明的
- super()或super(实参列表)：调用父类的构造器协助当前对象的实例化，只能在构造器首行，只会找直接父类的对应构造器，找不到就报错
5.4 练习
练习1：修改方法重写的练习2中定义的类Kids中employeed()方法，在该方法中调用父类ManKind的employeed()方法，然后再输出“but Kids should study and no job.”
练习2：修改继承中的练习3中定义的Cylinder类，在Cylinder类中覆盖findArea()方法，计算圆柱的表面积。考虑：findVolume方法怎样做相应的修改？
在CylinderTest类中创建Cylinder类的对象，设置圆柱的底面半径和高，并输出圆柱的表面积和体积。
附加题：在CylinderTest类中创建一个Circle类的对象，设置圆的半径，计算输出圆的面积。体会父类和子类成员的分别调用。
练习3：
1、写一个名为Account的类模拟账户。该类的属性和方法如下图所示。该类包括的属性：账号id，余额balance，年利率annualInterestRate；包含的方法：访问器方法（getter和setter方法），返回月利率的方法getMonthlyInterest()，取款方法withdraw()，存款方法deposit()。
写一个用户程序测试Account类。在用户程序中，创建一个账号为1122、余额为20000、年利率4.5%的Account对象。使用withdraw方法提款30000元，并打印余额。
再使用withdraw方法提款2500元，使用deposit方法存款3000元，然后打印余额和月利率。
提示：在提款方法withdraw中，需要判断用户余额是否能够满足提款数额的要求，如果不能，应给出提示。
运行结果如图所示：
2、创建Account类的一个子类CheckAccount代表可透支的账户，该账户中定义一个属性overdraft代表可透支限额。在CheckAccount类中重写withdraw方法，其算法如下：
如果（取款金额<账户余额），
可直接取款
如果（取款金额>账户余额），
计算需要透支的额度
判断可透支额overdraft是否足够支付本次透支需要，如果可以
将账户余额修改为0，冲减可透支金额
如果不可以
提示用户超过可透支额的限额
要求：写一个用户程序测试CheckAccount类。在用户程序中，创建一个账号为1122、余额为20000、年利率4.5%，可透支限额为5000元的CheckAccount对象。
使用withdraw方法提款5000元，并打印账户余额和可透支额。
再使用withdraw方法提款18000元，并打印账户余额和可透支额。
再使用withdraw方法提款3000元，并打印账户余额和可透支额。
提示：
（1）子类CheckAccount的构造方法需要将从父类继承的3个属性和子类自己的属性全部初始化。
（2）父类Account的属性balance被设置为private，但在子类CheckAccount的withdraw方法中需要修改它的值，因此应修改父类的balance属性，定义其为protected。
运行结果如下图所示：
（来源：尚硅谷-宋红康）