能否用方法的返回值来区分重载函数?

happyharold 2013-03-13 08:34:31
在《thinking in java》第四版中文版,机械工业出版社,第82页中有这样一段话:
读者可能会想:“在区分重载方法的时候,为什么只能以类名和方法的形参列表作为标准呢?能否考虑用方法的返回值来区分?”比如以下两个方法,虽然它们有同样的名字和形式参数,但却很容易区分它们:
void f() {}
int f() {return 1;}
只要编译器可以根据语境明确判断出语义,比如在int x=f()中,那么的确可以据此却分重载方法。

我为了验证这段话,编写了以下的程序:
public class test{
void f(){}
int f(){
return 1;
}
}

public class test2 {
public static void main(String [] args){
test t=new test();
int a=t.f();
System.out.println(a);
}
}

编译出现错了,是书错了,还是我的验证方法错误?
...全文
588 11 打赏 收藏 转发到动态 举报
写回复
用AI写文章
11 条回复
切换为时间正序
请发表友善的回复…
发表回复
Leexs 2014-08-24
  • 打赏
  • 举报
回复
class Ex05_p82_5_2_3 {
	/*
	public static void f() {
		System.out.println("f()");
	}
	//compile error: 已在类中定义了方法f()
	public static int f() {
		return 1;
	}
	*/	

	public static int add(int x, int y) {
		return x + y;
	}
	public static String add(String str1, String str2) {
		return str1 + str2;
	}

	public static void main(String [] args) {

		String c = add("a", "b");
		System.out.println(c);
		int x = add(1,1);
		System.out.println(x);
	}

}
这里个人认为应该理解为:不能单单依靠返回值类型来区分方法重载。
hu_xinxin 2013-03-13
  • 打赏
  • 举报
