Java基础系列15-面向对象之继承

x33g5p2x  于2021-12-18 转载在 其他  
字(7.1k)|赞(0)|评价(0)|浏览(522)

一.继承概述

继承的概述:

  1. 多个类中存在相同的属性和行为时,将这些内容抽取到单独一个类中,那么多个类无需在定义这些属性和行为,只要继承那个类(extends)即可.
  2. 单独的这个类称为父类,基类或者叫超类,多个类可以称为子类或者派生类.
  3. 有了继承以后,我们定义一个类的时候,可以在一个已经存在的类的基础上,还可以定义自己的新成员.

实现继承的方式:

  1. 通过extends关键字可以实现类与类的继承
  2. 格式:public class 子类名 extends 父类名{}

1.1 继承的好处和弊端

继承的好处:

  1. 提高了代码的复用性,多个类相同的成员可以放到同一个类中;
  2. 提高了代码的维护性,如果功能的代码需要修改,修改一处即可;
  3. 让类与类之间产生了关系,是多态的前提,好处的第三点同时也是继承的弊端。

继承的弊端:
类与类之间产生了关系,让类的耦合性增强了

1.2 Java中继承的特点

  1. Java中只支持单继承,不支持多继承
    1)一个类只能有一个父类,不可以有多个父类
    public class Son extends Father{} // ok
    public class Son extends Father,GrandFather // Error
  2. Java中类支持多层继承(继承体系)
    Public class GrandFather{}
    Public class Father extends GrandFather{}
    Public class Son extends Father{}

1.3 Java继承中成员变量的特点

  1. A.局部变量
  2. a.定义位置:定义在局部范围中,如:函数内,语句内等;
  3. b.初始值:无,先定义,赋值后才能使用;
  4. c.调用方式:- - -
  5. d.作用域: 只在所属的区域有效;
  6. e.物理存储: 存储在 虚拟机栈(JVM Stack) 中(栈内存分为:虚拟机栈和本地方法栈);
  7. 变量名 都在虚拟机栈(JVM Stack)的栈帧(Stack Frame) 局部变量表(Local Variable Table) 中;
  8. f.生命周期:与方法共存亡,随着方法的调用而存在,随着方法调用完毕自动回收释放;
  9. B.成员变量(别名:实例变量)
  10. a.定义位置:在类中,方法外;
  11. b.初始值:有默认初始化值;
  12. c.调用方式:对象调用;
  13. d.作用域:在整个类中都可以被访问;
  14. e.物理存储:
  15. 对象的实例存储在 堆内存(Heap) 中。堆内存速度慢、成本低、空间较大。这个堆内存会有一个内存地址;
  16. 对象的引用存储在 ==虚拟机栈(JVM Stack)中
  17. f.生命周期:与对象共存亡,随着对象的创建而存在,随着对象被回收而释放;
  18. C.静态变量(别名:类变量)
  19. a.定义位置:由staic修饰的,在类中,方法外;
  20. b.初始值:有默认初始化值;
  21. c.调用方式:对象调用,类名调用;
  22. d.作用域:全局中都能使用、被所有对象所共享;
  23. e.物理存储:存储在 方法区(Method Area) 静态域(Static Field) 中;
  24. f.生命周期:与类共存亡,随着类的加载而存在,随着类的消失而消失。

成员变量名称不一样,使用的时候非常简单
成员变量名称一样的情况:
 在子类中访问变量:(就近原则)
  在方法的局部范围找,如果有就使用
  在子类的成员范围找,如果有就使用
  在父类的成员范围找,如果有就使用
  如果还找不到 就报错

1.4 继承案例

1.4.1 父子类案例

接下来,我们创建一个父子类,父类是人类的类,子类是学生类,然后学生类继承人类 类。

