-
方法的重载（overload）：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
-
"两同一不同":同一个类、相同方法名
-
参数列表不同：参数个数不同，参数类型不同
2.判断是否是重载：
-
跟方法的权限修饰符、返回值类型、形参变量名、方法体都没有关系！
3.在通过对象调用方法时，如何确定某一个指定的方法：
-
方法名 ---> 参数列表
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 d1,double d2){
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");
}
}
练习：
1.编写程序，定义三个重载方法并调用。方法名为mOL。
三个方法分别接收一个int参数、两个int参数、一个字符串参数。
分别执行平方运算并输出结果，相乘并输出结果，输出字符串信息。在主类的main ()方法中分别用参数区别调用三个方法。
public class OverloadExer {
//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值中的最大值，并分别调用三个方法。
public class OverloadExer {
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;
}
}
可变形参的方法
可变个数形参的方法
-
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(new String[]{"AA","BB","CC"});
}
public void show(int i){
}
public void show(String s){
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]);
}
}
//不能与上一个方法同时存在
//public void show(String[] strs){
// 方法体
// }
//public void show(String ...strs,int i){
// 方法体
// }
方法参数的值传递机制（最重要）
-
关于变量的赋值内存分析：
-
如果变量是基本数据类型，此时赋值的是变量所保存的数据值。
-
如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值。
-
从创建o1对象开始在栈空间中产生变量o1指向堆空间中的o1对象实体，然后给堆空间中的o1对象的orderId赋值1001，然后在栈空间中产生o2变量，把栈空间中的o1变量里存放的堆空间中o1对象的地址值，赋值给o2，这个时候o2和o1都指向堆空间中o1对象，所以o1.orderId和o2.orderId的值是同一个值。
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);//m=10,n=10
n = 20;
System.out.println("m = " + m + ", n = " + n);//m=10,n=20
System.out.println("***********引用数据类型：****************");
Order o1 = new Order();
o1.orderId = 1001;
Order o2 = o1;//赋值以后，o1和o2的地址值相同，都指向了堆空间中同一个对象实体。
//从创建o1对象开始在栈空间中产生变量o1指向堆空间中的o1对象实体，然后给堆空间中的o1对象的orderId赋值1001，
然后在栈空间中产生o2变量，把栈空间中的o1变量里存放的堆空间中o1对象的地址值，赋值给o2，这个时候o2和o1都指向堆空间中o1对象，所以o1.orderId和o2.orderId的值是同一个值
System.out.println("o1.orderId = " + o1.orderId + ",o2.orderId = " +o2.orderId);
//o1.orderId =1001,o2.orderId =1001
o2.orderId = 1002;
System.out.println("o1.orderId = " + o1.orderId + ",o2.orderId = " +o2.orderId);
//o1.orderId =1002,o2.orderId =1002
}
}
class Order{
int orderId;
}
-
方法的形参的传递机制：值传递
-
形参：方法定义时，声明的小括号内的参数
-
实参：方法调用时，实际传递给形参的数据
-
-
值传递机制：
-
如果参数是基本数据类型，此时实参赋给形参的是实参真实存储的数据值。
-
如果参数是引用数据类型，此时实参赋给形参的是实参存储数据的地址值。
-
-
基础数据变量的值传递：
从main方法中定义变量m，n，在栈空间中产生main()方法中的m变量并赋值10，n变量并赋值20，然后通过v对象调用swap方法，调用swap的时候会在栈空间中产生swap()方法中的m变量和n变量，v.swap(m,n)方法中的m，n为实参，把实参m，n的值赋给定义的swap()方法中的形参m和n，m=10，n=20（swap()方法中的m，n），执行swap()方法的时候，栈空间中会产生一个变量temp并把m=10的值给了temp，把n=20的值给了m，把temp=10的值给了n。在swap()方法里输出m=20，n=10，执行完swap方法之后，变量temp，m，n都会销毁出栈，这个时候再主函数打印m=10，n=20.
-
引用数据类型的值传递
从main()函数开始执行，创建对象，在堆空间中产生data对象，首地址值为0x7788，在栈空间中产生data变量，并指向堆空间中首地址值为0x7788的data对象，堆空间中data对象中的变量m赋值10，n赋值20；swap()方法里的实参data是栈空间中的指向堆空间中data对象的data变量，这个时候会在栈空间中产生一个属于swap()方法中的变量data，这个变量的值也是堆空间中的data对象的地址值，然后执行swap方法的方法体，栈空间中产生swap方法里的temp变量，通过调用data对象的属性m获取m=10，把10赋值给temp；通过调用堆空间data对象的n参数获取n=20，把20赋值给堆空间data对象中的属性m，把栈空间swap方法中的temp变量的值10赋值给堆空间中data对象的n属性；执行完swap方法之后栈空间中的变量temp，和data对象变量出栈。回到main函数，执行输出语句data.n=10，data.m=20。
public class ValueTransferTest1 {
public static void main(String[] args) {
int m = 10;
int n = 20;
System.out.println("m = " + m + ", n = " + n);
//m = 10, n = 20
ValueTransferTest1 test = new ValueTransferTest1();
test.swap(m, n);
System.out.println("m = " + m + ", n = " + n);
//m = 10, n = 20
}
//交换两个变量的值的操作
public void swap(int m,int n){
int temp = m ;
m = n;
n = temp;
System.out.println("m = " + m + ", n = " + n);
//m = 20, n = 10
}
}
练习：
1，定义一个Circle类，包含一个double型的radius属性代表圆的半径，一个findArea()方法返回圆的面积。
public class Circle {
double radius;//半径
//求圆的面积
public double findArea(){
return Math.PI * radius * radius;
}
}
2,定义一个类PassObject，在类中定义一个方法printAreas()，该方法的定义如下：public void printAreas(Circle c,inttime)printAreas方法中打印输出1到time之间的每个整数半径值，以及对应的面积。例如，time为5，则输出半径1，2，3，4，5，以及对应的圆面积。
public class PassObject {
public static void main(String[] args) {
PassObject test = new PassObject();
Circle c = new Circle();
test.printAreas(c, 5);
System.out.println("now radius is " + c.radius);
}
public void printAreas(Circle c, int time){
System.out.println("RadiusttArea");
int i = 1;
for(;i <= time;i++){
//设置圆的半径
c.radius = i;
double area = c.findArea();
System.out.println(c.radius + "tt" + area);
}
//
// c.radius = time + 1;
c.radius = i;
}
public class Circle {
double radius;//半径
//求圆的面积
public double findArea(){
return Math.PI * radius * radius;
}
}
}
递归方法
递归方法：一个方法体内调用它自身。
-
方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无须循环控制。
-
递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环。
练习：
1.请用 Java 写出递归求阶乘 (n!) 的算法。
public int getSum1(int n) {
if (n == 1) {
return 1;
} else {
return n * getSum1(n - 1);
}
}
2，已知 有一个数列: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);
}
}
3，输入一个数据，计算斐波那契数列(fibonacci)的第n个值
规律：一个数等于前两个数之和
要求：计算斐波那契数列的第n个值，并计算整个数列打印出来
例：1 1 2 3 5 8 13 21 34 55
4,汉诺塔问题
5,快排
