Java方法重载代码示例

于 2024-03-25 21:36:47 发布
阅读量1.2k 收藏 7
点赞数 29
文章标签： java 前端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/2301_80284166/article/details/137023515
版权
本文详细介绍了Java中的方法重载和父子类继承中的方法重写概念，通过计算器类的代码示例，展示了如何在继承结构中使用方法重载，以及如何处理不同类型参数的计算。

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

1.简单介绍

方法重载和父子继承方法重写有着较大的区别。

父子类继承中方法重写，方法重写是子类重新定义了父类中已经存在的方法，方法名、参数列表和返回类型必须要与父类相同。

而方法重载则不同，方法重载是在同一个类里定义了多个方法名相同的方法，它们的参数数量、参数类型或返回类型是不同的，它会根据我们输入的参数而取匹配一个合适的方法进行操作，这就展现了方法重载代码的可读性和灵活性。

2.代码示例

我们以模拟计算器为例给大家做分析。

我们先写一个计算器类(Caculator):

package Calculator;

import Calculator.add.Add;
import Calculator.div.Div;
import Calculator.mul.Mul;
import Calculator.sub.Sub;

public class Calculator {
    public String operator;
    public String num1;
    public String num2;
    public  Calculator( String num1, String operator, String num2) {
        this.num1 = num1;
        this.operator = operator;
        this.num2 = num2;
    }
    public void getResult() {
        switch (operator) {
            case "+" -> {
                Add a = new Add(num1, operator, num2);
                try {
                    int n1 = Integer.parseInt(num1);
                    try {
                        int n2 = Integer.parseInt(num2);
                        System.out.println(num1 + operator + num2 + "=" + a.add(n1, n2));
                    } catch (NumberFormatException e) {
                        double n2 = Double.parseDouble(num2);
                        System.out.println(num1 + operator + num2 + "=" + a.add(n1, n2));
                    }
                } catch (NumberFormatException e) {
                    double n1 = Double.parseDouble(num1);
                    try {
                        int n2 = Integer.parseInt(num2);
                        System.out.println(num1 + operator + num2 + "=" + a.add(n1, n2));
                    } catch (NumberFormatException e1) {
                        double n2 = Double.parseDouble(num2);
                        System.out.println(num1 + operator + num2 + "=" + a.add(n1, n2));
                    }
                }
            }
            case "-" -> {
                Sub s = new Sub(num1, operator, num2);
                try {
                    int n1 = Integer.parseInt(num1);
                    try {
                        int n2 = Integer.parseInt(num2);
                        System.out.println(num1 + operator + num2 + "=" + s.sub(n1, n2));
                    } catch (NumberFormatException e) {
                        double n2 = Double.parseDouble(num2);
                        System.out.println(num1 + operator + num2 + "=" + s.sub(n1, n2));
                    }
                } catch (NumberFormatException e) {
                    double n1 = Double.parseDouble(num1);
                    try {
                        int n2 = Integer.parseInt(num2);
                        System.out.println(num1 + operator + num2 + "=" + s.sub(n1, n2));
                    } catch (NumberFormatException e1) {
                        double n2 = Double.parseDouble(num2);
                        System.out.println(num1 + operator + num2 + "=" + s.sub(n1, n2));
                    }
                }
            }
            case "/" -> {
                Div d = new Div(num1, operator, num2);
                try {
                    int n1 = Integer.parseInt(num1);
                    try {
                        int n2 = Integer.parseInt(num2);
                        System.out.println(num1 + operator + num2 + "=" + d.div(n1, n2));
                    } catch (NumberFormatException e) {
                        double n2 = Double.parseDouble(num2);
                        System.out.println(num1 + operator + num2 + "=" + d.div(n1, n2));
                    }
                } catch (NumberFormatException e) {
                    double n1 = Double.parseDouble(num1);
                    try {
                        int n2 = Integer.parseInt(num2);
                        System.out.println(num1 + operator + num2 + "=" + d.div(n1, n2));
                    } catch (NumberFormatException e1) {
                        double n2 = Double.parseDouble(num2);
                        System.out.println(num1 + operator + num2 + "=" + d.div(n1, n2));
                    }
                }
            }
            case "*" -> {
                Mul m = new Mul(num1, operator, num2);
                try {
                    int n1 = Integer.parseInt(num1);
                    try {
                        int n2 = Integer.parseInt(num2);
                        System.out.println(num1 + operator + num2 + "=" + m.mul(n1, n2));
                    } catch (NumberFormatException e) {
                        double n2 = Double.parseDouble(num2);
                        System.out.println(num1 + operator + num2 + "=" + m.mul(n1, n2));
                    }
                } catch (NumberFormatException e) {
                    double n1 = Double.parseDouble(num1);
                    try {
                        int n2 = Integer.parseInt(num2);
                        System.out.println(num1 + operator + num2 + "=" + m.mul(n1, n2));
                    } catch (NumberFormatException e1) {
                        double n2 = Double.parseDouble(num2);
                        System.out.println(num1 + operator + num2 + "=" + m.mul(n1, n2));
                    }
                }
            }
            default -> System.out.println("输入有问题");
        }
    }
}

