Java方法重载和Java方法重写

Java方法重载

Java 允许同一个类中定义多个同名方法,只要它们的形参列表不同即可。如果同一个类中包含了两个或两个以上方法名相同的方法,但形参列表不同,这种情况被称为方法重载(overload)。

例如,在 JDK 的 java.io.PrintStream 中定义了十多个同名的 println() 方法。

public void println(int i){…}
public void println(double d){…}
public void println(String s){…}

这些方法完成的功能类似,都是格式化输出。根据参数的不同来区分它们,以进行不同的格式化处理和输出。它们之间就构成了方法的重载。实际调用时,根据实参的类型来决定调用哪一个方法。例如:

System.out.println(102);    // 调用println(int i)方法
System.out.println(102.25);    // 调用println(double d)方法
System.out.println("价格为 102.25");    // 调用println(String s)方法

方法重载的要求是两同一不同:同一个类中方法名相同,参数列表不同。至于方法的其他部分,如方法返回值类型、修饰符等,与方法重载没有任何关系。

使用方法重载其实就是避免出现繁多的方法名,有些方法的功能是相似的,如果重新建立一个方法,重新取个方法名称,会降低程序可读性。

例 1

在比较数值时,数值的个数和类型是不固定的,可能是两个 int 类型的数值,也可能是两个 double 类型的数值,或者是两个 double、一个 int 类型的数值;在这种情况下就可以使用方法的重载来实现数值之间的比较功能。

具体实现代码如下:

public class OverLoading {
    public void max(int a, int b) {
        // 含有两个int类型参数的方法
        System.out.println(a > b ? a : b);
    }
    public void max(double a, double b) {
        // 含有两个double类型参数的方法
        System.out.println(a > b ? a : b);
    }
    public void max(double a, double b, int c) {
        // 含有两个double类型参数和一个int类型参数的方法
        double max = (double) (a > b ? a : b);
        System.out.println(c > max ? c : max);
    }
    public static void main(String[] args) {
        OverLoading ol = new OverLoading();
        System.out.println("1 与 5 比较,较大的是:");
        ol.max(1, 5);
        System.out.println("5.205 与 5.8 比较,较大的是:");
        ol.max(5.205, 5.8);
        System.out.println("2.15、0.05、58 中,较大的是:");
        ol.max(2.15, 0.05, 58);
    }
}

编译、运行上面程序完全正常,虽然 3 个 max() 方法的方法名相同,但因为它们的形参列表不同,所以系统可以正常区分出这 3 个方法。当运行时,Java 虚拟机会根据传递过来的不同参数来调用不同的方法。

运行结果如下:

1 与 5 比较,较大的是:
5
5.205 与 5.8 比较,较大的是:
5.8
2.15、0.05、58 中,较大的是:
58.0

为什么方法重载不能用方法的返回值类型区分呢?

对于int f( ) { }void( ) { }两个方法,如果这样调用int result = f();,系统可以识别是调用返回值类型为 int 的方法,但 Java 调用方法时可以忽略方法返回值,如果采用如下方法来调用f();,你能判断是调用哪个方法吗?如果你尚且不能判断,那么 Java 系统也会糊涂。

在编程过程中有一条重要规则就是不要让系统糊涂,系统一糊涂,肯定就是你错了。

因此,Java 里不能用方法返回值类型作为区分方法重载的依据。

Java方法重写

在子类中如果创建了一个与父类中相同名称、相同返回值类型、相同参数列表的方法,只是方法体中的实现不同,以实现不同于父类的功能,这种方式被称为方法重写(override),又称为方法覆盖。

当父类中的方法无法满足子类需求或子类具有特有功能的时候,需要方法重写。

子类可以根据需要,定义特定于自己的行为。既沿袭了父类的功能名称,又根据子类的需要重新实现父类方法,从而进行扩展增强。

在重写方法时,需要遵循下面的规则:

  • 参数列表必须完全与被重写的方法参数列表相同。
  • 返回的类型必须与被重写的方法的返回类型相同(Java1.5 版本之前返回值类型必须一样,之后的 Java 版本放宽了限制,返回值类型必须小于或者等于父类方法的返回值类型)。
  • 访问权限不能比父类中被重写方法的访问权限更低(public>protected>default>private)。
  • 重写方法一定不能抛出新的检査异常或者比被重写方法声明更加宽泛的检査型异常。例如,父类的一个方法声明了一个检査异常 IOException,在重写这个方法时就不能抛出 Exception,只能拋出 IOException 的子类异常,可以抛出非检査异常。