回复
不能的哦,你想想:假如我调用这个方法,但是我不要返回值。那你说我是调用哪个方法呢?你是让机器糊涂了,让机器糊涂了,也就是你错了。 public class TestOveride{ public void test1(){ System.out.println("无参数test1"); } public void test1(String s){ System.out.println("有参数test1"); } public static void main(String[] args){ TestOveride t = new TestOveride(); t.test1("hello"); //你看,假如我不要返回值,你说用返回值来看,我都没有返回值。你说是调用哪一个方法?所以要看参数。 } }
kissoday 2013-03-13
  • 打赏
  • 举报
回复
Java重载口诀:同类同名不同参,与修饰符,返回值,异常无关
泰坦小毛驴 2013-03-13
  • 打赏
  • 举报
回复
有没有想过调用的时候怎么区分呢,难不成要看是否有接收返回值吧
  • 打赏
  • 举报
回复
不行的,重载要看参数
lvzg_005 2013-03-13
  • 打赏
  • 举报
回复
引用 2 楼 a597926661 的回复:
我们很易对下面这些问题感到迷惑:为什么只有类名和方法自变量列出?为什么不根据返回值对方法加以区 分?比如对下面这两个方法来说,虽然它们有同样的名字和自变量,但其实是很容易区分的: void f() {} int f() {} 若编译器可根据上下文(语境)明确判断出含义,比如在 int x=f()中,那么这样做完全没有问题。然而, 我们也可能调用一个方法,同时忽略返回值;我们通常……
读书要读完整啊,不能读一片段就理解所有意思
  • 打赏
  • 举报
回复
看函数签名。。。
LCore 2013-03-13
  • 打赏
  • 举报
回复
引用 2 楼 a597926661 的回复:
我们很易对下面这些问题感到迷惑:为什么只有类名和方法自变量列出?为什么不根据返回值对方法加以区 分?比如对下面这两个方法来说,虽然它们有同样的名字和自变量,但其实是很容易区分的: void f() {} int f() {} 若编译器可根据上下文(语境)明确判断出含义,比如在 int x=f()中,那么这样做完全没有问题。然而, 我们也可能调用一个方法,同时忽略返回值;我们通常……
对的,函数的返回值只是作为函数运行之后的一个“状态” 他是保持方法的调用者与被调用者进行通信的关键。 并不能作为某个方法的“标识”
Candylibin 2013-03-13
  • 打赏
  • 举报
回复
所谓重载就是方法名相同 XX() 但是参数列表不同,比如参数的顺序,类型,个数等 (就是括号里的东西) 方法重载跟返回值类型和修饰符无关 那么在执行时,你传给方法哪些参数,java虚拟机就会去找对应的方法执行(所以不用担心混乱)
a597926661 2013-03-13
  • 打赏
  • 举报
回复
我们很易对下面这些问题感到迷惑:为什么只有类名和方法自变量列出?为什么不根据返回值对方法加以区 分?比如对下面这两个方法来说,虽然它们有同样的名字和自变量,但其实是很容易区分的: void f() {} int f() {} 若编译器可根据上下文(语境)明确判断出含义,比如在 int x=f()中,那么这样做完全没有问题。然而, 我们也可能调用一个方法,同时忽略返回值;我们通常把这称为“为它的副作用去调用一个方法”,因为我 们关心的不是返回值,而是方法调用的其他效果。所以假如我们象下面这样调用方法: f(); Java 怎样判断f()的具体调用方式呢?而且别人如何识别并理解代码呢?由于存在这一类的问题,所以不能 根据返回值类型来区分过载的方法。 楼主 这下你知道了吧
chengxu2011 2013-03-13
  • 打赏
  • 举报
回复
是你错了,重载不能用返回值来做判断void f(){} int f(){ return 1; } 这2个方法编译器会认为是同一个方法。 不能用返回值来重载,因为方法的调用者不一定会关心方法的返回值...
重载与覆写/重写的区别 区别 重载 覆写 1 单词 OverLoading Override 2 概念 方法名称相同,参数的类型或个数不同 方法名称相同,参数的类型或个数相 同,返回值类型相同 3 范围 发生在一个类之中 发生在类的继承关系中 4 权限 一个类中所重载多个方法可以不同的权限 被子类所覆写的方法不能拥有比父类更严格 的访问控制权限 重载可以改变返回值类型,但是这样做没有任何的意义, 可是对于覆写而言,绝对不能修改返回值类型,但是在子类中所覆写的方法应该可以继续进行重载重载(Overloading)  (1) 方法重载是让类以统一的方式处理不同类型数据的一种手段。多个同名函数同时存在,具有不同的参数个数/类型。   重载Overloading是一个类中多态性的一种表现。 (2) Java的方法重载,就是在类中可以创建多个方法,它们具有相同的名字,但具有不同的参数和不同的定义。   调用方法时通过传递给它们的不同参数个数和参数类型来决定具体使用哪个方法, 这就是多态性。 (3) 重载的时候,方法名要一样,但是参数类型和个数不一样,返回值类型可以相同也可以不相同。     无法以返回值类型作为重载函数区分标准。 复制代码 /** * 1. 方法重载只可以通过方法名和方法参数来区别,即“方法签名” * @return * @throws NumberFormatException */ public int getSides(Object obj) throws NumberFormatException { return 1; } /** * 2. 不能通过访问权限,返回类型,异常列表进行重载 * * 下面方式错误! */ private Object getSides() throws NumberFormatException, Exception { return 1; } /** * 3. 方法异常类型和数目不会对重载造成影响。 * 下面方式错误! */ public int getSides() throws NumberFormatException, IndexOutOfBoundsException, Exception { } 复制代码 重写(Overriding) (1) 父类与子类之间的多态性,对父类的函数进行重新定义。   如果在子类中定义某方法与其父类有相同的名称和参数,我们说该方法被重写 (Overriding)。   在Java中,子类可继承父类中的方法,而不需要重新编写相同的方法。   但有时子类并不想原封不动地继承父类的方法,而是想作一定的修改,这就需要采用方法的重写。   方法重写又称方法覆盖。 (2)若子类中的方法与父类中的某一方法具有相同的方法名、返回类型和参数表,则新方法将覆盖原有的方法。   如需父类中原有的方法,可使用super关键字,该关键字引用了当前类的父类。 (3)子类函数的访问修饰权限不能小于父类的;  多态性是面向对象编程的一种特性,和方法无关, 简单说,就是同样的一个方法能够根据输入数据的不同,做出不同的处理,   即方法重载——有不同的参数列表(静态多态性)   而当子类继承自父类的相同方法,输入数据一样,但要做出有别于父类的响应时,你就要覆盖父类方法, 即在子类中重写该方法——相同参数,不同实现(动态多态性) 复制代码 public class Base { void test(int i) { System.out.print(i); } void test(byte b) { System.out.print(b); } } public class Dog extends Base { void test(int i) { i++; System.out.println(i); } public static void main(String[] agrs) { Base b = new Dog(); b.test(0); b.test((byte) 0); } } 复制代码 这时的输出结果是1 0,这是运行时动态绑定的结果。   简单说来重写就是子类对父类(层级上)中非私有成员方法的重新功能定义。 复制代码 // begin /** * 1. 重写方法必须和被重写方法的“方法签名”一致,即方法名+参数必须相同 */ public int getSides() { return 3; } // end // begin /** * 1. 重写方法访问修饰符一定要大于被重写方法访问修饰符 * (public > protected > default > private) * * 原因: * 2. 有一个可以装1升水的瓶子;你需要用另一个瓶子去继承它, 那你觉得你能用一个半升谁的瓶子继承他吗? */ /** * @return * 本方法重写方式错误 */ // protected int getSides() { // return 3; // } /** * 对父类Shape中getSide方法进行重写,实现多态 * @return */ public int getSides() { return 3; } // end // begin /** * 3. 重写和被重写方法返回值必须相同 * 此方法错误 */ // public double getSides() { // return 3d; // } // end // begin /** * 4. 重写方法抛出的异常必须和被重写方法抛出异常一致,或者是其子类 * 详细见:overrideexception包中例子 */ public int getSides() throws NullPointerException { return 3; } // end /** * 5. 父类中private方法不能被子类重写,因为private只有父类本类可见。 */ /** * 6. 静态方法不存在重写概念,重写是面向对象特性,静态方法是类方法,用类名直接访问。 */ 复制代码
函数的定义 什么是函数? •函数就是定义在类中的具有特定功能的一段独立小程序。 •函数也称为方法函数的格式: •修饰符 返回值类型 函数名(参数类型 形式参数1,参数类型 形式参数2,...) { 执行语句; return 返回值; } 返回值类型:函数运行后的结果的数据类型。 参数类型:是形式参数的数据类型。 形式参数:是一个变量,用于存储调用函数时传递给函数的实际参数。 实际参数:传递给形式参数的具体数值。 return:用于结束函数返回值:该函数运算后的结果,该结果会返回给调用者。 函数的特点 定义函数可以将功能代码进行封装 便于对该功能进行复用 函数只有被调用才会被执行 函数的出现提高了代码的复用性 对于函数没有具体返回值的情况,返回值类型用关键字void表示, 那么该函数中的return语句如果在最后一行可以省略不写。 注意: •函数中只能调用函数,不可以在函数内部定义函数。 •定义函数时,函数的结果应该返回给调用者,交由调用者处理。 函数的应用 两个明确 •明确要定义的功能最后的结果是什么? •明确在定义该功能的过程中,是否需要未知内容参与运算 示例: •需求:定义一个功能,可以实现两个整数的加法运算。 •分析: •该功能的运算结果是什么?两个数的和,也是一个整数(int) •在实现该功能的过程中是否有未知内容参与运算?加数和被加数是不确定的。(两个参数int,int) •代码: int getSum(int x,int y) { return x+y; } 函数重载(overload) 重载的概念 在同一个类中,允许存在一个以上的同名函数,只要它们的参数个数或者参数类型不同即可。 重载的特点: 与返回值类型无关,只看参数列表。 重载的好处: 方便于阅读,优化了程序设计。 重载示例: //返回两个整数的和 int add(int x,int y){return x+y;} //返回三个整数的和 int add(int x,int y,int z){return x+y+z;} //返回两个小数的和 double add(double x,double y){return x+y;} 函数的功能一样,仅仅是参与运算的未知内容不同时, 可以定义多函数,却使用统一函数名称,这样方便阅读。 在调用时,虚拟机通过参数列表的不同来区分同名函数。 数组 数组的定义 概念 同一种类型数据的集合。其实数组就是一个容器。 数组的好处 可以自动给数组中的元素从0开始编号,方便操作这些元素。 格式1: 元素类型[]  数组名 = new 元素类型[元素个数或数组长度]; 示例:int[] arr = new int[5]; 格式2: 元素类型[] 数组名 = new 元素类型[]{元素,元素,……}; int[] arr = new int[]{3,5,1,7}; int[] arr = {3,5,1,7}; 数组内存结构 内存结构 Java程序在运行时,需要在内存中的分配空间。为了提高运算效率,有对空间进行了不同区域的划分,因 为每一片区域都有特定的处理数据方式和内存管理方式。 栈内存   用于存储局部变量,当数据使用完,所占空间会自动释放。 堆内存   数组和对象,通过new建立的实例都存放在堆内存中。   每一个实体都有内存地址值   实体中的变量都有默认初始化值   实体不在被使用,会在不确定的时间内被垃圾回收器回收 方法区,本地方法区,寄存器 数组操作常见问题   数组脚标越界异常(ArrayIndexOutOfBoundsException) int[] arr = new int[2]; System.out.println(arr[3]); 访问到了数组中的不存在的脚标时发生。   空指针异常(NullPointerException) int[] arr = null; System.out.println(arr[0]); arr引用没有指向实体,却在操作实体中的元素时。

62,614

社区成员

发帖
与我相关
我的任务
社区描述
Java 2 Standard Edition
社区管理员
  • Java SE
加入社区
  • 近7日
  • 近30日
  • 至今
社区公告
暂无公告

试试用AI创作助手写篇文章吧