java函数方法

1.方法重载

（1）源代码

// MethodOverload.java

// Using overloaded methods

public class MethodOverload {

public static void main(String[] args) {

System.out.println("The square of integer 7 is " + square(7));

System.out.println("\nThe square of double 7.5 is " + square(7.5));

}

public static int square(int x) {

return x * x;

}

public static double square(double y) {

return y * y;

}

}

（2）程序截图：

（3）分析结果，有什么特殊之处吗

这个程序展示了方法的重载，方法的名字相同，但是参数不一样，而且这两个方法都可以调用，互不影响，只是结果不一样。

满足重载的条件：

（1）方法名相同；

（2）参数类型不同，参数个数不同，或者是参数类型的顺序不同。

（3）还需要注意一点：

方法的返回值不作为方法重载的判断条件，和方法的参数有关。

在我们常用的函数方法中就有重载的，系统给出的，有好多就是只有参数不同，进行重载。

2. 使用计算机计算组合数：

内容要求（1）使用组合数公式利用n!来计算（2）使用递推的方法用杨辉三角形计算(3) 使用递归的方法用组合数递推公式计算

1）源代码

import java.util.Scanner;

//（1）使用组合数公式利用n!来计算（2）使用递推的方法用杨辉三角形计算(3) 使用递归的方法用组合数递推公式计算

public class suanfashu {

public static  void main(String args[])

{

System.out.println("组合数："+s1(8,5));

long s;

s=s2(8)/(s2(5)*s2(8-5));

System.out.println("组合数："+s);

}

static long s1(int n,int k)//第一种方法，用递推方法求组合数

{

long Cnn=1,Ckk=1,Cnk=1;

for(int i=1;i<=n;i++)

{

Cnn=Cnn*i;

}

for(int i=1;i<=k;i++)

{

Ckk=Ckk*i;

}

for(int i=1;i<=n-k;i++)

{

Cnk=Cnk*i;

}

return Cnn/(Ckk*Cnk);

}

static //第二种方法，递归

long s2(int n)

{

if(n==0||n==1)return 1;

return n*s2(n-1);

}

}

2）编译错误

利用递归方法是必须要有终结的条件，没有终结条件时就会报错，在写函数时必须要有static，不然就不能运行出来了，还有String args[]也必须要有，否则就不能找到函数main函数了，不能运行。

3）结论

递归就是“自己调用自己”，特点有他的递归是先从大到小，再从小到大；

每个步骤要干的事情都是类似的，只不过其规模“小一号”；必须要保持递归调用的过程可以终结，每个递归函数一定有一个控制递归可以终结的变量；

递推”是“从前到后”，先求第1项，然后，在此基础上求第2项，第3项，直至第n项，通常可以直接使用循环语句实现。

4）截图

5)设计思想

组合数求值，用到了递归和递推，用两个方法，分别表示这两种方法，之后在主方法中调用这两种方法，输出结果。

3.

(1)源代码

import java.math.BigInteger;

import java.util.Scanner;

public class CalculateN {

/**

* @param args

*/

public static void main(String[] args) {

System.out.print("请输入N：");

Scanner scanner=new Scanner(System.in);

int number=scanner.nextInt();

System.out.println(number+"!="+calculateN2(number));

}

public static long calculateN(int n) {

if(n==1 || n==0){

return 1;

}

return n*calculateN(n-1);

}

public static BigInteger calculateN2(int n) {

if(n==1 || n==0){

return BigInteger.valueOf(1);

}

return BigInteger.valueOf(n).multiply(calculateN2((n-1)));

}

}

（2）程序结果截图

（3）结果分析

结果是负数，本来应该是整数的，但是由于阶乘后结果太大，超出范围，所以就会出现乱码，可以用到大数来表示，这样就不会出现溢出的情况了。

public static BigInteger calculateN2(int n) {

if(n==1 || n==0){

return BigInteger.valueOf(1);

}

return BigInteger.valueOf(n).multiply(calculateN2((n-1)));

}

改后的截图：

不会有溢出了。

4.汉诺塔问题

(1)源程序

package demo;

//用递归方式编程解决汉诺塔问题。

