JAVA继承 super 重写与重载

1 继承

1.继承的关键字extends 格式： 子类 extends 父类
2.继承相当于子类把父类的功能复制了一份，包括私有资源
3.Java只支持单继承：一个子类只能有一个父类，一个父类可以有多个子类
4.继承具有传递性：爷爷的功能会传给爸爸，爸爸的功能会传给孙子
5.子类只可以使用父类的非私有资源，私有资源不可用的原因是不可见
6.子类可以拥有自己的特有功能
7.继承是is a 强耦合的关系，依赖性非常强，比如我们看到”熊孩子”，就知道他有一个”熊父母”

1.1.继承中变量的使用

如果父类的成员变量与子类的成员变量同名时，使用super.变量名指定父类的成员变量

package cn.tedu.oop2;
/*本类用于测试继承中变量的使用*/
public class ExtendsDemo1 {
    public static void main(String[] args) {
        //7.创建子类的匿名对象，调用study()
        new Son().study();
    }
}
//1.创建父类
class Father{
    //3.创建父类的成员变量
    int sum = 1;
    int count = 2;

}
//2.创建子类
class Son extends Father{
    //4.创建子类的成员变量
    int sum = 10;
    //5.创建子类的普通方法
    public void study(){
        System.out.println("goog good study , day day up");
        //6.创建子类的局部变量
        int sum = 100;
        //8.打印子类的局部变量sum
        System.out.println(sum);//100
        //9.打印子类的成员变量sum
        System.out.println(this.sum);//10
        //10.打印父类的成员变量sum
        /*当父类的成员变量与子类的成员变量同名时，可以使用super指定父类的成员变量
        * 我们可以把super看作是父类的对象：Father super = new Father();*/
        System.out.println(super.sum);//1
        System.out.println(count);
    }
}

1.2.继承中构造方法的使用

1.我们每次创建对象的时候，都会先触发构造函数
2.创建子类对象时，会先调用父类的无参构造，因为子类的构造函数中默认存在一个super();
3.如果父类没有无参构造的话，我们就需要手动指定子类去调用父类的含参构造super(参数)；
4.构造方法不可以被继承，原因是：构造方法名必须是本类的类名，不可能在子类中存在一个父类名字的构造方法

package cn.tedu.oop2;
/*本类用于测试继承中构造方法的使用
* 1.子类在创建对象时，默认会先调用父类的构造方法
* 2.原因是子类构造函数中的第一行默认存在super();--表示调用父类的无参构造
* 3.当父类没有无参构造时，可以通过super(参数)调用父类的其他含参构造
* 子类必须调用一个父类的构造函数，不管是无参还是含参，选一个即可
* 4.构造方法不可以被继承！因为语法的原因：要求构造方法的名字必须是本类类名
* 不能在子类中出现一个父类名字的构造方法*/
public class ExtendsDemo2 {
    public static void main(String[] args) {
        //6.1通过父类的无参构造创建父类对象
        //Father2 f = new Father2();
        //6.2通过父类的含参构造创建父类对象
        //Father2 f2 = new Father2("哈哈哈");
        //7.创建子类对象
        Son2 s = new Son2();
    }
}
//1.创建父类
class Father2{
    //3.创建父类的无参构造
//    public Father2(){
//        System.out.println("我是父类的无参构造");
//    }
    //4.创建父类的含参构造
    public Father2(String s){
        System.out.println("我是父类的含参构造"+s);
    }
}
//2.创建子类
class Son2 extends Father2{
    //5.创建子类的无参构造
    public Son2(){
        //super();//调用父类的无参构造
        super("你好~");
        System.out.println("我是子类的无参构造");
    }
}

3.方法的重写

