java 两个数字字符串相加 java两个string相加

转载

mob6454cc6dcf7f 2023-06-14 20:13:53

文章标签 java 两个数字字符串相加 java两个string相加 System Test 递归 文章分类 Java 后端开发

正文

一方法的基本使用

1.1 什么是方法

方法就是一个代码片段，类似 C 语言的“函数”。

1.2 方法定义语法

基本语法

// 方法定义
public static 方法返回值类型 方法名称(参数类型 形参 ...){
方法体代码;
return 返回值;
}
// 方法调用
返回值变量 = 方法名称(实参...);

// 方法定义
public static 方法返回值类型 方法名称(参数类型 形参 ...){
方法体代码;
return 返回值;
}
// 方法调用
返回值变量 = 方法名称(实参...);

例1：实现一个方法实现两个整数相加

class Test {
 public static void main(String[] args) {
  int a = 10;
  int b = 20;
  // 方法的调用
  int ret = add(a, b);
  System.out.println("ret = " + ret);
}
// 方法的定义
 public static int add(int x, int y) {
  return x + y;
 }
}
// 执行结果
ret = 30

class Test {
 public static void main(String[] args) {
  int a = 10;
  int b = 20;
  // 方法的调用
  int ret = add(a, b);
  System.out.println("ret = " + ret);
}
// 方法的定义
 public static int add(int x, int y) {
  return x + y;
 }
}
// 执行结果
ret = 30

注意：

public 和 static 两个关键字在此处具有特定含义, 我们暂时不讨论, 后面会详细介绍
方法定义时, 参数可以没有. 每个参数要指定类型
方法定义时, 返回值也可以没有, 如果没有返回值, 则返回值类型应写成 void
方法定义时的参数称为 "形参", 方法调用时的参数称为 "实参"。参数数量需要匹配。
方法的定义必须在类之中, 代码书写在调用位置的上方或者下方均可
Java 中没有 "函数声明" 这样的概念

例2：方法写在调用它的函数的上方或下方都是可以的

方法写在 main 函数上方

public class helloWorld{
   
 public static int addSum(int a, int b){
  
  return a + b;
 }
 
 public static void main(String[] args) {
  
  int a = 10, b = 20;
  int ret = addSum(a, b);
  System.out.println("sum = " + ret);
  
 }  
}

public class helloWorld{
   
 public static int addSum(int a, int b){
  
  return a + b;
 }
 
 public static void main(String[] args) {
  
  int a = 10, b = 20;
  int ret = addSum(a, b);
  System.out.println("sum = " + ret);
  
 }  
}

方法写在 main 函数下方

public class helloWorld{
   
 public static void main(String[] args) {
  
  int a = 10, b = 20;
  int ret = addSum(a, b);
  System.out.println("sum = " + ret);
  
 } 

 public static int addSum(int a, int b){
  
  return a + b;
 }
}

public class helloWorld{
   
 public static void main(String[] args) {
  
  int a = 10, b = 20;
  int ret = addSum(a, b);
  System.out.println("sum = " + ret);
  
 } 

 public static int addSum(int a, int b){
  
  return a + b;
 }
}

以上两种写法都是可以的。

练习：

写一个方法比较两个数的最大值
写一个方法比较三个数的最大值

参考答案：

class Test {
 public static void main(String[] args) {
  int a = 10;
  int b = 20;
  int c = 30;
  int max = threeNumMax(a, b, c);
  System.out.printf("Max = %d", max);
 }
 
 public static int threeNumMax(int x, int y, int z) {
  
  int max = twoNumMax(twoNumMax(x, y), z);
  //twoNumMax(a,b)返回 a，b 中的较大值，然后再次调用twoNumMax比较 这个较大值 与 c
  return max;
 }
 
 public static int twoNumMax(int x, int y) {
  return (x > y ? x : y);
 }
}

class Test {
 public static void main(String[] args) {
  int a = 10;
  int b = 20;
  int c = 30;
  int max = threeNumMax(a, b, c);
  System.out.printf("Max = %d", max);
 }
 
 public static int threeNumMax(int x, int y, int z) {
  
  int max = twoNumMax(twoNumMax(x, y), z);
  //twoNumMax(a,b)返回 a，b 中的较大值，然后再次调用twoNumMax比较 这个较大值 与 c
  return max;
 }
 
 public static int twoNumMax(int x, int y) {
  return (x > y ? x : y);
 }
}

1.3 方法调用的执行过程

基本规则

定义方法的时候, 不会执行方法的代码. 只有调用的时候才会执行
当方法被调用的时候, 会将实参赋值给形参
参数传递完毕后, 就会执行到方法体代码
当方法执行完毕之后(遇到 return 语句), 就执行完毕, 回到方法调用位置继续往下执行
一个方法可以被多次调用