//陈晓阳 2016.10.19

public class TowersOfHanoi

{

//递归的移动塔上的盘子

public static void solveTowers( int disks, int sourcePeg,

int destinationPeg, int tempPeg )

{

// base case -- only one disk to move

if ( disks == 1 )//只剩一个盘子就退出

{

System.out.printf( "\n%d --> %d", sourcePeg, destinationPeg );

return;//return空，去掉后就会出错

}

//将disks-1个盘子借用目标塔从起始塔移动到中间塔

solveTowers( disks - 1, sourcePeg, tempPeg, destinationPeg );

//destinationPeg是最终的塔；sourcePeg表示起始塔, tempPeg表示中间塔

// 输出结果，从开始点->终点

System.out.printf( "\n%d --> %d", sourcePeg, destinationPeg );

// 移动中间塔上的disks-1个到目标塔

solveTowers( disks - 1, tempPeg, destinationPeg, sourcePeg );

}

public static void main( String[] args )

{

int startPeg = 1; // 开始位置设为1

int endPeg = 3; //目标塔设为3

int tempPeg = 2; // 中间塔设为2

int totalDisks = 3; // 盘子的个数

// 调用递归方法

solveTowers( totalDisks, startPeg, endPeg, tempPeg );

} // end main

} // end class TowersOfHanoi

（2）设计思想

首先将起始塔上的n-1个盘子移到中间塔上，借助目标塔；然后再将第n个移到目标塔上，中间塔上的n-1个盘子移到目标塔上，借助起始塔。移动借助一个方法，将方法写成递归函数，递归调用。

（3）结果截图

(4)编译结果分析：

首先一定要分析清楚是怎样移动的，将这些步骤写成函数，递归调用；每一次移动一定要输出。理解起来容易，但是程序写起来确实不太好写，理解程序有一些难。

5.回文数

(1)源程序

package demo;

import javax.swing.JOptionPane;

public class Number {

public static void main(String args[])

{

int number=0,d5,d4,d3,d2,d1;

String str=JOptionPane.showInputDialog("输入一个1到99999之间的数");

number=Integer.parseInt(str);//取所输入的数

if(number>=1&&number<=99999)//判断number是否在1-99999之间

{

d5=number/10000;//表示万位

d4=number%10000/1000;//表示千位

d3=number%1000/100;//表示百位

d2=number%100/10;//表示十位

d1=number%10;//表示个位

if(d5>0)//判断是否是5位数，是的话就是否为回文数

{

System.out.println(number+"是5位数");

if(d5==d1&&d4==d2)

{

System.out.println(number+"是回文数");

}

else

{

System.out.println(number+"不是回文数");

}

}

else if(d4>0)//判断是否是四位数，如果是四位数就判断是否为回文数；否则就判断是否为三位数

{

System.out.println(number+"是4位数。");

if(d4==d1&&d3==d2)

{

System.out.println(number+"是回文数");

}

else

{

System.out.println(number+"不是回文数");

}

}

else if(d3>0)//判断是否是三位数，是三位数就判断是否是回文数，不是三位数就判断是否是两位数

{

System.out.println(number+"是3位数");

if(d3==d1)

{

System.out.println(number+"是回文数");

}

else

{

System.out.println(number+"不是回文数");

}

}

else if(d2>0)//判断是否是两位数，是的话就判断是否是回文数，不是就判断是否是一位数

{

System.out.println(number+"是2位数");

if(d2==d1)

{

System.out.println(number+"是回文数");

}

else

{

System.out.println(number+"不是回文数");

}

}

else if(d1!=0)

{

System.out.println(number+"是1位数");

System.out.println(number+"是回文数");

}

}

else

{

System.out.println(number+"不在1-99999之间");

}

}

}

(2)设计思想

输入一个数，判断是不是在1-99999之间，分别得到输入的数的各位上的数字，判断是几位数，接着判断是不是回文数，输出判断后的结果，要注意偶数位数和奇数位数不一样，偶数比较的是前一半和后一半，奇数比较的是前一半和后一半，中间剩下一个，不用比较。当是一位数时直接输出是回文数。

(3)结果截图