继承的概述

面向对象的三大特征：封装性、继承性、多态性
继承是多态的前提，如果没有继承，就没有多态

继承主要解决的问题是：共性提取

继承当中的特点：

  • 子类可以拥有父类的“内容”
  • 子类还可以拥有自己专有的内容

image.png

继承的格式

  1. package com.Demo07;
  3. import com.Demo05.Student;
  5. /*
  6. 在继承的关系中，“子类就是一个父类”，也就是说，子类可以被当作父类看待
  7. 列入父类时员工，子类时讲师，那么“讲师就是一个员工”，关系：is-a
  9. 定义父类的格式：（一个普通的类定义）
  10. public class 父类名称{
  11.     //...
  12. }
  13. 定义子类的格式：
  14. public class 子类名称 extends 父类名称{
  15.     //...
  16. }
  17.  */
  18. public class Demo01Extends {
  19.     public static void main(String[] args) {
  20.         //创建一个子类对象
  21.         Teacher obj = new Teacher();
  22.         //Teacher类当中虽然什么都没有写，但是会继承来自父类的method方法
  23.         obj.method();
  25.         //创建另一个子类助教的方法
  26.         Assistant obj1=new Assistant();
  27.         obj1.methodZi();   //子类自己专有的方法
  28.     }
  29. }
  31. ===============================================================================================
  32. package com.Demo07;
  34. public class Employee {
  35.     public void method(){
  36.         System.out.println("父类构造方法执行！");
  37.     }
  38. }
  40. ===============================================================================================
  41. package com.Demo07;
  43. public class Teacher extends Employee{
  44. }
  46. ================================================================================================
  47. package com.Demo07;
  49. public class Assistant extends Employee{
  50.     public void methodZi(){
  51.         System.out.println("子类构造方法执行！");
  52.     }
  53. }

继承中成员变量/成员方法的访问特点

  1. package com.Demo07;
  3. /*
  4. 在父子类的继承关系中，如果成员变量重名，则创建子类对象时，访问有两种方式。
  6. 直接通过子类对象访问成员变量：
  7.     等号左边是谁，就优先用谁，没有则往上找
  8. 见解通过成员方法访问成员变量：
  9.     该方法属于谁，就优先用谁，没有则往上找
  11.  在父子类的继承关系中，创建子类对象，访问成员方法的规则：
  12.  创建的对象是谁，就优先用谁，没有就向上找
  14.  【注意事项】
  15.  不论是成员变量还是成员方法，如果没有都是往上找父类，绝对不会往下找子类。
  16.  */
  17. public class Demo02ExtendsField {
  18.     public static void main(String[] args) {
  19.         Fu fu = new Fu();  //创建父类对象
  20.         System.out.println(fu.numFu);    //只能使用父类的东西，没有任何子类的东西
  21.         System.out.println("========================");
  23.         Zi zi = new Zi();
  24.         System.out.println(zi.numFu);   //10
  25.         System.out.println(zi.numZi);   //20
  26.         System.out.println("=======================");
  28.         //等号左边是谁就优先用谁
  29.         System.out.println(zi.num);
  30. //        System.out.println(zi.ab);   //导出都没有编译报错
  31.         System.out.println("==================");
  33.         //这个方法是子类的，优先用子类，没有再往上找
  34.         zi.methodZi();
  35.         //这个方法是在父类中定义的
  36.         zi.methodFu();
  38.         //创建的是new了子类对象，所以优先用子类方法
  39.         zi.method();   //
  40.     }
  41. }

image.png

区分子类方法中重名的三种

  1. package com.Demo07;
  3. /*
  4. 局部变量：   直接写成员变量名
  5. 本类的成员变量：  this.成员变量名
  6. 父类的成员变量：  super.成员变量名
  7.  */
  8. public class Demo02ExtendsField {
  9.     public static void main(String[] args) {
  10.         Zi zi = new Zi();
  11.         zi.method();   
  12.     }
  13. }
  15. =================================================================================================
  16. package com.Demo07;
  18. public class Fu {
  19.     int num=10;
  21.     public void method(){
  22.         System.out.println("父类 重名方法method");
  23.     }
  24. }
  26. =================================================================================================
  27. package com.Demo07;
  29. public class Zi extends Fu{
  30.     int num=20;
  32.     public void method(){
  33.         int num=30;
  34.         System.out.println("子类 重名方法method");
  35.         System.out.println(num);   //30  局部变量
  36.         System.out.println(this.num);   //20  本类中的成员变量
  37.         System.out.println(super.num);   //10  父类的成员变量
  38.     }
  39. }

继承中方法的覆盖重写

  1. package com.Demo07;
  3. /*
  4. 重写（override）
  5. 概念：在继承关系中，方法名称一样，参数列表也一样
  7. 重写（override）：方法名称一样，参数列表【也一样】。  覆盖、覆写
  8. 重载（overload）：方法名称一样，参数列表【不一样】
  10. 方法的覆盖重写特点：创建的是子类对象，则优先用子类方法
  12. 方法覆盖重写的注意事项：
  13. 1.必须保证父子类之间方法名称相同，参数列表也相同。
  14. @override：写在方法前面，用力啊检测是不是有效的正确覆盖重写
  15. 这个注释就算是不写，只要满足要求，也是正确的方法覆盖重写
  17. 2.子类方法的返回值必须【小于等于】父类方法的返回值范围
  18. 小扩展提示：java.lang.Object类是所有类的公过最高父类（祖宗类），java.lang.String就是Object类的子类
  20. 3.子类方法的权限必须【大于等于】父类方法的权限修饰符
  21. 小扩展提示：public>protected>(default)>private
  22. 备注：（default）不是关键字default，而是什么都不写，留空
  24.  */
  25. public class Demo02ExtendsField {
  26.     public static void main(String[] args) {
  27.         Zi zi = new Zi();
  28.         zi.method();
  29.     }
  30. }
  32. ================================================================================================
  33. package com.Demo07;
  35. public class Fu {
  36.     int num=10;
  37.     public void method(){
  38.         System.out.println("父类 重名方法method");
  39.     }
  40. }
  42. ================================================================================================
  43. package com.Demo07;
  45. public class Zi extends Fu{
  46.     int num=20;
  47.     @Override
  48.     public void method(){
  49.         int num=30;
  50.         super.method();  //把父类的method方法拿来重复利用
  51.         System.out.println("子类 重名方法method");
  52.     }
  53. }

