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笔记 —— 方法重载和方法重写的更多相关文章

  1. JAVA学习(七):方法重载与方法重写、thiskeyword和superkeyword

    方法重载与方法重写.thiskeyword和superkeyword 1.方法重载 重载可以使具有同样名称但不同数目和类型參数的类传递给方法. 注: 一是重载方法的參数列表必须与被重载的方法不同,而且 ...

  2. Java学习总结之方法重载和方法重写

    在学习方法的阶段我学习了方法重载(Overload),而在学习面向对象三大特性之继承的时候我又学习了方法重写(Override).   概念: 方法重载:在同一个类中,允许存在一个以上的同名方法,只要 ...

  3. Java 方法重载与方法重写

    方法重载(Overload): 1.在同一个类中 2.方法名相同 3.参数的个数或类型不同 4.与方法的返回类型无关 5.与方法的修饰符无关 方法重写(Override): 方法重写必须是子类继承父类 ...

  4. AJPFX总结方法重载与方法重写的区别

    方法重载在同一个类中,可以出现同名方法,但是这些同名方法的参数列表必须不同,这样定义方法叫做方法重载.方法重载的特点重载的注意事项重载与返回值无关重载与具体的变量标识符无关重载只与方法名与参数相关重载 ...

  5. PHP面向对象编程——深入理解方法重载与方法覆盖(多态)

    什么是多态? 多态(Polymorphism)按字面的意思就是“多种状态”.在面向对象语言中,接口的多种不同的实现方式即为多态.引用Charlie Calverts对多态的描述——多态性是允许你将父对 ...

  6. PHP面向对象编程之深入理解方法重载与方法覆盖(多态)

    这篇文章主要介绍了PHP面向对象编程之深入理解方法重载与方法覆盖(多态)的相关资料,需要的朋友可以参考下: 什么是多态? 多态(Polymorphism)按字面的意思就是"多种状态" ...

  7. 疯狂java学习笔记之面向对象(六) - 构造器重载、方法重载和方法重写

    一.方法重载(Overload): Java允许同一个类中定义多个同名方法,只要形参不一样就可以,如果同一个类中包含了两个或两个以上方法名相同的方法,但形参列表不同,则被成为方法重载(两同一异). 同 ...

  8. Java 方法重载,方法重写(覆盖),继承等细节注意

    1.方法重载(method overload)的具体规范 如果有两个方法的方法名相同,但参数不一致,那么可以说一个方法是另一个方法的重载. 一.方法名一定要相同. 二.方法的参数表必须不同,包括参数的 ...

  9. Java基础-方法重载和方法重写的区别

    什么是java方法重载 (1) 方法重载是让类以统一的方式处理不同类型数据的一种手段.多个同名函数同时存在,具有不同的参数个数/类型. 重载Overloading是一个类中多态性的一种表现. (2)  ...

随机推荐

  1. Opencv常用函数讲解

    1.approxPolyDP(Mat(ps), poly, 5, true);//根据点集,拟合出多边形 2.fillConvexPoly(mask, Mat(ps), Scalar(255));根据 ...

  2. 2018北京网络赛D 80days (尺取)

    #1831 : 80 Days 时间限制:1000ms 单点时限:1000ms 内存限制:256MB 描述 80 Days is an interesting game based on Jules ...

  3. POJ1054 The Troublesome Frog

    题目来源:http://poj.org/problem?id=1054 题目大意: 有一种青蛙在晚上经过一片稻田,在庄稼上跳跃,会把庄稼压弯.这让农民很苦恼.我们希望通过分析青蛙跳跃的路径,找出对稻田 ...

  4. 【学习笔记】Python 3.6模拟输入并爬取百度前10页密切相关链接

    [学习笔记]Python 3.6模拟输入并爬取百度前10页密切相关链接 问题描述 通过模拟网页,实现百度搜索关键词,然后获得网页中链接的文本,与准备的文本进行比较,如果有相似之处则代表相关链接. me ...

  5. 6.过滤器(Filter)

    ---恢复内容开始--- 1.过滤器简介: 过滤器是一个用于拦截在数据源和数据目的地之间消息的一个对象. 过滤器 功能: 分析请求,将请求发送给指定的资源或自己创建一个响应返回:在请求到达服务器端前处 ...

  6. 新磁盘创建lvm并挂载

    ### .查看硬盘 fdisk -l ### 删除分区 fdisk /dev/sdc ### 按d删除,按w保存并退出 ### 创建pv pvcreate /dev/sdc ### 创建 vg vgc ...

  7. Problem07 处理字符串

    题目:输入一行字符,分别统计出其中英文字母.空格.数字和其它字符的个数. 程序分析:利用while 语句,条件为输入的字符不为'\n'. import java.util.*; public clas ...

  8. linux 6 安装 使用 XtraBackup

    帮助文档:https://www.cnblogs.com/imweihao/p/7290026.html ---Yum安装 官网地址:https://www.percona.com/doc/perco ...

  9. django建表报错

     今天在用pycharm创建数据库的表的时候碰见了一个报错,这还是头一次碰见这种奇怪的错误.这里记住希望能避免错误. 我所创建的表是用的django原有的用户表,做了一下继承. class UserI ...

  10. linux 查看页大小

    # getconf PAGE_SIZE 一般是4096