代码:
jicheng1类

  1. package Java_study;
  2. /**
  3. *
  4. * @author 只是甲
  5. * @date 2021-6-24
  6. * @remark 继承案例1, 人类 类
  7. *
  8. */
  9. public class jicheng1 {
  10. private String name;
  11. private int age;
  12. /**
  13. * @remark 无参构造
  14. */
  15. public jicheng1() {
  16. }
  17. /**
  18. * @remark 全参构造
  19. * @param name
  20. * @param age
  21. */
  22. public jicheng1(String name, int age) {
  23. this.name = name;
  24. this.age = age;
  25. }
  26. public String getName() {
  27. return name;
  28. }
  29. public void setName(String name) {
  30. this.name = name;
  31. }
  32. public int getAge() {
  33. return age;
  34. }
  35. public void setAge(int age) {
  36. this.age = age;
  37. }
  38. }

student_new类

  1. package Java_study;
  2. /**
  3. * @author 只是甲
  4. * @date 2021-06-24
  5. * @remark 学生类,继承人类类
  6. */
  7. public class student_new extends jicheng1 {
  8. public void teach() {
  9. System.out.println("老师要好好讲课");
  10. }
  11. }

jicheng_test

  1. package Java_study;
  2. /**
  3. * @author 只是甲
  4. * @date 2021-06-24
  5. * @remark 测试类
  6. */
  7. public class jicheng_test{
  8. public static void main(String[] args) {
  9. //创建对象
  10. student_new student1 = new student_new();
  11. //调用父类方法
  12. student1.setName("杜兰特");
  13. student1.setAge(32);
  14. System.out.println("学生姓名:" + student1.getName());
  15. System.out.println("学生年龄:" + student1.getAge());
  16. //调用子类方法
  17. student1.teach();
  18. }
  19. }

测试记录:

  1. 学生姓名:杜兰特
  2. 学生年龄:32
  3. 老师要好好讲课

1.4.2 多重继承案例

接下来是一个多重继承的,祖父、父亲、儿子三个类。

代码:
grandFather类:

  1. package Java_study;
  2. /**
  3. *
  4. * @author Administrator
  5. * @date 2021-06-24
  6. * @remark 多重继承祖父类
  7. */
  8. public class grandFather {
  9. public void grandFatherSay() {
  10. System.out.println("爷爷都是从孙子熬过来的");
  11. }
  12. }

father类

  1. package Java_study;
  2. /**
  3. *
  4. * @author Administrator
  5. * @date 2021-06-24
  6. * @remark 多重继承父类
  7. */
  8. public class father extends grandFather {
  9. public void fatherSay() {
  10. System.out.println("爸爸都是从儿子走过来的");
  11. }
  12. }

son类

  1. package Java_study;
  2. /**
  3. *
  4. * @author Administrator
  5. * @date 2021-06-24
  6. * @remark 多重继承子类
  7. */
  8. public class son extends father {
  9. public static void main(String[] args) {
  10. father son = new father();
  11. son.fatherSay();
  12. son.grandFatherSay();
  13. }
  14. }

测试记录:

  1. 爸爸都是从儿子走过来的
  2. 爷爷都是从孙子熬过来的

二. super关键字以及继承中的方法重写

2.1 super关键字的概述和使用

super的用法和this很像
  this代表本类对象的引用
  super代表父类存储空间的标识(可以理解为父类对象引用)
  super()且放在第一行 ; 目的是在初始化当前对象时,先保证了父类对象先初始化 。

用法(this和super均可如下使用)
  访问成员变量
    this.成员变量
    super.成员变量
  访问构造方法
    this(…)
    super(…)
  访问成员方法
    this.成员方法()
    super.成员方法()

