1、继承的概念

继承是java面向对象编程技术的一块基石，因为它允许创建分等级层次的类。
继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

1.1、生活中的继承：

07_面向对象 - 图1
兔子和羊属于食草动物类，狮子和豹属于食肉动物类。
食草动物和食肉动物又是属于动物类。
所以继承需要符合的关系是：is-a，父类更通用，子类更具体。
虽然食草动物和食肉动物都是属于动物，但是两者的属性和行为上有差别，所以子类会具有父类的一般特性也会具有自身的特性。

2、 类的继承

面向对象的三大特性：

  1. 封装（封装细节）
  2. 继承
  3. 多态
  • 继承是面向对象的重要概念，软件中的继承和现实中的继承概念是一样的
  • 继承是实现软件可重用性的重要手段，如：A继承B，A就拥有了B的所有公开的特性
  • java中只支持类的单继承，也就是说A只能继承B，A不能同时继承C

java中的继承使用extends 关键字，语法格式：
[修饰符] class 子类 extends 父类{

}
【代码示例】

  1. public class ExtendsTest01 {
  3.     public static void main(String[] args) {
  5.         //如果参数比较多尽量使用setter方法，不要使用构造函数
  6.         //因为参数比较多，构造函数表达的不是很明确        
  7.         Student student = new Student();
  8.         student.setId(1001);
  9.         student.setName("张三");
  10.         student.setSex(true);
  11.         student.setAddress("北京");
  12.         student.setAge(20);
  13.         student.setClassesId(10);
  15.         System.out.println("id=" + student.getId());        
  16.         System.out.println("name=" + student.getName());
  17.         System.out.println("sex=" + student.getSex());
  18.         System.out.println("address=" + student.getAddress());
  19.         System.out.println("age=" + student.getAge());                
  20.         System.out.println("classid=" + student.getClassesId());            
  22.         System.out.println("");
  23.         System.out.println("");
  24.         Employee emp = new Employee();
  25.         emp.setId(1002);
  26.         emp.setName("李四");
  27.         emp.setSex(true);
  28.         emp.setAddress("上海");
  29.         emp.setAge(30);
  30.         emp.setWorkYear(10);
  32.         System.out.println("id=" + emp.getId());        
  33.         System.out.println("name=" + emp.getName());
  34.         System.out.println("sex=" + emp.getSex());
  35.         System.out.println("address=" + emp.getAddress());
  36.         System.out.println("age=" + emp.getAge());        
  37.         System.out.println("workYear=" + emp.getWorkYear());        
  38.     }    
  39. }
  42. class Student {
  44.     //学号
  45.     private int id;    
  47.     //姓名
  48.     private String name;
  50.     //性别
  51.     private boolean sex;
  53.     //地址
  54.     private String address;
  56.     //年龄
  57.     private int age;
  59.     //班级编号
  60.     private int classesId;
  62.     /*
  63.     public Student(int id, String name, boolean sex, String address, int age) {
  64.         this.id = id;
  65.         this.name = name;
  66.         this.sex = sex;
  67.         this.address = address;
  68.         this.age = age;
  69.     }
  70.     */
  72.     //设置学号
  73.     public void setId(int studentId) {
  74.         id = studentId;        
  75.     }
  77.     //读取学号
  78.     public int getId() {
  79.         return id;    
  80.     }
  82.     public void setName(String studentName) {
  83.         name = studentName;
  84.     }
  86.     public String getName() {
  87.         return name;    
  88.     }
  90.     public void setSex(boolean studentSex) {
  91.         sex = studentSex;
  92.     }
  94.     public boolean getSex() {
  95.         return sex;    
  96.     }
  98.     public void setAddress(String studentAddress) {
  99.         address = studentAddress;
  100.     }
  102.     public String getAddress() {
  103.         return address;    
  104.     }
  106.     public void setAge(int studentAge) {
  107.         if (studentAge >=0 && studentAge <=120) {
  108.             age = studentAge;
  109.         }
  110.     }
  112.     public int getAge() {
  113.         return age;    
  114.     }
  116.     public void setClassesId(int classesId) {
  117.         this.classesId = classesId;
  118.     }
  120.     public int getClassesId() {
  121.         return classesId;
  122.     }
  123. }
  125. class Employee {
  127.     //员工编号
  128.     private int id;    
  130.     //姓名
  131.     private String name;
  133.     //性别
  134.     private boolean sex;
  136.     //地址
  137.     private String address;
  139.     //年龄
  140.     private int age;
  142.     //工作年限
  143.     private int workYear;
  145.     //设置学号
  146.     public void setId(int studentId) {
  147.         id = studentId;        
  148.     }
  150.     //读取学号
  151.     public int getId() {
  152.         return id;    
  153.     }
  155.     public void setName(String studentName) {
  156.         name = studentName;
  157.     }
  159.     public String getName() {
  160.         return name;    
  161.     }
  163.     public void setSex(boolean studentSex) {
  164.         sex = studentSex;
  165.     }
  167.     public boolean getSex() {
  168.         return sex;    
  169.     }
  171.     public void setAddress(String studentAddress) {
  172.         address = studentAddress;
  173.     }
  175.     public String getAddress() {
  176.         return address;    
  177.     }
  179.     public void setAge(int studentAge) {
  180.         if (studentAge >=0 && studentAge <=120) {
  181.             age = studentAge;
  182.         }
  183.     }
  185.     public int getAge() {
  186.         return age;    
  187.     }
  189.     public void setWorkYear(int workYear) {
  190.         this.workYear = workYear;    
  191.     }         
  193.     public int getWorkYear() {
  194.         return workYear;            
  195.     }
  196. }

