Java基础入门【第六章 static、继承、重写、多态】_静态代码块和显式初始化-CSDN博客

本文链接：https://blog.csdn.net/H551493l/article/details/141202720

本章内容
static关键字
继承super
关键字权限
修饰符方法
重写
多态
final关键字
引用类型转换

1 static

1.1 问题引入
某市有三所中学：第一中学、秀峰中学、娄江中学，分别有3000人、2500
人、1800人，它们都没有图书馆，也无力独自建造一所图书馆。市领导了解这
一情况后，经研究决定，由市委市政府出资建造一所图书馆，命名为"栋梁图
书馆"，供该市所有中学师生公共使用。
根据前期学习的内容，用面向对象的编程思想编码描述上述案例，代码具体
如下：

//学校类
class School {
p r i v a t e S t r i n g n a m e ; //名称
p r i v a t e i n t n u m ; //师生数量
private String library;
//定义构造器
public School() {}
//图书馆
public School(String name, int num, String library)
{ this.name = name;
this.num = num;
this.library = library;
}
public void show() {
S y s t e m .o u t .p r i n t l n (" 学校名称 : " + t h i s . n a m e );
S y s t e m .o u t .p ri n t l n (" 师生数量 : " + n u m );
S y s t e m . o u t . p r i n t l n ( " 图书馆 : " + l i b r a r y ) ;
}
}
public class Test0101_School {
public static void main(String[] args) {
S c h oo l s 1 = n e w S c ho o l ("第一中学 ",3 0 0 0 ,"栋梁图书馆 ");
S c h oo l s 2 = n e w S c ho o l ("秀峰中学 ",2 5 0 0 ,"栋梁图书馆 ");
S c h o o l s 3 = n e w S c h o o l ("娄江中学 ",1 8 0 0 ,"栋梁图书馆 ");
s1.show();
System.out.println("--------------");
s2.show();
System.out.println("--------------");
s3.show();
}
}

思考：上述案例中，学校类中添加图书馆属性 private String library; 是
否合理？
结论是不合理。
因为图书馆不为某一个学校所特有，而是为市里面所有中学共同所有，目前
是3所中学共享，将来如果市里建造第四、第五所高中，新高中的师生也是可
以使用该图书馆的。

而 private String library; 这样定义属性，则表示每个学校对象，都有自己独立的图书馆，与实际业务不符。具体可结合下面对象内存图理解：实际我们想要的效果为图书馆有且只有一个，只占用一块内存区域，具体如下图：

static 修饰符能够帮我们实现这样的效果，该关键字的具体细节后续专门学
习。
static是一个修饰符，表示静态的意思，可以修饰属性、方法、代码块
1.2 静态成员
static修饰类中的数据成员，该成员就成了静态数据成员，也称为类成员；
类成员，是属于类的，为这个类所有对象共享，只占用一块内存空间。
生活中案例：
普通成员变量
就像教室中，同学们的水杯，每个同学都有一个自己的水杯，和其他人相
互不影响
静态数据成员
就像教室中，角落里的饮水机，它是这个教室中所有同学共享的，张三接
一杯水，李四就会看到饮水机中的水少了一些，同样的李四接一杯水，张
三也会看到饮水机中的水少了一些
static成员特点：
被类的所有对象共享
随着类的加载而加载，先于对象存在
对象需要类被加载后，才能被创建出来
可以通过类名调用，也可以通过对象名调用，推荐使用类名调用
格式：类名 .静态数据成员 ;
方法区中有一块专门的区域：静态区，专门用来存储类的static成员
静态成员访问方式，案例描述：
class Demo {
public static int num; }
public static void main(String[] args) {
//可以使用类名来访问，推荐用法
Demo.num = 10;
Demo demo = new Demo();
//也可以对象来访问，但不推荐
demo.num = 20; }
静态数据成员是属于类的，并且为这个类所有对象共享，案例描述：
class Demo {
public static int num; }
public static void main(String[] args) {
//1.静态数据成员会随着类的加载而加载（开辟内存并进行默认初始化）
//先于对象存在
Demo.num = 10;
//2.实例化两个对象，然后通过对象访问静态成员，输出其值
Demo demo1 = new Demo();
Demo demo2 = new Demo();
S y s t e m .ou t.println (d e m o 1 .n u m );//输出结果为 1 0
S y s t e m .ou t .println (d e m o 2 .n u m );//输出结果为 1 0
//3.通过类名修改静态成员值，再借助对象 .static成员，输出其值
Demo.num = 20;
S y s t e m .ou t.println (d e m o 1 .n u m );//输出结果为 2 0
S y s t e m .ou t .println (d e m o 2 .n u m );//输出结果为 2 0

//4.通过对象名修改静态成员值，再借助类名 .static成员，输出其值
demo1.num = 30;
S y s t e m .ou t .println (D e m o .n u m );//输出结果为 3 0
S y s t e m .out .println (d e m o 2 .n u m );//输出结果为 3 0
}
可以看出，无论是使用类访问静态属性，还是使用这个类的某个对象访问
静态属性，效果是一样的，这个属性对这个类的所有对象都是可见的、共
享的。
静态属性存储位置：
在方法区中有一块静态区，专门用来存储各个类静态数据成员。当操作静态数
据成员时，不论是通过类名，还是通过对象名操作，都是操作静态区中对应的
内存区域。

