Java 基础 Day02：继承、多态、接口与设计模式

认识继承#

• 父类 People（name/sex），子类 Teacher（加 skill）、Consultant（加 number）
• 子类自动拥有父类的非私有成员：t.setName("张三") 直接能用
• 关键理解：子类对象 = 子类设计图 + 父类设计图共同创建，内存里父类那部分数据也真实存在（后面构造器一节呼应）

访问修饰符#

1
private   void privateMethod() {}   // 只能本类访问
2
          void method() {}          // default：本类 + 同包
3
protected void protectedMethod() {} // 本类 + 子类 + 同包
4
public    void publicMethod() {}    // 任意位置

注：protected 的”子类”指跨包继承时子类内部能访问，不代表任意位置都能通过对象访问。实际项目里成员变量基本用 private，对外走 getter/setter。

继承的注意事项#

• 单继承：Java 一个类只能继承一个父类（不支持多继承），但支持多层继承（A ← B ← C）
• 所有类直接或间接继承 Object
• 就近原则：同名变量/方法，优先用最近的——name（局部）→ this.name（本类）→ super.name（父类）

1
class Zi extends Fu {
2
    String name = "zi";
3
    public void show() {
4
        String name = "show";
5
        System.out.println(name);        // show   局部
6
        System.out.println(this.name);   // zi     本类成员
7
        System.out.println(super.name);  // fu     父类成员
8
        run();        // zi run  本类优先
9
        super.run();  // fu run  指定父类
10
    }
11
}

方法重写#

• 重写条件：方法名、参数列表必须相同；返回类型可以不同（但要兼容，协变返回类型）；修饰符权限不能比父类更严格（只能相同或更宽松，如父类 protected 子类可 public）；@Override 标注让编译器帮检查
• super.方法()：在子类重写方法里调用被覆盖的父类版本（super.eat()）
• 经典应用场景：重写 Object.toString()——默认打印内存地址，重写后打印对象内容（Student{name=张三, age=18, sex=男}）

继承下的构造器#

• 子类构造器必须调用父类构造器：第一行默认隐式 super()（调父类无参构造）
• 父类无无参构造时，子类必须显式 super(参数) 指定
• super 和 this 都必须写在构造器第一行，且不能同时出现

1
class Zi extends Fu {
2
    public Zi() {
3
        super(555);       // 先调父类构造器
4
        System.out.println("子类无参构造器");  // 再执行自己的
5
    }
6
}

• 父类只有有参构造时，子类用 super(name, sex) 把父类部分交给父类构造器初始化，再用 this.skill = skill 初始化子类独有部分
• 兄弟构造器 this(参数)：一个构造器调用同类的另一个构造器，复用初始化逻辑

1
public Student(String name, int age) {
2
    this(name, age, "上海大学");   // 转发给 3 参构造器
3
}
4
public Student(String name, int age, String school) {
5
    this.name = name; this.age = age; this.school = school;
6
}

认识多态#

• 对象多态：父类引用指向子类对象 Animal a1 = new Wolf();
• 行为多态：同一个 eat()，不同子类不同表现（狼”嚼嚼嚼”、龟”叫叫叫”）
• 口诀：编译看左边，运行看右边——调方法时看引用类型（左边）是否允许调，真正执行看对象类型（右边）的实现
• 成员变量例外：编译看左边，运行也看左边！a1.name 拿到的是父类的 "动物"，不是子类的 "狼"——因为变量是编译期绑定的，方法才有多态（动态绑定）

多态的应用#

• 方法参数声明为父类类型，就能接收任意子类对象 → 解耦（调用方随便换实现，不用改方法）

1
public static void eaeet(Animal w) {   // 传 Wolf / Tortoise 都行
2
    w.eat();
3
}

• 多态前提：必须有继承关系 + 子类重写方法
• 局限：父类类型引用不能调用子类独有功能（a2.run() 编译报错）

强制转换（向下转型）#

