11.0_[Java 继承]-继承/重写/抽象类/抽象方法/ final 修饰符

##################################################

继承

什么是继承

继承语法

super 关键字

如何使用继承

java.lang.Object 类

默认从父类的继承

访问修饰符的访问权限

重写和继承关系中的构造方法

方法重写

子类重写父类的方法

super 关键字

重载和重写的区别

继承关系中的构造方法

多级继承的构造

抽象类

抽象类和抽象方法的特点

示例抽象类和抽象方法

final 修饰符

final 的应用

final 修饰类

final 修饰方法

final 修饰变量

final 修饰引用型变量

abstract 是否可以与 private、static 或 final 共用

##################################################

继承

——————————

什么是继承

继承是面向对象的三大特性之一

是 Java 中实现代码重用的重要手段之一

Java 中只支持单继承每个类都只能有一个直接父类

继承表达的是 is a 的关系或者说是一种特殊和一般的关系例如 You is a Ren

同样可以让学生继承人让香蕉继承水果让三角形继承几何图形

我们之前设计的程序有许多不足一是代码重复二是修改量大

我们将多类中相同的属性和方法从父类继承避免了代码重复也方便了日后代码修改

可以将 A 类和 B 类中相同的属性和方法提取出来存放在一个单独的 C 类中

然后让 A 类和 B 类继承 C 类同时保留自己特有的属性和方法

这就需要使用 Java 的继承功能来实现

——————————

继承语法

语法：

修饰符 SubClass extends SuperClass {/* 类定义部分 */
}

继承/inheritance 通过 extends 关键字来实现

其中的 SubClass 称为子类

SuperClass 为父类、基类或超类

修饰符如果是 public 则该类在整个项目中可见

若无 public 修饰符则该类只能在当前包可见

不可以使用 private 和 protected 修饰类

——————————

super 关键字

super 关键字表示直接调用父类的方法包括构造方法：

super(构造方法);
super.方法();

——————————

如何使用继承

创建一个人人类：

package demo;public class RRen {
/* 人人类 是人类的父类 */private String name = "无名氏"; // 姓名private Double gao = 1.89;    // 身高public RRen () {/* 无参构造方法设置身高 */this.gao = 2.50;System.out.println ( "执行人类的无参构造方法.." );}public RRen(String name) {/* 带参构造设置姓名 */this.name = name;}public String getName() {/* 获取姓名方法 */return this.name;}public double getGao() {/* 获取身高方法 */return this.gao;}public void print () {/* 输出个人信息 */System.out.println ();System.out.printf ( "姓名 >>> [%s]\n", this.getName() );System.out.printf ( "身高 >>> [%f]\n", this.getGao() );}
}

人类继承人人类：

package demo;public class Ren extends RRen {
/* 人类继承人人类 */private String str = "我没什么话要说..";   // 说话public Ren ( String name, String str ) {/* 有参构造方法 参数为姓名和话语 */super(name);  // 调用父类的有参构造方法 这里不能使用 this.name = namethis.str = str;}public String getStr () {/* 获取话语 */return this.str;}
}

小孩类也继承人人类：

package demo;public class Hai extends RRen {
/* 孩子类继承人人类 */private char sex = '女';    // 说话public Hai ( String name, char sex ) {/* 有参构造方法 参数为姓名和话语 */super(name);    // 调用父类的有参构造方法 这里不能使用 this.name = namethis.sex = sex;}public char getSex () {/* 获取性别 */return this.sex;}
}

在测试类中调用：

package demo;public class Test {
/* 测试类 */public static void main(String[] args) {/* 创建一个人人对象并输出信息 */RRen rr = new RRen( "沙琪玛" );rr.print ();/* 创建一个人对象并输出信息 */Ren r = null;r = new Ren ( "奥利给", "大家好,我是人！" );r.print ();/* 创建一个小孩对象并输出信息 */Hai h = new Hai( "冰淇淋", '女' );h.print ();}
}

执行结果如下：


姓名 >>> [沙琪玛]
身高 >>> [1.890000]姓名 >>> [奥利给]
身高 >>> [1.890000]姓名 >>> [冰淇淋]
身高 >>> [1.890000]

