Java笔记5-修饰符,重载,递归,数组

方法的定义
修饰符 返回类型 方法名(参数列表) throws 异常类型列表 {
//方法体
}
==
如何来设计一个方法：
案例：
请根据如下的业务分别设计出方法
1.根据给定的年份判断是否是闰年？
public boolean isLeapYear(int year){
}

2.求两个浮点数之和
public double add(double a, double b){

}
3.求给定整数的阶乘
public long factor(int n){

}
4.求给定整数的二进制字符串形式
public String toBinary(int i){

}
5.求两个整数的最大公约数
public int gcd(int a, int b){

}
6.打印输出指定范围内的完美数
public void printPerfectNumber(int start, int end){

}

--------------------------------------
1.方法的重载 [overload]
定义：
在同一个类中，有相同方法名但参数列表不同的方法，就构成方法的重载
特点：
方法名相同
参数列表不同
1).参数个数不同
2).参数类型不同
3).在2)的基础上，顺序不同

作用：
1). 对于方法的调用者，无需为相同业务的方法记不同的方法名
2). 重载的方法一定是具有相同的业务。

如：
public void Xxx {
public int add(int a, int b){ return a + b; }

public double add(double a, double b){ return a + b; }

// public double add(int b, int a){ return a + b; } 不构成重载

public double add(int a, double b){ return a + b; }

public double add(double b, int a){ return a + b; }

}

对于JVM来说，如何定位一个方法，它依赖的是 方法名与参数类型。
所以，上面的类的方法表如下：
add(int,int)
add(double,double)
add(int,double)
add(double,int)
对于重载的方法，发生调用时,JVM如何选择：
1).首先 精确匹配
如：
x.add(5, 9); //invoke add(int,int)
x.add(5.0,9.0); //invoke add(double,double)
2). 如果不能精确匹配，则遵守 类型的就近向上匹配原则。
如：
int i = 19;
float f = 18;
x.add(i, f); //invoke add(int,double)
byte b1 = 18;
byte b2 = 19;
x.add(b1,b2); //invoke add(int,int);
----

2.递归方法 [recursive]
定义，就是指直接或间接调用自己的方法，就是递归方法。

递归方法的作用
用来解决某些特殊的问题，比如：汉诺塔，菲波娜齐数组等

使用递归的条件
1).一定要有规律
2).一定要有退出条件

如：
求一个整数的阶乘
//采用循环的方式
public long factor(int n){
long result = 1L;
for(int i=n;i>=1;i--){
result *= i;
}
return result;
}
//使用递归思想
5! = 5 * 4!
4! = 4 * 3!
3! = 3 * 2!
2! = 2 * 1!
此时，我们知道1!等于 1
使用数学表式法：
f(n) = n * f(n-1)
//code:
public long factor(int n){
//1.指定退出条件
if(n == 1){ return 1L;}
//2.递归
return n * factor(n - 1);
}

--
菲波娜齐数列，是这样的一组数列
1 1 2 3 5 8 13 21 34 55 89 ....
设计一个方法，求出指定位置处的菲波娜齐数列值
public long fibo(int pos){

}

-----------------------------
方法的调用
首先，方法是类的成员[member]
其次，方法的修饰符中是否有 static
因为加了static的方法，可以通过 类名.方法名 来调用
没有加static的方法，必需通过创建对象后来调用[对象.方法]
==
有关实参与形参
在方法调用时，实参的值会COPY一份给形参。

===============================
数组 [array]
数组，本身是一种对象数据类型。
它是用来保存一组具有相同数据类型的数据的。

语法：
数据类型[] 数组名;
或
数据类型[] 数组名 = new 数据类型[length];
=============================
数据类型 数组名[];
或
数据类型 数组名[] = new 数据类型[length];

注：数组在初始化时必需要指定长度，而且长度一旦确定，不可再变。
数组的空间是连续的。

数组的特点
1).数组元素共享同一个数组名
2).通过下标来访问元素，下标从0至length-1. 如果下标在此范围，
则会出现数组下标越界的异常。

比如：
要记录某个人的年龄，则利用
int age = 19;
如果要记录5个人的年龄，怎么办？
int age1 = 18;
int age2 = 17;
int age3 = 20;
int age4 = 15;
int age5 = 16;
这里我们采用数组来记录的话，则只需要定义一个整型数组即可
int[] arr = new int[5];
arr[0] = 18;
arr[1] = 17;
arr[2] = 20;
arr[3] = 15;
arr[4] = 16;

注：
虽然数组是对象类型，但是数组元素可以是任意的类型。
比如：
int[] intArr; //申明了一个整型数组
String[] sArr; //申明了字符串类型的数组

--
数组一旦初始化，即使没有给元素赋值，元素也有默认值，
其中：
int,byte,long,short => 0
double,float => 0.0
boolean => false
char => '\u0000'
对象类型 => null

==
如何给数组元素赋值？
1). 按下标一个一个赋值。
如：
int[] arr = new int[3];
arr[0] = 100;
arr[1] = 150;
arr[2] = 200;

2). 在初始化数组时，直接以大括号来给元素赋值
语法：
数据类型[] 数组名 = new 数据类型[]{值1,值2,....,值N};
或
数据类型[] 数组名 = {值1,值2,....,值N};
注：第2种语法不能分开写。

如：
int[] arr = new int[]{100, 150, 200};
或
int[] arr2 = {199,32,234,23432,4234,23423};

int[] arr3;
arr3 = {1,4,3,34,4,34}; //error
arr3 = new int[]{1,4,3,34,4,34}; //ok

3).如果元素值存在一定的规律，则可以通过循环来赋值
如：
int[] arr = new int[3];
for(int i=0;i<arr.length;i++){
arr[i] = 100 + 50*i;
}
//

练习：

作业1：
设计一个方法，根据给定的长度，返回一个充满菲波娜齐数组值的数组。

作业2：
利用递归思想，求出任意两个整数的最大公约数
public int gcd(int a, int b){

}
作业3：
设计一个方法，求出1000以内所有的水仙花数[daffodil]
水仙花数是指一个n位数(n>=3)刚好等于它的所有位数的n次幂之和。
如：
157 = 1^3 + 5^3 + 7^3