另外还要注意以下几条:

  • 重写的方法可以使用 @Override 注解来标识。
  • 父类的成员方法只能被它的子类重写。
  • 声明为 final 的方法不能被重写。
  • 声明为 static 的方法不能被重写,但是能够再次声明。
  • 构造方法不能被重写。
  • 子类和父类在同一个包中时,子类可以重写父类的所有方法,除了声明为 private 和 final 的方法。
  • 子类和父类不在同一个包中时,子类只能重写父类的声明为 public 和 protected 的非 final 方法。
  • 如果不能继承一个方法,则不能重写这个方法。

例 1

每种动物都有名字和年龄属性,但是喜欢吃的食物是不同的,比如狗喜欢吃骨头、猫喜欢吃鱼等,因此每种动物的介绍方式是不一样的。

下面编写 Java 程序,在父类 Animal 中定义 getInfo() 方法,并在子类 Cat 中重写该方法, 实现猫的介绍方式。

父类 Animal 的代码如下:

public class Animal {
    public String name; // 名字
    public int age; // 年龄
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getInfo() {
        return "我叫" + name + ",今年" + age + "岁了。";
    }
}

子类 Cat 的代码如下:

public class Cat extends Animal {
    private String hobby;
    public Cat(String name, int age, String hobby) {
        super(name, age);
        this.hobby = hobby;
    }
    public String getInfo() {
        return "喵!大家好!我叫" + this.name + ",我今年" + this.age + "岁了,我爱吃" + hobby + "。";
    }
    public static void main(String[] args) {
        Animal animal = new Cat("小白", 2, "鱼");
        System.out.println(animal.getInfo());
    }
}

如上述代码,在 Animal 类中定义了一个返回值类型为 String、名称为 getInfo() 的方法,而 Cat 类继承自该类,因此 Cat 类同样含有与 Animal 类中相同的 getInfo() 方法。

但是我们在 Cat 类中又重新定义了一个 getInfo() 方法,即重写了父类中的 getInfo() 方法。

在 main() 方法中,创建了 Cat 类的对象 animal,并调用了 getInfo() 方法。输出的结果如下:

喵!大家好!我叫小白,我今年2岁了,我爱吃鱼。

如果子类中创建了一个成员变量,而该变量的类型和名称都与父类中的同名成员变量相同,我们则称作变量隐藏。

Java入门基础视频教程,java零基础自学就选黑马程序员Java入门教程(含Java项目和Java真题)

### JAVA方法重写方法重载的区别 #### 一、概念区分 - **方法重写(Override)** 是指子重新定义父中已有的方法,其目的是为了扩展修改父的功能。它主要应用于继承关系中,体现了运行时多态性[^1]。 - **方法重载(Overload)** 则是在同一中通过不同的参数列表(数量、顺序的不同)定义多个同名方法,用于实现多种功能的统一接口设计[^3]。 --- #### 二、核心区别 | 特性 | 方法重写(Override) | 方法重载(Overload) | |-------------------|-----------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------| | **发生位置** | 发生在具有继承关系的父子之间 | 同一个内部 | | **方法签名** | 方法名、参数列表必须完全一致 | 方法名相同,但参数的数量、顺序至少有一个不同 | | **返回值型** | 返回值型可以是协变返回型(即子可返回更具体的型),但在大多数情况下保持一致 | 不影响重载判断,即使返回值不同也可以构成重载 | | **访问修饰符** | 子方法的访问权限不能低于父方法的访问权限 | 对于重载无特殊要求 | | **抛出异常** | 抛出的异常范围不能大于父方法所声明的异常范围 | 对于重载无直接影响 | --- #### 三、代码示例 ##### 1. 方法重写(Override) 以下是方法重写的典型例子: ```java class Animal { public void sound() { System.out.println("Animal makes a sound"); } } class Dog extends Animal { @Override // 表明这是重写操作 public void sound() { System.out.println("Dog barks"); } } ``` 在这个例子中,`Dog` 重写了 `sound()` 方法,从而改变了行为逻辑[^2]。 ##### 2. 方法重载(Overload) 下面是方法重载的一个实例: ```java public class Calculator { public int add(int a, int b) { return a + b; } public double add(double a, double b) { return a + b; } public int add(int a, int b, int c) { return a + b + c; } } ``` 这里展示了如何在同一中通过调整参数列表来实现方法重载[^5]。 --- #### 四、使用场景分析 - **方法重写(Override)** - 当需要扩展定制父的行为时适用,比如子希望提供更加具体化的实现方式。 - 常见于框架开发中,例如 Java Swing Android 开发中的事件监听器回调函数重写[^4]。 - **方法重载(Overload)** - 提供灵活的操作入口,使程序能够根据不同输入执行相应动作。 - 如数学计算工具可能针对整型浮点型分别提供加法运算支持[^5]。 --- ### 总结 综上所述,虽然两者都涉及到了“方法”的再利用,但从本质上讲它们解决的问题完全不同——一个是关于继承体系下的动态绑定机制优化问题;另一个则是单一模块内的功能性增强手段探讨[^3]。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值