Java方法重载与重写之同名方法的双面魔法(最新整理)

class KungFuMaster {
    // 基础招式
    public void attack() {
        System.out.println("普通拳法！");
    }
    // 重载版本1：带武器
    public void attack(String weapon) {
        System.out.println("使用" + weapon + "攻击！");
    }
    // 重载版本2：带武器和力量
    public void attack(String weapon, int power) {
        System.out.println("使用" + weapon + "发动" + power + "成功力！");
    }
    // 重载版本3：不同参数顺序
    public void attack(int power, String weapon) {
        System.out.println(power + "成功力施展" + weapon + "！");
    }
}

KungFuMaster master = new KungFuMaster();
master.attack();                    // 普通拳法！
master.attack("宝剑");              // 使用宝剑攻击！
master.attack("宝剑", 8);           // 使用宝剑发动8成功力！
master.attack(8, "宝剑");           // 8成功力施展宝剑！

class ErrorExample {
    public void show() { }
    public int show() { return 1; } // 编译错误！
}
// 原因：编译器无法区分调用哪个方法，只看方法名和参数列表

class ErrorExample2 {
    public void train(String student) { }
    public void train(String master) { } // 编译错误！
}
// 原因：参数名不同不算重载，要看参数类型

// 父类：老拳师
class OldMaster {
    public void secretMove() {
        System.out.println("老式绝招：降龙十八掌");
    }
    public final void forbiddenMove() {
        System.out.println("禁招：不得传授");
    }
}
// 子类：新拳师
class NewMaster extends OldMaster {
    @Override
    public void secretMove() {
        System.out.println("新式绝招：升级版降龙十八掌");
    }
    // 不能重写final方法
    // @Override
    // public void forbiddenMove() { } // 编译错误！
}

class SmartMaster extends OldMaster {
    @Override  // 加上这个注解更安全
    public void secretMove() {
        System.out.println("智能绝招");
    }
    // 如果没有@Override，拼写错误不会被发现
    public void secretmove() { // 本想重写，但方法名写错了
        System.out.println("这其实是个新方法，不是重写！");
    }
}

class Animal {
    // 重载示例
    public void eat() {
        System.out.println("动物吃东西");
    }
    public void eat(String food) {
        System.out.println("动物吃" + food);
    }
    // 可重写的方法
    public void sleep() {
        System.out.println("动物睡觉");
    }
}
class Dog extends Animal {
    // 重写父类方法
    @Override
    public void sleep() {
        System.out.println("狗狗趴着睡觉");
    }
    // 重载：新增方法
    public void eat(String food, int amount) {
        System.out.println("狗狗吃" + amount + "份" + food);
    }
}

class Fruit {
    public Fruit getFruit() {
        return new Fruit();
    }
}
class Apple extends Fruit {
    @Override
    public Apple getFruit() { // 返回Apple而不是Fruit
        return new Apple();
    }
}

// Java 5之前的写法（需要强制转型）
class OldApple extends Fruit {
    @Override
    public Fruit getFruit() {
        return new Apple(); // 返回Fruit类型
    }
}
Apple apple = (Apple) new OldApple().getFruit(); // 需要强制转型
// 原因：早期Java要求返回类型必须完全一致

class MartialArtsSchool {
    private String name;
    private int studentCount;
    // 默认构造器
    public MartialArtsSchool() {
        this("无名武馆", 10);
    }
    // 重载构造器1
    public MartialArtsSchool(String name) {
        this(name, 20);
    }
    // 重载构造器2
    public MartialArtsSchool(String name, int studentCount) {
        this.name = name;
        this.studentCount = studentCount;
    }
}

class ErrorSchool {
    private String name;
    public ErrorSchool() {
        // 忘记初始化name
    }
    public ErrorSchool(String name) {
        this(); // 调用无参构造器
        this.name = name; // 但无参构造器没初始化
    }
}
// 原因：构造器链调用时要确保所有路径都正确初始化

class ImprovedMaster extends OldMaster {
    @Override
    public void secretMove() {
        super.secretMove(); // 先调用父类方法
        System.out.println("追加新招式：九阳神功");
    }
}

class WrongMaster extends OldMaster {
    @Override
    public void secretMove() {
        System.out.println("我的新招式");
        super.secretMove(); // 顺序可能不对
    }
}
// 可能的问题：业务逻辑要求先执行父类方法

// 基础武术类
class MartialArt {
    protected String name;
    public MartialArt(String name) {
        this.name = name;
    }
    // 可重写的方法
    public void practice() {
        System.out.println("练习" + name);
    }
    public void practice(int hours) {
        System.out.println("练习" + name + hours + "小时");
    }
}
// 具体武术类型
class TaiChi extends MartialArt {
    public TaiChi() {
        super("太极拳");
    }
    @Override
    public void practice() {
        System.out.println("以柔克刚：" + name);
    }
    // 重载：新增练习方式
    public void practice(String style) {
        System.out.println("练习" + style + "式" + name);
    }
}
class ShaolinKungfu extends MartialArt {
    public ShaolinKungfu() {
        super("少林功夫");
    }
    @Override
    public void practice() {
        super.practice(); // 调用父类方法
        System.out.println("追加：金钟罩铁布衫");
    }
}

public class MartialArtsTest {
    public static void main(String[] args) {
        MartialArt[] arts = {
            new TaiChi(),
            new ShaolinKungfu()
        };
        for (MartialArt art : arts) {
            art.practice(); // 多态：调用实际类型的重写方法
        }
        TaiChi taiChi = new TaiChi();
        taiChi.practice(2);    // 重载：练习太极拳2小时
        taiChi.practice("陈式"); // 重载：练习陈式太极拳
    }
}

class ConfusionExample {
    public void method(Object obj) {
        System.out.println("Object版本");
    }
    public void method(String str) {
        System.out.println("String版本");
    }
}
ConfusionExample example = new ConfusionExample();
example.method(null); // 输出：String版本
// 原因：重载解析选择最具体的类型

class Parent {
    public static void staticMethod() {
        System.out.println("父类静态方法");
    }
}
class Child extends Parent {
    public static void staticMethod() {
        System.out.println("子类静态方法");
    }
}
Parent obj = new Child();
obj.staticMethod(); // 输出：父类静态方法（不是多态！）
// 原因：静态方法不支持重写，只支持隐藏