咱们先把整个场景的核心逻辑理清楚：你要的就是让K类的同名方法根据传入的参数类型（B或C实例）自动执行不同的删除逻辑——这刚好可以用方法重载机制来实现，下面一步步拆解实现步骤：

1. 定义基础接口A #

先把接口A定义出来，作为B和C的父类型：

public interface A {
    // 可根据业务需求添加通用方法，这里暂时为空即可
}

2. 实现类B和C #

分别创建B和C类，实现A接口，并各自持有需要操作的属性：

public class B implements A {
    private String name;

    // 构造器、getter/setter
    public B(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

public class C implements A {
    private String lastName;

    // 构造器、getter/setter
    public C(String lastName) {
        this.lastName = lastName;
    }

    public String getLastName() {
        return lastName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }
}

3. 实现K类的重载delete方法 #

这是核心环节：在K类中定义两个同名的delete方法，参数分别为B和C的实例，各自处理对应的属性删除逻辑（这里以置空为例，你可以根据业务需求改成数据库删除等操作）：

public class K {
    // 处理B实例：删除name属性
    public void delete(B bInstance) {
        bInstance.setName(null);
        System.out.println("已清除B实例的name属性");
    }

    // 处理C实例：删除lastName属性
    public void delete(C cInstance) {
        cInstance.setLastName(null);
        System.out.println("已清除C实例的lastName属性");
    }
}

4. 在类G中调用测试 #

现在在G类里，直接实例化B、C和K，把对应实例传给delete方法即可——JVM会在编译时自动根据参数类型匹配对应的重载方法：

public class G {
    public static void main(String[] args) {
        // 实例化对象
        B b = new B("Alice");
        C c = new C("Smith");
        K k = new K();

        // 传入B实例，触发对应delete逻辑
        k.delete(b);
        System.out.println("B实例的name现在是：" + b.getName()); // 输出null

        // 传入C实例，触发对应delete逻辑
        k.delete(c);
        System.out.println("C实例的lastName现在是：" + c.getLastName()); // 输出null
    }
}

额外场景：如果需要通过接口A类型传递参数？ #

如果你的场景是在G类中用A类型的变量（比如A a = new B("Bob")），直接传a给delete会编译报错（因为重载是编译时确定的），这时候有两种优化方式：

方式1：instanceof判断（简单直接） #

给K类新增一个接收A类型的方法，内部做类型判断后转发：

public class K {
    // 保留原有两个重载方法
    public void delete(B bInstance) { /* ... */ }
    public void delete(C cInstance) { /* ... */ }

    // 新增接收A类型的方法
    public void delete(A aInstance) {
        if (aInstance instanceof B) {
            delete((B) aInstance);
        } else if (aInstance instanceof C) {
            delete((C) aInstance);
        } else {
            throw new IllegalArgumentException("不支持的参数类型");
        }
    }
}

这样在G类里就可以直接传A类型变量了：

A a1 = new B("Charlie");
k.delete(a1); // 自动匹配B的delete方法

A a2 = new C("Brown");
k.delete(a2); // 自动匹配C的delete方法

方式2：访问者模式（优雅扩展） #

如果后续可能新增更多A的实现类，访问者模式可以避免大量instanceof判断：

1. 在接口A中定义accept方法：

public interface A {
    void accept(K visitor);
}

2. 在B和C中实现accept方法：

public class B implements A {
    // 原有属性和方法保留
    @Override
    public void accept(K visitor) {
        visitor.delete(this);
    }
}

public class C implements A {
    // 原有属性和方法保留
    @Override
    public void accept(K visitor) {
        visitor.delete(this);
    }
}

3. 在G类中调用：

A a1 = new B("Dave");
a1.accept(k); // 自动触发B对应的delete方法

A a2 = new C("Wilson");
a2.accept(k); // 自动触发C对应的delete方法

内容的提问来源于stack exchange，提问作者mostafa3dmax