构造方法中this()或者super()要放在第一行

  1. 在构造函数中,如果你不指定 构造器之间的调用关系 ,那么编译器会给你加上 super()且放在第一行 ; 目的是在初始化当前对象时,先保证了父类对象先初始化 。所以,你指定了构造函数间的调用,那么this()必须在第一行,以保证在执行任何动作前,对象已经完成了初始化。
  2. 构造函数只能被构造函数调用,因为对象只会初始化一次。
    this()和super()这样的方法被称为构造方法,顾名思义,他的作用就是在JVM堆中构建出一个指定类型的对象,如果你调用了两个这种形式的方法,岂不是代表着构建出了两个对象。
  3. 同理,为了避免构建出两个对象这种问题的出现,Java在编译时对这种情况做了强校验, 用户不能再同一个方法内调用多次this()或super(),同时为了避免对对象本身进行操作时,对象本身还未构建成功(也就找不到对应对象),所以对this()或super()的调用只能在构造方法中的第一行实现,防止异常。
  4. 在普通的成员方法中,如果调用super()或者this(),你是想要重新创建一个对象吗?抱歉Java为了保证自身对象的合理性,不允许你做这样的操作。

代码:
super1

  1. package Java_study;
  2. /**
  3. *
  4. * @author 只是甲
  5. * @date 2021-06-25
  6. * @remark 人类父类 super关键字概述
  7. *
  8. */
  9. public class super1 {
  10. //为了演示案例的方便,这里我们使用public修饰了成员变量,实际开发中,修饰符使用private
  11. //年龄
  12. public int age = 45;//c:在父类的成员范围找,如果有就使用
  13. }

super2

  1. package Java_study;
  2. /**
  3. *
  4. * @author 只是甲
  5. * @date 2021-06-25
  6. * @remark 人类子类 super关键字概述
  7. *
  8. */
  9. public class super2 extends super1 {
  10. // 年龄
  11. public int age = 20;
  12. public void printAge() {
  13. int age = 10;
  14. //我要访问局部范围的age?//10
  15. System.out.println(age);
  16. //我要访问成员范围的age
  17. System.out.println(this.age);
  18. //我要访问父类成员范围的age? //45
  19. System.out.println(super.age);
  20. }
  21. }

super3

  1. package Java_study;
  2. /**
  3. *
  4. * @author 只是甲
  5. * @date 2021-06-25
  6. * @remark 人类测试类 super关键字概述
  7. *
  8. */
  9. public class super3 {
  10. public static void main(String[] args) {
  11. super2 s = new super2();
  12. //s.show();
  13. //10
  14. //20
  15. //45
  16. s.printAge();
  17. }
  18. }

2.2 Java继承中构造方法的特点

子类所有构造方法都默认访问父类的空参数的构造方法
为什么呢?
  因为子类会继承父类中的数据,可能还会使用父类的数据,所以,子类初始化之前,一定要先完成父类数据的初始化
  每一个构造方法的第一条默认语句都是super

如果父类中没有构造方法,该怎么办呢?
  在父类中加一个无参的构造方法
  通过使用super关键字去显示的调用父类的带参构造方法
  通过这里我们发现第一种解决方案最简单,所以,建议我们自定义类的时候永远自己给出无参构造方法

代码:
jicheng_gouzao1

  1. package Java_study;
  2. /**
  3. *
  4. * @author 只是甲
  5. * @date 2021-06-25
  6. * @remark 人类父类 Java继承中构造方法的访问特点
  7. *
  8. */
  9. public class jicheng_gouzao1 {
  10. /**
  11. * @remark Father无参构造方法
  12. */
  13. public jicheng_gouzao1() {
  14. System.out.println("Father无参构造方法");
  15. }
  16. /**
  17. * @remark Father带参构造方法
  18. * @param name 姓名
  19. */
  20. public jicheng_gouzao1(String name) {
  21. System.out.println("Father带参构造方法");
  22. System.out.println("father:" + name);
  23. }
  24. }

jicheng_gouzao2

  1. package Java_study;
  2. /**
  3. *
  4. * @author 只是甲
  5. * @date 2021-06-25
  6. * @remark 人类子类 Java继承中构造方法的访问特点
  7. *
  8. */
  9. public class jicheng_gouzao2 extends jicheng_gouzao1 {
  10. String name;
  11. public jicheng_gouzao2() {
  12. //super();
  13. System.out.println("Son无参构造方法");
  14. }
  15. public jicheng_gouzao2(String name) {
  16. super( name);
  17. //this();
  18. System.out.println("Sone带参构造方法");
  19. System.out.println("son:" + name);
  20. }
  21. }