重写：子类对父类的方法不满意时，可以重写父类的方法
注意：重写是在不改变父类方法的前提下，实现功能的修改与拓展，重写后子类对象调用的就是重写后的功能
重写的语法规则：两同 两小 一大
1.一大：子类方法的修饰符权限 >= 父类方法的修饰符权限
2.两同：方法名相同，参数列表相同
3.两小：子类方法的返回值类型 <= 父类方法的返回值类型
子类方法抛出的异常类型 <= 父类方法抛出的异常类型【这个还没学，不用管】
4.注意1：如果父类方法的返回值类型为void,那子类方法的返回值类型也是void
5.注意2：我们这里说的返回值类型的大小，不是值的大小，而是继承关系，比如：

父：int 子：int 可以
父：int 子：long 不可以，因为这两者没有继承关系
父：Animal 子：Animal/Cat/Dog… 可以
父：Animal 子：Car 不可以，小动物与小汽车也没有继承关系

6.我们还可以给方法上加@Override注解，标记这是一个重写的方法

4 方法的重载

1.定义：如果在同一个类中，存在多个同名方法，但参数列表不同的现象
2.作用：重载使我们的代码更灵活，传入不同的参数，都可以有对应的方法被调用
3,== 方法是否构成重载，与方法参数的类型有关，与方法参数的名字无关==

前提：同一个类中，同名的方法
1.方法的参数个数不同：一定构成重载
2.方法的参数个数相同：就需要查看对应位置上参数的类型

5.重写与重载的比较：

1.重载：在一个类中的现象：同一个类中，存在方法名相同，参数列表不同的方法
2.重写：是指建立了继承关系以后，子类对父类的方法不满意，可以重写，遵循两同两小一大原则
3.重载的意义：是为了外界调用方法时方便，不管传入什么样的参数，都可以匹配到对应的同名方法
4.重写的意义：在不修改源码的情况下，进行功能的修改与拓展（OCP原则：面向修改关闭，面向拓展开放）

6. this与super

1.this代表的是本类对象的引用，我们可以把this看作是Cat this = new Cat();
super代表的是父类对象的引用，我们可以把super看作是Father super = new Father();
2.当本类的成员变量与局部变量同名时，需要使用this.变量名指定本类的成员变量
当本类的成员变量与父类的成员变量同名时，需要使用super.变量名指定父类的成员变量
3.this可以实现调用本类构造方法的功能，不能互相调用，需要写在构造方法首行
this();表示调用本类的无参构造 this(参数);表示调用本类的对应参数的构造
super也可以实现调用父类构造方法的功能
super();表示调用父类的无参构造 super(参数);表示调用父类的对应参数的构造
4.注意：super的使用前提是继承，没有父子类关系，就没有super
5.注意：this调用构造方法或者super调用构造方法，都必须出现在构造方法的第一行
6.注意：如果父类没有无参构造，需要手动在子类构造方法的第一行调用其他的含参构造
7.拓展：如果子类重写了父类的方法以后，可以使用super.方法名(参数列表)来调用

7. 关键字final

1.final表示最终
2.被final修饰的类是最终类，不可以被继承
3.被final修饰的方法是这个方法的最终实现，不可以被重写
4.被final修饰的是常量，值不可以被修改，而且常量定义时必须赋值

8.关键字static

1.被static修饰的资源统称为静态资源，可以修饰变量、方法、代码块
2.静态资源属于类资源，随着类的加载而加载，优先于对象进行加载
3.所以静态资源可以被类名直接调用，不创建对象也可以
4.静态资源被全局所有的对象共享
5.静态只能调用静态

9.静态代码块

1.格式：static{ }
2.位置：类里方法外
3.执行时机：随着类的加载而加载，优先于对象进行加载【只加载一次】
4.作用：用于加载那些需要第一时间就加载，并且只加载一次的资源，常用来初始化
5.顺序：静态代码块 构造代码块 构造方法 普通方法【如果普通方法里有局部代码块，执行局部代码块】
TIPS: 如果有多个静态资源，加载顺序取决于先后位置
TIPS: 静态不可以与this和super共用