CGBTN2109-DAY08复习总结

Posted 2021-11-02 程序媛 泡泡

DAY08 复习

1.继承中变量的使用

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

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

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

3.方法的重写

重写：子类对父类的方法不满意时，可以重写父类的方法
注意：重写是在不改变父类方法的前提下，实现功能的修改与拓展，重写后子类对象调用的就是重写后的功能
原则：两同 两小 一大
两同：方法名+参数列表相同
一大：子类方法的修饰符权限 >= 父类方法的修饰符权限
两小：子类方法的返回值类型，有两种选择：
1）子类方法的返回值类型是父类方法的返回值类型的子类
2）子类方法的返回值类型与父类方法的返回值类型相同
比如：父：void 子：void
父：int 子：int 但是：byte short long都不行！没有继承关系
父：Animal 子：Animal/Cat都可以，但不可以是Car
我们还可以给方法上加@Override注解，标记这是一个重写的方法
package cn.tedu.review;
/本类用于复习方法的重写/
//重写的原则：
//两同：方法名与参数列表
//两小：方法的返回值类型 属于 父类方法返回值类型的子类/保持一致
//一大：方法的修饰符 >= 父类方法的修饰符

public class TestExtends {
    public static void main(String[] args) {
        //4.创建两个类的对象
        Father f = new Father();
        Son s = new Son();
        //5.1测试重写的方法第1组
        f.eat();
        s.eat();
        //6.3测试重写的方法第2组
        f.sleep(6);
        s.sleep(8);
        //7.3测试重写的方法第3组
        int a = f.play();
        System.out.println("从父类方法中接收到的返回值："+a);
        int b = s.play();
        System.out.println("从子类方法中接收到的返回值："+b);

        //8.4试重写的方法第4组
        Animal a2 = f.getPet();
        System.out.println(a2.name);
        Dog d2 = s.getPet();
        System.out.println(d2.name);
    }
}
//1.创建父类
class Father{
    //3.1添加父类的方法
    public void eat(){
        System.out.println("爸爸爱吃肉");
    }
    //6.1添加父类的方法
    public void sleep(int n){
        System.out.println("爸爸晚上睡"+n+"个小时");
    }
    //7.1定义父类中的方法
    public int play(){
        System.out.println("爸爸在玩风筝");
        return 666;
    }
    //8.2定义父类中的方法
    public Animal getPet(){
        Animal a = new Animal();
        return a;
    }
}
//2.创建子类
class Son extends Father{
    //3.2子类重写父类对应的方法
    @Override
    public void eat(){
        System.out.println("儿子爱吃蔬菜");
    }
    //6.2添加子类重写的方法
    @Override
    public void sleep(int n){
        System.out.println("儿子要睡"+n+"个小时");
    }
    //7.3重写父类的方法
    public int play(){
    //public long play(){//报错：long与int没有继承关系
        System.out.println("儿子在玩游戏");
        return 999;
    }
    //8.3重写父类中的方法
    //写法一：父子类的返回值类型一致
//    public Animal getPet(){
//        Animal a = new Animal();
//        return a;
//    }
    //写法二：子类方法的返回值类型是父类方法返回值类型的子类
    @Override
    public Dog getPet(){
        Dog d = new Dog();
        return d;
    }

}
//8.1准备两个辅助测试的类
class Animal{
    String name = "啥动物都行";
}
class Dog extends Animal{
    String name = "小狗";
}         

4.静态：

1.static可以修饰成员变量和方法
2.被static修饰的资源称为静态资源
3.静态资源随着类的加载而加载，最先加载，优先于对象进行加载
4.静态资源可以通过类名直接调用，也被称作类资源
5.静态被全局所有对象共享，值只有一份
6.静态资源只能调用静态资源
7.静态区域内不允许使用this与super关键字

5.静态代码块static{}

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

6.final 关键字

1. 修饰类：最终类，不可以被继承
2. 修饰方法：这个方法的最终实现，不可以被重写
3. 修饰常量：值不可以被更改，并且常量定义时必须赋值
   注意：常量的定义需要使用全大写，单词之间使用下划线分隔

7.重写与重载的比较：

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