以上输出是完全正确的，但程序上存在一些冗余，因为Student和Employee都重复出现了id,name,address，sex,age属性，而Student和Employee其实都是Person，所以应该具有person的相关属性，所以完全可以抽取出一个Person类出来，让Student和Employee继承它，这样我们的冗余代码就会减少

【代码示例】，提取Person类，让Student和Employee继承Person

  1. public class ExtendsTest02 {
  3.     public static void main(String[] args) {
  5.         Student student = new Student();
  6.         student.setId(1001);
  7.         student.setName("张三");
  8.         student.setSex(true);
  9.         student.setAddress("北京");
  10.         student.setAge(20);
  11.         student.setClassesId(10);
  13.         System.out.println("id=" + student.getId());        
  14.         System.out.println("name=" + student.getName());
  15.         System.out.println("sex=" + student.getSex());
  16.         System.out.println("address=" + student.getAddress());
  17.         System.out.println("age=" + student.getAge());                
  18.         System.out.println("classid=" + student.getClassesId());            
  20.         System.out.println("");
  21.         System.out.println("");
  22.         Employee emp = new Employee();
  23.         emp.setId(1002);
  24.         emp.setName("李四");
  25.         emp.setSex(true);
  26.         emp.setAddress("上海");
  27.         emp.setAge(30);
  28.         emp.setWorkYear(10);
  30.         System.out.println("id=" + emp.getId());        
  31.         System.out.println("name=" + emp.getName());
  32.         System.out.println("sex=" + emp.getSex());
  33.         System.out.println("address=" + emp.getAddress());
  34.         System.out.println("age=" + emp.getAge());        
  35.         System.out.println("workYear=" + emp.getWorkYear());        
  36.     }    
  37. }
  39. class Person {
  42.     //姓名
  43.     private String name;
  45.     //性别
  46.     private boolean sex;
  48.     //地址
  49.     private String address;
  51.     //年龄
  52.     private int age;
  54.     //设置学号
  55.     public void setId(int studentId) {
  56.         id = studentId;        
  57.     }
  59.     //读取学号
  60.     public int getId() {
  61.         return id;    
  62.     }
  64.     public void setName(String studentName) {
  65.         name = studentName;
  66.     }
  68.     public String getName() {
  69.         return name;    
  70.     }
  72.     public void setSex(boolean studentSex) {
  73.         sex = studentSex;
  74.     }
  76.     public boolean getSex() {
  77.         return sex;    
  78.     }
  80.     public void setAddress(String studentAddress) {
  81.         address = studentAddress;
  82.     }
  84.     public String getAddress() {
  85.         return address;    
  86.     }
  88.     public void setAge(int studentAge) {
  89.         if (studentAge >=0 && studentAge <=120) {
  90.             age = studentAge;
  91.         }
  92.     }
  94.     public int getAge() {
  95.         return age;    
  96.     }    
  97. }
  99. class Student extends Person {
  100.     //学号
  101.     private int sid;
  102.     //班级编号
  103.     private int classesId;
  105.     public void setClassesId(int classesId) {
  106.         this.classesId = classesId;
  107.     }
  109.     public int getClassesId() {
  110.         return classesId;
  111.     }
  112. }
  114. class Employee extends Person {
  115.     //编号
  116.     private int eno;
  117.     //工作年限
  118.     private int workYear;
  120.     public void setWorkYear(int workYear) {
  121.         this.workYear = workYear;    
  122.     }         
  124.     public int getWorkYear() {
  125.         return workYear;            
  126.     }
  127. }

运行结果和前面的一样，先从代码数量上来看，比以前少多了，没有重复了，软件设计有一个原则“重复的代码最好不要出现两次或多次”，如果出现两次以上相同的代码，那么就不好维护了，如果要改的话，那么多处都要改，给维护带来不变，而从我们的这个示例，大家看到采用继承可以达到重用性，把父类中的所有属性都继承下来了。

注：继承是对象级别的继承，将父类对象属性、方法继承过来
静态信息是存储在方法区，可以直接通过类名调用，在对象之前创建，所以不是对象级别的，更不能被继承

3、 方法的覆盖(Override)

首先看一下方法重载(Overload)，回顾方法重载的条件：

  • 方法名称相同
  • 方法参数类型、个数、顺序至少有一个不同
  • 方法的返回类型可以不同，因为方法重载和返回类型没有任何关系
  • 方法的修饰符可以不同，因为方法重载和修饰符没有任何关系
  • 方法重载只出现在同一个类中

