Java Overload 与 Override 差别

2024-06-23 15:48
文章标签 java override overload 差别

本文主要是介绍Java Overload 与 Override 差别,希望对大家解决编程问题提供一定的参考价值,需要的开发者们随着小编来一起学习吧!

当开始思考和记录下面这些案例时,才意识到我对它们的了解并不像自己想象的那样。为了让内容更有趣,下面会把它们列为一系列谜题,同时也提供了答案。如果你能不偷看做出所有答案,我会对你刮目相看。

 

1. 单一分派

 

给定下面两个类:

 

class Parent {void print(String a) { log.info("Parent - String"); }void print(Object a) { log.info("Parent - Object"); }
}
class Child extends Parent {void print(String a) { log.info("Child - String"); }void print(Object a) { log.info("Child - Object"); }
}

 

下面代码打印结果是什么?

 

String string = "";
Object stringObject = string;
// 打印结果是什么?
Child child = new Child();
child.print(string);
child.print(stringObject);
Parent parent = new Child();
parent.print(string);
parent.print(stringObject);

 

答案:

 

child.print(string);        // Prints: "Child - String"
child.print(stringObject);  // Prints: "Child - Object"
parent.print(string);       // Prints: "Child - String"
parent.print(stringObject); // Prints: "Child - Object"

 

child.print(string) 和 parent.print(string) 是 Java 面向对象程序编程的教科书式示例。调用的方法取决于实例的“实际”类型,而非“声明”类型。也就是说,不论把变量定义为 Child 还是 Parent,因为实际的实例类型是Child 都会调用 Child::print。

 

第二组输出结果更为棘手。stringObject 和 string 是完全相同的字符串,唯一的区别在于 string 声明为 String,而 stringObject 声明为 Object。Java 不支持双重分派(double-dispatch),因此在处理方法参数时,参数的“声明”类型优先于“实际”类型。即使参数“实际”类型是 String 还是会调用 print(Object)。

 

2. 隐式 Override

 

给定下面两个类:

 

class Parent {void print(Object a) { log.info("Parent - Object"); }
}
class Child extends Parent {void print(String a) { log.info("Child - String"); }
}

 

下面代码打印结果是什么?

 

String string = "";
Parent parent = new Child();
parent.print(string);

 

答案:

 

parent.print(string);  // Prints: "Parent - Object"

 

实例的“实际”类型是 Child,声明的参数类型是 String。代码中确实有一个 Child::print(String) 方法。前面的例子中 parent.print(string) 调用的正是这个方法,但这里不是。

 

检查子类 Override 前,Java 似乎要先选择调用哪个方法。这种情况下,实例声明的类型是 Parent,而 Parent 中唯一匹配的方法是 Parent::print(Object)。接着,Java 会检查 Parent::print(Object) 有没有潜在的 Override 方法,结果没有找到。因此,最后执行的就是这个方法。

 

3. 显式 Override

 

给定下面两个类:

 

class Parent {void print(Object a) { log.info("Parent - Object!"); }void print(String a) { throw new RuntimeException(); }
}
class Child extends Parent {void print(String a) { log.info("Child - String!"); }
}

 

下面代码打印结果是什么?

 

String string = "";
Parent parent = new Child();
parent.print(string);

 

答案:

 

parent.print(string);  // Prints: "Child - String!"

 

这个例子与前面的唯一区别在于添加了一个新的 Parent::print(String) 方法。实际上这个方法从来没有执行。如果运行,会抛出一个异常。然而,正是因为它的存在让 Java 执行了一个不同的方法。

 

运行时在分析 parent.print(String) 的时候,找到了一个可以匹配的 Parent::print(String) 方法,然后看到这个方法被 Child::print(String) 覆写。

 

通常认为如果不调用,只是添加一个新方法绝不会改变系统行为。上面的例子显然是另一种情况。

 

4. 带有歧义的参数

 

给定下面的类:

 

class Foo {void print(Cloneable a) { log.info("I am cloneable!"); }void print(Map a) { log.info("I am Map!"); }
}

 

下面代码打印结果是什么?

 

HashMap cloneableMap = new HashMap();
Cloneable cloneable = cloneableMap;
Map map = cloneableMap;
// 打印结果是什么?
Foo foo = new Foo();
foo.print(map);
foo.print(cloneable);
foo.print(cloneableMap);

 

答案:

 

foo.print(map);           // Prints: "I am Map!"
foo.print(cloneable);     // Prints: "I am cloneable!"
foo.print(cloneableMap);  // 编译失败

 

与单一分派类似,参数声明的类型优先于实际类型。如果传入参数有多个方法可以匹配,Java 会抛出编译错误,要求明确指定调用哪个方法。

 

