面向对象三大特征--继承

Posted 2020-08-21 Dev_Nick

了解继承之前先了解一下显示生活中事物与事物之间存在的两种关系：
1、整体与部分的关系--has a 关系；例如：球队和球员的关系。

代码示例如下：

 1 //球员
 2 class Player{
 3     int num;
 4     String name;
 5     public Player(int num, String name){
 6         this.num = num;
 7         this.name = name;
 8     }
 9     public void run(){
10         System.out.println(name+"开跑……");
11     }
12 }
13 
14 //球队
15 class Team{
16     String name;
17     Player p;
18     public Team(String name, Player p){
19         this.name = name;
20         this.p = p;
21     }
22     public void startGame(){
23         System.out.println(name+"开赛了");
24     }
25 }
26 
27 class Demo{
28     public static void main(String[] args){
29         Player p = new Player(12,"梅西");
30         Team t = new Team("巴西",p);
31         t.startGame();
32         System.out.println("上场球员名字："+t.p.name);
33     }
34 }

View Code

 

2、继承的关系--is a 关系；例如：人类和学生的关系。

继承是通过关键字extends体现的，格式如下：
class 子类名 extends 父类名{
}

代码示例如下：

 1 // 人类
 2 class Person{
 3     String name;
 4     public Person(String name){
 5         this.name = name;
 6     }
 7     public Person(){
 8         System.out.println("Person类的构造方法被调用了......");
 9     }
10     public void eat(){
11         System.out.println(name+"在吃饭.....");
12     }
13 }
14 
15 //学生类
16 class Student extends Person{
17     int num;
18     public Student(){
19         System.out.println("Student类的构造方法被调用了");
20     }
21     public void study(){
22         System.out.println(name+"正在学习....");
23         System.out.println(name+"的学号是"+num);
24     }
25 }
26 class Demo{
27     public static void main(String[] args){
28         Student s = new Student();
29         s.name = "狗娃";
30         s.num = 123456;
31         s.eat();
32         s.study();
33     }
34 }

View Code

继承要注意的事项：
    1. 千万不要为了减少重复代码而去继承，只有真正存在着继承关系的时候才去继承。
    2. 父类私有的成员不能被继承。
    3. 父类的构造函数不能被继承。
    4. 创建子类对象时默认会先调用父类无参的构造函数。

 

super关键字：
super关键字代表了父类空间的引用。

super关键字的 作用：
    1. 子父类存在着同名的成员时，在子类中默认是访问子类的成员，可以通过super关键字指定访问父类的成员。
    2. 创建子类对象时，默认会先调用父类无参的构造方法，可以通过super关键字指定调用父类的构造方法。

super关键字调用父类构造方法要注意的事项：
    1. 如果在子类的构造方法上没有指定调用父类的构造方法，那么java编译器会在子类的构造方法上面加上super()语句。
    2. super关键字调用父类的构造函数时，该语句必须要是子类构造函数中的第一个语句。
    3. super与this关键字不能同时出现在同一个构造函数中调用其他的构造函数。因为两个语句都需要第一个语句。

super关键字与this关键字的区别：
    1. 代表的事物不一致。
            1. super关键字代表的是父类空间的引用。    
            2. this关键字代表的是所属函数的调用者对象。
    2. 使用前提不一致。
            1. super关键字必须要有继承关系才能使用。
            2. this关键字不需要存在继承关系也可使用。
    3. 调用构造函数的区别：
            1. super关键字是调用父类的构造函数。
            2. this关键字是调用本类的构造函数。
            
方法重写
方法重写的前提： 必须要存在继承的关系。

方法的重写: 子父类出了同名的函数，这个我们就称作为方法的重写。

什么是时候要使用方法的重写：父类的功能无法满足子类的需求时。

方法重写要注意的事项：
    1.方法重写时， 方法名与形参列表必须一致。
    2.方法重写时，子类的权限修饰符必须要大于或者等于父类的权限修饰符。
    3.方法重写时，子类的返回值类型必须要小于或者 等于父类的返回值类型。
    4.方法重写时， 子类抛出的异常类型要小于或者等于父类抛出的异常类型。
            Exception(最坏)
            RuntimeException(小坏) 

super关键字的使用和重写代码示例如下：

 1 class Fu{
 2     int x = 10;
 3     String name;
 4     public Fu(){
 5         System.out.println("Fu类的无参构造方法");
 6     }
 7 
 8     public Fu(String name){
 9         this.name = name;
10         System.out.println("Fu类的有参构造方法");
11     }
12     public void eat(){
13         System.out.println("Fu类对象正在吃");
14     }
15 }
16 
17 class Zi extends Fu{
18     int x = 20;
19     public Zi(String name){
20         super(name); //调用父类的有参构造方法
21         System.out.println("Zi类带有参数的构造方法");
22     }
23     public Zi(){ //jvm会默认调用父类的无参构造方法
24         System.out.println("Zi类无参的构造方法");
25     }
26     public void print(){
27         System.out.println("Zi类中的 x = "+x);
28         System.out.println("Fu类中的 x = "+super.x); //获取子父类中同名的父类变量
29     }
30     public void eat(){ //方法重写
31         System.out.println("zi类在吃饭。。。");
32     }
33 }
34 
35 class Demo{
36     public static void main(String[] args){
37         Zi z = new Zi();
38         Zi z2 = new Zi("张三");
39         z2.print();
40         z2.eat();
41     }
42 }

View Code

java是单继承。

一个类最多只能有一个直接的父类。但是有多个间接的父类。

final(最终、修饰符)  
    
final关键字的用法：
    1. final关键字修饰一个基本类型的变量时，该变量不能重新赋值，第一次的值为最终的。
    2. fianl关键字修饰一个引用类型变量时，该变量不能重新指向新的对象。
    3. final关键字修饰一个函数的时候，该函数不能被重写。
    4. final关键字修饰一个类的时候，该类不能被继承。

常量的修饰符一般为： public static final

常量的命名规范：全部字母大写，单词与单词 之间 使用下划线分隔。