——————————

java.lang.Object 类

在 Java 中所有的类都间接或直接继承了 Object 类

Object 类是所有 Java 类的祖先

在定义一个类时如果没有使用 extends 关键字那么这个类直接继承 Object 类

例如：

public class MyObject {}

表明 MyObject 类的直接父类为 Object 类

Object 类的方法列表：

    equals(对象) 返回布尔值
测试指定对象是否与该对象相等getClass() 返回类
返回该对象的运行时类hashCode() 返回整型
返回该对象的哈希码值notify() 返回空值
唤醒该对象监视器上等待的单个进程notifyAll() 返回空值
唤醒该对象监视器上等待的所有进程toString() 返回字符串
返回该对象的字符串表示wait() 返回空值
在其她线程调用此对象的 notify() 或 notifyAll() 前导致该线程等待wait(时间量) 返回空值
在其她线程调用此对象的 notify()/notifyAll() 或超过指定的时间量前导致该线程等待wait(时间量, 中断信号) 返回空值
在其她线程调用此对象的 notify()/notifyAll() 和超过指定的时间量前以及某个线程中断当前线程导致该线程等待

——————————

默认从父类的继承

在 Java 中子类默认从父类中继承 public 和 protected 修饰的属性和方法而无论子类和父类是否在同一个包中

继承默认权限修饰符 friendly 修饰的属性和方法但子类和父类必须在同一个包中

无法继承 private 修饰的属性和方法

也无法继承父类的构造方法

——————————

访问修饰符的访问权限

私密 private

本类

默认 friendly

本类

同包

同包 protected

本类

同包

子类

公开 public

本类

同包

子类

其她

##################################################

重写和继承关系中的构造方法

——————————

方法重写

在子类中可以根据需求对从父类继承的方法进行重新编写

称为方法的重写或方法的覆盖/overriding

方法重写必须满足如下要求：

重写方法和被重写方法必须具有相同的方法名

重写方法和被重写方法必须具有相同的参数列表

重写方法的返回值必须和被重写方法的返回值类型相同或者是其子类

重写方法不能缩小被重写方法的访问权限

——————————

子类重写父类的方法

如果从父类继承的方法不能满足子类的需求

例如子类的方法输出内容是父类方法的内容

则在子类中可以对父类的同名方法进行重写/覆盖以符合需求！

例如重写刚刚的人人类是人类和小孩类的父类

但是人类和小孩类的 print() 输出方法输出的信息是人人类这个父类的成员属性信息

我们需要在子类中重写 print() 以覆盖父类的方法！

这是父类的 print 方法：

public void print () {
/* 输出个人信息 */System.out.println ();System.out.printf ( "姓名 >>> [%s]\n", this.getName() );System.out.printf ( "身高 >>> [%f]\n", this.getGao() );
}

Ren.java code：

