JAVA学习Day6（继承、this、super、抽象类）

1 回顾

常用API
Scanner
int nextInt()
String next()
String
通过xx来构造对象: String char[] byte[]
int length()
int indexOf(char/String[, index])
boolean equals(String)
String substring(int start[, int end])
System
static long currentTimeMills()
static void arraycopy(src, int srcPos, dest, destPos, length)
Arrays
static String toString(array)
static void sort(array)
int[] copyOf(int[], int newLength)
面向对象:
类: 成员变量\成员方法\静态方法\静态成员变量\构造方法\静态代码块\代码块

成员变量\成员方法 在使用之前必须要创建对象
静态方法\静态成员变量 可以直接通过类来调用

2 继承: extends

1.概念:子类/衍生类/扩展类: Dog
父类/基类: Animal
2.子类继承父类, 就继承了父类所有的成员变量和方法
3.所有的类, 都有唯一的父类,
如果没有写父类, 说明父类就是 Object
4.子类中还可以定义自己的独特的成员变量和方法
子类的功能一定比父类要强大

代码体现
父类：

public class Demo01Extends {
    public static void main(String[] args) {
        Dog d = new Dog("旺财");
        // name是在父类中声明的, 子类可以直接使用
        System.out.println(d.name);
//        d.name = "旺财";
        d.eat(); // 子类方法
//        d.wang();
    }
}

子类：关键字（extends）

/**
 * 小狗类 继承了 动物类
 * 1.概念:子类/衍生类/扩展类: Dog  父类/基类: Animal
 * 2.子类继承父类, 就继承了父类所有的成员变量和方法
 * 3.所有的类, 都有唯一的父类, 如果没有写父类, 说明父类就是:Object
 * 4.子类中还可以定义自己的独特的成员变量和方法
 *   子类的功能一定比父类要强大
 */
public class Dog extends Animal {
    String name;
    Dog() {
        // 调用父类有参构造方法
        super("");
        System.out.println("Dog空参构造器");
    }
    Dog(String name) {
        super(); // 默认调用父类无参构造方法
        super.name = name;
        this.name = "小强";
        System.out.println("Dog有参构造器");
    }
    void wang() {
        System.out.println(name + "汪汪!");
    }
    // 重写的父类中的eat
    void eat() {
        // 子类自己的功能
        System.out.println(this.name + "舔舔小爪子!");
        // 和父类中的eat方法一致
        super.eat();
        // 子类自己的功能
        System.out.println(this.name + "舔舔嘴巴!");
    }
}

特殊情况:
1.子类中的成员变量和父类同名 name
Dog d = new Dog();
d.name -> 就是指自己定义的name,不是继承过来的name
结论: 父子类中的成员变量不要同名
2.子类中可以引用父类对象
super
3.创建子类对象之前, 会先创建父类对象
加载子类之前, 会先加载父类
4.构造方法: 父类的构造方法不能被子类继承的
创建子类对象, 会先默认调用父类的无参构造器
原因: 子类构造方法中, 第一行默认 super()
可以手动调用父类其他构造方法
结论: 子类构造方法中, 一定会先调用父类的构造方法
父类中, 建议先写无参构造器
5.通过子类对象调用方法时
先看子类中有没有定义这个方法, 定义了, 调用子类方法
子类中没有这个方法, 调用父类继承的方法

方法的重写\覆盖:
子类中定义的方法, 方法返回值类型\方法名\参数列表
都和父类中定义的方法完全一致

3 this和super

supert和this的含义
super ：代表⽗类的存储空间标识（可以理解为⽗亲的引⽤）。
this ：代表当前对象的引⽤（谁调⽤就代表谁）。

在每次创建⼦类对象时，先初始化⽗类空间，再创建其⼦类对象本身。⽬的在于⼦类对象中包含
了其对应的⽗类空间，便可以包含其⽗类的成员，如果⽗类成员⾮private修饰，则⼦类可以随
意使⽤⽗类成员。代码体现在⼦类的构造⽅法调⽤时，⼀定先调⽤⽗类的构造⽅法。理解图解如
下：

4 abstract: - 抽象的

抽象方法: 方法没有方法体
一个类中, 存在抽象方法, 那么这个类就必须也是abstract
抽象类: 用abstract修饰的类
抽象类不能直接new对象
有构造方法, 为了给子类使用
抽象类的非抽象子类, 必须实现/重写抽象类的所有抽象方法
判断:
1.有抽象方法的类叫抽象类 √
2.抽象类就是有抽象方法的类 ×
3.抽象类中可以没有抽象方法 √
//代码体现

抽象类：

/**
 * 飞行物
 */
public abstract class FlyObject {
    int x;
    int y;
    FlyObject() {
        System.out.println();
    }
    // 公共部分, 为了让所有的子类统一
    // 父类方法体没有意义 - 抽象方法
    abstract void move();//在子类继承时必须将其实现
}

抽象类的子类

public class Hero extends FlyObject {
    int score;

    void move() {//方法的重写
        System.out.println("英雄机跟着鼠标动, 发射");
    }
}

/**
 * 敌机
 */
public /*abstract*/ class Airplane extends FlyObject {
    int life;
    Airplane() {
        super();//不写默认调用父类构造方法
    }
    // 重写方法 -> 实现方法
    void move() {
        System.out.println("敌机向下移动");
    }
}

主方法

public class Demo01AbstractInit {
    public static void main(String[] args) {
        // 抽象类不能直接new对象
//        FlyObject fly = new FlyObject();

        Hero hero = new Hero();
        hero.move();

        Airplane plane = new Airplane();
        plane.move();
    }
}