5. 多重继承:接口

 

给定下面的接口:

 

interface Father {default void print() { log.info("I am Father!"); }
}
interface Mother {default void print() { log.info("I am Mother!"); }
}
class Child implements Father, Mother {}

 

下面代码打印结果是什么?

 

new Child().print();

 

与前面的例子类似,这个示例也不能编译通过。具体来说,由于 Father 和 Mother 中存在互相冲突的默认方法,Child 类无法编译通过。需要在 Child 类定义中明确指定 Child::print。

 

6. 多重继承:类与接口

 

给定下面的类和接口:

 

class ParentClass {void print() { log.info("I am a class!"); }
}
interface ParentInterface {default void print() { log.info("I am an interface!"); }
}
class Child extends ParentClass implements ParentInterface {}

 

下面代码打印结果是什么?

 

new Child().print();

 

答案:

 

new Child().print();  // Prints: "I am a class!"

 

说明:如果类和接口在继承时发生冲突,继承类优先。

 

7. Override 传递

 

给定下面的类:

 

class Parent {void print() { foo(); }void foo() { log.info("I am Parent!"); }
}
class Child extends Parent {void foo() { log.info("I am Child!"); }
}

 

下面代码打印结果是什么?

 

new Child().print();

 

答案:

 

new Child().print();  // Prints: "I am Child!"

 

Override 对传递调用也有效。看过 Parent 定义的人可能认为 Parent::print 总是调用 Parent::foo。但是如果该方法被 Override,那么 Parent::print 将调用 Override 版本的 foo()。

 

8. 私有 Override

 

给定下面的类:

 

class Parent {void print() { foo(); }private void foo() { log.info("I am Parent!"); }
}
class Child extends Parent {void foo() { log.info("I am Child!"); }
}

 

下面代码打印结果是什么?

 

new Child().print();

 

答案:

 

new Child().print();  // Prints: "I am Parent!"

 

现在 Parent.foo() 声明变为 private,除此之外,这个示例与前面的例子完全相同。无论 foo() 在子类中是否实现了其它版本,也不管调用 print() 的实例类型如何,当 Parent.print() 调用 foo() 时,foo() 都会硬编码为 Parent.foo()。

 

通常认为,把一个方法从 public 改为 private,只要编译成功,仅仅是一次重构。上面的例子证明这种想法是错的:即使编译成功,系统行为也可能出现意料之外的变化。

 

解决方法,可以为方法加上 @Override 注解。一旦改变基类方法的可见性,就会引起编译错误。

 

9. 静态 Override

 

给定下面的类:

 

class Parent {static void print() { log.info("I am Parent!"); }
}
class Child extends Parent {static void print() { log.info("I am Child!"); }
}

 

下面代码打印结果是什么?

 

Child child = new Child();
Parent parent = child;
parent.print();
child.print();

 

答案:

 

parent.print(); // Prints: "I am Parent!"
child.print();  // Prints: "I am Child!"

 

Java 不支持静态方法 Override。如果父类和子类中定义了相同的静态方法,仅根据声明类型决定调用哪个方法,不考虑实例类型。

 

这与非静态方法的处理完全相反:非静态方法会依据实例类型决定调用哪个方法,忽略声明类型。因此,把方法改为静态方法或者反向操作需要格外小心。即使没有编译错误,系统行为也可能出现意料之外的变化。

 

这也是给方法加上 @Override 注解的另一个重要原因。上面的例子中,如果为 Child::print 加上注解会报告一个编译错误:静态方法不能 Override。

 

不仅如此,最佳实践也要求不使用实例调用静态方法:不仅可能导致类似上面的意外结果,在重构出现问题时也无法告警。示例中这样调用 static 方法时,像 Intellij 这样的 IDE 会给出警告,最好给予足够的重视并处理。

 

10. 静态链接

 

给定下面的类:

 

class Parent {void print() { staticMethod(); instanceMethod(); }static void staticMethod() { log.info("Parent::staticMethod"); }void instanceMethod() { log.info("Parent::instanceMethod"); }
}
class Child extends Parent {static void staticMethod() { log.info("Child::staticMethod"); }void instanceMethod() { log.info("Child::instanceMethod"); }
}

 

下面代码打印结果是什么?

 

Child child = new Child();
child.print();

 

答案:

 

Parent::staticMethod
Child::instanceMethod

 

这个例子组合了之前讨论的各个主题。即使调用方法在父类中,Override 也会生效。然而,对于静态方法,即使变量声明的类型是 Child 仍然调用的是 Parent::staticMethod。

 

11. 总结

 

