CGBTN2111-DAY08总结复习

Posted 2022-01-02 程序媛 泡泡

DAY08 复习

1.继承中变量的使用

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

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

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

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) 
        //7.创建子类对象进行测试
        ComputerStudent s1 = new ComputerStudent(1,"张三",'男',98);
        MathStudent s2 = new MathStudent(2,"李四",'女',89);
        ChineseStudent s3 = new ChineseStudent(3,"王五",'女',100);
        //8.利用创建好的对象进行方法测试
        s1.proClass();
        s1.hobby();
        s2.proClass();
        s2.hobby();
        s3.proClass();
        s3.hobby();
        //9.创建父类对象进行方法测试
        Student s0 = new Student(0,"海绵宝宝",'男',3);
        s0.thinkingClass();
        s0.proClass();
    

//1.定义学生类
class Student
    //2.定义学生的属性
    int sno;//学号
    String name;//姓名
    char gender;//性别
    double score;//分数

    //6.1添加父类的全参构造
    public Student(int sno, String name, char gender, double score) 
        this.sno = sno;
        this.name = name;
        this.gender = gender;
        this.score = score;
    
    //3.1定义父类的功能
    public void thinkingClass()
        System.out.println("正在上思修课");
    
    //3.2定义父类的功能
    public void proClass()
        System.out.println("正在上专业课");
    

//2.定义学生类的子类,区分不同的专业
class ComputerStudent extends Student//计算机专业学生
    //6.2生成子类的全参构造,并调用父类的全参构造
    public ComputerStudent(int sno, String name, char gender, double score) 
        super(sno, name, gender, score);
    
    //4.1重写父类的功能
    @Override
    public void proClass()
        System.out.println("正在上编程课");
    
    //5.1定义子类的特有功能
    public void hobby()
        System.out.println("喜欢敲代码~");
    

class MathStudent extends Student//数学专业学生
    //6.3生成子类的全参构造,并调用父类的全参构造
    public MathStudent(int sno, String name, char gender, double score) 
        super(sno, name, gender, score);
    
    //4.2重写父类的功能
    @Override
    public void proClass()
        System.out.println("正在上数学理论课");
    
    //5.2定义子类的特有功能
    public void hobby()
        System.out.println("喜欢学模糊数学");
    

class ChineseStudent extends Student//中文专业学生
    //6.4生成子类的全参构造,并调用父类的全参构造
    public ChineseStudent(int sno, String name, char gender, double score) 
        super(sno, name, gender, score);
    
    //4.3重写父类的功能
    @Override
    public void proClass()
        System.out.println("正在上写作课");
    
    //5.3定义子类的特有功能
    public void hobby()
        System.out.println("喜欢写小说");
    

4.静态：

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

5.静态代码块static

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

6.final 关键字

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

7.面向对象之多态

1. 前提：继承+重写

2. 口诀1：父类引用指向子类对象

解释：父类类型的引用类型变量保存的是子类类型的对象的地址值

3. 口诀2：编译看左边，运行看右边

解释：编译时要看父类是否定义了这个资源，运行时使用的是子类的功能

4. 资源使用情况

1. 成员变量使用的是父类的
2. 成员方法使用的是父类的方法定义，子类的方法体
3. 如果多态对象调用的是子类没有重写过的方法，方法定义与方法体使用的都是父类的，所以这个不符合多态的前提，直接使用纯纯的父类对象调用即可
4. 静态资源属于类资源，随着类的加载而加载，只会加载一次，优先于对象进行加载，可以通过类名直接调用，被全局所有对象共享，所以静态不存在重写的现象，在哪个类定义，就属于哪个类的资源
5. 我们现在学习的多态，把自己看作是父类类型，参考“花木兰替父从军”