方法的覆盖(Override)的条件：

  1. 必须要有继承关系
  2. 覆盖只能出现在子类中，如果没有继承关系，不存在覆盖，只存在重载
  3. 在子类中被覆盖的方法，必须和父类中的方法完全一样，也就是方法名，返回类型、参数列表，完全一样
  4. 子类方法的访问权限不能小于父类方法的访问权限
  5. 子类方法不能抛出比父类方法更多的异常，但可以抛出父类方法异常的子异常
  6. 父类的静态方法不能被子类覆盖
  7. 父类的私有方法不能覆盖
  8. 覆盖是针对成员方法，而非属性

为什么需要覆盖？
就是要改变父类的行为。

1、对成员方法覆盖

【代码示例】，继承父类方法，不覆盖

  1. public class OverrideTest01 {
  3.     public static void main(String[] args) {
  5.         Student student = new Student();
  6.         student.setId(1001);
  7.         student.setName("张三");
  8.         student.setSex(true);
  9.         student.setAddress("北京");
  10.         student.setAge(20);
  11.         student.setClassesId(10);
  13.         student.printInfo();
  15.         System.out.println("");
  16.         Employee emp = new Employee();
  17.         emp.setId(1002);
  18.         emp.setName("李四");
  19.         emp.setSex(true);
  20.         emp.setAddress("上海");
  21.         emp.setAge(30);
  22.         emp.setWorkYear(10);
  24.         emp.printInfo();
  25.     }    
  26. }
  28. class Person {
  29.     //学号
  30.     private int id;    
  32.     //姓名
  33.     private String name;
  35.     //性别
  36.     private boolean sex;
  38.     //地址
  39.     private String address;
  41.     //年龄
  42.     private int age;
  44.     public void printInfo() {
  45.         System.out.println("id=" + id + ", name=" + name + ",sex=" + sex + ", address=" + address + ", age=" + age);    
  46.     }
  48.     //设置学号
  49.     public void setId(int studentId) {
  50.         id = studentId;        
  51.     }
  53.     //读取学号
  54.     public int getId() {
  55.         return id;    
  56.     }
  58.     public void setName(String studentName) {
  59.         name = studentName;
  60.     }
  62.     public String getName() {
  63.         return name;    
  64.     }
  66.     public void setSex(boolean studentSex) {
  67.         sex = studentSex;
  68.     }
  70.     public boolean getSex() {
  71.         return sex;    
  72.     }
  74.     public void setAddress(String studentAddress) {
  75.         address = studentAddress;
  76.     }
  78.     public String getAddress() {
  79.         return address;    
  80.     }
  82.     public void setAge(int studentAge) {
  83.         if (studentAge >=0 && studentAge <=120) {
  84.             age = studentAge;
  85.         }
  86.     }
  88.     public int getAge() {
  89.         return age;    
  90.     }    
  91. }
  93. class Student extends Person {
  95.     //班级编号
  96.     private int classesId;
  98.     public void setClassesId(int classesId) {
  99.         this.classesId = classesId;
  100.     }
  102.     public int getClassesId() {
  103.         return classesId;
  104.     }
  105. }
  107. class Employee extends Person {
  109.     //工作年限
  110.     private int workYear;
  112.     public void setWorkYear(int workYear) {
  113.         this.workYear = workYear;    
  114.     }         
  116.     public int getWorkYear() {
  117.         return workYear;            
  118.     }
  119. }

1646726843(1).png

【代码示例】，继承父类方法，覆盖父类中的方法（改变父类的行为）

  1. public class OverrideTest02 {
  3.     public static void main(String[] args) {
  5.         Student student = new Student();
  6.         student.setId(1001);
  7.         student.setName("张三");
  8.         student.setSex(true);
  9.         student.setAddress("北京");
  10.         student.setAge(20);
  11.         student.setClassesId(10);
  13.         student.printInfo();
  15.         System.out.println("");
  16.         Employee emp = new Employee();
  17.         emp.setId(1002);
  18.         emp.setName("李四");
  19.         emp.setSex(true);
  20.         emp.setAddress("上海");
  21.         emp.setAge(30);
  22.         emp.setWorkYear(10);
  24.         emp.printInfo();
  25.     }    
  26. }
  28. class Person {
  29.     //学号
  30.     private int id;    
  32.     //姓名
  33.     private String name;
  35.     //性别
  36.     private boolean sex;
  38.     //地址
  39.     private String address;
  41.     //年龄
  42.     private int age;
  44.     public void printInfo() {
  45.         System.out.println("id=" + id + ", name=" + name + ",sex=" + sex + ", address=" + address + ", age=" + age);    
  46.     }
  48.     //设置学号
  49.     public void setId(int studentId) {
  50.         id = studentId;        
  51.     }
  53.     //读取学号
  54.     public int getId() {
  55.         return id;    
  56.     }
  58.     public void setName(String studentName) {
  59.         name = studentName;
  60.     }
  62.     public String getName() {
  63.         return name;    
  64.     }
  66.     public void setSex(boolean studentSex) {
  67.         sex = studentSex;
  68.     }
  70.     public boolean getSex() {
  71.         return sex;    
  72.     }
  74.     public void setAddress(String studentAddress) {
  75.         address = studentAddress;
  76.     }
  78.     public String getAddress() {
  79.         return address;    
  80.     }
  82.     public void setAge(int studentAge) {
  83.         if (studentAge >=0 && studentAge <=120) {
  84.             age = studentAge;
  85.         }
  86.     }
  88.     public int getAge() {
  89.         return age;    
  90.     }    
  91. }
  93. class Student extends Person {
  95.     //班级编号
  96.     private int classesId;
  98.     public void setClassesId(int classesId) {
  99.         this.classesId = classesId;
  100.     }
  102.     public int getClassesId() {
  103.         return classesId;
  104.     }
  106.     public void printInfo() {
  107.         System.out.println("id=" + getId() + ", name=" + getName() + ",sex=" + getSex() + ", address=" + getAddress() + ", age=" + getAge() + ",classesid=" + classesId);    
  108.     }
  110. }
  112. class Employee extends Person {
  114.     //工作年限
  115.     private int workYear;
  117.     public void setWorkYear(int workYear) {
  118.         this.workYear = workYear;    
  119.     }         
  121.     public int getWorkYear() {
  122.         return workYear;            
  123.     }
  125.     public void printInfo() {
  126.         System.out.println("id=" + getId() + ", name=" + getName() + ",sex=" + getSex() + ", address=" + getAddress() + ", age=" + getAge() + ", workYear=" + workYear);    
  127.     }
  129. }