jicheng_gouzao3

  1. package Java_study;
  2. /**
  3. *
  4. * @author 只是甲
  5. * @date 2021-06-25
  6. * @remark 人类测试类 Java继承中构造方法的访问特点
  7. *
  8. */
  9. public class jicheng_gouzao3 {
  10. public static void main(String[] args) {
  11. /*
  12. Father无参构造方法
  13. Son无参构造方法
  14. */
  15. jicheng_gouzao2 s1 = new jicheng_gouzao2();
  16. System.out.println("----------");
  17. /*
  18. Father带参构造方法
  19. father:杜兰特
  20. Son带参构造方法
  21. son:杜兰特
  22. */
  23. jicheng_gouzao2 s2 = new jicheng_gouzao2("杜兰特");
  24. }
  25. }

测试记录:

  1. Father无参构造方法
  2. Son无参构造方法
  3. ----------
  4. Father带参构造方法
  5. father:杜兰特
  6. Sone带参构造方法
  7. son:杜兰特

2.3 Java继承中成员方法的特点

通过子类对象去访问一个方法

  1. 首先在子类中找
  2. 然后在父类中找
  3. 如果还是没有就会报错

代码:
jicheng_chengyuan1

  1. package Java_study;
  2. /**
  3. *
  4. * @author 只是甲
  5. * @date 2021-06-25
  6. * @remark 人类父类 Java继承中成员方法的访问特点
  7. *
  8. */
  9. public class jicheng_chengyuan1 {
  10. public void method() {
  11. System.out.println("Father method");
  12. }
  13. public void show() {
  14. System.out.println("Father show");
  15. }
  16. }

jicheng_chengyuan2

  1. package Java_study;
  2. /**
  3. *
  4. * @author 只是甲
  5. * @date 2021-06-25
  6. * @remark 人类子类 Java继承中成员方法的访问特点
  7. *
  8. */
  9. public class jicheng_chengyuan2 extends jicheng_chengyuan1 {
  10. @Override
  11. public void method() {
  12. super.method();
  13. }
  14. /**
  15. * @remark 重写父类方法
  16. */
  17. @Override
  18. public void show() {
  19. System.out.println("Son show");
  20. }
  21. }

jicheng_chengyuan3

  1. package Java_study;
  2. /**
  3. *
  4. * @author 只是甲
  5. * @date 2021-06-25
  6. * @remark 人类测试类 Java继承中成员方法的访问特点
  7. *
  8. */
  9. public class jicheng_chengyuan3 {
  10. public static void main(String[] args) {
  11. jicheng_chengyuan2 s = new jicheng_chengyuan2();
  12. //直接调用父类的method方法:Father method
  13. s.method();
  14. //重写了父类的show方法:Son show
  15. s.show();
  16. }
  17. }

测试记录:

  1. Father method
  2. Son show

2.4 方法重写的概述和使用

方法重写的概述:
  方法重写:子类中出现了和父类中一摸一样的方法声明

方法重写的应用:
  当子类需要父类的功能,而功能主体子类有自己特有的内容时,可以重写中的方法,这样重写父类中的方法
  这样,即沿袭了父类的功能,又定义了子类特有的内容

方法重写的注意事项:

  1. 注解
    @Override表明该方法的重写父类的方法
  2. 方法重写的注意事项
    1)父类中私有方法不能被重写
    2)子类重写父类方法时,访问权限不能更低
    3)子类重写父类方法时,建议访问权限一摸一样

具体案例可以参考上一节2.3。

参考:

  1. https://blog.csdn.net/qq_43529621/article/details/115209518

相关文章