class Test {
 public static void main(String[] args) {
  int a = 10;
  int b = 20;
  System.out.println("第一次调用方法之前");
  int ret = add(a, b);
  System.out.println("第一次调用方法之后");
  System.out.println("ret = " + ret);
  System.out.println("第二次调用方法之前");
  ret = add(30, 50);
  System.out.println("第二次调用方法之后");
  System.out.println("ret = " + ret);
}
 public static int add(int x, int y) {
  System.out.println("调用方法中 x = " + x + " y = " + y);
  return x + y;
}
}
// 执行结果
一次调用方法之前
调用方法中 x = 10 y = 20
第一次调用方法之后
ret = 30
第二次调用方法之前
调用方法中 x = 30 y = 50
第二次调用方法之后
ret = 80

class Test {
 public static void main(String[] args) {
  int a = 10;
  int b = 20;
  System.out.println("第一次调用方法之前");
  int ret = add(a, b);
  System.out.println("第一次调用方法之后");
  System.out.println("ret = " + ret);
  System.out.println("第二次调用方法之前");
  ret = add(30, 50);
  System.out.println("第二次调用方法之后");
  System.out.println("ret = " + ret);
}
 public static int add(int x, int y) {
  System.out.println("调用方法中 x = " + x + " y = " + y);
  return x + y;
}
}
// 执行结果
一次调用方法之前
调用方法中 x = 10 y = 20
第一次调用方法之后
ret = 30
第二次调用方法之前
调用方法中 x = 30 y = 50
第二次调用方法之后
ret = 80

例 3: 计算 1！+ 2！+ 3！+ 4！+ 5！

Class Test {
 public static void main(String[] args) {
  int sum = 0;
  for (int i = 1; i <= 5; i++) {
  sum += factor(i);
  }
  System.out.println("sum = " + sum);
 }
 public static int factor(int n) {
  System.out.println("计算 n 的阶乘中! n = " + n);
  int result = 1;
     for (int i = 1; i <= n; i++) {
  result *= i;
  }
  return result;
 }
}
// 执行结果
计算 n 的阶乘中! n = 1
计算 n 的阶乘中! n = 2
计算 n 的阶乘中! n = 3
计算 n 的阶乘中! n = 4
计算 n 的阶乘中! n = 5
sum = 153

Class Test {
 public static void main(String[] args) {
  int sum = 0;
  for (int i = 1; i <= 5; i++) {
  sum += factor(i);
  }
  System.out.println("sum = " + sum);
 }
 public static int factor(int n) {
  System.out.println("计算 n 的阶乘中! n = " + n);
  int result = 1;
     for (int i = 1; i <= n; i++) {
  result *= i;
  }
  return result;
 }
}
// 执行结果
计算 n 的阶乘中! n = 1
计算 n 的阶乘中! n = 2
计算 n 的阶乘中! n = 3
计算 n 的阶乘中! n = 4
计算 n 的阶乘中! n = 5
sum = 153

1.4 实参和形参的关系

例4：交换两个整型变量

class Test {
 public static void main(String[] args) {
  int a = 10;
  int b = 20;
  swap(a, b);
  System.out.println("a = " + a + " b = " + b);
 }
 public static void swap(int x, int y) {
  int tmp = x;
  x = y;
  y = tmp;
 }
}
// 运行结果
a = 10 b = 20

class Test {
 public static void main(String[] args) {
  int a = 10;
  int b = 20;
  swap(a, b);
  System.out.println("a = " + a + " b = " + b);
 }
 public static void swap(int x, int y) {
  int tmp = x;
  x = y;
  y = tmp;
 }
}
// 运行结果
a = 10 b = 20

分析

刚才的代码，没有完成数据的交换。

对于基础类型来说，形参相当于实参的拷贝，即 传值调用。

上面的代码相当于：

int a = 10;
int b = 20;

int x = a;
int y = b;
int tmp = x;
x = y;
y = tmp;

int a = 10;
int b = 20;

int x = a;
int y = b;
int tmp = x;
x = y;
y = tmp;

上面的方法实际上就是创建了 x，y 两个临时变量(形参)，将 a，b(实参)的值传给 x，y。然后创建临时变量 tmp 交换的是 x，y 的值。

解决办法： 传引用类型参数(后面会讲)

1.5 没有返回值的方法

方法的返回值是可选的，有些时候可以没有的。

代码示例