1646728183(1).png

以上子类对父类的方法进行了覆盖，改变了父类的行为，当我们new子类的时候，它不会再调用父类的方法了，而直接调用子类的方法，所以我们就完成了对父类行为的扩展。
【代码示例】，改善以上示例

  1. public class OverrideTest03 {
  3.     public static void main(String[] args) {
  5.         //Student student = new Student();
  7.         //此种写法是错误的，Person不是Student
  8.         //Student person_student = new Person();
  10.         //此种写法是正确的，Student是Person
  11.         Person person_student = new Student();
  13.         person_student.setId(1001);
  14.         person_student.setName("张三");
  15.         person_student.setSex(true);
  16.         person_student.setAddress("北京");
  17.         person_student.setAge(20);
  19.         //编译出错，因为Person看不到子类Student的属性
  20.         //person_student.setClassesId(10);
  22.         person_student.printInfo();
  24.         System.out.println("");
  25.         //Employee person_emp = new Employee();
  26.         Person person_emp = new Employee();
  28.         person_emp.setId(1002);
  29.         person_emp.setName("李四");
  30.         person_emp.setSex(true);
  31.         person_emp.setAddress("上海");
  32.         person_emp.setAge(30);
  33.         //编译出错，因为Person看不到子类Employee的属性
  34.         //person_emp.setWorkYear(10);
  36.         person_emp.printInfo();
  37.     }    
  38. }
  40. class Person {
  41.     //学号
  42.     private int id;    
  44.     //姓名
  45.     private String name;
  47.     //性别
  48.     private boolean sex;
  50.     //地址
  51.     private String address;
  53.     //年龄
  54.     private int age;
  56.     public void printInfo() {
  57.         System.out.println("id=" + id + ", name=" + name + ",sex=" + sex + ", address=" + address + ", age=" + age);    
  58.     }
  60.     //设置学号
  61.     public void setId(int studentId) {
  62.         id = studentId;        
  63.     }
  65.     //读取学号
  66.     public int getId() {
  67.         return id;    
  68.     }
  70.     public void setName(String studentName) {
  71.         name = studentName;
  72.     }
  74.     public String getName() {
  75.         return name;    
  76.     }
  78.     public void setSex(boolean studentSex) {
  79.         sex = studentSex;
  80.     }
  82.     public boolean getSex() {
  83.         return sex;    
  84.     }
  86.     public void setAddress(String studentAddress) {
  87.         address = studentAddress;
  88.     }
  90.     public String getAddress() {
  91.         return address;    
  92.     }
  94.     public void setAge(int studentAge) {
  95.         if (studentAge >=0 && studentAge <=120) {
  96.             age = studentAge;
  97.         }
  98.     }
  100.     public int getAge() {
  101.         return age;    
  102.     }    
  103. }
  105. class Student extends Person {
  107.     //班级编号
  108.     private int classesId;
  110.     public void setClassesId(int classesId) {
  111.         this.classesId = classesId;
  112.     }
  114.     public int getClassesId() {
  115.         return classesId;
  116.     }
  118.     public void printInfo() {
  119.         System.out.println("id=" + getId() + ", name=" + getName() + ",sex=" + getSex() + ", address=" + getAddress() + ", age=" + getAge() + ",classesid=" + classesId);    
  120.     }
  122. }
  124. class Employee extends Person {
  126.     //工作年限
  127.     private int workYear;
  129.     public void setWorkYear(int workYear) {
  130.         this.workYear = workYear;    
  131.     }         
  133.     public int getWorkYear() {
  134.         return workYear;            
  135.     }
  137.     public void printInfo() {
  138.         System.out.println("id=" + getId() + ", name=" + getName() + ",sex=" + getSex() + ", address=" + getAddress() + ", age=" + getAge() + ", workYear=" + workYear);    
  139.     }
  141. }

