重载和覆盖重写

本文详细介绍了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
    }

}

八:重写的特点:

           1. 必须发生在子父类中

           2. 子父类中必须要有相同的方法名称,相同的参数列表及其顺序结构,返回值类型要一致

           3. 子类的修饰符必须要大于父类的参数名称

           4. 父类的修饰符不能为private修饰

           5. 当子类访问的方法或者成员变量不在子类当中时,便会向上寻找。  

### C++ 中重写重载覆盖的概念及用法 #### 函数重载 (Overloading) 函数重载是指在同一作用域内定义多个同名函数,只要参数列表不同即可。编译器会根据调用时传递的实际参数来决定具体调用哪个版本的函数。 ```cpp class Example { public: void func(int a); // 版本一 void func(double d, int b);// 版本二 }; ``` 注意,返回值类型不作为区分标准的一部分[^1]。 #### 成员函数覆盖 (Hiding) 成员函数覆盖发生在派生类中声明了一个与基类相同名称的方法,即使签名完全不同也会隐藏掉基类中的所有同名方法。如果希望访问被隐藏的方法,则需通过作用域解析运算符 `::` 明确指定要调用的是哪一个版本的方法。 ```cpp class Base { public: virtual void show() { cout << "Base class"; } }; class Derived : public Base { public: void show(int i) { cout << "Derived class with parameter"; } // 隐藏了show() }; ``` 这里需要注意,在子类中重新定义父类已有的非虚函数将会完全遮蔽原有实现,而不是扩展其功能[^3]。 #### 方法重写 (Override) 当一个派生类拥有与其基类相同的原型(即具有相同的形参表)的虚拟成员函数时,就构成了对该成员函数的重写。此时,派生于该类型的对象可以表现出不同的行为模式——这就是所谓的运行时期间动态绑定或多态性的体现之一。 ```cpp #include <iostream> using namespace std; class Animal { public: virtual void sound() const = 0; // 抽象类 }; class Dog : public Animal { public: void sound() const override { cout << "Woof!"; } // 重写了sound() }; ``` 上述例子展示了如何利用纯虚函数创建接口,并由具体的子类提供实际的行为逻辑[^2]。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值