本文记录了什么是继承、何时使用继承、继承的限制、继承中的super与this关键字，以及给出完整实例解释继承的相关知识点。

  • 什么是继承
    继承是Java面向对象三大特性（封装、继承、多态）之一，用extends关键字表示继承，比如有A类、B类，B类继承A类，如下写法：
    public class B extends A{ }通常我们管A类叫父类，管B类叫子类。
    如果一个类没有写extends关键字，那这个类默认继承java.lang.Object类，Object类是所有类的祖先类。

  • 何时用继承
    继承通常是为了消除代码的重复、冗余，使代码更易维护。说白了就是将一些公共的属性、方法提取出来，放到一个通用的类中，然后有需要的类再继承这个通用的类。
    比如普通员工和经理，他们都享有公司五险一金的基本福利，普通员工每年有一次国内游的福利，经理每年有一次带家人国内游以及一次国外旅游的福利。这里很明显可以把五险一金福利放到父类中，因为只要是公司员工就有，这是公共的福利。详见下文实例分析。

  • 继承的限制
    final类是不允许被继承的，final方法是不允许被子类重写的。通过关键字就很好理解，final是最终的意思，既然是最终了，那也就不会有下一层级的子类了。
    不允许多继承（接口可以弥补这个缺陷，在接口中详解）。比如有A类、B类、C类三个类，C类不能同时继承A类、B类：public class C extends A,B { }以上写法是错误的。

  • 继承中子类拥有的权限
    子类拥有父类所有非private的属性和方法；
    子类可以拥有自己的属性和方法；
    子类可以重写父类非final、static声明的方法；

  • super与this关键字
    通过super关键字可以访问父类非private的属性、方法、构造器，比如要在子类中访问父类的test()方法，可以用super.test()，要访问父类的构造器则是通过super()可以访问到父类的无参构造器，如果要访问有参构造器则在括号中带上参数即可；
    通过this关键字，可以访问子类所有的属性、方法、构造器，说白了就是指当前类的引用了。
    注意：很多人认为super与this引用是一样的概念，实际不是的。this是当前对象的引用，可以直接赋值给另一个对象变量，即可以使用Object obj = this;；而super其实是Java一个特殊关键字，可以调用父类的非private的属性、方法、构造器，但不能赋值给另一个对象变量，也就是不能使用 Object obj = super;

  • 继承中的构造器
    详细可以查看我的这篇文章java 构造器（构造方法）使用详细说明

需求：公司有普通员工和经理，他们都享有公司五险一金的基础福利，普通员工每年有一次国内游的福利，经理每年有一次带家人国内游以及一次国外旅游的福利。分别打印出普通员工的福利和经理的福利。

定义普通员工类：

  1. /**
  2.  * 员工类
  3.  */
  4. public class Employee {
  5.     /**
  6.      * 基本福利
  7.      */
  8.     private String basicWelfare;
  10.     /**
  11.      * 国内旅游福利
  12.      */
  13.     private String internalTour;
  14.     /**
  15.      * 构造函数，初始化福利
  16.      */
  17.     public Employee(){
  18.         this.basicWelfare = "五险一金";
  19.         this.internalTour = "一年一次国内游";
  20.     }
  22.     /**
  23.      * 打印员工福利
  24.      */
  25.     public void printWelfare(){
  26.         System.out.println(this.basicWelfare);
  27.         System.out.println(this.internalTour);
  28.     }
  30. }

定义经理类

  1. /**
  2.  * 经理
  3.  */
  4. public class Manager{
  5.     /**
  6.      * 基本福利
  7.      */
  8.     private String basicWelfare;
  10.     /**
  11.      * 国内旅游福利
  12.      */
  13.     private String internalTour;
  15.     /**
  16.      * 国外旅游福利
  17.      */
  18.     private String externalTour;
  19.     
  20.     /**
  21.      * 构造函数，初始化福利
  22.      */
  23.     public Manager(){
  24.         this.basicWelfare = "五险一金";
  25.         this.internalTour = "一年一次带家人国内游";
  26.         this.externalTour = "一年一次国外旅游";
  27.     }
  29.     /**
  30.      * 打印员工福利
  31.      */
  32.     public void printWelfare(){
  33.         System.out.println(this.basicWelfare);
  34.         System.out.println(this.internalTour);
  35.         System.out.println(this.externalTour);
  36.     }
  38. }