继承中构造方法的访问特点

  1. package com.Demo07;
  3. /*
  4. 继承关系中，父类的构造方法的访问特点：
  6. 1.子类构造方法当中有一个默认隐含的“super()”调用，所以一定是先调用的父类构造，后执行的子类构造
  7. 2.父类构造可以通过supper关键字来调用重载构造
  8. 3.supper的父类构造调用，必须是子类构造方法的第一个语句。不能一个子类构造调用多次supper构造
  10. 总结：
  11. 子类必须调用父类构造方法，不写则赠送supper()，写了则用写的指定的supper调用，supper只能有一个，还必须是第一个
  13.  */
  14. public class Demo02ExtendsField {
  15.     public static void main(String[] args) {
  16.         Zi zi = new Zi();
  17.     }
  18. }
  20. =================================================================================================
  21. package com.Demo07;
  23. public class Fu {
  24.     public Fu(){
  25.         System.out.println("父类无参构造方法");
  26.     }
  27.     public Fu(int num){
  28.         System.out.println("父类全参构造方法");
  29.     }
  30. }
  32. =================================================================================================
  33. package com.Demo07;
  35. public class Zi extends Fu{
  36.     public Zi(){
  37. //        super();   //在调用父类无参构造方法   默认赠送 可不写
  38.         super(12);   //在调用父类全参构造方法
  39.         System.out.println("子类构造方法！");
  40.     }
  41. }

image.png

supper关键字的三种用法

  1. package com.Demo07;
  3. public class Demo02ExtendsField {
  4.     public static void main(String[] args) {
  5.         Zi zi = new Zi();
  6.         zi.method();
  7.         zi.methodZi();
  8.     }
  9. }
  11. =================================================================================================
  12. package com.Demo07;
  14. public class Fu {
  15.     int num=30;
  16.     public Fu(){
  17.         System.out.println("父类无参构造方法");
  18.     }
  19.     public Fu(int num){
  20.         System.out.println("父类全参构造方法");
  21.     }
  22.     public void method(){
  23.         System.out.println("父类的method方法");
  24.     }
  25. }
  27. =================================================================================================
  28. package com.Demo07;
  30. /*
  31. supper关键字的三种用法：
  32. 1.在子类的成员方法中，访问父类的成员变量
  33. 2.在子类的成员方法中，访问父类的成员方法
  34. 3.在子类的构造方法中，访问父类的构造方法
  35.  */
  36. public class Zi extends Fu{
  37.     int num=20;
  38.     public Zi(){
  39. //        super();   //在调用父类无参构造方法   默认赠送 可不写
  40.         super(12);   //在调用父类全参构造方法
  41.         System.out.println("子类构造方法！");
  42.     }
  43.     public void methodZi(){
  44.         System.out.println(super.num);   //父类的 num
  45.     }
  46.     public void method(){
  47.         super.method();   //访问父类的method方法
  48.         System.out.println("子类的method方法");
  49.     }
  50. }

this关键字的三种用法

  1. package com.Demo07;
  3. /*
  4. supper关键字用来访问父类内容，而this关键字用力啊访问本类内容，用法也有三种：
  5. 1.在本类的成员方法中，访问本类的成员变量
  6. 2.在本类的成员方法中，访问本类的另一个成员方法
  7. 3.在本类的构造方法中，访问本类的另一个构造方法
  9. 在第三个方法要注意：
  10. A：this(...)调用也必须试构造方法的第一个语句
  11. B：super和this两种构造调用不能同时使用
  12.  */
  13. public class Zi extends Fu{
  14.     int num=20;
  15.     public Zi(){
  16. //        super();    //不再赠送
  17.         this(12);    //本类的无参构造调用本类的有参构造
  18. //        this();            //错误写法！！
  19.     }
  20.     public Zi(int num1){
  21.         System.out.println("子类的有参构造");
  22.     }
  23.     public void method(){
  24.         int num=30;
  25.         System.out.println(num);     //成员变量
  26.         System.out.println(this.num);   //本类中的成员变量
  27.         System.out.println(super.num);   //父类中的成员变量
  28.     }
  29.     public void methodA(){
  30.         System.out.println("AAA");
  31.     }
  32.     public void methodB(){
  33.         this.methodA();
  34.         System.out.println("BBB");
  35.     }
  36. }
  38. ================================================================================================
  39. package com.Demo07;
  41. public class Fu {
  42.     int num=10;
  43.     public Fu(){
  44.         System.out.println("父类无参构造方法");
  45.     }
  46. }
  48. ================================================================================================
  49. package com.Demo07;
  51. public class Demo02ExtendsField {
  52.     public static void main(String[] args) {
  53.         Zi zi = new Zi(1);
  54.         zi.methodB();
  55.     }
  56. }

super和this关键字图解

image.png

Java继承的三个特点

  • java语言是单继承的
  • java语言可以多级继承
  • 一个子类的直接父类是唯一的，但是一个父类可以拥有很多个子类，可以拥有很多个兄弟姐妹

image.png