上午（2.5h）继承核心 + super & this

1. 继承基本概念（0.5h）

核心知识点

• 继承：让一个类（子类）拥有另一个类（父类）的属性和方法。
• 关键字：extends
• 父类（基类）：被继承的类
• 子类（派生类）：继承别人的类
• Java 只支持单继承：一个类只能有一个直接父类
• 作用：代码复用、抽取共性、结构清晰

---

完整案例代码

java

运行

// 父类：人类
class Person {
    String name; // 姓名
    int age;     // 年龄

    public void showInfo() {
        System.out.println("姓名：" + name + "，年龄：" + age);
    }
}

// 子类：学生 继承 人类
class Student extends Person {
    int score; // 子类独有：成绩

    // 子类独有方法
    public void study() {
        System.out.println(name + "正在学习，成绩：" + score);
    }
}

// 测试类
public class TestExtends {
    public static void main(String[] args) {
        Student s = new Student();

        // 子类可以直接使用父类成员
        s.name = "小明";
        s.age = 18;
        s.score = 99;

        s.showInfo(); // 调用父类方法
        s.study();    // 调用子类方法
    }
}

代码解释

• Student extends Person：学生继承人类，自动拥有name、age、showInfo()
• 子类可以加自己的属性和方法（score、study）
• 父类代码不用重复写 → 复用性极强

---

2. 继承后成员访问规则（0.7h）

核心规则

1. 子类可以直接使用父类非私有（非 private）成员
2. 父类 private 成员，子类不能直接访问，必须用 getter/setter
3. 子类独有的成员，父类不能用

---

完整代码

java

运行

class Person {
    String name;         // 默认权限：子类可用
    private int age;     // private：子类不能直接访问

    // 给private的age提供get/set
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

class Student extends Person {
    int score;

    public void show() {
        System.out.println("姓名：" + name); // ✅ 可以访问
        // System.out.println(age); // ❌ 报错！private不能直接访问
        System.out.println("年龄：" + getAge()); // ✅ 通过getter访问
    }
}

public class TestVisit {
    public static void main(String[] args) {
        Student s = new Student();
        s.name = "小红";
        s.setAge(20);
        s.show();
    }
}

---

3. super 关键字（重点 0.8h）

三大用法

1. super.成员变量 → 访问父类成员变量
2. super.成员方法() → 调用父类成员方法
3. super(...) → 调用父类构造方法（必须写在第一行）

---

完整代码

java

运行

class Fu {
    String name = "父类名字";

    public Fu() {
        System.out.println("父类无参构造");
    }
    public Fu(String name) {
        this.name = name;
        System.out.println("父类有参构造");
    }

    public void method() {
        System.out.println("父类方法");
    }
}

class Zi extends Fu {
    String name = "子类名字";

    public Zi() {
        // super(); // 默认隐藏，不写也会自动调用父类无参
        super("传参给父类"); // 调用父类有参构造
        System.out.println("子类构造");
    }

    public void test() {
        System.out.println(name); // 子类name
        System.out.println(super.name); // 父类name
        super.method(); // 调用父类方法
    }
}

public class TestSuper {
    public static void main(String[] args) {
        Zi z = new Zi();
        z.test();
    }
}

---

4. this 与 super 区别（对比记忆 0.5h）

一句话区别

• this：当前对象自己
• super：父类对象

重点规则

• 都必须在构造方法第一行
• this (...) 与 super (...) 不能同时出现

---

下午（3h）方法重写 + 权限修饰符 + 构造方法执行

1. 方法重写（Override）（1h）

重写必须满足 5 条

1. 方法名相同
2. 参数列表相同
3. 返回值类型相同 / 子类类型
4. 子类权限 ≥ 父类权限
5. 必须加 @Override 注解（校验用，不是可选）

作用：子类对父类方法增强 / 修改

---

完整代码

java

运行

class Phone {
    public void call() {
        System.out.println("打电话");
    }
}

class SmartPhone extends Phone {
    // 重写：对父类方法增强
    @Override
    public void call() {
        super.call(); // 先执行父类功能
        System.out.println("视频通话"); // 子类扩展
    }
}

public class TestOverride {
    public static void main(String[] args) {
        SmartPhone sp = new SmartPhone();
        sp.call();
    }
}

输出

plaintext

打电话
视频通话

---

2. 权限修饰符（面试必考 1h）

从大到小 4 种

1. public：任意位置都能访问
2. protected：同包 + 子类
3. 默认（缺省）：同包
4. private：仅自己类

必须背会表格

表格

修饰符	同一个类	同包	子类	任意包
public	✅	✅	✅	✅
protected	✅	✅	✅	❌
默认	✅	✅	❌	❌
private	✅	❌	❌	❌

---

测试代码（自己试报错）

java

运行

package day7;

public class TestModifier {
    public int a;    // public
    protected int b; // protected
    int c;           // 默认
    private int d;   // private

    public void test() {
        // 自己类里都能用
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
        System.out.println(d);
    }
}

---

3. 继承下构造方法执行流程（1h）

核心结论

• 创建子类对象 → 先执行父类构造 → 再执行子类构造
• 子类构造默认隐藏调用 super()
• 父类没有无参构造时，子类必须手动写 super(参数)

---

完整代码

java

运行

class Fu {
    public Fu() {
        System.out.println("父类无参构造");
    }
}

class Zi extends Fu {
    public Zi() {
        // super(); // 隐藏自动调用
        System.out.println("子类无参构造");
    }
}

public class TestConstructor {
    public main(String[] args) {
        new Zi();
    }
}

输出

plaintext

父类无参构造
子类无参构造

---

晚上（1.5h）综合实战 + 今日验收

必做实战（完整代码 + 逐行解释）

需求

• 父类：Animal（name、age、eat ()、sleep ()）
• 子类：Dog、Cat 继承 Animal
• 子类重写 eat ()
• 测试调用

---

完整实战代码

java

运行

// 父类：动物
class Animal {
    String name;
    int age;

    // 吃饭方法
    public void eat() {
        System.out.println("动物吃东西");
    }

    public void sleep() {
        System.out.println("动物睡觉");
    }
}

// 子类：狗
class Dog extends Animal {
    // 重写eat
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
}

// 子类：猫
class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

// 测试
public class TestAnimal {
    public static void main(String[] args) {
        Dog d = new Dog();
        d.name = "旺财";
        d.age = 3;
        d.eat();
        d.sleep();

        Cat c = new Cat();
        c.name = "咪咪";
        c.age = 2;
        c.eat();
        c.sleep();
    }
}

输出

plaintext

狗吃骨头
动物睡觉
猫吃鱼
动物睡觉

---

 必须达到的硬标准（你今天必须全部做到）

✅ 能写出继承结构，知道 Java 是单继承✅ 能区分重写（Override）和重载（Overload）✅ 熟练用 super 访问父类变量、方法、构造✅ 能说出 4 种权限修饰符范围✅ 能说出继承中构造执行顺序：先父后子

今天讲解的是面向对象三大特性之二 —— 继承

注意：

继承是单向的：子类能访问父类，父类绝对不能访问子类！

构造方法与成员方法的区分？

答：构造方法：名字必须和类名完全一样，大小写也一样

       成员方法：名字随便起，不能和类名一样

难点：

1. 只要是子类，就一定有 super ()
2. 你写不写构造，它都在
3. 你写了，它藏在构造第一行
4. 你没写，它连构造带 super 一起藏
5. 执行顺序永远：先父类 → 后子类

拓展：

为什么父类、子类只用 class 开头，不用写 public？

答：Java 语法规定：一个 .java 文件里，只能有一个 public 类，而且这个类名必须和文件名一样！