Java中extends与implements解析:继承与接口实现的本质区别

class 父类 {
    // 父类成员
}
class 子类 extends 父类 {
    // 子类特有成员
}

interface 接口 {
    void 方法();
}
class 实现类 implements 接口 {
    @Override
    public void 方法() {
        // 具体实现
    }
}

interface 可飞 {
    void 飞();
}
interface 可游 {
    void 游();
}
class 鸭嘴兽 implements 可飞, 可游 {  // 正确：实现多个接口
    @Override
    public void 飞() { /*...*/ }
    @Override
    public void 游() { /*...*/ }
}
// 以下写法会编译错误
class 动物 {}
class 哺乳动物 {}
class 鸭嘴兽 extends 动物, 哺乳动物 {}  // 错误：Java不支持多继承

abstract class 图形 {
    abstract double 计算面积();
}
interface 可缩放 {
    void 缩放(double 比例);
}
class 圆形 extends 图形 implements 可缩放 {
    private double 半径;
    @Override
    double 计算面积() {
        return Math.PI * 半径 * 半径;
    }
    @Override
    public void 缩放(double 比例) {
        半径 *= 比例;
    }
}

class 父类 {
    protected Number 获取值() { return 0; }
}
class 子类 extends 父类 {
    @Override
    public Integer 获取值() { return 1; }  // 合法：Integer是Number子类，且访问权限更宽松
}

interface 接口A {
    default void 方法() { System.out.println("A"); }
}
interface 接口B {
    default void 方法() { System.out.println("B"); }
}
class 实现类 implements 接口A, 接口B {
    @Override  // 必须重写，否则编译错误
    public void 方法() {
        接口A.super.方法();  // 显式选择接口A的实现
    }
}

class 汽车 extends 交通工具 {}
class 经理 extends 员工 {}

abstract class 抽象列表 {
    protected Object[] 元素;
    public int 大小() { return 元素.length; }
    // 其他通用方法...
}
class 动态数组 extends 抽象列表 {
    // 只需实现特有功能
}

public abstract class InputStream {
    public abstract int read();
    public int read(byte[] b) {
        // 模板方法，控制读取流程
        for (int i = 0; i < b.length; i++) {
            int val = read();
            if (val == -1) return i;
            b[i] = (byte)val;
        }
        return b.length;
    }
}

class 智能设备 implements 可联网, 可升级, 可远程控制 {}

public interface Connection {
    Statement createStatement() throws SQLException;
    void close() throws SQLException;
    // 其他数据库操作契约...
}

interface 支付方式 {
    boolean 支付(订单 订单);
}
class 支付宝 implements 支付方式 { /*...*/ }
class 微信支付 implements 支付方式 { /*...*/ }
// 使用时可以互换
支付方式 支付 = new 支付宝();
支付 = new 微信支付();

interface A {
    default void foo() { System.out.println("A"); }
}
interface B extends A {
    @Override
    default void foo() { System.out.println("B"); }
}
interface C extends A {
    @Override
    default void foo() { System.out.println("C"); }
}
class D implements B, C {  // 编译错误：foo()冲突
    // 必须重写foo()方法
    @Override
    public void foo() {
        B.super.foo();  // 显式选择B的实现
    }
}

class 父类 {
    父类(String name) { System.out.println("父类构造：" + name); }
}
class 子类 extends 父类 {
    子类() {
        super("默认");  // 必须显式调用，因为父类没有无参构造
        System.out.println("子类构造");
    }
    子类(String name) {
        this();  // 调用本类其他构造方法
        System.out.println("子类构造：" + name);
    }
}

interface 现代接口 {
    // 传统抽象方法
    void 传统方法();
    // 默认方法（Java 8）
    default void 默认方法() {
        System.out.println("默认实现");
    }
    // 静态方法（Java 8）
    static void 静态方法() {
        System.out.println("接口静态方法");
    }
    // 私有方法（Java 9）
    private void 私有方法() {
        System.out.println("接口内部使用");
    }
}

abstract class 数据导出器 {
    // 模板方法
    public final void 导出() {
        准备数据();
        转换格式();
        写入文件();
    }
    protected abstract void 准备数据();
    protected void 转换格式() {
        // 通用实现
    }
    protected abstract void 写入文件();
}
class CSV导出器 extends 数据导出器 {
    @Override
    protected void 准备数据() { /* CSV特有 */ }
    @Override
    protected void 写入文件() { /* CSV特有 */ }
}

interface 排序策略 {
    void 排序(int[] 数组);
}
class 快速排序 implements 排序策略 {
    @Override
    public void 排序(int[] 数组) { /* 实现 */ }
}
class 归并排序 implements 排序策略 {
    @Override
    public void 排序(int[] 数组) { /* 实现 */ }
}
class 排序上下文 {
    private 排序策略 策略;
    public void 设置策略(排序策略 策略) {
        this.策略 = 策略;
    }
    public void 执行排序(int[] 数组) {
        策略.排序(数组);
    }
}

public sealed class 图形 permits 圆形, 矩形 {
    // 只有圆形和矩形可以继承
}
public final class 圆形 extends 图形 {}  // 合法
public final class 矩形 extends 图形 {}  // 合法
public class 三角形 extends 图形 {}     // 编译错误

public interface 数据处理器 {
    default void 处理A() {
        公共辅助方法();
        // A特有处理
    }
    default void 处理B() {
        公共辅助方法();
        // B特有处理
    }
    private void 公共辅助方法() {
        // 被多个默认方法共享的逻辑
    }
}