java 非法重载_java中重载和重写(覆写)遇到的问题

重载

最近匹配原则

关于重载的基本条件原则，这里不做细致介绍，网上的介绍一大堆。这里主要来记录一下在看《设计模式之禅》时，遇到的一个例子，这个例子涉及到重载的最近匹配原则，以前都没怎么注意过。

Father类源码：

public class Father {

public Collection doSomething(HashMap map){

System.out.println("父类被执行...");

return map.values();

}

}

子类源码：

public class Son extends Father {

//放大输入参数类型

public Collection doSomething(Map map){

System.out.println("子类被执行...");

return map.values();

}

}

注意这里不是重写(覆写)，因为参数不同的，这里子类中方法的参数是父类方法中参数的父类，相当于扩大了参数的类型范围。这是就是子类和父类间的方法重载。

接下来进行测试：

public class Client {

public static void invoker(){

//父类存在的地方，子类就应该能够存在

Father f = new Father();

HashMap map = new HashMap();

f.doSomething(map);

}

public static void main(String[] args) {

invoker();

}

}

此时的输出结果为

父类被执行...

这里理所应当的认为是这样的结果，可是将 Father f = new Father();的代码改变时，如下：

public class Client {

public static void invoker(){

//父类存在的地方，子类就应该能够存在

Son f =new Son();

HashMap map = new HashMap();

f.doSomething(map);

}

public static void main(String[] args) {

invoker();

}

}

这样时，应该调用的是子类还是父类的方法呢？

揭晓，调用的还是父类的方法。输出结果和上面一样，这是因为此时是根据重载的最近匹配原则进行匹配方法的，这样就会调用父类中的方法，子类的方法并不会被调用。

HashMap-->Map是这样的子类父类关系，那么出传入的参数 HashMap map = new HashMap() 肯定会优先匹配HashMap，那么自然就找到父类的方法了。

这里是《设计模式之禅》中讲里氏替换原则的一个例子，这里就是体现的是里氏替换原则的

覆盖或实现父类的方法时输入参数可以被放大

父类方法的输入参数是HashMap类型，子类的输入参数是Map类型，也就是说子类的输入参数类型的范围扩大了，子类代替父类传递到调用者中，子类的方法永远都不会被执行。这是正确的，如果你想让子类的方法运行，就必须覆写父类的方法。

重写

关于重写，网上也有很多的详细内容，这里主要记录看到的一个博客，在我查询上述的重载问题是遇到的，也挺有意思的。

对于以下例子：

package myTest;

class A {

public String show(D obj) {

return ("A and D");

}

public String show(A obj) {

return ("A and A");

}

}

class B extends A {

@Override

public String show(A obj) {

return ("B and A");

}

public String show(B obj) {

return ("B and B");

}

}

class C extends B {

}

class D extends B {

}

/**

* @author luwanglin

* @email 1769862620@qq.com

* @Date 2020/9/18 15:34

* @Version 1.0

*/

public class MultiTest {

public static void main(String[] args) {

A ab = new B();

B b = new B();

C c = new C();

System.out.println(ab.show(b));

System.out.println(ab.show(c));

System.out.println(b.show(c));

}

}

继承关系图如下：

运行结果如下：

B and A

B and A

B and B

产生的疑问是：

为什么前两个结果不是

B and B

B and B

第三个结果可以根据以上的最近匹配原则可以解释。

记录下网上看到的比较好的回答：

A ab = new B();

这里ab的引用类型是A，但是它指向的内存是类型为B的一个实例

想对ab进行方法调用，你调用的方法都必须在 class A里面有的才行(因为你的引用类型为A)

这里 class A有show(A obj) show(D obj)着两个方法

ab.show(b) 在class A中没有找到类型匹配的方法，但是对b进行类型提升后，可以找到 show(A obj)方法，同理 ab.show(c)也是show(A obj)方法；但是ab内存地址指向一个类型为B内存空间，如果class B Override 了 class A的show(A obj)方法，则调用B的方法，反之，则调用A自己的方法

可以猜测 D d = new D()； ab.show(d)的结果是 A and D

如果注释掉 class A的 show(A obj)方法， ab.show(b) ab.show(c)都会出错。

这里你只要记住，能调用那些方法，由引用类型决定，具体执行情况，由实际内存对象类型决定

java执行方法时，会根据对象的类型得到相应的方法，如果不存在编译时会报错，真正执行时，会动态去匹配，如果真正的对象是子类的话，且此方法在子类中被覆盖的话，就会执行子类方法。

java类型匹配时，如果不能匹配的话就做向上类型转换，转换为父类，直到能够匹配为止，若一直不能匹配在编译时会报错。

java的多态中的向上转型，简单来说，父类引用生成子类对象，那这个引用只能调用在父类中已经定义过的属性和方法，而对子类自己新定义的属性和方法则不能访问。比如你这里的A ab=new B();,ab是一个父类引用，之后执行ab.show(b),这时ab先从父类中查找方法，与之匹配的只有show(A obj)方法，而且发现子类重写了该方法，这时动态链接到子类的show(A obj)方法。

假如你执行b.show(c),这里，b中有show(A obj)方法和show(B obj)方法，继承层次为C->B->A，根据重载的最近匹配原则，会调用show(B obj)方法。

参考文章