• 想调子类独有方法，把父类引用强转回子类类型：Tortoise t1 = (Tortoise) a2; → t1.run()
• 强转前要用 instanceof 判断，否则转错类型运行时会抛 ClassCastException：if (a2 instanceof Tortoise) { ... }
• 编译期规则：兄弟类（Wolf/Tortoise）之间直接强转或 instanceof，编译器直接报「不可转换的类型」——只有当引用变量是父类类型时，强转/判断才有意义

认识抽象类#

• 抽象类不能创建对象（new A() 报错）
• 抽象方法没有方法体，必须 abstract 修饰，子类必须重写（B extends A 重写 show()）

抽象类的使用场景#

• Animal 定义抽象 cry()，Cat 喵喵、Dog 汪汪——每个动物叫声不同，父类没法给通用实现，只能定”规则”（方法签名），让子类各自实现
• 父类类型引用子类对象：Animal a = new Dog(); a.cry();——抽象类也能玩多态

模板方法设计模式#

• 场景：老师和学生都要写作文《我的爸爸》，首尾两段一样，中间一段各不相同
• 做法：父类把固定骨架写死在具体方法 write() 里，把变化的部分抽成抽象方法 writeContent() 交给子类填

1
public abstract class People {
2
    public void write() {              // 模板方法：骨架固定
3
        System.out.println("《我的爸爸》");
4
        System.out.println("一个好人");
5
        writeContent();                // 变化的部分，子类去实现
6
        System.out.println("太好了");
7
    }
8
    public abstract void writeContent();
9
}

1
People p = new Teacher();  p.write();  // 老师写的
2
People p1 = new Student(); p1.write(); // 学生写的

认识接口#

• JDK 8 之前：接口里只能定义常量 + 抽象方法
• 解决单继承的不足：一个类只能继承一个父类，但可以实现多个接口——class Test implements A, B，把 A、B 所有抽象方法都重写即可
• JDK 8 之后新增三种方法：
  • default 方法：实现类对象直接调用，可选择性重写
  • static 方法：只能通过接口名调用（A.washHands()）
  • private 方法：在接口内部被 default 方法复用

接口小案例：面向接口编程#

• ClassDate 接口定义能力：printStudentInfo() + printAverageScore()
• 两套实现随意切换：
  • ClassDateImpl1：打印全班信息 + 平均分
  • ClassDateImpl12：打印男女人数 + 去掉最高最低分的平均分
• 调用方只面对接口 ClassDate，换成哪套实现都不影响调用代码——这就是接口的好处（解耦）

1
ClassDate cdi = new ClassDateImpl1(allStudents);   // 方案一
2
cdi.printStudentInfo();
3
ClassDate cdi2 = new ClassDateImpl12(allStudents); // 换成方案二
4
cdi2.printAverageScore();

五步演进#

关键设计决策#

1. Repository 接口化 = 给数据库留插座：ArticleService 构造器只依赖 ArticleRepository 接口，将来 MyBatis 版只需新建 DbArticleRepository implements ArticleRepository，Service 一行不改——这就是「面向接口编程」的实战意义
2. 数据层用单例：数据层是全局”数据库”，必须只有一份，否则多个入口各自 new 数据就分裂了。验证方式：构造器打印「初始化」，运行只出现一次 = 实例唯一（比 == 更直观）
3. 模板方法把「表头→逐行→表尾」写死，formatOne 留给子类——和写作文案例一模一样，只是把”首尾段固定/中段变化”搬到了列表展示
4. 表头表尾做成抽象 vs 默认空实现：最终选了抽象（强制统一）；另一条路是默认空实现（灵活省事）——没有对错，是”强制统一 vs 灵活”的取舍，这正是设计模式的精髓
5. 多态切换展示：printer = (choice == 1) ? new SimplePrinter() : new DecoratedPrinter()，getClass().getSimpleName() 打印运行时的真实类名——「编译看左边运行看右边」的直接证据

踩坑与解法#

演进方向#

• Day01 复盘里”将来加 @Service / 换 Mapper / 加注解”的计划，到这里已经把接口层和单例预先铺好，Spring 阶段接入成本更低
• ArticleStatus 枚举，将来就是数据库里 status 字段 + MyBatis 的枚举映射
• “换展示实现”，将来就是 Spring 里「换 Bean 实现」（@Qualifier / 多实现注入）的控制反转雏形