class Test {
 public static void main(String[] args) {
  int a = 10;
  int b = 20;
        //没有变量接收 print 方法的返回值，因为它没有返回值
  print(a, b);
 }
 public static void print(int x, int y) {
  System.out.println("x = " + x + " y = " + y);
 }
}

class Test {
 public static void main(String[] args) {
  int a = 10;
  int b = 20;
        //没有变量接收 print 方法的返回值，因为它没有返回值
  print(a, b);
 }
 public static void print(int x, int y) {
  System.out.println("x = " + x + " y = " + y);
 }
}

例5：没有返回值的方法可能是有“缺陷”的

没有返回值：

class Test {
 public static void main(String[] args) {
  int a = 10;
  int b = 20;
  addSum(a, b);
 }
 public static void addSum1(int x, int y) {
  System.out.println("a + b = "+ (x + y));
 }
}
//输出
a + b = 30

class Test {
 public static void main(String[] args) {
  int a = 10;
  int b = 20;
  addSum(a, b);
 }
 public static void addSum1(int x, int y) {
  System.out.println("a + b = "+ (x + y));
 }
}
//输出
a + b = 30

有返回值：

class Test {
 public static void main(String[] args) {
  int a = 10;
  int b = 20;
  int ret = addSum(a, b);
  System.out.printf("%d + %d = %d, 2 * (%d + %d) = %d", a, b, ret, a, b, 2*ret);
 }
 public static int addSum2(int x, int y) {
  return x + y;
 }
}
//输出：
10 + 20 = 30, 2 * (10 + 20) = 60

class Test {
 public static void main(String[] args) {
  int a = 10;
  int b = 20;
  int ret = addSum(a, b);
  System.out.printf("%d + %d = %d, 2 * (%d + %d) = %d", a, b, ret, a, b, 2*ret);
 }
 public static int addSum2(int x, int y) {
  return x + y;
 }
}
//输出：
10 + 20 = 30, 2 * (10 + 20) = 60

可以看到，对于没有返回值的方法来说，addSum1 仅仅是讲参数相加然后输出而已；而 addSum2 将计算结果返回， main 函数拿到了计算结果，可以做更多的操作(比如示例种的运算)，当然也可以输出。

void 类型的函数可以 return 吗？

class Test {
 public static void main(String[] args) {
 testVoidReturn();
}
 public static void testVoidReturn(){
  return;
  System.out.println("return 是没有什么用的！");
 }
}
//编译报错：
Test.java:9: 错误: 无法访问的语句
                System.out.println("return 是没有什么用的！");
                ^
1 个错误

class Test {
 public static void main(String[] args) {
 testVoidReturn();
}
 public static void testVoidReturn(){
  return;
  System.out.println("return 是没有什么用的！");
 }
}
//编译报错：
Test.java:9: 错误: 无法访问的语句
                System.out.println("return 是没有什么用的！");
                ^
1 个错误

二方法的重载

有些时候我们需要用一个函数同时兼容多种参数的情况，我们就可以使用到方法重载。

2.1 方法重载要解决的问题

class Test {
 public static void main(String[] args) {
  int a = 10;
  int b = 20;
  int ret = add(a, b);
  System.out.println("ret = " + ret);
  double a2 = 10.5;
  double b2 = 20.5;
  double ret2 = add(a2, b2);
  System.out.println("ret2 = " + ret2);
 }
 public static int add(int x, int y) {
  return x + y;
 }
}
// 编译出错
Test.java:13: 错误: 不兼容的类型: 从double转换到int可能会有损失
double ret2 = add(a2, b2);
     ^

class Test {
 public static void main(String[] args) {
  int a = 10;
  int b = 20;
  int ret = add(a, b);
  System.out.println("ret = " + ret);
  double a2 = 10.5;
  double b2 = 20.5;
  double ret2 = add(a2, b2);
  System.out.println("ret2 = " + ret2);
 }
 public static int add(int x, int y) {
  return x + y;
 }
}
// 编译出错
Test.java:13: 错误: 不兼容的类型: 从double转换到int可能会有损失
double ret2 = add(a2, b2);
     ^

由于参数类型不匹配, 所以不能直接使用现有的 add 方法。

2.2 使用重载

对于上面的问题，下面这种方法是否可行？

class Test {
 public static void main(String[] args) {
  int a = 10;
  int b = 20;
  int ret = addInt(a, b);
  System.out.println("ret = " + ret);
  double a2 = 10.5;
  double b2 = 20.5;
  double ret2 = addDouble(a2, b2);
  System.out.println("ret2 = " + ret2);
 }
 public static int addInt(int x, int y) {
  return x + y;
 }
 public static double addDouble(double x, double y) {
  return x + y;
 }
}

