Java笔记-继承

一.什么是继承

1. 通俗来讲就是像是师傅传授武功给弟子,倾囊相授,对弟子毫无保留,弟子拥有师父的全部武功.
2. 语言上就是子类继承父类(基类,超类),可以直接使用父类创建好的所有方法,可以大大减少重复代码量.
3. Java是一门面向对象语言,具有封装,继承,多态三大特性,继承就是第二大特性.

---

二.继承的实现

在继承的关系中，“子类就是一个父类”。也就是说，子类可以被当做父类看待。
例如父类是员工，子类是老师，那么“老师就是一个员工”。关系：is-a。

定义父类的格式：（一个普通的类定义）
public class 父类名称 
{
       // ...
}

定义子类的格式：
public class 子类名称 extends 父类名称
 {
              // ...
}

Java继承的特点 :

1. Java语言是单继承的,一个类的直接父亲只有唯一一个
2. Java语言可以多级继承.
   class A{}
   class B extends classA{};
   class C extends classB{};
3. 一个子类的直接父亲是唯一的,但是一个父类可以拥有多个子类
   class A{}
   class B extends classA{};
   class C extends classA{};

在父子类的继承关系当中，如果成员变量重名，则创建子类对象时，访问有两种方式：

直接通过子类对象访问成员变量：
等号左边是谁，就优先用谁，没有则向上找。
间接通过成员方法访问成员变量：
该方法属于谁，就优先用谁，没有则向上找。

son.method 就优先调用子类的method
father.method 就优先调用父类的method

public static void main(String[] args)
    {
        Fashi fashi = new Fashi(); //创建父类对象
        System.out.println(fashi.oneFashi);//父类只能用父类内容,不能用子类
        System.out.println("==============");

        Fashu fashu = new Fashu();

        System.out.println(fashu.oneFashi); //子类调用父类方法
        System.out.println(fashu.oneFashu); //子类调用本类方法

        System.out.println("===================");
        System.out.println("调用子类就优先子类变量 " + fashu.num); //成员变量名字一样时,等号左边是谁,就优先用谁
        System.out.println("调用父类就优先父类变量 " + fashi.num);

        System.out.println("+++++++++++");
        fashu.printNum();//虽然是子类调用,但用的是父类成员变量

    }

---

三.覆写

在父子类的继承关系当中，创建子类对象，访问成员方法的规则：
创建的对象是谁，就优先用谁，如果没有则向上找。

注意:
无论是成员方法还是成员变量，如果没有都是向上找父类，绝对不会向下找子类的。

重写（Override）
概念：在继承关系当中，方法的名称一样，参数列表也一样。

重写（Override）：方法的名称一样，参数列表也一样。(覆盖、覆写)。
重载（Overload）：方法的名称一样，参数列表不一样。

方法的覆盖重写特点：创建的是子类对象，则优先用子类方法

1. 必须保证父子类之间方法的名称相同，参数列表也相同。
   @Override：写在方法前面，用来检测是不是有效的正确覆盖重写。
   这个注解就算不写，只要满足要求，也是正确的方法覆盖重写。

2. 子类方法的返回值必须小于等于父类方法的返回值范围。
   java.lang.Object类是所有类的公共最高父类（祖宗类），java.lang.String就是Object的子类。

3. 子类方法的权限必须大于等于父类方法的权限修饰符。
   四种权限修饰符范围: public > protected > (default) > private
   备注：(default)不是关键字default，而是什么都不写，留空。

继承关系中,父子类构造方法的访问特点:

1. 子类构造方法当中有一个默认隐含的"super()"调用,所以一定是先调用的父类构造,后执行的子类构造
2. 子类构造可以通过super关键字来调用父类重载构造
3. super的父类构造调用,必须是子类构造方法的第一个语句,不能一个子类构造调用多次super构造
4. 总结:
   子类必须调用父类构造方法,不写则赠送super(),写了则用写的指定的super调用,super只能有一个,必须是第一个

super关键字三种用法:

1. 在子类的成员方法中,访问父类的成员变量
2. 在子类的成员方法中,访问父类的成员方法
3. 在子类的构造方法中,访问父类的构造方法

public class Zi extends Fu 
{

   int num = 10;

   public Zi()
    {
       super();
   }

   public void methodZi()
    {
       System.out.println(super.num); // 父类中的num
   }

   public void method() 
   {
       super.method(); // 访问父类中的method
       System.out.println("子类方法");
   }

}

super关键字用来访问父类内容，而this关键字用来访问本类内容。用法也有三种：
this关键字的三种用法

1. 在本类的成员方法中，访问本类的成员变量。
2. 在本类的成员方法中，访问本类的另一个成员方法。
3. 在本类的构造方法中，访问本类的另一个构造方法。

注意：
4. this(…)调用也必须是构造方法的第一个语句，并且是唯一一个。
5. super和this两种构造调用，不能同时使用。

四.super与this的内存图

//伪代码
class Fu //父类
	 {
            int num = 10;
            method(){};//父
     }
class Zi extends Fu  //子类继承父类
     {
            int num = 20;
            method(){};
            show()
            {
                int num = 30;
                sout(num);//打印
                sout(this.num);
                sout(super.num);
            }
      }
  Demo
        {
            main(String[] args)
            {
                Zi zi = new Zi();
                zi.show();
                zi.method();
            }
        }

有了继承之后,super_class是编译完后,是.class文件当中有的一种特殊标记,这个特殊标记是一个指向,
指向父类,相当于告诉子类,父亲是谁
程序开始后,main()方法会先从方法区先进栈,进栈后,首先创建一个子类对象,(new出来的都在堆当中),子类当中包含一个完整的父类结构,
先把父类的内容执行完后,才开始执行子类内容. (记住:堆当中保存的都是地址值)

调用子类的show()方法时,show()会先进栈,
sout(num)会优先用自己的局部变量
sout(this.num)会使用堆上面 this代表的外围内容,num = 20 就在里面, sout(super.num) 类似.

main()方法里的 zi.method() 调用时,会优先让方法区中子类的 method()进栈
如果子类方法method()里super调用了父类方法,就会让父类方法method()进栈(子类方法调用父类方法)