这里我解释一下这一部分代码：

Add a = new Add(num1, operator, num2);
                try {
                    int n1 = Integer.parseInt(num1);
                    try {
                        int n2 = Integer.parseInt(num2);
                        System.out.println(num1 + operator + num2 + "=" + a.add(n1, n2));
                    } catch (NumberFormatException e) {
                        double n2 = Double.parseDouble(num2);
                        System.out.println(num1 + operator + num2 + "=" + a.add(n1, n2));
                    }
                } catch (NumberFormatException e) {
                    double n1 = Double.parseDouble(num1);
                    try {
                        int n2 = Integer.parseInt(num2);
                        System.out.println(num1 + operator + num2 + "=" + a.add(n1, n2));
                    } catch (NumberFormatException e1) {
                        double n2 = Double.parseDouble(num2);
                        System.out.println(num1 + operator + num2 + "=" + a.add(n1, n2));
                    }
                }

因为用户是不需要考虑到一定要输入什么类型，只需要根据用户自己的要求输入，所以一开始这里我们是不知道用户会输入什么，所以我们开始会用字符串去存储数字，后面我们使用异常处理关键字(try)去嵌套判断用户到底输入的是何种类型，然后再进行计算。

 

在父类计算器(Caculator)的基础上，我们可以创建四个子类，分别为加法(Add)、减法(Sub)、乘法(Mul)、除法(Div)，在这些子类中进行方法重载。

加法类(Add):

package Calculator.add;

import Calculator.Calculator;

public class Add extends Calculator {
    public Add(String num1, String operator, String num2) {
        super(num1, operator, num2);
    }

    public int add(int a, int b) {
        return a + b;
    }
    public Double add( int a, double b) {
        return a + b;
    }
    public Double add( double a, int b) {
        return a + b;
    }
    public Double add( double a, double b) {
        return a + b;
    }
}

减法类(Sub):

package Calculator.sub;

import Calculator.Calculator;

public class Sub extends Calculator {
    public Sub(String num1, String operator, String num2) {
        super(num1, operator, num2);
    }

    public int sub(int a, int b) {
        return a - b;
    }
    public Double sub( int a, double b) {
        return a - b;
    }
    public Double sub( double a, int b) {
        return a - b;
    }
    public Double sub( double a, double b) {
        return a - b;
    }
}

乘法类(Mul):

package Calculator.mul;

import Calculator.Calculator;

public class Mul extends Calculator {
    public Mul(String num1, String operator, String num2) {
        super(num1, operator, num2);
    }

    public int mul(int a, int b) {
        return a * b;
    }
    public Double mul( int a, double b) {
        return a * b;
    }
    public Double mul( double a, int b) {
        return a * b;
    }
    public Double mul( double a, double b) {
        return a * b;
    }
}

除法类(Div):

package Calculator.div;

import Calculator.Calculator;

public class Div extends Calculator {
    public Div(String num1, String operator, String num2) {
        super(num1, operator, num2);
    }

    public int div(int a, int b) {
        return a / b;
    }
    public Double div( int a, double b) {
        return a / b;
    }
    public Double div( double a, int b) {
        return a / b;
    }
    public Double div( double a, double b) {
        return a / b;
    }
}

我们可以看到在每一个子类中，都有方法名相同的方法，但是它们都些不同，要不是返回类型不同，就是参数列表不同，而在我们调用时则直接根据方法名去调用即可，它们会根据我们传入的参数来计算及决定返回类型。

注意:我在写实现计算器代码时是分了多个包去存储代码的，这样会更加清晰和规范

 

3.代码综合

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        String num1 = s.next();
        String operator = s.next();
        String num2 = s.next();
        Calculator c = new Calculator( num1, operator, num2);
        c.getResult();
    }
}

