重载和覆盖重写

最新推荐文章于 2022-08-15 18:07:38 发布

原创最新推荐文章于 2022-08-15 18:07:38 发布 · 624 阅读

3 ·

CC 4.0 BY-SA版权

文章标签：

#java #重载 #重写

java基础专栏收录该内容

8 篇文章

订阅专栏

本文详细介绍了Java中的重载和重写概念。重载发生在同一类中，方法名相同但参数列表不同，常用于构造器重载，提供便利。而重写发生在子父类之间，要求方法名、返回值类型和参数列表一致，但子类的访问修饰符需更开放。通过实例展示了重载和重写的应用和特点。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一. 什么是重载：

重载即在同一个类中，方法名称相同，参数列表不同（参数列表的顺序不同或者参数列表的个数不同）的方法，称为重载。

二. 重载的例子：构造器的重载

public class OverloadDemo {
    private String name;
    private int age;
    private double score;

    public OverloadDemo() {
        System.out.println("无参构造器");
    }

    public OverloadDemo(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("两个参数的构造器");
    }

    public OverloadDemo(String name, int age, double score) {
        this.name = name;
        this.age = age;
        this.score = score;
        System.out.println("三个参数的构造器");
    }

    public static void main(String[] args) {
        /**
         * 通过构造器的重载，可以根据实际情况来选择对应的构造器创建对象并初始化数据。
         */
       OverloadDemo demo = new OverloadDemo();  //调用无参构造器
       OverloadDemo demo1 = new OverloadDemo("张三",23);  //调用两个参数的构造器
       OverloadDemo demo2 = new OverloadDemo("张三",23,100);  //调用三个参数的构造器
    }
}

三. 重载的优点：

1. 方法重载可以定义相同的方法名，方便阅读。

2. 优化程序，使得编写代码更少。

四. 重载的特点：

1. 方法重载必须要在同一个类中。

2. 重载必须方法名相同，参数不同（即参数的列表不同，参数的顺序不一致，与参数的名称无关）

3. 与修饰符和返回值类型无关。

五. 重载的一个小练习：

public class OverloadDemo {
    public static byte num =9;
    public static char index = '9';

    public static void show(byte num){
        System.out.println("byte:"+num);
    }
    public static void show(short num){
        System.out.println("short"+num);
    }
    public static void show(char num){
        System.out.println("char："+num);
    }
    public static void show(Byte num){
        System.out.println("int:"+num);
    }
    public static void show(Character num){
        System.out.println("Character:"+num);
    }
    public static void show(Integer num){
        System.out.println("int:"+num);
    }

    public static void main(String[] args) {
        show(num);    
        show(index);
    }

}

输出结果：

char类型遵循的结果为：char-->int-->long-->float-->double-->Character(跟自己类型匹配的包装类型)

基本数据类型遵循的结果： byte-->short-->int-->long-->float-->double-->(跟自己类型匹配的包装类型（自动装箱）)

比如说：把byte传参的方法注释掉,则会输出short9;其他同理

把所有的原始数据类型传参的方法注释掉，唯独留下char、Character、Integer传参的方法，在传一个字符的数据，打印的结果cahr:57,接着再注释上次打印所属的方法。再次打印得，Character：9,同上一步，最后报错。

六. 重写的概述：

重写是指在子类和父类中具有相同的方法名称，相同的返回值类型和参数列表，方法体可以不一样。

七. 重写的例子（继承中）：

1. 创建Father类：

public class Father {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void mehtod(){
        System.out.println("父类的method方法");
    }

    int message(int age){
        System.out.println("父类的年龄："+age);
        return age;
    }
}

2. 创建Son类继承Father类：

public class Son extends Father {
    // 注意成员的属性不能被覆盖重写
    //@Override   会报错  
    private String name;
    private int age;

    public Son(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public void mehtod() {
        System.out.println("子类的method方法");
    }

    @Override
    //子类的修饰符大于父类的修饰符
    public int message(int age) {
        System.out.println("子类的年龄："+age);
        return age;
    }
}

3. 测试方法：

public class TestMain {
    public static void main(String[] args) {
        Son son = new Son("tom",16);
        son.mehtod();   //输出 子类的method方法 （父类的方法被覆盖重写）
        son.message(16);  //输出 子类的年龄：16
    }

}