【代码示例】，改善以上示例

  1. public class OverrideTest04 {
  3.     public static void main(String[] args) {
  4.         Person person_student = new Student();
  6.         person_student.setId(1001);
  7.         person_student.setName("张三");
  8.         person_student.setSex(true);
  9.         person_student.setAddress("北京");
  10.         person_student.setAge(20);
  12.         print(person_student);
  14.         Person person_emp = new Employee();
  16.         person_emp.setId(1002);
  17.         person_emp.setName("李四");
  18.         person_emp.setSex(true);
  19.         person_emp.setAddress("上海");
  20.         person_emp.setAge(30);
  22.         print(person_emp);        
  24.         Person person = new Person();
  25.         person.setId(1003);
  26.         person.setName("王五");
  27.         person.setSex(true);
  29.         print(person);
  30.     }    
  32.     private static void print(Person person) {
  33.         person.printInfo();
  34.     }
  35. }
  39. class Person {
  40.     //学号
  41.     private int id;    
  43.     //姓名
  44.     private String name;
  46.     //性别
  47.     private boolean sex;
  49.     //地址
  50.     private String address;
  52.     //年龄
  53.     private int age;
  55.     public void printInfo() {
  56.         System.out.println("id=" + id + ", name=" + name + ",sex=" + sex + ", address=" + address + ", age=" + age);    
  57.     }
  59.     //设置学号
  60.     public void setId(int studentId) {
  61.         id = studentId;        
  62.     }
  64.     //读取学号
  65.     public int getId() {
  66.         return id;    
  67.     }
  69.     public void setName(String studentName) {
  70.         name = studentName;
  71.     }
  73.     public String getName() {
  74.         return name;    
  75.     }
  77.     public void setSex(boolean studentSex) {
  78.         sex = studentSex;
  79.     }
  81.     public boolean getSex() {
  82.         return sex;    
  83.     }
  85.     public void setAddress(String studentAddress) {
  86.         address = studentAddress;
  87.     }
  89.     public String getAddress() {
  90.         return address;    
  91.     }
  93.     public void setAge(int studentAge) {
  94.         if (studentAge >=0 && studentAge <=120) {
  95.             age = studentAge;
  96.         }
  97.     }
  99.     public int getAge() {
  100.         return age;    
  101.     }    
  102. }
  104. class Student extends Person {
  106.     //班级编号
  107.     private int classesId;
  109.     public void setClassesId(int classesId) {
  110.         this.classesId = classesId;
  111.     }
  113.     public int getClassesId() {
  114.         return classesId;
  115.     }
  117.     public void printInfo() {
  118.         System.out.println("id=" + getId() + ", name=" + getName() + ",sex=" + getSex() + ", address=" + getAddress() + ", age=" + getAge() + ",classesid=" + classesId);    
  119.     }
  121. }
  123. class Employee extends Person {
  125.     //工作年限
  126.     private int workYear;
  128.     public void setWorkYear(int workYear) {
  129.         this.workYear = workYear;    
  130.     }         
  132.     public int getWorkYear() {
  133.         return workYear;            
  134.     }
  136.     public void printInfo() {
  137.         System.out.println("id=" + getId() + ", name=" + getName() + ",sex=" + getSex() + ", address=" + getAddress() + ", age=" + getAge() + ", workYear=" + workYear);    
  138.     }
  140. }

多态其实就是多种状态，overload（重载）是多态的一种，属于编译期绑定，也就是静态绑定（前期绑定），override是运行期间绑定（后期绑定）。
多态存在的条件：

  • 有继承
  • 有覆盖
  • 父类指向子类的引用

1646728510(1).png

2、对静态方法覆盖

【代码示例】、

  1. public class OverrideTest05 {
  3.     public static void main(String[] args) {
  4.         Person person_student = new Student();
  6.         person_student.setId(1001);
  7.         person_student.setName("张三");
  8.         person_student.setSex(true);
  9.         person_student.setAddress("北京");
  10.         person_student.setAge(20);
  12.         print(person_student);
  14.         Person person_emp = new Employee();
  16.         person_emp.setId(1002);
  17.         person_emp.setName("李四");
  18.         person_emp.setSex(true);
  19.         person_emp.setAddress("上海");
  20.         person_emp.setAge(30);
  22.         print(person_emp);        
  24.     }    
  26.     private static void print(Person person) {
  27.         person.printInfo();
  28.     }
  29. }
  33. class Person {
  34.     //学号
  35.     private int id;    
  37.     //姓名
  38.     private String name;
  40.     //性别
  41.     private boolean sex;
  43.     //地址
  44.     private String address;
  46.     //年龄
  47.     private int age;
  49.     public static void printInfo() {
  50.         System.out.println("------------Person--------------");        
  51.     }
  53.     //设置学号
  54.     public void setId(int studentId) {
  55.         id = studentId;        
  56.     }
  58.     //读取学号
  59.     public int getId() {
  60.         return id;    
  61.     }
  63.     public void setName(String studentName) {
  64.         name = studentName;
  65.     }
  67.     public String getName() {
  68.         return name;    
  69.     }
  71.     public void setSex(boolean studentSex) {
  72.         sex = studentSex;
  73.     }
  75.     public boolean getSex() {
  76.         return sex;    
  77.     }
  79.     public void setAddress(String studentAddress) {
  80.         address = studentAddress;
  81.     }
  83.     public String getAddress() {
  84.         return address;    
  85.     }
  87.     public void setAge(int studentAge) {
  88.         if (studentAge >=0 && studentAge <=120) {
  89.             age = studentAge;
  90.         }
  91.     }
  93.     public int getAge() {
  94.         return age;    
  95.     }    
  96. }
  98. class Student extends Person {
  100.     //班级编号
  101.     private int classesId;
  103.     public void setClassesId(int classesId) {
  104.         this.classesId = classesId;
  105.     }
  107.     public int getClassesId() {
  108.         return classesId;
  109.     }
  111.     public static void printInfo() {
  112.         System.out.println("------------Student------------");
  113.     }
  115. }
  117. class Employee extends Person {
  119.     //工作年限
  120.     private int workYear;
  122.     public void setWorkYear(int workYear) {
  123.         this.workYear = workYear;    
  124.     }         
  126.     public int getWorkYear() {
  127.         return workYear;            
  128.     }
  130.     public static void printInfo() {
  131.         System.out.println("------------Employee------------");
  132.     }
  134. }

