定义父类 Super，要求定义 int hashCode()方法、boolean equals(Object obj)方法。定义子 类 Suber，继承 Super 类，并覆盖上述定义的方法。要求用@Override 注解。定义主类 Main，要求 main 方法中，使用上述类，能体现动态绑定。

好的，我来解答你的问题。

首先，我们需要定义父类 Super，代码如下：

public class Super {
    private int id;
    private String name;

    public Super(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public int hashCode() {
        return Objects.hash(id, name);
    }

    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj == null || getClass() != obj.getClass()) {
            return false;
        }
        Super that = (Super) obj;
        return id == that.id && Objects.equals(name, that.name);
    }
}

在父类 Super 中，我们定义了两个属性 id 和 name，并且实现了 int hashCode() 方法和 boolean equals(Object obj) 方法。其中，hashCode() 方法用于产生对象的哈希码，equals(Object obj) 方法用于比较两个对象是否相等。

接下来，我们定义子类 Suber，代码如下：

public class Suber extends Super {
    private String desc;

    public Suber(int id, String name, String desc) {
        super(id, name);
        this.desc = desc;
    }

    @Override
    public int hashCode() {
        return Objects.hash(super.hashCode(), desc);
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj == null || getClass() != obj.getClass()) {
            return false;
        }
        Suber that = (Suber) obj;
        return super.equals(obj) && Objects.equals(desc, that.desc);
    }
}

在子类 Suber 中，我们继承了父类 Super，并覆盖了父类中的 hashCode() 方法和 equals(Object obj) 方法，同时增加了一个属性 desc。

在 hashCode() 方法中，我们调用了父类的 hashCode() 方法，并将子类的 desc 属性也参与哈希码的计算。

在 equals(Object obj) 方法中，我们调用了父类的 equals(Object obj) 方法，并将子类的 desc 属性也参与对象的比较。

最后，我们定义主类 Main，代码如下：

public class Main {
    public static void main(String[] args) {
        Super superObj = new Super(1, "Super");
        Super suberObj = new Suber(2, "Suber", "Desc");

        System.out.println(superObj.hashCode()); // 输出 823525412
        System.out.println(suberObj.hashCode()); // 输出 -1352978930

        System.out.println(superObj.equals(suberObj)); // 输出 false
        System.out.println(suberObj.equals(superObj)); // 输出 false

        Super superObj2 = suberObj;
        System.out.println(superObj2.hashCode()); // 输出 -1352978930

        System.out.println(superObj2.equals(superObj)); // 输出 false
        System.out.println(superObj2.equals(suberObj)); // 输出 true
    }
}

在主类 Main 中，我们创建了一个父类对象 superObj 和一个子类对象 suberObj，并分别测试了它们的哈希码和对象比较结果。

我们还将 suberObj 赋值给父类类型的变量 superObj2，并测试了它与 superObj 和 suberObj 的比较结果，体现了动态绑定的特性。

以上就是对你问题的回答，希望能解决你的疑问。