Java笔记 —— 方法重载和方法重写
Java笔记 —— 方法重载和方法重写
h2{
color: #4ABCDE;
}
a{
text-decoration: none !important;
}
a:hover{
color: red !important;
text-decoration: underline !important;
}
pre{
border: solid 1px #CCCCCC;
border-radius: 3px;
background-color: #F8F8F8;
margin: 15px;
overflow: auto;
white-space: pre;
font-size: 13px;
font-family: consolas, courier, monospace;
line-height: 20px;
padding: 6px 10px;
tab-size: 4;
}
p.textRight{
text-align: right;
}
p.header{
color: #787878;
font-size: 20px;
font-family: 楷体, "微软雅黑", arial;
font-weight: bold;
}
一、方法重载
1）在同一个类中，如果想创建多个名称相同的方法，那么就会用到方法重载。方法重载通过参数区分名称相同的方法，参数可以类型不同，数目不同，或者顺序不同
package com.example;
public class T{
public void show(){
System.out.println("show()");
}
/*error
public int show(){
return 100;
}
*/
public void show(int i){
System.out.println("show" + "(" + i + ")");
}
public void show(String str){
System.out.println("show" + "(" + str + ")");
}
public void show(int i, String str){
System.out.println("show" + "(" + i + ", " + str + ")");
}
public void show(String str, int i){
System.out.println("show" + "(" + str + ", " + i + ")");
}
}
package com.example;
public class Test{
public static void main(String[] args){
T t = new T();
t.show();
t.show(10);
t.show("张三");
t.show(10, "张三");
t.show("张三", 10);
}
}
运行结果： show()
show(10)
show(张三)
show(10, 张三)
show(张三, 10)
- 方法名称相同时，不能通过改变返回值的类型来进行区分，只能通过改变参数的类型、参数的数目、或者参数的顺序来对方法进行区分
2）类中可以创建多个构造器也是利用了方法重载
package com.example;
public class T{
public T(){
}
public T(int i){
}
public T(String str){
}
}
3）方法重载时，如果参数列表都是基本数据类型，编译器会将传入的参数自动匹配相应的类型。如果没有相匹配的类型，编译器会将参数进行类型提升或者窄化转换
例1：
package com.example;
public class T{
public void f1(char i) {System.out.print("f1(char) ");}
public void f1(byte i) {System.out.print("f1(byte) ");}
public void f1(short i) {System.out.print("f1(short) ");}
public void f1(int i) {System.out.print("f1(int) ");}
public void f1(long i) {System.out.print("f1(long) ");}
public void f1(float i) {System.out.print("f1(float) ");}
public void f1(double i) {System.out.print("f1(double) ");}
public void f2(byte i) {System.out.print("f2(byte) ");}
public void f2(short i) {System.out.print("f2(short) ");}
public void f2(int i) {System.out.print("f2(int) ");}
public void f2(long i) {System.out.print("f2(long) ");}
public void f2(float i) {System.out.print("f2(float) ");}
public void f2(double i) {System.out.print("f2(double) ");}
public void f3(short i) {System.out.print("f3(short) ");}
public void f3(int i) {System.out.print("f3(int) ");}
public void f3(long i) {System.out.print("f3(long) ");}
public void f3(float i) {System.out.print("f3(float) ");}
public void f3(double i) {System.out.print("f3(double) ");}
public void f4(int i) {System.out.print("f4(int) ");}
public void f4(long i) {System.out.print("f4(long) ");}
public void f4(float i) {System.out.print("f4(float) ");}
public void f4(double i) {System.out.print("f4(double) ");}
public void f5(long i) {System.out.print("f5(long) ");}
public void f5(float i) {System.out.print("f5(float) ");}
public void f5(double i) {System.out.print("f5(double) ");}
public void f6(float i) {System.out.print("f6(float) ");}
public void f6(double i) {System.out.print("f6(double) ");}
public void f7(double i) {System.out.print("f7(double) ");}
public void showChar(){
char i = 0;
System.out.println("char: ");
f1(i); f2(i); f3(i); f4(i); f5(i); f6(i); f7(i);
System.out.println("\n");
}
public void showByte(){
byte i = 0;
System.out.println("byte: ");
f1(i); f2(i); f3(i); f4(i); f5(i); f6(i); f7(i);
System.out.println("\n");
}
public void showShort(){
short i = 0;
System.out.println("short: ");
f1(i); f2(i); f3(i); f4(i); f5(i); f6(i); f7(i);
System.out.println("\n");
}
public void showInt(){
int i = 0;
System.out.println("int: ");
f1(i); f2(i); f3(i); f4(i); f5(i); f6(i); f7(i);
System.out.println("\n");
}
public void showLong(){
long i = 0;
System.out.println("long: ");
f1(i); f2(i); f3(i); f4(i); f5(i); f6(i); f7(i);
System.out.println("\n");
}
public void showFloat(){
float i = 0;
System.out.println("float: ");
f1(i); f2(i); f3(i); f4(i); f5(i); f6(i); f7(i);
System.out.println("\n");
}
public void showDouble(){
double i = 0;
System.out.println("double: ");
f1(i); f2(i); f3(i); f4(i); f5(i); f6(i); f7(i);
System.out.println("\n");
}
}
package com.example;
public class Test{
public static void main(String[] args){
T t = new T();
t.showChar();
t.showByte();
t.showShort();
t.showInt();
t.showLong();
t.showFloat();
t.showDouble();
}
}
运行结果： char:
f1(char) f2(int) f3(int) f4(int) f5(long) f6(float) f7(double) byte:
f1(byte) f2(byte) f3(short) f4(int) f5(long) f6(float) f7(double) short:
f1(short) f2(short) f3(short) f4(int) f5(long) f6(float) f7(double) int:
f1(int) f2(int) f3(int) f4(int) f5(long) f6(float) f7(double) long:
f1(long) f2(long) f3(long) f4(long) f5(long) f6(float) f7(double) float:
f1(float) f2(float) f3(float) f4(float) f5(float) f6(float) f7(double) double:
f1(double) f2(double) f3(double) f4(double) f5(double) f6(double) f7(double)
- char 类型比较特别，当重载的方法中没有 char 类型时，传入的参数会提升为 int 类型，而不是 byte 类型，例如：f2 方法和 f3 方法，这两个方法都没有重载 char 类型的参数，所以传入的参数直接提升为 int 类型，从运行结果的第一行可以看到这一特性
例2：
package com.example;
public class T{
public void f1(char i) {System.out.print("f1(char) ");}
public void f1(byte i) {System.out.print("f1(byte) ");}
public void f1(short i) {System.out.print("f1(short) ");}
}
package com.example;
public class Test{
public static void main(String[] args){
int i = 0;
T t = new T();
//t.f1(i); // error
t.f1((char)i);
t.f1((byte)i);
t.f1((short)i);
}
}
运行结果： f1(char) f1(byte) f1(short)
- 如果传入的参数需要窄化转型，那么必须要显式地对传入的参数进行强制类型转换
[ 返回顶部 ]
二、方法重写
1）方法重写只存在于子类中（继承或实现接口）
package com.example;
public class Person{ // 父类
public void speak(){
System.out.println("Person: speak()");
}
}
package com.example;
public class Man extends Person{ // 子类
public void speak(){ // 重写父类的 speak 方法
super.speak(); // 调用父类的 speak 方法
System.out.println("Man: speak()");
}
}
运行结果： Person: speak()
Man: speak()
- 方法重写时，子类方法的方法名称、返回值类型、参数列表都应该与父类中的方法相同
2）子类中重写的方法的访问控制权限不能低于父类中方法的访问控制权限
package com.example;
public class Person{ // 父类
public void p1(){
}
protected void p2(){
}
void p3(){
}
private void p4(){
}
}
package com.example;
public class Man extends Person{ // 子类
public void p1(){ // 父类的 p1 方法的访问控制权限是 public，那么子类的 p1 方法的访问控制权限只能是 public
}
/* public void p2(){ // 可以是 public 或者 protected
} */
protected void p2(){
}
/* public void p3(){
}
protected void p3(){
} */
void p3(){
}
/* public void p4(){
}
protected void p4(){
}
void p4(){
} */
private void p4(){
}
}
3）继承关系中，子类也可以对父类的方法进行方法重载
package com.example;
public class Person{ // 父类
public void speak(int i){
System.out.println("Person: speak" + "(" + i + ")");
}
}
package com.example;
public class Man extends Person{ // 子类
public void speak(String str){ // 方法重载
System.out.println("Man: speak" + "(" + str + ")");
}
}
package com.example;
public class Test{
public static void main(String[] args){
Man m = new Man();
m.speak("张三");
}
}
运行结果： Man: speak(张三)
4）Java 为了保证重写方法时不会出错，所以引入了 @Override
package com.example;
public class Person{ // 父类
public void speak(int i){
System.out.println("Person: speak" + "(" + i + ")");
}
}
package com.example;
public class Man extends Person{ // 子类
/* @Override
public void speak(String str){
System.out.println("Man: speak" + "(" + str + ")");
} */ // error，用了 @Override ，那么 @Override 下面的方法必须是方法重写，否则编译时会出错
@Override
public void speak(int i){
System.out.println("Man: speak" + "(" + i + ")");
}
}
package com.example;
public class Test{
public static void main(String[] args){
Man m = new Man();
m.speak(10);
}
}
运行结果： Man: speak(10)
[ 返回顶部 ]
参考资料：
《Java 编程思想》第4版
End~
Java笔记 —— 方法重载和方法重写的更多相关文章
- JAVA学习（七）：方法重载与方法重写、thiskeyword和superkeyword
方法重载与方法重写.thiskeyword和superkeyword 1.方法重载 重载可以使具有同样名称但不同数目和类型參数的类传递给方法. 注: 一是重载方法的參数列表必须与被重载的方法不同,而且 ...
- Java学习总结之方法重载和方法重写
在学习方法的阶段我学习了方法重载(Overload),而在学习面向对象三大特性之继承的时候我又学习了方法重写(Override). 概念: 方法重载:在同一个类中,允许存在一个以上的同名方法,只要 ...
- Java 方法重载与方法重写
方法重载(Overload): 1.在同一个类中 2.方法名相同 3.参数的个数或类型不同 4.与方法的返回类型无关 5.与方法的修饰符无关 方法重写(Override): 方法重写必须是子类继承父类 ...
- AJPFX总结方法重载与方法重写的区别
方法重载在同一个类中,可以出现同名方法,但是这些同名方法的参数列表必须不同,这样定义方法叫做方法重载.方法重载的特点重载的注意事项重载与返回值无关重载与具体的变量标识符无关重载只与方法名与参数相关重载 ...
- PHP面向对象编程——深入理解方法重载与方法覆盖（多态）
什么是多态? 多态(Polymorphism)按字面的意思就是“多种状态”.在面向对象语言中,接口的多种不同的实现方式即为多态.引用Charlie Calverts对多态的描述——多态性是允许你将父对 ...
- PHP面向对象编程之深入理解方法重载与方法覆盖（多态）
这篇文章主要介绍了PHP面向对象编程之深入理解方法重载与方法覆盖(多态)的相关资料,需要的朋友可以参考下: 什么是多态? 多态(Polymorphism)按字面的意思就是"多种状态" ...
- 疯狂java学习笔记之面向对象(六) - 构造器重载、方法重载和方法重写
一.方法重载(Overload): Java允许同一个类中定义多个同名方法,只要形参不一样就可以,如果同一个类中包含了两个或两个以上方法名相同的方法,但形参列表不同,则被成为方法重载(两同一异). 同 ...
- Java 方法重载，方法重写（覆盖），继承等细节注意
1.方法重载(method overload)的具体规范 如果有两个方法的方法名相同,但参数不一致,那么可以说一个方法是另一个方法的重载. 一.方法名一定要相同. 二.方法的参数表必须不同,包括参数的 ...
- Java基础-方法重载和方法重写的区别
什么是java方法重载 (1) 方法重载是让类以统一的方式处理不同类型数据的一种手段.多个同名函数同时存在,具有不同的参数个数/类型. 重载Overloading是一个类中多态性的一种表现. (2) ...
随机推荐
- [SDOI2008]烧水问题 规律
题目描述 把总质量为1kg的水分装在n个杯子里,每杯水的质量均为(1/n)kg,初始温度均为0℃.现需要把每一杯水都烧开.我们可以对任意一杯水进行加热.把一杯水的温度升高t℃所需的能量为(4200*t ...
- [SCOI2007]蜥蜴 BZOJ1066 最大流
题目背景 07四川省选 题目描述 在一个r行c列的网格地图中有一些高度不同的石柱,一些石柱上站着一些蜥蜴,你的任务是让尽量多的蜥蜴逃到边界外. 每行每列中相邻石柱的距离为1,蜥蜴的跳跃距离是d,即蜥蜴 ...
- 14.Diameter of Binary Tree（二叉树的直径）
Level: Easy 题目描述: Given a binary tree, you need to compute the length of the diameter of the tree. ...
- pytorch构建优化器
这是莫凡python学习笔记. 1.构造数据,可以可视化看看数据样子 import torch import torch.utils.data as Data import torch.nn.func ...
- android:id 中区别。。
一. android:id="@android:id/tabhost" 是调用系统内部的ID 和代码中 mTabContent = (FrameLayout) findView ...
- C语言中函数声明、形参、实参
函数原型: 原型prototype是函数的声明:描述了函数的返回值与参数: 函数原型说明了两点: 1.该函数的返回值 2.该函数的参数及其类型 ++++++++++++++++++++++++++++ ...
- 2.2 Go 常量与枚举
package main import ( "fmt" "math" ) //常量 func cons(){ , //常量的数字在不明确指定类型的情况下,即可以 ...
- Android文件/文件夹选择器（支持多选操作），已封装为lib库，直接添加依赖即可。
话不多少,先上图一览: 接下来我们开始写个app测试: 1.新建Android工程:FileSelectorTest 2.更改MainActivity: 在里面写四个textview模拟button, ...
- jemeter、windox下安装教程
JMeter是Apache软件基金会的产品,用于对静态和动态的资源(文件,Servlet,Perl脚本,Java对象,数据库和查询,FTP服务器等等)的性能进行测试,是一款很方便的测试软件. 系统:w ...
- LeetCode 62.不同路径（C++）
一个机器人位于一个 m x n 网格的左上角 (起始点在下图中标记为“Start” ). 机器人每次只能向下或者向右移动一步.机器人试图达到网格的右下角(在下图中标记为“Finish”). 问总共有多 ...