文章目录
前言:
面向对象程序三大特性:封装、继承、多态。本篇博客主要整理了面向对象之继承的引入及概念,子类访问父类成员变量及方法的访问规则,super关键字的引入及概念,子类构造方法,super与this的区别,protected关键字,继承方式,final关键字
一、继承的引入及概念
1.1继承的引入
Java中使用类对现实世界中实体来进行描述,类经过实例化之后的产物对象,则可以用来表示现实中的实体,但是现实中的对象会存在一些关联,例如猫和狗都是动物类,它们都有名字,年龄,都会吃饭,都会睡觉等等,这些都是共有的属性。那么我们是不是在定义猫类和狗类甚至更多的相似类时,都要定义这些属性?代码示例如下:
public class Cat() {
public String name;
public int age;
public void eat() {
System.out.println(this.name +"正在吃饭...")
}
public void sleep() {
System.out.println(this.name +"正在睡觉...")
}
public void mew() {
System.out.println("喵喵喵~")
}
}
public class Dog() {
public String name;
public int age;
public void eat() {
System.out.println(this.name +"正在吃饭...")
}
public void sleep() {
System.out.println(this.name +"正在睡觉...")
}
public void bark() {
System.out.println("汪汪汪~")
}
}
这样会造成大量的重复定义操作,代码冗长。那能否将这些共性抽取呢?面向对象思想中提出了继承的概念,专门用来进行共性抽取,实现代码复用。
1.2继承的概念
继承机制:是面向对象程序设计使代码可以复用的最重要的手段,它允许程序员在保持原有类特性的基础上进行扩展,增加新功能,这样产生新的类,称派生类。继承呈现了面向对象程序设计的层次结构, 体现了由简单到复杂的认知过程。继承主要解决的问题是:共性的抽取,实现代码复用。
extends
是表示继承关系的关键字,利用继承关系实现上述代码,代码示例如下:
public class Animal() {
public String name;
public int age;
public void eat() {
System.out.println(this.name +"正在吃饭...")
}
public void sleep() {
System.out.println(this.name +"正在睡觉...")
}
}
public class Cat extends Animal() {
public void mew() {
System.out.println("喵喵喵~")
}
}
public class Dog extends Animal() {
public void bark() {
System.out.println("汪汪汪~")
}
}
将上面两个类中共性的成员,即
name
、age
成员变量以及eat
、sleep
成员方法抽取到一个Animal
类中,让Cat
类和Dog
类继承Animal
类,这里的Animal
类就称之为父类/基类,Cat
类和Dog
类称之为子类/派生类。这样子类就会继承父类的成员变量和成员方法。extends
是表示继承关系的关键字。
注意:
- 子类会将父类中的成员变量或者成员方法继承到子类中
- 子类继承父类之后,必须要新添加自己特有的成员,体现出与基类的不同,否则就没有必要继承了
二、父类成员的访问
2.1子类中访问父类的成员变量
在子类方法中 或者 通过子类对象访问成员变量时
- 父类和子类成员变量名字不相同
public class Base {
int a;
int b;
}
public class Derived extends Base{
int c;
public void method(){
a = 10; // 访问从父类中继承下来的a
b = 20; // 访问从父类中继承下来的b
c = 30; // 访问子类自己的c
}
}
- 父类和子类成员变量名字相同
public class Base {
int a;
int b;
int c;
}
public class Derived extends Base{
int a;
char b;
public void method(){
a = 10; // 访问从子类中的a
b = 20; // 访问从子类中的b
c = 30;//子类中没有c,一定是访问的是从父类继承下来的a
d = 40; // 编译失败,因为父类和子类都没有定义成员变量b
}
}
要点总结:
- 如果访问的成员变量子类中有,优先访问自己的成员变量。
- 如果访问的成员变量子类中没有,则访问从父类继承下来的,如果父类夜没有定义,则编译报错。
- 如果访问的成员变量与父类中的成员变量同名,优先访问自己的。
总之,成员访问遵循就近原则,优先访问子类自己的,子类自己没有再去父类中找,父类也没有则编译报错
2.2子类中访问父类的成员方法
在子类方法中 或者 通过子类对象访问成员方法时
- 成员方法名字不相同
- 优先访问自己的成员方法,子类中没有,则从父类中找,父类也没有,则报错。
- 成员方法名字相同
- 通过派生类对象访问父类与子类同名方法时,如果父类和子类同名方法的参数列表不同(重载),根据调用方法时所传递的参数选择合适的方法访问,如果没有则报错;
- 若子类重写了父类的方法,则一定是访问子类重写的方法。
三、super关键字
super关键字的引入
我们知道当子类成员变量名和父类成员变量名相同时,在子类方法中或者通过子类对象访问成员变量时,只能访问到子类的成员,无法访问到父类的成员,那么如何在子类中访问父类相同名称的成员呢?我们在java中引入了super
关键字,super
关键字的主要作用是:在子类方法中访问父类的成员。代码示例如下:
public class Base {
int a;
int b;
public void methodA(){
System.out.println("Base中的methodA()");
}
public void methodB(){
System.out.println("Base中的methodB()");
}
}
public class Derived extends Base{
int a; // 与父类中成员变量同名且类型相同
char b; // 与父类中成员变量同名但类型不同
// 与父类中methodA()构成重载,参数列表不同
public void methodA(int a) {
System.out.println("Derived中的method()方法");
}
// 与基类中methodB()构成重写(即原型一致,重写后序详细介绍)
public void methodB(){
System.out.println("Derived中的methodB()方法");
}
public void methodC(){
// 对于同名的成员变量,直接访问时,访问的都是子类的
a = 100;//子类中有,子类的a
b = 101;//子类中有,子类char类型的b
// 访问父类的成员变量时,需要借助super关键字
// super是获取到子类对象中从基类继承下来的部分
super.a = 200;
super.b = 201;
// 父类和子类中构成重载的方法,直接可以通过参数列表区分清访问父类还是子类方法
methodA(); // 没有传参,访问父类中的methodA()
methodA(20); // 传递int参数,访问子类中的methodA(int)
// 如果在子类中要访问重写的父类方法,则需要借助super关键字
methodB(); // 直接访问,则永远访问到的都是子类中的methodA(),基类的无法访问到
super.methodB(); // 访问基类的methodB()
}
}
super
关键字只能指代当前类的父类,不能指代父类的父类,甚至更远的父类
四、子类构造方法
父子父子,先有父再有子,即:子类对象构造时,需要先调用基类构造方法,然后执行子类的构造方法
public class Base {
public Base() {
System.out.println("Base()");
}
}
public class Derived extends Base{
public Derived() {
// super();
// 注意子类构造方法中默认会调用基类的无参构造方法:super(), 用户没有写时,编译器会自动添加,
//而且super()必须是子类构造方法中第一条语句,并且只能出现一次
System.out.println("Derived()");
}
}
public class Test {
public static void main(String[] args) {
Derived d = new Derived();
}
}
运行结果:Base()
Derived()
在子类构造方法中,并没有写任何关于基类构造的代码,但是在构造子类对象时,先执行父类的构造方法,然后执行子类的构造方法,因为:子类对象中成员是有两部分组成的,父类继承下来的以及子类新增加的部分 。父子父子肯定是先有父再有子,所以在构造子类对象时候 ,先要调用父类的构造方法,将从父类继承下来的成员构造完整,然后再调用子类自己的构造方法,将子类自己新增加的成员初始化完整 。
要点总结:
- 若父类显式定义无参或者默认的构造方法,在子类构造方法第一行默认有隐含的
super()
调用,即调用父类构
造方法 - 如果父类构造方法是带有参数的,此时需要用户为子类显式定义构造方法,并在子类构造方法中选择合适的
父类构造方法调用,否则编译失败。 - 在子类构造方法中,
super(...)
调用父类构造时,必须是子类构造函数中第一条语句。 super(...)
只能在子类构造方法中出现一次,并且不能和this同时出现
五、super和this的区别
相同点:
- 都是Java中的关键字
- 只能在类的非静态方法中使用,用来访问非静态成员方法和成员变量
- 在构造方法中调用时,必须是构造方法中的第一条语句,并且不能同时存在
不同点:
this
是当前对象的引用,当前对象即调用实例方法的对象,super
相当于是子类对象中从父类继承下来部分成员的引用
2.在非静态成员方法中,this
用来访问本类的方法和属性,super
用来访问父类继承下来的方法和属性- 在构造方法中:
this(...)
用于调用本类构造方法,super(...)
用于调用父类构造方法,两种调用不能同时在构造方法中出现 - 构造方法中一定会存在
super(...)
的调用,用户没有写编译器也会增加,但是this(...)
用户不写则没有
六、继承关系上各类代码块和构造方法的执行顺序
阅读以下代码,它们的执行顺序是什么,代码示例如下:
class Person {
public String name;
public int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
System.out.println("Person:构造方法执行");
}
{
System.out.println("Person:实例代码块执行");
}
static {
System.out.println("Person:静态代码块执行");
}
}
class Student extends Person{
public Student(String name,int age) {
super(name,age);
System.out.println("Student:构造方法执行");
}
{
System.out.println("Student:实例代码块执行");
}
static {
System.out.println("Student:静态代码块执行");
}
}
public class TestDemo4 {
public static void main(String[] args) {
Student student1 = new Student("张三",19);
System.out.println("===========================");
Student student2 = new Student("gaobo",20);
}
public static void main1(String[] args) {
Person person1 = new Person("bit",10);
System.out.println("============================");
Person person2 = new Person("gaobo",20);
}
}
执行结果:
Person:静态代码块执行
Student:静态代码块执行
Person:实例代码块执行
Person:构造方法执行
Student:实例代码块执行
Student:构造方法执行
===========================
Person:实例代码块执行
Person:构造方法执行
Student:实例代码块执行
Student:构造方法执行
通过分析执行结果,得出以下结论:
1、父类静态代码块优先于子类静态代码块执行,且是最早执行
2、父类实例代码块和父类构造方法紧接着执行
3、子类的实例代码块和子类构造方法紧接着再执行
4、第二次实例化子类对象时,父类和子类的静态代码块都将不会再执行
父类静态–>子类静态–>父类实例–>父类构造–>子类实例–>子类构造
七、protected关键字
在类和对象章节中,为了实现封装特性,Java中引入了访问限定符,主要限定:类或者类中成员能否在类外或者其他包中被访问.
关于访问限定符的更详细的介绍,请移步: 类和对象
各种访问限定符使用的代码示例如下:
// extend01包中
public class B {
private int a;
protected int b;
public int c;
int d;
}
// extend01包中
// 同一个包中的子类
public class D extends B{
public void method(){
// super.a = 10; // 编译报错,父类private成员在相同包子类中不可见
super.b = 20; // 父类中protected成员在相同包子类中可以直接访问
super.c = 30; // 父类中public成员在相同包子类中可以直接访问
super.d = 40; // 父类中默认访问权限修饰的成员在相同包子类中可以直接访问
}
}
// extend02包中
// 不同包中的子类
public class C extends B {
public void method(){
// super.a = 10; // 编译报错,父类中private成员在不同包子类中不可见
super.b = 20; // 父类中protected修饰的成员在不同包子类中可以直接访问
super.c = 30; // 父类中public修饰的成员在不同包子类中可以直接访问
//super.d = 40; // 父类中默认访问权限修饰的成员在不同包子类中不能直接访问
}
}
// extend02包中
// 不同包中的类
public class TestC {
public static void main(String[] args) {
C c = new C();
c.method();
// System.out.println(c.a); // 编译报错,父类中private成员在不同包其他类中不可见
// System.out.println(c.b); // 父类中protected成员在不同包其他类中不能直接访问
System.out.println(c.c); // 父类中public成员在不同包其他类中可以直接访问
// System.out.println(c.d); // 父类中默认访问权限修饰的成员在不同包其他类中不能直接访问
}
}
八、继承方式
- 单继承
- 多层继承
- 不同类继承同一个类
- 多继承(不支持)
java中不支持多继承
我们并不希望类之间的继承层次太复杂. 一般我们不希望出现超过三层的继承关系. 如果继承层次太多, 就需要考虑对代码进行重构了.
如果想从语法上进行限制继承, 就可以使用 final 关键字
九、final关键字
1. final
修饰变量或字段,表示常量(不能被修改),代码示例如下:
final int a = 10;
a = 20;//编译错误
2.final
修饰类,表示此类不能被继承,代码示例如下:
final public class Animal {
public int a;
}
public class Bird extends Animal {
...
}
编译出错,Animal不能被继承
3.final
修饰数组,数组当中的值不能改变;数组是引用数据类型,array
中存储的是地址
4.final
修饰方法,表示改方法不能被重写