从上面的输出可以看到，静态方法不存在多态的概念，多态和成员方法相关，静态方法只属于某一个类，声明的是那个一个类就调用的是哪一个类的静态方法和子类没有关系,不像覆盖了成员方法，new谁调谁，为什么覆盖成员方法可以构成多态（多种状态），主要是运行期的动态绑定（动态绑定构成多态），静态绑定的含义是在编译成class文件（字节码）的时候已经确定该调用哪个方法。

4、 super关键字

super关键字的作用：

  • 调用父类的构造方法
  • 调用父类的成员方法

需要注意：super只能应用在成员方法和构造方法中，不能应用在静态方法中（和this是一样的，代表父类对象），如果在构造方法中使用必须放在第一行
为什么会有super关键字？

  • 因为子类必须要调用父类的构造方法，先把父类构造完成，因为子类依赖于父类，没有父，也就没有子
  • 有时需要在子类中显示的调用父类的成员方法

那么我们以前为什么没有看到super，而且我们也有继承，如：Student继承了Person？

  • 因为子类中我们没有显示的调用构造方法，那么他会默认调用父类的无参构造方法，此种情况下如果父类中没有无参构造方法，那么编译时将会失败

注意构造方法不存在覆盖的概念，构造方法可以重载

1、调用默认构造方法

  1. public class SuperTest01 {
  3.     public static void main(String[] args) {
  4.         Person student = new Student();
  5.     }    
  6. }
  8. class Person {
  9.     //学号
  10.     private int id;    
  12.     //姓名
  13.     private String name;
  15.     //性别
  16.     private boolean sex;
  18.     //地址
  19.     private String address;
  21.     //年龄
  22.     private int age;
  24.     public Person() {
  25.         //System.out.println(this);
  26.         System.out.println("----------Person-----------");    
  27.     }
  29.     //设置学号
  30.     public void setId(int studentId) {
  31.         id = studentId;        
  32.     }
  34.     //读取学号
  35.     public int getId() {
  36.         return id;    
  37.     }
  39.     public void setName(String studentName) {
  40.         name = studentName;
  41.     }
  43.     public String getName() {
  44.         return name;    
  45.     }
  47.     public void setSex(boolean studentSex) {
  48.         sex = studentSex;
  49.     }
  51.     public boolean getSex() {
  52.         return sex;    
  53.     }
  55.     public void setAddress(String studentAddress) {
  56.         address = studentAddress;
  57.     }
  59.     public String getAddress() {
  60.         return address;    
  61.     }
  63.     public void setAge(int studentAge) {
  64.         if (studentAge >=0 && studentAge <=120) {
  65.             age = studentAge;
  66.         }
  67.     }
  69.     public int getAge() {
  70.         return age;    
  71.     }    
  72. }
  74. class Student extends Person {
  76.     //班级编号
  77.     private int classesId;
  79.     public Student() {
  80.         //System.out.println(this);
  81.         //显示调用父类的构造方法
  82.         //调用父类的无参的构造函数
  83.         //super();
  85.         System.out.println("--------Student----------");
  86.         //编译错误，必须将super放到构造函数的第一语句
  87.         //必须先创建父类，才能创建子类    
  88.         //super();
  89.     }
  91.     public void setClassesId(int classesId) {
  92.         this.classesId = classesId;
  93.     }
  95.     public int getClassesId() {
  96.         return classesId;
  97.     }
  98. }

关于构造方法的执行顺序，先执行父类的再执行子类的，必须完成父类的所有初始化，才能创建子类

