1、定义：
在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或参数类型不同即可。
“两同一不同” ：
同一个类、相同方法名
参数列表不同：参数个数，参数类型不同
2、举例：
Array类中重载的sort() / binarySearch()
3、判断是否是重载：
跟方法的权限修饰符、返回值类型、形参变量名、方法体都没有关系！
4、在通过对象调用方法时，如何确定某一个指定的方法：
方法名 --->参数列表
5、代码举例
public class OverLoadTest {
public static void main(String[] args) {
OverLoadTest test = new OverLoadTest();
test.getSum(1,2);
}
//如下的4个方法构成了重载
public void getSum(int i,int j){
System.out.println("1");
}
public void getSum(double b1,double b2){
System.out.println("2");
}
public void getSum(String s,int i){
System.out.println("3");
}
public void getSum(int i,String s){
System.out.println("4");
}
//不构成
// public int getSum(int i,int j){
// return 0;
// }
//
// public void getSum(int m,int n){
//
// }
}
6、练习
1.编写程序：定义三个重载方法并调用。方法名为mOl。
三个方法分别接受一个int参数，两个int参数、一个字符串参数。
分别执行平方运算并输出结果，相乘并输出结果，输出字符串信息。
在主类的main()方法中分别用参数区别调用三个方法。
//1.如下的三个方法构成重载
public void mOL(int i){
System.out.println(i * i);
}
public void mOL(int i,int j){
System.out.println(i * j);
}
public void mOL(String s){
System.out.println(s);
}
2.定义三个重载方法max().
第一个方法求两个int值中的最大值，
第二个方法求两个double值中的最大值，
第三个方法求三个double值中的最大值，
并调用三个方法。
//2.如下的三个方法构成重载
public int max(int i,int j){
return (i > j)? i : j;
}
public double max(double d1,double d2){
return (d1 > d2)? d1 : d2;
}
public double max(double d1,double d2,double d3){
double max = (d1 > d2)? d1 : d2;
return (max > d3)? max : d3;
}
二、可变参数的方法
1.jdk 5.0 新增的内容
2.具体使用：
2.1 可变个数参数的格式：数据类型...变量名
2.2 当调用可变个数形参的方法，传入的参数个数可以是：0个，1个，2个 ......
2.3 可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载
2.4 可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载。换句话说，二者不能共存。
2.5 可变个数形参在方法的形参中，必须声明在末尾
2.6 可变个数形参在方法的形参中，最多只能声明一个可变形参。
代码演示：
public class MethodArgsTest {
public static void main(String[] args) {
MethodArgsTest test = new MethodArgsTest();
test.show(12);
// test.show("hello");
// test.show("hello","world");
// test.show();
test.show("AA","BB","CC");
}
public void show(int i){
}
public void show(String i){
System.out.println("show(String)");
}
public void show(String ... strs){
System.out.println("show(String ... strs)");
for (int i = 0;i < strs.length;i++){
System.out.println(strs[i]);
}
}
//在jdk 5.0 之前如果需要传入多个参数，用下面数组的方式
// public void show(String[] strs){
//
// }
//报错（见2.6）：The variable argument type String of the method show must be the last parameter
// public void show(String ... strs,int i){
//
// }
}
三、关于变量的赋值
如果变量是基本数据类型，此时赋值的是变量所保存的数据集。
如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值。
代码演示：
public class ValueTransferTest {
public static void main(String[] args) {
System.out.println("*************基本数据类型：**************");
int m = 10;
int n = m;
System.out.println("m = " + m + ", n = " + n);
n = 20;
System.out.println("m = " + m + ", n = " + n);
System.out.println("*************引用数据类型：**************");
Order o1 = new Order();
o1.orderId = 1001;
Order o2 = o1;//赋值以后，o1和o2的地址值相同，都指向了堆空间中同一个对象实体。
System.out.println("o1.orderId = " + o1.orderId + "o2.orderId" + o2.orderId);
o2.orderId = 1002;
System.out.println("o1.orderId = " + o1.orderId + "o2.orderId" + o2.orderId);
}
}
class Order{
int orderId;
}
运行结果：
四、方法的形参的传递机制：值传递1.形参：方法定义时，声明的小括号内的参数
实参：方法调用时，实际传递给形参的数据
2.值传递机制：
如果参数是基本数据类型，此时实参赋给形参的是实参真实存储的数据值。
如果参数是引用数据类型，此时实参赋给形参的是实参存储数据的地址值。
针对基本数据类型：代码演示：
public class ValueTransferTest1 {
public static void main(String[] args) {
int m = 10;
int n = 20;
System.out.println("m = " + m + ", n = " + n);
//交换两个变量的值的操作
int temp = m ;
m = n;
n = temp;
// ValueTransferTest1 test = new ValueTransferTest1();
// test.swap(m, n);
System.out.println("m = " + m + ", n = " + n);
}
// public void swap(int m,int n){
// int temp = m ;
// m = n;
// n = temp;
// }
}
结果：
public class ValueTransferTest1 {
public static void main(String[] args) {
int m = 10;
int n = 20;
System.out.println("m = " + m + ", n = " + n);
//交换两个变量的值的操作
// int temp = m ;
// m = n;
// n = temp;
ValueTransferTest1 test = new ValueTransferTest1();
test.swap(m, n);
System.out.println("m = " + m + ", n = " + n);
}
public void swap(int m,int n){
int temp = m ;
m = n;
n = temp;
}
}
结果：
这里的swap在被调用后就被销毁了，没有传进去
针对引用数据类型：代码演示：
public class ValueTransferTest2 {
public static void main(String[] args) {
Data data = new Data();
data.m = 10;
data.n = 20;
System.out.println("m = " + data.m + ", n = " + data.n);
int temp = data.m ;
data.m = data.n;
data.n = temp;
System.out.println("m = " + data.m + ", n = " + data.n);
}
}
class Data{
int m ;
int n ;
}
结果：
public class ValueTransferTest2 {
public static void main(String[] args) {
Data data = new Data();
data.m = 10;
data.n = 20;
System.out.println("m = " + data.m + ", n = " + data.n);
// int temp = data.m ;
// data.m = data.n;
// data.n = temp;
ValueTransferTest2 test = new ValueTransferTest2();
test.swap(data);
System.out.println("m = " + data.m + ", n = " + data.n);
}
public void swap(Data data){
int temp = data.m ;
data.m = data.n;
data.n = temp;
}
}
class Data{
int m ;
int n ;
}
结果：
这里的Data data = new Data();是关键，传的是地址值，在堆中处理
五、递归方法的使用1.递归方法：一个方法内调用它自身。
2.方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无需循环控制。
递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环。
public class RecursionTest {
public static void main(String[] args) {
//例1：计算1-100之间所有的自然数的和
//方式一：
int sum = 0;
for (int i = 1;i <= 100;i++){
sum += i;
}
System.out.println(sum);
//方式二：
RecursionTest test = new RecursionTest();
int sum1 = test.getSum(100);
System.out.println(sum1);
System.out.println("**********************");
int value = test.f(10);
System.out.println(value);
}
//例1：计算1-n之间所有的自然数的和
public int getSum(int n){
if(n == 1){
return 1;
}else{
return n + getSum(n - 1);
}
}
//例2：计算1-n之间所有的自然数的乘积：n！
public int getSum1(int n){
if(n == 1){
return 1;
}else{
return n * getSum(n - 1);
}
}
//例3:已有一个数列：f(0) = 1,f(1) = 4,f(n + 2) = 2 * f(n + 1) + f(n),
//其中n是大于0的整数，求f(10)的值
public int f(int n){
if(n == 0){
return 1;
}else if(n == 1){
return 4;
}else{
// return f(n + 2) - 2 * f(n + 1);
return 2*f(n - 1) + f(n - 2);
}
}
}
结果：