静态数据成员初始化：
静态数据成员随着类加载而加载（开辟相应内存），并会进行默认的初始
化
其默认初始化值为 null(引用类型 )、 0(整形 )、 0.0(浮点型 )、 false(布
尔类型 ) 。
案例描述：
class Demo {
public static int num;
public static String str;
public static double dNum;
public static boolean flag;
}
public class Test0102_StaticValue {
public static void main(String[] args)
{ System.out.println(Demo.num); / / 0
System.out.println(Demo.str); //null
System.out.println(Demo.dNum); //0.0
System.out.println(Demo.flag); //false
}
}
对静态数据成员的初始化，一般采用两种方式
显式初始化、静态代码块初始化（后面章节介绍）
显式初始化格式： [修饰符 ] static 数据类型静态成员名 = 初始值 ;
例： p u b l i c s t a t i c S t r i n g l i b r a r y = " 栋梁图书馆 " ;
注意：尽量不要在构造方法中对static成员进行初始化，因为只要创建对象，
构造方法就会自动被执行，导致static成员值不经意间被修改！
案例描述：
请根据讲解内容，修改上一章节中School类代码，并完成测试。
//学校类
class School {
p r i v a t e S t r i n g n a m e ; //名称
p r i v a t e i n t n u m ; //师生数量
//该类所有对象共享的图书馆，显示初始化
p u b l i c s t a t i c S t r i n g l i b r a r y = " 栋梁图书馆 " ;
//定义构造器
public School() {}
public School(String name, int num)
{ this.name = name;
this.num = num; }
//该构造器不合适，尽量不要在构造方法中对 static成员进行初始化
// public School(String name, int num, String library) {
/ / this.name = name;
/ / this.num = num;
/ / this.library = library;
// }
public void show() {
S y s t e m . o u t .p r i n t l n ( " 学校名称 : " + t h i s .n a m e );
S y s t e m .o u t .p ri n t l n (" 师生数量 : " + n u m );
S y s t e m . o u t .p r i n t l n ( " 图书馆 : " + S c h o o l . l i b r a r y );
}
}
public class Test0102_School {
public static void main(String[] args) {
//1.在创建 School对象前，输出 static成员值
//此时程序正常输出，说明 static成员的创建与初始化先于对象
//结论： static成员依赖类，而与该类对象无关
System.out.println(School.library);
//2.创建类对象
S c h o o l s 1 = n e w S c h o o l ("第一中学 ",3 0 0 0 );
System.out.println(s1.library);
s1.show();
System.out.println("-------------");
S c h o o l s 2 = n e w S c h o o l ("秀峰中学 ",2 5 0 0 );
s2.show();
System.out.println("-------------");
S c h o o l s 3 = n e w S c h o o l ("娄江中学 ",1 8 0 0 );
s3.show();
}
}
运行效果：
1.3 静态方法
在类中，使用static修饰的方法，就是静态方法；
static方法的作用，主要是用来操作static成员；
static方法可以使用类名来调用，也可以使用对象来调用，但推荐使用类名。
案例描述：
public class Demo{
//定义静态方法
public static void test() {
S y s t e m . o u t . p r i n t l n ( " 我是 s t a t i c 静态方法 . . . " );
}
}
//测试方法
public static void main(String[] args){
//借助类名调用 static方法，推荐方式
Demo.test();
Demo demo = new Demo();
//借助对象调用 static方法，可以调用，但不推荐
demo.test(); }
static方法和普通成员方法区别：
静态方法只能访问静态的成员
非静态方法可以访问静态的成员，也可以访问非静态的成员
静态方法中没有this关键字（本质区别）
案例描述：
//学校类
class School {
p r i v a t e S t r i n g n a m e ; //名称
p r i v a t e i n t n u m ; //师生数量
//用 private 修饰 static成员，则该类外无法直接访问该 static成员
p r i v a t e s t a t i c S t r i n g l i b r a r y = " 栋梁图书馆 " ;
//定义 public修饰的 static方法，专门来操作 static成员
public static String getLibrary() {
//注意 1 ： static方法中没有 t h is
//return this.library; //error
//注意 2： static方法中不可以访问普通数据成员
/ / n a m e = "一高 ";
return library;
//error
}
}
//测试方法
public static void main(String[] args) {
//1.在创建 School对象前，输出 static成员值
//编译报错， library为 private ，只能 S choo l类内访问
//System.out.println(School.library);
//2.借助类名调用 static方法，推荐用法
String lib = School.getLibrary();
System.out.println(lib);
//3.借助方法名调用 static方法，不推荐
S c h o o l s 1 = n e w S c h o o l ("第一中学 ",3 0 0 0 );
System.out.println(s1.getLibrary()); }
思考：为什么静态方法中不能访问普通数据成员？
静态方法也称为类方法，该类方法的调用不依赖对象，可以直接通过类
名调用。
假设静态成员方法中能够访问普通数据成员，静态方法中有this引用，我
们来看下面场景：我们通过类名调用static方法，此时根本不会传递对象的
地址值给this引用，static方法内部也无法找到普通数据成员对应的内存空
间进行取值，这与我们要实现的功能是矛盾的。
故而，大家记住结论：静态只能访问静态。
1.4 代码块
在Java中，使用 { } 括起来的代码被称为代码块，可以分为三类：
局部代码块
构造代码块
静态代码块
1）局部代码块
位置：类的方法中定义
格式： { 语句体 ; }
作用：用于限定变量的生命周期，使其尽早释放，从而提高栈空间内存利
用率
重要程度：了解，使用不多
案例展示：

