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