class Test {
 public static void main(String[] args) {
  int a = 10;
  int b = 20;
  int ret = addInt(a, b);
  System.out.println("ret = " + ret);
  double a2 = 10.5;
  double b2 = 20.5;
  double ret2 = addDouble(a2, b2);
  System.out.println("ret2 = " + ret2);
 }
 public static int addInt(int x, int y) {
  return x + y;
 }
 public static double addDouble(double x, double y) {
  return x + y;
 }
}

重新命名一个新的方法来实现对不同类型的变量的相加。但是 Java 是支持方法重载的。我们一般使用下面的方式：

class Test {
 public static void main(String[] args) {
  int a = 10;
  int b = 20;
  int ret = add(a, b);
  System.out.println("ret = " + ret);
  double a2 = 10.5;
  double b2 = 20.5;
  double ret2 = add(a2, b2);
  System.out.println("ret2 = " + ret2);
  double a3 = 10.5;
  double b3 = 10.5;
  double c3 = 20.5;
  double ret3 = add(a3, b3, c3);
  System.out.println("ret3 = " + ret3);
}
 public static int add(int x, int y) {
  return x + y;
 }
 public static double add(double x, double y) {
  return x + y;
 }
 public static double add(double x, double y, double z) {
  return x + y + z;
 }
 
}

class Test {
 public static void main(String[] args) {
  int a = 10;
  int b = 20;
  int ret = add(a, b);
  System.out.println("ret = " + ret);
  double a2 = 10.5;
  double b2 = 20.5;
  double ret2 = add(a2, b2);
  System.out.println("ret2 = " + ret2);
  double a3 = 10.5;
  double b3 = 10.5;
  double c3 = 20.5;
  double ret3 = add(a3, b3, c3);
  System.out.println("ret3 = " + ret3);
}
 public static int add(int x, int y) {
  return x + y;
 }
 public static double add(double x, double y) {
  return x + y;
 }
 public static double add(double x, double y, double z) {
  return x + y + z;
 }
 
}

方法的名字都叫 add. 但是有的 add 是计算 int 相加, 有的是 double 相加; 有的计算两个数字相加, 有的是计算三个数字相加. 同一个方法名字, 提供不同版本的实现, 称为 方法重载

2.3 方法重载的规则

针对同一个类:
方法名相同
方法的参数不同(参数个数或者参数类型)
方法的返回值类型不影响重载(与 C++ 不同)

class Test {
 public static void main(String[] args) {
  int a = 10;
  int b = 20;
  int ret = add(a, b);
  System.out.println("ret = " + ret);
 }
 public static int add(int x, int y) {
  return x + y;
 }
 public static double add(int x, int y) {
  return x + y;
 }
}
// 编译出错
Test.java:13: 错误: 已在类 Test中定义了方法 add(int,int)
public static double add(int x, int y) {
       ^
1 个错误

class Test {
 public static void main(String[] args) {
  int a = 10;
  int b = 20;
  int ret = add(a, b);
  System.out.println("ret = " + ret);
 }
 public static int add(int x, int y) {
  return x + y;
 }
 public static double add(int x, int y) {
  return x + y;
 }
}
// 编译出错
Test.java:13: 错误: 已在类 Test中定义了方法 add(int,int)
public static double add(int x, int y) {
       ^
1 个错误

当两个方法的名字相同，参数也相同，但是返回值不同的时候，不构成重载。

三方法递归

3.1 递归的概念

一个方法在执行过程中调用自身，就称为 "递归。

public static void main(String[] args) {
 int n = 5;
 int ret = factor(n);
 System.out.println("ret = " + ret);
}
 public static int factor(int n) {
  if (n == 1) {
   return 1;
  }
  return n * factor(n - 1); // factor 调用函数自身
}
// 执行结果
ret = 120

public static void main(String[] args) {
 int n = 5;
 int ret = factor(n);
 System.out.println("ret = " + ret);
}
 public static int factor(int n) {
  if (n == 1) {
   return 1;
  }
  return n * factor(n - 1); // factor 调用函数自身
}
// 执行结果
ret = 120

3.2 递归执行过程

public static void main(String[] args) {
 int n = 5;
 int ret = factor(n);
 System.out.println("ret = " + ret);
}
public static int factor(int n) {
 System.out.println("函数开始, n = " + n);
 if (n == 1) {
  System.out.println("函数结束, n = 1 ret = 1");
 return 1;
}
 int ret = n * factor(n - 1);
 System.out.println("函数结束, n = " + n + " ret = " + ret);
 return ret;
}
// 执行结果
函数开始, n = 5
函数开始, n = 4
函数开始, n = 3
函数开始, n = 2
函数开始, n = 1
函数结束, n = 1 ret = 1
函数结束, n = 2 ret = 2
函数结束, n = 3 ret = 6
函数结束, n = 4 ret = 24
函数结束, n = 5 ret = 120
ret = 120

public static void main(String[] args) {
 int n = 5;
 int ret = factor(n);
 System.out.println("ret = " + ret);
}
public static int factor(int n) {
 System.out.println("函数开始, n = " + n);
 if (n == 1) {
  System.out.println("函数结束, n = 1 ret = 1");
 return 1;
}
 int ret = n * factor(n - 1);
 System.out.println("函数结束, n = " + n + " ret = " + ret);
 return ret;
}
// 执行结果
函数开始, n = 5
函数开始, n = 4
函数开始, n = 3
函数开始, n = 2
函数开始, n = 1
函数结束, n = 1 ret = 1
函数结束, n = 2 ret = 2
函数结束, n = 3 ret = 6
函数结束, n = 4 ret = 24
函数结束, n = 5 ret = 120
ret = 120

关于 "调用栈" 方法调用的时候, 会有一个 "栈" 这样的内存空间描述当前的调用关系，称为调用栈。每一次的方法调用就称为一个 "栈帧"，每个栈帧中包含了这次调用的参数是哪些，返回到哪里继续执行等信息。后面我们借助 IDEA 很容易看到调用栈的内容。

3.3 递归练习

1. 按顺序打印一个数字的每一位

(例如 1234 打印出 1 2 3 4)

方法1：

public static void printEveryDigit(int num){
  
  if(num / 10 == 0){
   System.out.print(num);
  }
  else{
   printEveryDigit(num / 10);
   System.out.print(" " + num % 10);
  }
 }
}

 public static void printEveryDigit(int num){
  
  if(num / 10 == 0){
   System.out.print(num);
  }
  else{
   printEveryDigit(num / 10);
   System.out.print(" " + num % 10);
  }
 }
}