2、调用带参数的构造方法

  1. public class SuperTest02 {
  3.     public static void main(String[] args) {
  5.         /*
  6.         Person person_student = new Student();
  8.         person_student.setId(1001);
  9.         person_student.setName("张三");
  10.         person_student.setSex(true);
  11.         person_student.setAddress("北京");
  12.         person_student.setAge(20);
  13.         */
  15.         //编译出错，因为Person看不到子类Student的属性
  16.         //person_student.setClassesId(10);
  18.         /*
  19.         person_student.printInfo();
  21.         System.out.println("");
  22.         Person person_emp = new Employee();
  24.         person_emp.setId(1002);
  25.         person_emp.setName("李四");
  26.         person_emp.setSex(true);
  27.         person_emp.setAddress("上海");
  28.         person_emp.setAge(30);
  29.         */
  31.         //编译出错，因为Person看不到子类Employee的属性
  32.         //person_emp.setWorkYear(10);
  34.         //person_emp.printInfo();
  36.         Person person_student = new Student(1001, "张三", true, "北京", 20, 10);
  37.         person_student.printInfo();
  38.     }    
  39. }
  41. class Person {
  42.     //学号
  43.     private int id;    
  45.     //姓名
  46.     private String name;
  48.     //性别
  49.     private boolean sex;
  51.     //地址
  52.     private String address;
  54.     //年龄
  55.     private int age;
  57.     public Person() {
  58.         System.out.println("--------------Person-------------");    
  59.     }
  61.     public Person(int id, String name, boolean sex, String address, int age) {
  62.         this.id = id;
  63.         this.name = name;
  64.         this.sex = sex;
  65.         this.address = address;
  66.         this.age= age;
  67.     }
  69.     public void printInfo() {
  70.         System.out.println("id=" + id + ", name=" + name + ",sex=" + sex + ", address=" + address + ", age=" + age);    
  71.     }
  73.     //设置学号
  74.     public void setId(int studentId) {
  75.         id = studentId;        
  76.     }
  78.     //读取学号
  79.     public int getId() {
  80.         return id;    
  81.     }
  83.     public void setName(String studentName) {
  84.         name = studentName;
  85.     }
  87.     public String getName() {
  88.         return name;    
  89.     }
  91.     public void setSex(boolean studentSex) {
  92.         sex = studentSex;
  93.     }
  95.     public boolean getSex() {
  96.         return sex;    
  97.     }
  99.     public void setAddress(String studentAddress) {
  100.         address = studentAddress;
  101.     }
  103.     public String getAddress() {
  104.         return address;    
  105.     }
  107.     public void setAge(int studentAge) {
  108.         if (studentAge >=0 && studentAge <=120) {
  109.             age = studentAge;
  110.         }
  111.     }
  113.     public int getAge() {
  114.         return age;    
  115.     }    
  116. }
  118. class Student extends Person {
  120.     //班级编号
  121.     private int classesId;
  123.     public Student(int id, String name, boolean sex, String address, int age, int classesId) {
  124.         /*
  125.         this.id = id;
  126.         this.name = name;
  127.         this.sex = sex;
  128.         this.address = address;
  129.         this.age= age;
  130.         this.classesId = id;
  131.         */
  133.         /*
  134.         setId(id);
  135.         setName(name);
  136.         setSex(sex);
  137.         setAddress(address);
  138.         setAge(age);
  139.         this.classesId = classesId;
  140.         */
  141.         //手动调用调用带参数的构造函数
  142.         super(id, name, sex, address, age);
  143.         this.classesId = classesId;
  145.     } 
  147.     public void setClassesId(int classesId) {
  148.         this.classesId = classesId;
  149.     }
  151.     public int getClassesId() {
  152.         return classesId;
  153.     }
  155.     public void printInfo() {
  156.         System.out.println("id=" + getId() + ", name=" + getName() + ",sex=" + getSex() + ", address=" + getAddress() + ", age=" + getAge() + ",classesid=" + classesId);    
  157.     }
  159. }
  161. class Employee extends Person {
  163.     //工作年限
  164.     private int workYear;
  166.     public void setWorkYear(int workYear) {
  167.         this.workYear = workYear;    
  168.     }         
  170.     public int getWorkYear() {
  171.         return workYear;            
  172.     }
  174.     public void printInfo() {
  175.         System.out.println("id=" + getId() + ", name=" + getName() + ",sex=" + getSex() + ", address=" + getAddress() + ", age=" + getAge() + ", workYear=" + workYear);    
  176.     }
  178. }