以上两个类，可以看到basicWelfare、internalTour两个属性以及printWelfare()方法是重复的。重复必然导致难维护！如果需求改为基本福利是六险一金以及1000块春节过节费，那这两个类都要改过去，不方便维护，特别是类越多，维护难度越大。此时继承就能尽显其优势！看以下例子。

分析需求，可以看到经理的福利基本上是包含了普通员工的福利，所以将员工类作为父类，并稍加改造，增加可以修改国内旅游属性的方法setInternalTour(String internalTour)，主要是因为internalTour属性是private的，不能在子类访问到，所以开放了一个方法供子类调用。这个改造主要是因为经理的国内游还可以带上家人。

定义员工类（父类）

  1. /**
  2.  * 员工类
  3.  */
  4. public class Employee {
  5.     /**
  6.      * 基本福利
  7.      */
  8.     private String basicWelfare;
  10.     /**
  11.      * 国内旅游福利
  12.      */
  13.     private String internalTour;
  15.     /**
  16.      * 初始化员工福利
  17.      */
  18.     public Employee(){
  19.         this.basicWelfare = "五险一金";
  20.         this.internalTour = "一年一次国内游";
  21.     }
  23.     /**
  24.      * 可以设置国内游的方法
  25.      * @param internalTour
  26.      */
  27.     public void setInternalTour(String internalTour){
  28.         this.internalTour = internalTour;
  29.     }
  31.     /**
  32.      * 打印员工福利
  33.      */
  34.     public void printWelfare(){
  35.         System.out.println(this.basicWelfare);
  36.         System.out.println(this.internalTour);
  37.     }
  39. }

定义经理类（子类），继承员工类

  1. /**
  2.  * 经理类
  3.  */
  4. public class Manager extends Employee{
  6.     /**
  7.      * 国外旅游福利
  8.      */
  9.     private String externalTour;
  11.     /**
  12.      * 初始化经理福利
  13.      */
  14.     public Manager(){
  15.         //由于经理国内游还可以带家人，所以这里通过super.setInternalTour方法重新设置
  16.         super.setInternalTour("一年一次带家人国内游");
  17.         this.externalTour = "一年一次国外旅游";
  18.     }
  20.     /**
  21.      * 重写父类的printWelfare()方法
  22.      * 由于父类已经有printWelfare()方法并且可以打印基本福利和国内游福利，
  23.      * 所以直接通过super调用父类的printWelfare()方法打印基本福利和国内游福利
  24.      */
  25.     @Override
  26.     public void printWelfare(){
  27.         //调用父类打印基本福利和国内游福利，
  28.         //这里必须带上super，否则就是调用子类的printWelfare()，那就是死循环了
  29.         super.printWelfare();
  30.         //打印国外游福利
  31.         System.out.println(this.externalTour);
  32.     }
  34. }

测试类

  1. public class ExtendsDemo {
  2.     public static void main(String[] args){
  4.         //打印员工福利
  5.         Employee employee = new Employee();
  6.         System.out.println("员工福利：");
  7.         employee.printWelfare();
  9.         //打印经理福利
  10.         Manager manager = new Manager();
  11.         System.out.println("员工福利：");
  12.         manager.printWelfare();
  13.     }
  14. }

执行以上测试类，输出：

  1. 员工福利：
  2. 五险一金
  3. 一年一次国内游
  5. 员工福利：
  6. 五险一金
  7. 一年一次带家人国内游
  8. 一年一次国外旅游

通过该继承的实例改造，就能很方便完成以上提出的需求改造，如果基本福利改为六险一金，那只要将Employee类中的五险一金改为六险一金即可；如果要增加一项基本福利，那也直接在Employee类改造即可。

以上示例都可以通过我的GitHub获取完整的代码，点击获取

版权声明：本文为mingsay原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/mingsay/p/12494002.html