如果说有什么值得注意的话,那就是处理继承非常棘手,而且很容易出错。如果试图在继承上耍小聪明,总有一天会吃苦头。还是建议循规蹈矩,用最佳实践来保护自己:

 

  1. 用@override 注解标记所有 Override 方法

  2. 始终用类而非实例调用静态方法

  3. 在 IDE 中设置警告或者 lint 错误,强制执行上面的规则检查有问题的代码

  4. 能用组合就不要继承

这篇关于Java Overload 与 Override 差别的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!



http://www.chinasem.cn/article/1087593

相关文章

JVM 的类初始化机制

前言 当你在 Java 程序中new对象时,有没有考虑过 JVM 是如何把静态的字节码(byte code)转化为运行时对象的呢,这个问题看似简单,但清楚的同学相信也不会太多,这篇文章首先介绍 JVM 类初始化的机制,然后给出几个易出错的实例来分析,帮助大家更好理解这个知识点。 JVM 将字节码转化为运行时对象分为三个阶段,分别是:loading 、Linking、initialization

Spring Security 基于表达式的权限控制

前言 spring security 3.0已经可以使用spring el表达式来控制授权,允许在表达式中使用复杂的布尔逻辑来控制访问的权限。 常见的表达式 Spring Security可用表达式对象的基类是SecurityExpressionRoot。 表达式描述hasRole([role])用户拥有制定的角色时返回true (Spring security默认会带有ROLE_前缀),去

浅析Spring Security认证过程

类图 为了方便理解Spring Security认证流程,特意画了如下的类图,包含相关的核心认证类 概述 核心验证器 AuthenticationManager 该对象提供了认证方法的入口,接收一个Authentiaton对象作为参数; public interface AuthenticationManager {Authentication authenticate(Authenti

Spring Security--Architecture Overview

1 核心组件 这一节主要介绍一些在Spring Security中常见且核心的Java类,它们之间的依赖,构建起了整个框架。想要理解整个架构,最起码得对这些类眼熟。 1.1 SecurityContextHolder SecurityContextHolder用于存储安全上下文(security context)的信息。当前操作的用户是谁,该用户是否已经被认证,他拥有哪些角色权限…这些都被保

Spring Security基于数据库验证流程详解

Spring Security 校验流程图 相关解释说明(认真看哦) AbstractAuthenticationProcessingFilter 抽象类 /*** 调用 #requiresAuthentication(HttpServletRequest, HttpServletResponse) 决定是否需要进行验证操作。* 如果需要验证,则会调用 #attemptAuthentica

Spring Security 从入门到进阶系列教程

Spring Security 入门系列 《保护 Web 应用的安全》 《Spring-Security-入门(一):登录与退出》 《Spring-Security-入门(二):基于数据库验证》 《Spring-Security-入门(三):密码加密》 《Spring-Security-入门(四):自定义-Filter》 《Spring-Security-入门(五):在 Sprin

Java架构师知识体认识

源码分析 常用设计模式 Proxy代理模式Factory工厂模式Singleton单例模式Delegate委派模式Strategy策略模式Prototype原型模式Template模板模式 Spring5 beans 接口实例化代理Bean操作 Context Ioc容器设计原理及高级特性Aop设计原理Factorybean与Beanfactory Transaction 声明式事物

Java进阶13讲__第12讲_1/2

多线程、线程池 1.  线程概念 1.1  什么是线程 1.2  线程的好处 2.   创建线程的三种方式 注意事项 2.1  继承Thread类 2.1.1 认识  2.1.2  编码实现  package cn.hdc.oop10.Thread;import org.slf4j.Logger;import org.slf4j.LoggerFactory

JAVA智听未来一站式有声阅读平台听书系统小程序源码

智听未来,一站式有声阅读平台听书系统 🌟 开篇:遇见未来,从“智听”开始 在这个快节奏的时代,你是否渴望在忙碌的间隙,找到一片属于自己的宁静角落?是否梦想着能随时随地,沉浸在知识的海洋,或是故事的奇幻世界里?今天,就让我带你一起探索“智听未来”——这一站式有声阅读平台听书系统,它正悄悄改变着我们的阅读方式,让未来触手可及! 📚 第一站:海量资源,应有尽有 走进“智听

在cscode中通过maven创建java项目

在cscode中创建java项目 可以通过博客完成maven的导入 建立maven项目 使用快捷键 Ctrl + Shift + P 建立一个 Maven 项目 1 Ctrl + Shift + P 打开输入框2 输入 "> java create"3 选择 maven4 选择 No Archetype5 输入 域名6 输入项目名称7 建立一个文件目录存放项目,文件名一般为项目名8 确定