方法2：

public static void print(int num) {
  if (num > 9) {
   print(num / 10);
  }
  System.out.println(num % 10);
 }

public static void print(int num) {
  if (num > 9) {
   print(num / 10);
  }
  System.out.println(num % 10);
 }

2.递归求 1 + 2 + 3 + ... + 10

class Test {
    
 public static void main(String[] args) {
  Scanner scan = new Scanner(System.in);
  int num = scan.nextInt();
  int sum = printSum(num);
  System.out.println(sum);
}
 public static int printSum(int num) {
  if(num == 1){
   return 1;
  }
  return num + printSum(num - 1); 
 }
}

class Test {
    
 public static void main(String[] args) {
  Scanner scan = new Scanner(System.in);
  int num = scan.nextInt();
  int sum = printSum(num);
  System.out.println(sum);
}
 public static int printSum(int num) {
  if(num == 1){
   return 1;
  }
  return num + printSum(num - 1); 
 }
}

3.写一个递归方法，输入一个非负整数，返回组成它的数字之和. 例如，输入 1729, 则应该返回1+7+2+9，它的和是19

class Test {
 public static void main(String[] args) {
 Scanner scan = new Scanner(System.in);
 int num = scan.nextInt();
 int sum = printSumOfDigit(num);
 System.out.println(sum);
}
 public static int printSumOfDigit(int num) {
  if(num > 9){
   return (num % 10) + printSumOfDigit(num / 10);
  }
  return num; 
 }
}

class Test {
 public static void main(String[] args) {
 Scanner scan = new Scanner(System.in);
 int num = scan.nextInt();
 int sum = printSumOfDigit(num);
 System.out.println(sum);
}
 public static int printSumOfDigit(int num) {
  if(num > 9){
   return (num % 10) + printSumOfDigit(num / 10);
  }
  return num; 
 }
}

4. 求斐波那契数列的第 N 项

public static int Fib(int n) {
  if(n == 1 || n == 2){
   return 1;
  }
  return Fib(n - 1) + Fib(n - 2);
}

public static int Fib(int n) {
  if(n == 1 || n == 2){
   return 1;
  }
  return Fib(n - 1) + Fib(n - 2);
}

3.4 递归小结

递归是一种重要的编程解决问题的方式.
有些问题天然就是使用递归方式定义的(例如斐波那契数列, 二叉树等), 此时使用递归来解就很容易.
有些问题使用递归和使用非递归(循环)都可以解决. 那么此时更推荐使用循环, 相比于递归, 非递归程序更加高效.

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。

上一篇：java过滤javascript Java过滤器的运行原理

下一篇：java中和的优先级 java中&&和||优先级

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