public class Test0104_LocalBlock {
/*
局部代码块
位置：方法中定义
作用：限定变量的生命周期，及早释放，提高内存利用率
*/
public static void main(String[] args) {
//局部代码块
{
int a = 10;
System.out.println(a);
}
//上面局部代码块中的a是局部变量，遇到 } 其占用的内存空间就销毁了
//故而，下面输出语句编译报错
//System.out.println(a); }
}
2）构造代码块
位置：类中方法外
格式： { 语句体 ; }
特点：每次构造方法执行前，都会先执行该代码块中代码
作用：如果多个构造方法中出现相同代码，可抽取到该块中，从而提高代
码复用性
重要程度：掌握
案例展示：

//基础类
class Module
{ private int
num;
//构造 |匿名代码块
{
S y s t e m .o u t .println ( "构造代码块 : 构造方法执行前执行 ..."); }
//无参构造方法
public Module()
{ System.out.println("Module() ..."
);
}
//有参构造方法
public Module(int num)
{ System.out.println("Module(int) ...");
this.num = num;
}
}
//测试类
public class Test0104_ConsBlock {
public static void main(String[] args) {
//实例化2个对象，观察程序输出效果：
//每次构造方法执行前，都会自动执行构造代码块
Module m1 = new Module();
Module m2 = new Module(10); }
}

3）静态代码块
位置：类中方法外
格式： s t a t i c { 语句体 ; }
特点：需要通过static关键字修饰，随着类的加载而加载，只执行一次
作用：类加载时做一些数据的初始化操作（一般给static成员赋值）
重要程度：掌握
案例展示：
基础类定义：
注意：去com.briup.chap06.bean下创建类School，避免与原来的School冲
突。
package com.briup.chap06.bean;
/*
静态代码块:
位置：类中方法外定义
特点：需要通过static关键字修饰，随着类的加载而加载，并且只执行一次
作用：在类加载的时候做一些数据初始化的操作
*/
//学校类
public class School {
p r i v a t e S t r i n g n a m e ; //名称
p r i v a t e i n t n u m ; //师生数量
//static成员第一种初始化方式：显式初始化
p r i v a t e s t a t i c S t r i n g l i b r a r y = " 栋梁图书馆 " ;
//静态代码块：随着类加载而加载，只执行一次
//static成员第二种初始化方式
static {
/ / l i b r a r y = " 凌云图书馆 ";
S y s t e m . o u t . p r i n t l n ( " s t a t i c 代码块执行 . . . " );
}
//构造代码块
{
S y s t e m .o u t .p ri n t l n ( " 构造代码块执行 .. ." );
}
public School()
{ System.out.println("School()..."
);
}
public School(String name, int num)
{ System.out.println("School(String,int)...");
this.name = name;
this.num = num; }
public void show() {
S y s t e m . o u t .p r i n t l n ( " 学校名称 : " + t h i s .n a m e );
S y s t e m .o u t .p ri n t l n (" 师生数量 : " + n u m );
S y s t e m . o u t .p r i n t l n ( " 图书馆 : " + S c h o o l . l i b r a r y );
}
}
测试类定义
import com.briup.chap06.bean.School;
public class Test0104_StaticBlock {
public static void main(String[] args)
{ School s1 = new School();
S c h o o l s 2 = n e w S c h o o l ("黄埔中学 ", 2 0 0 0 );
}
}

分析运行效果可知：static代码块随着类加载会执行，且只会执行一次。
补充内容：static成员显式初始化和静态代码块，执行顺序问题

结论：显式初始化和静态代码块，谁在上面，谁先执行！
1.5 类加载时机
加载类的含义：JVM虚拟机将该类的class文件加载到内存的方法区中。
当Java代码中用到某个类的时候，就会加载该类。
加载情况列举：
程序启动，找到main方法运行，此时用到main方法所属的类，应该加载该
类
//运行程序，先加载 Test.class
public class Test {
public static void main(String[] args) {
//...
}
}
第一次使用类：实例化对象
如： School s 1 = n e w School();
第一次使用类：通过类名访问其静态数据成员
如： S c h o o l . l i b r a r y = " 凌志楼 " ;
第一次使用类：通过类名调用其静态成员方法
如： S c h o o l . s e t L i b r a r y ( " 逸夫楼 ") ;
其他情况后续补充
1.6 对象创建过程
public static void main(String[] args) {
S c h o o l s = n e w S c h o o l ("一中 ",3 0 0 0 );
}
请描述 School类对象s 的创建和初始化过程：
对 School 类进行类加载
去方法区中的静态区为 School.library 分配内存空间，并做默认初始化
（值为 null ）
对 School.library 进行显式初始化，执行 School 类中的静态代码块
注意：谁在前面则谁先执行
在栈空间（main方法函数帧）开辟一块内存，用 s(引用变量) 标识
堆区中分配对象的内存空间，同时进行默认初始化
对 School 中的属性进行显式初始化
例如： public int n u m = 200 0 ;
执行 School 类的构造代码块
执行 School 类的构造方法
把对象堆空间的内存地址赋给变量s（写入s那块内存区域中）
至此：对象成功创建，并初始化成功！
案例展示：
基础类：跟之前基本保持一致，注意下面第5、21行
//学校类
public class School
{ private String
name;
//显式初始化
private int num = 2000;
//静态代码块
static {
l i b ra ry = "凌云图书馆 ";
S y s t e m . o u t . p r i n t l n ( " s t a t i c 代码块执行 . . . " );
}
//显式初始化
p r i v a t e s t a t i c S t r i n g l i b r a r y = " 栋梁图书馆 " ;
{
S y s t e m .o u t .p ri n t l n ( " 构造代码块执行 .. ." );
}
public School(String name, int num) {
//注意：this.num输出的值为 1000，说明显式初始化早与构造方法执
行
System.out.println("School(String,int)... num: " +
this.num);
this.name = name;
this.num = num;
}
/ / . . . 省略 }
测试类
package com.briup.chap06.test;
import com.briup.chap06.bean.School;
public class Test0106_ObjCreation {
public static void main(String[] args)
{ S c h o o l s = n e w S c h o o l ("黄埔中学 ",
1 0 0 0 ); s.show();
}
}
运行结果：
s t a t i c 代码块执行 ...
构造代码块执行 ...
School(String,int)... num: 2000
学校名称: 黄埔中学
师生数量 : 1000
图书馆: 栋梁图书馆
1.7 静态导入
JDK1.5中增加了静态导入的功能，具体描述如下：
在自定义类中，要使用另一个类中的静态属性和静态方法，可以使用静态
导入。
导入完成后，可以直接使用这个类中的静态属性和静态方法，而不用在前
面加上类名。
实际开发时，大家能看得懂静态导入相关代码即可，不强制要求使用静态导
入。
静态导入格式：
导入静态成员： i mpo r t static 类的全包名 .static数据成员名 ;
导入静态方法： i mpo r t static 类的全包名 .static成员方法名 ;
案例展示：
没有使用静态导

public class Test0107_StaticImport {
public static void main(String[] args) {
//访问Math类中的静态属性PI，表示圆周率π
System.out.println(Math.PI);
//访问 Math类中的静态方法 random(),生成随机数
System.out.println(Math.random());
}
}
使用静态导入的情况
package com.briup.chap06.test;
import static java.lang.Math.PI;
import static java.lang.Math.random;
public class Test0107_StaticImport {
public static void main(String[] args) {
//访问Math类中的静态属性PI，表示圆周率π
System.out.println(PI);
//访问 Math类中的静态方法 random(),生成随机数
System.out.println(random()); }
}
观察上述案例可知，使用静态导入可以简化我们的代码。

2 继承

类和类之间的关系有很多种，继承是其中一种，除此之外还有依赖、组
合、聚合等关系
2.1 概念理解
继承是面向对象三大特征之一，可以有效的提高代码的复用性。
生活中继承的案例有很多，例如：

继承关系体现的是一种 "is a" 的关系！
例如，蛇继承了爬行动物，爬行动物继承了动物，我们就可以描述：蛇 is a
爬行动物，爬行动物是动物中的一种。
2.2 继承实现
子类继承父类，使用 extends 关键字实现。
格式：
[p u b l i c ] c l a s s 子类名 e x t e n d s 父类名
{子类新增内容;
}
在继承关系中，父类也称基类、超类；子类也称派生类。
案例展示：

//定义 Person类，作为父类
class Person {
private String name;
public void setName(String name)
{ this.name = name;
}
public void sayHello()
{ System.out.println("hello~ I am " +
name);
}
}
//定义 Student类，作为子类继承 Person
class Student extends Person {
// 新增内容可以为空
}
public class Test0202_Basic {
// 测试代码
public static void main(String[] args) {
// 实例化一个子类对象
Student stu = new Student();
// setName方法从父类中继承而来
stu.setName("tom");
// sayHello方法从父类中继承而来
stu.sayHello();
}
}
2.3 继承特点
1）Java只支持单继承，不支持多继承

//错误示例：编译报错，一个类只能有且只有一个父类
p ub l i c c l a s s 博士生 e x t e n d s 老师 ,学生 {
}
2）Java支持多层继承
子类A 继承父类B ，父类B 继承爷爷类C

class Grandpa {
public void farming() {
S y s t e m .o u t .p ri n t l n ("爷爷喜欢种地 ");
}
}
class Father extends Grandpa {
// Father类继承父类中 farming 方法
//子类新增方法
public void fishing() {
S y s t e m . o u t .p ri n t l n ("爸爸爱钓鱼 ");
}
}
class Son extends Father {
// S o n 类继承父类中 farming 方法和 fishing方法
//子类新增方法
public void skidding() {
S y s t e m . o u t .p ri n t l n ("孙子爱轮滑 ");
}
}
//多层继承测试
public class Test0203_MulExtends {
public static void main(String[] args) {
Son s = new Son();
s.farming();
s.fishing();
s.skidding();
}
}
2.4 继承细节
子类只能继承父类所有非私有的成员（含成员方法和成员变量）
Java官方文档描述：从继承的概念来说，private修饰的成员不能被继承。
官网描述：
https://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html
案例展示：
父类Animal:

//提供父类
public class Animal {
//成员一个私有，一个公有
private String color;
public int age;
//提供 g e t | s e t 方法
public String getColor()
{ return color;
}
public void setColor(String color)
{ this.color = color;
}
public int getAge() {
System.out.println("in Animal getAge() ...");
return age;
}
public void setAge(int age)
{ this.age = age;
}
}
子类Dog：
package com.briup.chap06.bean;
//定义 Dog子类继承 Animal
public class Dog extends Animal {
// 父类中的 private成员，子类中不可以直接操作（无直接访问权限）
// Animal: private String color;
// 父类中的非 private成员，子类中可以直接操作
// Animal: public int age;
// 子类新增属性
private String name;
// 子类新增 get|set方法
public void setName(String name)
{ this.name = name;
}
public String getName()
{ return name;
}
// 子类新增方法：输出子类对象所有属性(含新增属性、从父类继承)
public void disp() {
// 子类方法中不能直接操作父类 private成员
/ / S y s t e m . o u t . p r i n t l n ( " 继承 c o l o r : " + c o l o r ) ; e r r o r
// 子类方法中可以间接操作 (借助 public的 get|set) 父类 private 成
员
S y s t e m . o u t . p r i n t l n ( " 继承 c o l o r : " + g e t C o l o r ( ) ) ;
// 子类方法中可以直接操作父类非 private成员
S y s t e m . o u t .p r i n t l n ( " 继承 a g e : " + a g e );
S y s t e m .o u t .p r i n t ( "新增 : " + n a m e );
}
}
测试案例：
package com.briup.chap06.test;
import com.briup.chap06.bean.Animal;
import com.briup.chap06.bean.Dog;
public class Test0204_AccessMember {
public static void main(String[] args)
{ Dog d = new Dog();
//子类对象调用从父类继承的 public方法
d.setColor("yellow");
d.setAge(2);
//子类对象调用新增的方法
d .s e t N a m e ( "虎子 ");
d.disp();
}
}
子类对象内存构成：

注意事项：
从内存角度来分析，父类中的private成员，子类实际上也完全继承了下来
（非专业描述）
非专业描述：完全继承、有限访问
新皇登基，全部继承（含private后宫），但不能直接访问，间接方式操作
（武才人）
父类private成员为父类私有，在父类成员方法中可以直接访问，在其他类
中（含子类），不能直接操作
子类中不能直接操作父类private成员，但是可以通过间接方式（比如借助
父类public的get|set方法）操作
额外补充：
Java类，如果定义时没有指定父类，那么这个类会默认继承Object类！
//默认继承了 Object，编译后会自动生成 extends Object 的代码语句
public class Student {
}
Object类描述如下：

上图注意事项：
Object类中没有属性
绿色圆点表示public修饰方法
黄色菱形表示protected修饰方法
红色方块表示private修饰方法
Java中的每个类都直接或间接继承Object类，Object类是Java继承体系中的最
顶层父类。
2.5 应用场景
使用继承，需要考虑类与类之间是否存在 is a 的关系，不能盲目使用继
承！
从语法上讲，一个类可以继承任何的另一个类，只要满足语法要求即可。但实
际开发中，只有具有 is a 的关系两个类，才会考虑是否要使用继承！
多个类中存在相同属性和行为，且类和类之间具有 is a 的关系，就可以将公
共的内容抽取到单独一个类中（父类），那么这些类（子类）就不需要再定义
这些属性和行为，只要继承同一个类（父类），它们就可以直接访问父类中的
非私有的属性和方法。
2.6 优缺点
优点：
提高代码的复用性
提高了代码的维护性（父类修改后，子类全部生效）
让类与类之间产生了 is a 的关系，是多态的前提
弊端：
继承是侵入性的
继承让类与类之间产生了关系，类的耦合性增强了
代码与代码之间存在关联都可以称之为" 耦合 "
降低了代码的灵活性
当父类发生变化时子类会跟着变化，削弱了子类的独立性

3 super

问题引入：
从父类继承的非private成员，和子类新增的成员重名，如何在子类成员方法
中区分两个成员？
答：
借助super关键字可以实现区分！
具体用法：
super.数据成员，表示从父类继承的数据成员
super.成员方法 (实参列表 ) ，表示调用从父类继承的成员方法
super表示子类对象中从父类继承的那部分（可看成一个父类对象）引用！
super内存结构图如下：

案例展示：
修改父类代码：

//提供父类
public class Animal {
//对age进行显示初始化，其他代码不动
public int age = 10;
/ / . . . 省略 }
修改子类代码：
package com.briup.chap06.bean;
//定义 Dog子类继承 Animal
public class Dog extends Animal {
//子类新增数据成员并做显式初始化，成员名和从父类继承的一样
private int age = 20;
//新增方法，其形参名（局部变量）和数据成员名一样
public void memberAccess(int age) {
System.out.println("age: " + age);
System.out.println("this.age: " + this.age);
System.out.println("super.age: " + super.age);
}
//新增重载方法，其形参为空
public void memberAccess() {
System.out.println("age: " + age);
System.out.println("this.age: " + this.age);
System.out.println("super.age: " + super.age);
}
//其他代码不变，省略 ...
}
测试类：
package com.briup.chap06.test;
public class Test0203_AccessMember {
//修改 main方法如下
public static void main(String[] args)
{ Dog d = new Dog();
d.memberAccess(30);
System.out.println("------------");
d.memberAccess(); }
}
运行效果：
在子类方法中访问变量，会遵循就近原则，具体如下：
1. 先在子类局部范围中查找局部变量
2. 再在子类中查找新增的成员变量
3. 最后从父类继承的成员变量中查找
如果一定要使用从父类继承的成员，可以通过super关键字，进行区分。
super 总结：
super 关键字的用法和 this 关键字的用法相似
this：代表本类对象的引用
super：代表父类存储空间的标识（可以理解为父类对象引用）

4 构造方法

思考：如何给子类对象进行初始化？
子类对象的数据成员包含两部分：继承部分，新增部分
对新增部分数据成员初始化，子类构造方法中直接 this.新增数据成员 =
值 ; 即可
对继承部分数据成员初始化
子类构造方法中直接 this.继承数据成员 = 值 ;
Bug：父类中数据成员如果private修饰，则子类中没有权限直接访问
子类构造方法中采用 this.setXxx(值); 对继承部分数据成员进行初
始化
Bug：过于繁琐，如果从父类继承的成员很多，要写很多set方法
子类对象的初始化（构造方法中），要借助父类的构造方法，对父类部分成员
进行初始化
子类构造方法通过super关键字调用父类构造方法
格式： super(实际参数列表 );
子类构造方法前，会优先找到父类构造方法调用，对父类继承部分成员进
行初始化
父类部分初始化完成后，再执行子类构造方法代码
如果子类构造方法中没有显式通过 super 调用父类构造方法，则系统会默
认调用 super()
案例展示：

//定义父类
class Fu {
//1个私有成员
private int f;
//2个构造方法
public Fu() {
System.out.println("in Fu() ..."); }
public Fu(int f)
{ System.out.println("in
Fu(int) ...");
this.f = f; }
//对应的 ge t| set 方法
public int getF()
{ return f;
}
public void setF(int f)
{ this.f = f;
}
}
//定义子类
class Zi extends Fu {
//新增 1个数据成员
private int z;
//子类构造方法
public Zi() {
//如果不显式调用 super,则默认调用父类无参构造器
//super();
System.out.println("in Zi() ...");
}
public Zi(int z)
{ super(10);
System.out.println("in Zi(int) ...");
this.z = z;
}
public Zi(int f, int z) {
//下面这行注释的代码，放开则编译报错
//System.out.println("in Zi(int,int) ...");
//super调用，必须为子类构造方法的第一行有效代码
super(f);
System.out.println("in Zi(int,int) ...");
this.z = z; }
// 新增方法
public void disp() {
//借助super可以直接访问父类继承部分的成员
System.out.println("super.f: " + super.getF());
//借助 this，会先去找子类新增 getF(),如果找不到，再去父类继承部分
查找
System.out.println("this.f: " + this.getF());
System.out.println("Zi.z: " + z);
}
}
public class Test04_Init {
public static void main(String[] args)
{ Zi z1 = new Zi();
z1.disp();
System.out.println("---------------");
Zi z2 = new Zi(20);
z2.disp();
System.out.println("---------------");
Zi z3 = new Zi(100,200);
z3.disp();
}
}
运行效果：
注意1：子类构造方法中如果显式调用super(实参列表)，则该代码必须为第一
行有效代码！
注意2：子类构造方法中显式调用的super(实参列表)，父类中必须提供，否则
编译报错！