Java笔记 —— 方法重载和方法重写

h2 { color: #4ABCDE }
a { text-decoration: none !important }
a:hover { color: red !important; text-decoration: underline !important }
pre { border: solid 1px #CCCCCC; background-color: #F8F8F8; margin: 15px; overflow: auto; white-space: pre; font-size: 13px; font-family: consolas, courier, monospace; line-height: 20px; padding: 6px 10px }
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~

原文地址：https://www.cnblogs.com/huangzenglie/p/8836904.html

时间： 2024-10-06 13:59:05

Java笔记 —— 方法重载和方法重写的相关文章

JAVA学习（七）：方法重载与方法重写、thiskeyword和superkeyword

方法重载与方法重写.thiskeyword和superkeyword 1.方法重载重载可以使具有同样名称但不同数目和类型參数的类传递给方法. 注: 一是重载方法的參数列表必须与被重载的方法不同,而且这样的不同必须足以清楚地确定要调用哪一个方法: 二是重载方法的返回值类型能够与被重载的方法同样,也能够不同,可是仅仅有返回值类型不同不能表示为重载. 比如,最经常使用的println()方法在JDK的java.io.PrintStream中定义了十几种形式的重载,经常使用格式例如以下: public

JAVA学习（七）：方法重载与方法重写、this关键字和super关键字

方法重载与方法重写.this关键字和super关键字 1.方法重载重载能够使具有相同名称但不同数目和类型参数的类传递给方法. 注: 一是重载方法的参数列表必须与被重载的方法不同,并且这种不同必须足以清楚地确定要调用哪一个方法: 二是重载方法的返回值类型可以与被重载的方法相同,也可以不同,但是只有返回值类型不同不能表示为重载. 例如,最常用的println()方法在JDK的java.io.PrintStream中定义了十几种形式的重载,常用格式如下: public void println(in

Java学习之方法重载和方法重写（覆盖）比较

方法重载和方法覆盖请带着下面两点来看文章: 覆盖即重写,覆盖不等于重载,即重写不等于重载. 覆盖(重写)蕴含继承性,而重载只能在本类中使用,不含继承. 方法名和参数列表的比较方法覆盖中的方法名和参数首先创建基类Shape: public class Shape { public void draw() { System.out.println("Shape.draw()"); } } 子类Circle: public class Circle extends Shape {

面向过程和面向对象的区别，方法重载和方法重写的区别

先有面向过程,而后退出面向对象面向过程和面向对象两者都是软件开发思想,先有面向过程,后有面向对象.在大型项目中,针对面向过程的不足推出了面向对象开发思想. 打个比方蒋介石和毛主席分别是面向过程和面向对象的杰出代表,这样充分说明,在解决复制问题时,面向对象有更大的优越性. 面向过程是蛋炒饭,面向对象是盖浇饭.盖浇饭的好处就是"菜""饭"分离,从而提高了制作盖浇饭的灵活性.饭不满意就换饭,菜不满意换菜.用软件工程的专业术语就是"可维护性"比较好,

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

方法重载在同一个类中,可以出现同名方法,但是这些同名方法的参数列表必须不同,这样定义方法叫做方法重载.方法重载的特点重载的注意事项重载与返回值无关重载与具体的变量标识符无关重载只与方法名与参数相关重载方法方法名必须相同重载方法参数必须不同:参数个数不同参数类型不同参数顺序不同方法重写(方法重载是在一个类里) 严格检查方法的格式 @Override 方法重写 @Overload方法重载在方法前添加概念当子类继承父类后,拥有了父类非私有的方法并可以直接调用.但是子类可以按照子类自身的逻辑重新

java面向对象编程（六）--四大特征之继承、方法重载和方法覆盖

一.继承 1.继承的概念继承可以解决代码复用,让我们的编程更加靠近人类思维.当多个类存在相同的属性(变量)和方法时,可以从这些类中抽象出父类,在父类中定义这些相同的属性和方法,所有的子类不需要重新定义这些属性和方法,只需要通过extends语句来声明继承父类.语法如下: class 子类 extends 父类这样,子类就会自动拥有父类定义的某些属性和方法.另外,并不是父类的所有属性.方法都可以被子类继承.父类的public修饰符的属性和方法,protected修饰符的属性和方法,默认修饰符属

Java方法继承、方法重载、方法覆盖小总结

转自:http://blog.csdn.net/cdsnmdl/article/details/3968688 ———————————————————————————————————— 1.方法继承:利用extends关键字一个方法继承另一个方法,而且只能直接继承一个类. 当Sub类和Base类在同一个包时Sub类继承Base类中的public/protected/默认级别的变量个方法在不同包时继承public/protected级别的变量和方法. 2.方法重载:如果有两个方法的方法名相同,但

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

一.方法重载(Overload): Java允许同一个类中定义多个同名方法,只要形参不一样就可以,如果同一个类中包含了两个或两个以上方法名相同的方法,但形参列表不同,则被成为方法重载(两同一异). 同时这这里我们需要注意以下两点: A.方法重载与返回值类型没有任何关系; B.方法重载与是否有static修饰没有任何关系. 那我们如何才能确定到底调用的哪个方法呢? A.主调者:明确是谁在调用这个方法,是类还是对象 B.方法名和形参:确定调用哪个方法(由方法名和形参共同决定) 例1: 1 p

JAVA SE中方法重载和方法重写及数据库中子程序的重载

首先方法重写和方法重载是建立在Java的面向对象的继承和多态的特性基础上而出现的.至于面向对象的继承和多态的特性我就不在这里多说了.继承是指在一个父类的基础再创建一个子类,这样子类就拥有了父类的非私有的特性,同时子类还可以扩展自己的特性,这样就引出了方法重写和方法重载! 一.方法重写(Override) 在Java中如何来定义重写:Java程序中类的继承特性可以产生一个子类,子类继承父类就拥有了父类的非私有的属性(方法和变量),在子类中可以增加自己的属性(方法和变量),同时也可以