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)结果截图