package demo;public class Ren extends RRen {private String str = "我没什么话要说..";public Ren ( String name, String str ) {super(name);this.str = str;}public String getStr () {return this.str;}public void print() {/* 重写父类的 print() 方法 */super.print ();    // 调用父类的 print 输出信息方法/* 下面加入自己的成员属性信息 */System.out.printf ( "我想说:“%s”\n", this.getStr() );}
}

Hai.java code：

package demo;public class Hai extends RRen {private char sex = '女';public Hai ( String name, char sex ) {super(name);this.sex = sex;}public char getSex () {return this.sex;}public void print() {/* 重写父类的 print() 方法 */super.print ();  // 调用父类的 print 输出信息方法/* 下面加入自己的成员属性信息 */System.out.printf ( "性别 >>> [%c]\n", this.getSex() );}
}

IDE demo：


姓名 >>> [沙琪玛]
身高 >>> [1.890000]姓名 >>> [奥利给]
身高 >>> [1.890000]
我想说:“大家好,我是人！”姓名 >>> [冰淇淋]
身高 >>> [1.890000]
性别 >>> [女]

此时子类的方法覆盖了父类调用的不再是父类的方法而是子类的方法

——————————

super 关键字

如果在子类中想调用父类的被重写的方法可以通过 super 关键字点方法来调用

super 代表对当前对象的直接父类对象的默认引用

在子类中可以通过 super 关键字来访问父类的成员

包括父类的属性、方法和构造方法

注意访问权限的限制

例如无法通过 super 访问 private 成员

假如以下调用的方法都没有被 private 限制：

super.name;    // 访问直接父类的 name 属性
super.print ();    // 访问直接父类的 print 方法
super.(name);    // 访问直接父类的对应构造方法 只能出现在构造方法中

super 必须出现在子类的方法和构造方法中而不是其她位置！！

——————————

重载和重写的区别

重载 overloading 涉及同一个类中的同名方法要求方法名相同

并不要求参数列表的异同与返回值类型、访问修饰符无关

而重写 overriding 涉及的是子类和父类之间的同名方法要求如下相同：

方法名

参数列表

返回值类型或是其子类

访问修饰符不能严于父类

——————————

继承关系中的构造方法

继承关系中的构造方法调用规则如下：

    如果子类的构造方法中没有通过 super 显式地调用父类的有参构造方法也没有通过 this 显式调用自身的其她构造方法则系统会默认先调用父类的无参构造方法在该情况下 有没有 super 都是一样的如果子类的构造方法中通过 super 显式地调用父类的有参构造方法则将执行父类相应的构造方法 而不执行子类无参构造方法如果子类的构造方法中通过 this 显式地调用自身的其她构造方法则在相应构造方法中应用以上两条规则特别注意 如果存在多级继承关系 则在创建一个子类对象时 以上规则会多次向更高一级父类应用一直到执行顶级父类 Object 类的无参构造方法为止在构造方法中如果有 this 语句或者 super 语句出现则只能是第一条语句在一个构造方法中不允许同时出现使用 this 和 suoer 语句调用构造方法否则就有两条第一条语句……在类方法中不允许出现 this 或 super 关键字在实例方法中 this 和 super 语句不要求是第一条语句 可以共存

如果我们将子类中的构造方法中的第一条 super 语句去掉会如何？

Ren 类：

package demo;public class Ren extends RRen {private String str = "我没什么话要说..";public Ren ( String name, String str ) {this.str = str;}public String getStr () {return this.str;}public void print() {/* 重写父类的 print() 方法 */super.print ();    // 调用父类的 print 输出信息方法/* 下面加入自己的成员属性信息 */System.out.printf ( "我想说:“%s”\n", this.getStr() );}
}

Hai 类：

package demo;public class Hai extends RRen {private char sex = '女';public Hai ( String name, char sex ) {this.sex = sex;}public char getSex () {return this.sex;}public void print() {/* 重写父类的 print() 方法 */super.print ();  // 调用父类的 print 输出信息方法/* 下面加入自己的成员属性信息 */System.out.printf ( "性别 >>> [%c]\n", this.getSex() );}
}

很多程序员可能认为无非就是不调用父类对应的构造方法而已只是仅仅給相应属性赋值

但是 demo 结果出乎意料地调用了父类的无参构造方法：


姓名 >>> [沙琪玛]
身高 >>> [1.890000]
执行人类的无参构造方法..姓名 >>> [无名氏]
身高 >>> [2.500000]
我想说:“大家好,我是人！”
执行人类的无参构造方法..姓名 >>> [无名氏]
身高 >>> [2.500000]
性别 >>> [女]

而我们并没有在子类中使用 super 调用父类的无参构造

完全匹配刚刚提到的第一条规则

——————————

多级继承的构造

下面测试一个存在多级继承关系的代码深入了解继承条件下构造方法的调用规则

即继承条件下创建子类对象的执行过程

Main.java demo && code：

/*   IDE demo：
执行 Persion 无参构造..
执行 Student()..
调用 Teacher()..执行 Persion 带 [崽子] 参数构造..
执行 Persion(崽子, 西安大学)..
执行 Persion(崽子, 西安大学, 军老师)..*/package demo;class Person {
/* 人类 */String name;    // 姓名public Person() {/* 人的无参构造 *//* super();   // 有没有 super 语句效果都一样 */System.out.println ( "执行 Persion 无参构造.." );}public Person(String name) {/* 人的一参构造 */this.name = name;System.out.printf ( "执行 Persion 带 [%s] 参数构造..\n", name );}
}class Student extends Person {
/* 学生类 继承自人类 */String schoolName;   // 学校名public Student() {/* 学校的无参构造 *//* super();    // 有没有 super 语句效果都一样 */System.out.println ( "执行 Student().." );}public Student(String name, String schoolName) {/* 学校的带参构造 */super(name); // 显式地调用了父类有参构造方法 将不执行无参构造this.schoolName = schoolName;System.out.printf ( "执行 Persion(%s, %s)..\n", name, schoolName );}
}class Teacher extends Student {
/* 教师类 继承自学生类 */String teacherName; // 教师名public Teacher() {/* 教师的无参构造 *//* super();    // 有没有 super 语句效果都一样 */System.out.println ( "调用 Teacher().." );}public Teacher(String name, String schoolName, String teacherName) {/* 教师的带参构造 */super(name, schoolName); // 显式地调用了父类有参构造方法 将不执行无参构造this.teacherName = teacherName;System.out.printf ( "执行 Persion(%s, %s, %s)..\n",name, schoolName, teacherName );}
}public class Main {
/* 主要类 */public static void main(String[] args) {Teacher tear = null;tear = new Teacher();System.out.println ();tear = new Teacher ( "崽子", "西安大学", "军老师" );}
}

执行

tear = new Teacher();

时调用无参构造方法 Teacher()

在 Teacher() 无参构造方法中首先调用其父类的无参构造方法 Student()

而在调用 Student() 无参构造时又会调用学生类的父类 Person 类的无参构造方法 Person()

而在执行 Person() 无参构造方法时会调用她的直接父类 Object 的无参构造方法该构造方法内容为空

执行

tear = new Teacher ( "崽子", "西安大学", "军老师" );

时调用构造方法 Teacher ( "崽子", "西安大学", "军老师" )

在 Teacher ( "崽子", "西安大学", "军老师" ) 构造方法中首先调用其父类的构造方法 Student ( "崽子", "西安大学" )

而在调用 Student ( "崽子", "西安大学" ) 时又会调用学生类的父类 Person 类的构造方法 Person ( "崽子" )

而在执行 Person( "崽子" ) 构造方法时会调用她的直接父类 Object 的无参构造方法 Object() 该构造方法内容为空

##################################################

抽象类

——————————

抽象类和抽象方法的特点

抽象类和抽象方法都通过 abstract 关键字来修饰…

抽象类不能实例化

抽象类中可以没有或有一个或多个抽象方法

甚至全部方法都可以是抽象方法！

抽象方法只有方法声明而没有方法实现

有抽象方法的类必须声明为抽象类

子类必须重写所有的抽象方法才能实例化否则子类还是一个抽象类！

    这是一个有实现但实现为空的普通方法：
public void 方法名() { }这才是一个抽象方法 不要忘记最后的分号：
public abstract void 方法名();

abstract 可以用来修饰类和方法但是不能用来修饰属性和构造方法

抽象类中可以有构造方法但是其构造方法可以被本来的其她构造方法调用！

若此构造方法不是由 private 修饰也可以由被本类的子类中的构造方法调用……

——————————

示例抽象类和抽象方法

%%%%%

有些时候创建的一些对象是没有意义的只是我们人类抽象出来的一个概念此时不可以实例化对象

例如上面的人人类是人类的父类人人类只是我们抽象出来的一个概念现实世界中并没有人人类的人类

所以我们需要把人人类限制为不能实例化！

可以使用 Java 中的抽象类来实现用 abstract 来修饰抽象类被修饰的类不能通过 new 实例化！

示例代码：

package demo;abstract class RRen {
/* 添加 abstract 修饰符变成抽象类 */private String name = "无名氏";private Double gao = 1.89;public RRen () {this.gao = 2.50;System.out.println ( "执行人类的无参构造方法.." );}public RRen(String name) {this.name = name;}public String getName() {return this.name;}public double getGao() {return this.gao;}public void print () {System.out.println ();System.out.printf ( "姓名 >>> [%s]\n", this.getName() );System.out.printf ( "身高 >>> [%f]\n", this.getGao() );}
}class Ren extends RRen {private String str = "我没什么话要说..";public Ren ( String name, String str ) {super(name);this.str = str;}public String getStr () {return this.str;}
}class Hai extends RRen {private char sex = '女';public Hai ( String name, char sex ) {super(name);this.sex = sex;}public char getSex () {return this.sex;}
}public class Main {
/* 主要类 */public static void main(String[] args) {RRen rr = new RRen(); /* 该处报错 不能实例化抽象类 */rr.print ();Ren r = null;r = new Ren ( "奥利给", "大家好,我是人！" );r.print ();Hai h = new Hai( "冰淇淋", '女' );h.print ();}
}

此时如果实例化人人类会报错：

%%%%%

但是人人类提供了 print() 这个方法

如果子类重写该方法则会正确输出子类信息

若子类中没有重写该方法则子类将继承人人的该方法从而无法正确输出子类信息

能否强迫子类必须重写该方法否则就提示出错呢？

此时可以使用 Java 中的抽象方法来实现用 abstract 来修饰方法则子类必须重写被修饰的方法！

示例代码：

package demo;abstract class RRen {
/* 添加 abstract 修饰符变成抽象类 */private String name = "无名氏";private Double gao = 1.89;public RRen () {this.gao = 2.50;System.out.println ( "执行人类的无参构造方法.." );}public RRen(String name) {this.name = name;}public String getName() {return this.name;}public double getGao() {return this.gao;}public abstract void print();   /* 将 print 改为抽象方法 */
}class Ren extends RRen {private String str = "我没什么话要说..";public Ren ( String name, String str ) {super(name);this.str = str;}public String getStr () {return this.str;}
}class Hai extends RRen {private char sex = '女';public Hai ( String name, char sex ) {super(name);this.sex = sex;}public char getSex () {return this.sex;}
}public class Main {
/* 主要类 */public static void main(String[] args) {RRen rr = new RRen(); /* 该处报错 不能实例化抽象类 */rr.print ();Ren r = null;r = new Ren ( "奥利给", "大家好,我是人！" );r.print ();Hai h = new Hai( "冰淇淋", '女' );h.print ();}
}

此时两个子类报错里面并没有重写抽象方法！

子类必须实现继承来自父类的抽象方法！

现在我们在子类中重写 print() 抽象方法

示例代码：

package demo;abstract class RRen {
/* 添加 abstract 修饰符变成抽象类 */private String name = "无名氏";private Double gao = 1.89;public RRen () {this.gao = 2.50;System.out.println ( "执行人类的无参构造方法.." );}public RRen(String name) {this.name = name;}public String getName() {return this.name;}public double getGao() {return this.gao;}public abstract void print();   /* 将 print 改为抽象方法 */
}class Ren extends RRen {private String str = "我没什么话要说..";public Ren ( String name, String str ) {super(name);this.str = str;}public String getStr () {return this.str;}public void print () {/* 子类重写父类抽象方法 */System.out.println ();System.out.printf ( "姓名 >>> [%s]\n", this.getName() );System.out.printf ( "身高 >>> [%.2f]\n", this.getGao() );System.out.printf ( "我想说 >>> [%s]\n", this.getStr() );}
}class Hai extends RRen {private char sex = '女';public Hai ( String name, char sex ) {super(name);this.sex = sex;}public char getSex () {return this.sex;}public void print () {/* 子类重写父类抽象方法 */System.out.println ();System.out.printf ( "姓名 >>> [%s]\n", getName() );System.out.printf ( "身高 >>> [%.2f]\n", getGao() );System.out.printf ( "性别 >>> [%c]\n", getSex() );}
}public class Main {
/* 主要类 */public static void main(String[] args) {/* 不再实例化抽象类 */Ren r = null;r = new Ren ( "奥利给", "大家好,我是人！" );r.print ();Hai h = new Hai( "冰淇淋", '女' );h.print ();}
}

运行结果如下：


姓名 >>> [奥利给]
身高 >>> [1.89]
我想说 >>> [大家好,我是人！]姓名 >>> [冰淇淋]
身高 >>> [1.89]
性别 >>> [女]

##################################################

final 修饰符

——————————

final 的应用

如果想要某个类不能够被其她类继承不允许再有子类

可以給该类添加 final 修饰符来实现

或者某个类可以有子类但是她的方法不能够再被子类重写

可以給该方法添加 final 修饰符来实现

再或者该类可以有子类但是增加一个成员属性规定只能取一个常量值

可以通过給该属性添加 final 修饰符来实现

final 和 abstract 是功能相反的两个关键字可以对比记忆

abstract 可以用来修饰类和方法不能用来修饰属性和构造方法

final 可以用来修饰类、方法和属性不能够修饰构造方法

    Java 提供的很多类都是 final 类例如 String 类、Math 类她们不能再有子类Object 类中一些方法 例如
getClass ()
notify ()
wait ()都是 final 方法只能被子类继承而不能被重写但是
hashCode ()
toString ()
equals ()不是 final 方法可以被重写！

%%%%%

final 修饰类

被 final 修饰的类不能够再被继承

例如：

final class 类名_1 {}class 类名_2 extends 类名_1 {
/* 这样会报错！不能够继承被 final 修饰的类 */}

%%%%%

final 修饰方法

被 final 修饰的方法不能被子类重写

例如：

class 类名_1 {public final void 方法名_1 () {}
}class 类名_2 extends 类名_1 {public void 方法名_1 () {/* 报错 被 final 修饰的方法不能被子类重新 */}
}

%%%%%

final 修饰变量

用 final 修饰的变量包括成员变量和局部变量

将变成常量！

只能被赋值一次！

示例：

public class 类名_1 {final String name = "是崽崽！";    // 被 final 修饰的变量称为常变量public void 方法名_1 ( String name ) {this.name = name;    // 会报错！被 final 修饰的常变量不可以再被赋值！}
}

——————————

final 修饰引用型变量

final 修饰引用型变量那么变量所指向的对象属性值是否能够被改变呢？

使用 final 修饰引用型变量时变量的值是固定不变的

而变量所指向的对象的属性值是可以改变的！

如下：

package demo;class Ren {String name;public Ren ( String name ) {this.name = name;}
}public class Main {public static void main(String[] args) {final Ren ren = new Ren ( "崽子" );ren.name = "仔哦"; /* 正确 */ren = new Ren ( "打死你" ); /* 错误 */}
}

上面 ren 已经被定义为 final 修饰的常量其值不可改变

所以 ren = new Ren ( "打死你" ) 是错误的！

因为使用 final 修饰的引用型变量不可以再指向另外的对象

但是所指对象的内容是可以改变的！

所以 ren.name = "仔哦" 是正确的

对于引用型变量一定要区分对象的引用值和对象的属性值是两个概念

——————————

abstract 是否可以与 private、static 或 final 共用

abstract 只可以与 public 同时修饰

abstract 不能和 private 同时修饰一个方法

abstract 不能和 static 同时修饰一个方法

abstract 不能和 final 同时修饰一个方法或类

%%%%%

abstract 不可以与 private 修饰符共用

如下：

private abstract void 方法名();

抽象方法是用来让子类重写的而子类无法继承到 private 方法自然无法重写…

%%%%%

abstract 不可以与 static 修饰符共用

如下：

staic abstract void 方法名();

抽象方法只有声明没有实现而 static 方法可以通过类名直接访问但无法访问一个没有实现的方法

%%%%%

abstract 也不可以与 final 修饰符共用

示例：

final abstract void 方法名();

抽象方法是让子类来重写的而 final 修饰的方法不能被重写！

这是相互矛盾的。。

同理抽象类只有让子类继承才能实例化而 final 修饰的类不允许被子类继承

%%%%%

abstract 可以跟 public 修饰符搭配使用！

例如：

public abstract void 方法名();

这两个关键字并不冲突！