3、采用super调用父类的方法

  1. public class SuperTest03 {
  3.     public static void main(String[] args) {
  4.         Person person_student = new Student();
  6.         person_student.setId(1001);
  7.         person_student.setName("张三");
  8.         person_student.setSex(true);
  9.         person_student.setAddress("北京");
  10.         person_student.setAge(20);
  12.         print(person_student);
  14.         Person person_emp = new Employee();
  16.         person_emp.setId(1002);
  17.         person_emp.setName("李四");
  18.         person_emp.setSex(true);
  19.         person_emp.setAddress("上海");
  20.         person_emp.setAge(30);
  22.         print(person_emp);        
  23.     }    
  25.     private static void print(Person person) {
  26.         person.printInfo();
  27.     }
  28. }
  32. class Person {
  33.     //学号
  34.     private int id;    
  36.     //姓名
  37.     private String name;
  39.     //性别
  40.     private boolean sex;
  42.     //地址
  43.     private String address;
  45.     //年龄
  46.     private int age;
  48.     public void printInfo() {
  49.         System.out.println("id=" + id + ", name=" + name + ",sex=" + sex + ", address=" + address + ", age=" + age);    
  50.     }
  52.     //设置学号
  53.     public void setId(int studentId) {
  54.         id = studentId;        
  55.     }
  57.     //读取学号
  58.     public int getId() {
  59.         return id;    
  60.     }
  62.     public void setName(String studentName) {
  63.         name = studentName;
  64.     }
  66.     public String getName() {
  67.         return name;    
  68.     }
  70.     public void setSex(boolean studentSex) {
  71.         sex = studentSex;
  72.     }
  74.     public boolean getSex() {
  75.         return sex;    
  76.     }
  78.     public void setAddress(String studentAddress) {
  79.         address = studentAddress;
  80.     }
  82.     public String getAddress() {
  83.         return address;    
  84.     }
  86.     public void setAge(int studentAge) {
  87.         if (studentAge >=0 && studentAge <=120) {
  88.             age = studentAge;
  89.         }
  90.     }
  92.     public int getAge() {
  93.         return age;    
  94.     }    
  95. }
  97. class Student extends Person {
  99.     //班级编号
  100.     private int classesId;
  102.     public void setClassesId(int classesId) {
  103.         this.classesId = classesId;
  104.     }
  106.     public int getClassesId() {
  107.         return classesId;
  108.     }
  110.     public void printInfo() {
  111.         //System.out.println("id=" + getId() + ", name=" + getName() + ",sex=" + getSex() + ", address=" + getAddress() + ", age=" + getAge() + ",classesid=" + classesId);    
  112.         //采用super调用父类的方法
  113.         super.printInfo();        
  114.         System.out.println("classesId=" + classesId);
  115.     }
  117. }
  119. class Employee extends Person {
  121.     //工作年限
  122.     private int workYear;
  124.     public void setWorkYear(int workYear) {
  125.         this.workYear = workYear;    
  126.     }         
  128.     public int getWorkYear() {
  129.         return workYear;            
  130.     }
  132.     public void printInfo() {
  133.         //System.out.println("id=" + getId() + ", name=" + getName() + ",sex=" + getSex() + ", address=" + getAddress() + ", age=" + getAge() + ", workYear=" + workYear);    
  134.         System.out.println("workYear=" + workYear);
  135.         //采用super调用父类的方法
  136.         super.printInfo();
  137.     }
  139. }

5、 final关键字

final表示不可改变的含义

  • 采用final修饰的类不能被继承
  • 采用final修饰的方法不能被覆盖
  • 采用final修饰的变量不能被修改
  • final修饰的变量必须显示初始化
  • 如果修饰的引用，那么这个引用只能指向一个对象，也就是说这个引用不能再次赋值，但被指向的对象是可以修改的
  • 构造方法不能被final修饰

  • 会影响JAVA类的初始化:final定义的静态常量调用时不会执行java的类初始化方法，也就是说不会执行static代码块等相关语句，这是由java虚拟机规定的。我们不需要了解的很深，有个概念就可以了。

    1、采用final修饰的类不能被继承

    ```java public class FinalTest01 {

    public static void main(String[] args) {

    }
    }

final class A1 { public void test1() {

  1. }

}

//不能继承A1，因为A1采用final修饰了 class B1 extends A1 {

  1. public void test2() {
  3. }

}

  1. <a name="poRfD"></a>
  2. ### **2、采用final修饰的方法不能被覆盖**
  3. ```java
  4. public class FinalTest02 {
  6.     public static void main(String[] args) {
  8.     }    
  9. }
  11. class A1 {
  13.     public final void test1() {
  15.     }    
  16. }
  18. class B1 extends A1 {
  20.     //覆盖父类的方法，改变其行为
  21.     //因为父类的方法是final修饰的，所以不能覆盖
  22.     public void test1() {
  24.     }
  26.     public void test2() {
  28.     }
  29. }

3、采用final修饰的变量(基本类型)不能被修改

  1. public class FinalTest03 {
  3.     private static final long CARD_NO = 878778878787878L;
  5.     public static void main(String[] args) {
  6.         //不能进行修改，因为CARD_NO采用final修改了
  7.         CARD_NO = 99999999999999L;
  8.     }    
  9. }

4、final修饰的变量必须显示初始化

  1. public class FinalTest04 {
  3.     //如果是final修饰的变量必须初始化
  4.     private static final long CARD_NO = 0L;
  6.     public static void main(String[] args) {
  7.         int i;
  8.         //局部变量必须初始化
  9.         //如果不使用可以不初始化
  10.         System.out.println(i);
  11.     }    
  12. }

5、如果修饰的引用，那么这个引用只能指向一个对象，也就是说这个引用不能再次赋值，但被指向的对象是可以修改的

  1. public class FinalTest05 {
  3.     public static void main(String[] args) {
  4.         Person p1 = new Person();
  6.         //可以赋值
  7.         p1.name = "张三"; 
  8.         System.out.println(p1.name);
  10.         final Person p2 = new Person();
  11.         p2.name = "李四";
  12.         System.out.println(p2.name);
  14.         //不能编译通过
  15.         //p2采用final修饰，主要限制了p2指向堆区中的地址不能修改(也就是p2只能指向一个对象)
  16.         //p2指向的对象的属性是可以修改的
  17.         p2 = new Person();
  19.     }    
  20. }
  22. class Person {
  24.     String name;    
  25. }

1646729170(1).png