class Calculator {
    public String operator;
    public String num1;
    public String num2;
    public  Calculator( String num1, String operator, String num2) {
        this.num1 = num1;
        this.operator = operator;
        this.num2 = num2;
    }
    public void getResult() {
        switch (operator) {
            case "+" -> {
                Add a = new Add(num1, operator, num2);
                try {
                    int n1 = Integer.parseInt(num1);
                    try {
                        int n2 = Integer.parseInt(num2);
                        System.out.println(num1 + operator + num2 + "=" + a.add(n1, n2));
                    } catch (NumberFormatException e) {
                        double n2 = Double.parseDouble(num2);
                        System.out.println(num1 + operator + num2 + "=" + a.add(n1, n2));
                    }
                } catch (NumberFormatException e) {
                    double n1 = Double.parseDouble(num1);
                    try {
                        int n2 = Integer.parseInt(num2);
                        System.out.println(num1 + operator + num2 + "=" + a.add(n1, n2));
                    } catch (NumberFormatException e1) {
                        double n2 = Double.parseDouble(num2);
                        System.out.println(num1 + operator + num2 + "=" + a.add(n1, n2));
                    }
                }
            }
            case "-" -> {
                Sub s = new Sub(num1, operator, num2);
                try {
                    int n1 = Integer.parseInt(num1);
                    try {
                        int n2 = Integer.parseInt(num2);
                        System.out.println(num1 + operator + num2 + "=" + s.sub(n1, n2));
                    } catch (NumberFormatException e) {
                        double n2 = Double.parseDouble(num2);
                        System.out.println(num1 + operator + num2 + "=" + s.sub(n1, n2));
                    }
                } catch (NumberFormatException e) {
                    double n1 = Double.parseDouble(num1);
                    try {
                        int n2 = Integer.parseInt(num2);
                        System.out.println(num1 + operator + num2 + "=" + s.sub(n1, n2));
                    } catch (NumberFormatException e1) {
                        double n2 = Double.parseDouble(num2);
                        System.out.println(num1 + operator + num2 + "=" + s.sub(n1, n2));
                    }
                }
            }
            case "/" -> {
                Div d = new Div(num1, operator, num2);
                try {
                    int n1 = Integer.parseInt(num1);
                    try {
                        int n2 = Integer.parseInt(num2);
                        System.out.println(num1 + operator + num2 + "=" + d.div(n1, n2));
                    } catch (NumberFormatException e) {
                        double n2 = Double.parseDouble(num2);
                        System.out.println(num1 + operator + num2 + "=" + d.div(n1, n2));
                    }
                } catch (NumberFormatException e) {
                    double n1 = Double.parseDouble(num1);
                    try {
                        int n2 = Integer.parseInt(num2);
                        System.out.println(num1 + operator + num2 + "=" + d.div(n1, n2));
                    } catch (NumberFormatException e1) {
                        double n2 = Double.parseDouble(num2);
                        System.out.println(num1 + operator + num2 + "=" + d.div(n1, n2));
                    }
                }
            }
            case "*" -> {
                Mul m = new Mul(num1, operator, num2);
                try {
                    int n1 = Integer.parseInt(num1);
                    try {
                        int n2 = Integer.parseInt(num2);
                        System.out.println(num1 + operator + num2 + "=" + m.mul(n1, n2));
                    } catch (NumberFormatException e) {
                        double n2 = Double.parseDouble(num2);
                        System.out.println(num1 + operator + num2 + "=" + m.mul(n1, n2));
                    }
                } catch (NumberFormatException e) {
                    double n1 = Double.parseDouble(num1);
                    try {
                        int n2 = Integer.parseInt(num2);
                        System.out.println(num1 + operator + num2 + "=" + m.mul(n1, n2));
                    } catch (NumberFormatException e1) {
                        double n2 = Double.parseDouble(num2);
                        System.out.println(num1 + operator + num2 + "=" + m.mul(n1, n2));
                    }
                }
            }
            default -> System.out.println("输入有问题");
        }
    }
}

class Add extends Calculator {
    public Add(String num1, String operator, String num2) {
        super(num1, operator, num2);
    }

    public int add(int a, int b) {
        return a + b;
    }
    public Double add( int a, double b) {
        return a + b;
    }
    public Double add( double a, int b) {
        return a + b;
    }
    public Double add( double a, double b) {
        return a + b;
    }
}

class Sub extends Calculator {
    public Sub(String num1, String operator, String num2) {
        super(num1, operator, num2);
    }

    public int sub(int a, int b) {
        return a - b;
    }
    public Double sub( int a, double b) {
        return a - b;
    }
    public Double sub( double a, int b) {
        return a - b;
    }
    public Double sub( double a, double b) {
        return a - b;
    }
}

class Mul extends Calculator {
    public Mul(String num1, String operator, String num2) {
        super(num1, operator, num2);
    }

    public int mul(int a, int b) {
        return a * b;
    }
    public Double mul( int a, double b) {
        return a * b;
    }
    public Double mul( double a, int b) {
        return a * b;
    }
    public Double mul( double a, double b) {
        return a * b;
    }
}

class Div extends Calculator {
    public Div(String num1, String operator, String num2) {
        super(num1, operator, num2);
    }

    public int div(int a, int b) {
        return a / b;
    }
    public Double div( int a, double b) {
        return a / b;
    }
    public Double div( double a, int b) {
        return a / b;
    }
    public Double div( double a, double b) {
        return a / b;
    }
}

这里我把整个代码放在一起了 。

 

努力的码
关注
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值