类的结构之二：方法
方法：描述类应该具有的功能。
比如：
Math类:sqrt()、random()...
Scanner类:nextXxxx...
Arrays类:sort()、binarySearch()、toString()、equals()...
1.常见格式：
- public void eat() {}
- public void sleep(int hour) {}
- public String getName() {}
- public String getNation(String nation) {}
2.方法的声明：
权限修饰符 返回值类型 方法名(形参列表) {
方法体;
}
//注意：static、final、abstract 来修饰的方法，后面再讲。
3.说明：
- 关于权限修饰符：
默认权限的修饰符使用public。
Java规定的4种权限修饰符：private、 public、缺省、protected.--->封装性再细说。
- 返回值类型：有返回值 vs 无返回值
(1)如果方法有返回值，必须在方法声明时，指定返回值的类型。同时方法中需要使用return关键字来返回指定类型的数据。
(2) 如果方法没有返回值，则方法声明时，使用void来表示。通常没有返回值的方法中，就不需要使用return，
但是，如果使用的话，只能"return;"表示结束此方法的意思。
(3) 定义方法时，该不该有返回值？
①看题目要求
②凭经验：具体问题具体分析。
- 方法名：
属于标识符，遵循标识符的规则和规范，"见名知意".
- 形参列表：
(1)方法可以声明0个，1个或者多个形参。
(2)格式：数据类型1 形参1,数据类型2 形参2...
(3)定义方法时，该不该定义形参：
①看题目要求
②凭经验：具体问题具体分析。
- 方法体：
方法功能的体现。
一、return关键字的使用:
- 使用范围：使用在方法体中
- 作用：
①结束方法
②针对于有返回值的方法，使用"return 数据"方法返回所要的数据。
return后面不可以声明执行语句。
注意：
方法的使用中，可以调用当前类的属性或者方法。
特殊的：方法A中又调用了方法A:递归调用。
方法中不可以定义方法。
二、方法的重载
1.定义：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
"两同一不同"
相同：同一个类，相同方法名。
不同：参数列表不同：参数个数不同、参数类型不同。
2.举例1:
Arrays类中重载的sort()方法、binarySearch()...
举例2：
public class Overload {
public static void main(String[] args) {
Overload v1 = new Overload();
v1.getSum(1, 1);//1
}
//如下四个方法构成了重载：
public void getSum(int i, int j) {
System.out.println("1");
}
public void getSum(double i,double j) {
System.out.println("2");
}
public void getSum(String s, int k) {
System.out.println("3");
}
public void getSum(int k,String s) {
System.out.println("4");
}
//如下的方法不能与上述方法构成重载
public void getSum(int m, int n) {
}
public int getSum(int i,int j) {
}
private void getSum(int i,int j) {
}
}
3.判断是否是重载：严格按照定义。
跟方法的权限修饰符、返回值类型、形参变量名、方法体都没有关系！！！
4.在通过对象调用方法时，如何确定某一个指定的方法▲ ▲ ▲
方法名 ---> 参数列表
三、可变个数形参的方法
1.jdk5.0新增的内容。
2.具体使用：
2.1可变个数行参格式：数据类型...变量名
2.2当调用可变个数的形参的方法时，传入的参数的个数，可以是0、1、2.....个
2.3可变个数形参的方法与本类中方法名相同、形参不同的方法名构成重载。
2.4可变个数形参的方法与本类中方法名相同、形参类型也相同的数组不构成重载。二者不能共存！！！
2.5可变个数形参在方法的形参中，必须声明在末尾。
2.6可变个数形参在方法的形参中，最多只能声明一个可变形参。
3.举例：
public class MethodArgsTest {
public static void main(String[] args) {
MethodArgsTest m1 = new MethodArgsTest();
m1.show(1);
m1.show("a");
// m1.show("a","b");
// m1.show();//也可以是0个形参
//数组
m1.show("AA","BB","CC");
//m1.show(new String()[] {"AA","BB","CC"}); 也可以！
}
public void show(int i) {
System.out.println("整型");
}
public void show(String s) {
System.out.println("字符型");
}
public void show(String...sts) {
for(int i = 0;i < sts.length;i++) {
System.out.println(sts[i]);
}
}
//不能与上一个方法同时存在。
// public void show(String[] strs) {
//
// }
public void show(int i,String ...strs) { //声明在末尾!
}
}
四、值传递机制
1.关于变量的赋值
规则：
如果变量为基本数据类型，此时赋值的是变量所保存的数据值。
如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值.
举例：
public class ValueTansferTest {
public static void main(String[] args) {
//基本数据类型：
int m = 10;
int n = m;
System.out.println("m为:" + m + " " + "n为: " + n);
n = 20;
System.out.println("m为:" + m + " " + "n为: " + n);
//引用数据类型：
Order o1 = new Order();
o1.orderId = 1000;
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;
}
2.方法的形参的传递机制：值传递
①形参：方法定义时，声明的小括号内的参数。
②实参：方法调用时，实际传递给形参的数据。
3.值传递机制：
规则:
如果参数是基本数据类型，此时实参赋给形参的是，实参真实存储的数据值。
如果参数是引用数据类型，此时实参赋给形参的是，实参存储数据地址值。
举例：
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 test1 = new ValueTransferTest1();
test1.swap(m, n);
System.out.println("m为:" + m + " " + "n为: " + n);//依然输出的是main()方法中的m、n的值。
}
public void swap(int m,int n) {//实参的数据值赋给swap()方法中的形参。
int temp = m;
m = n;
n = temp;
System.out.println("m为：" + m + "," + "n为：" + n);//
}
}
五、递归方法
递归方法：一个方法体内调用它自身。
方法递归，包含了一种隐形的循环，它会重复执行某段代码，但这种重复执行无需循环控制。
递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环。
举例：
public class RecursionTest {
public static void main(String[] args) {
//例1：计算1-100之间所有的自然数的和
//方式一：
int sum = 0;
for(int i = 0 ;i <= 100;i++) {
sum += i;
}
System.out.println(sum);
//方式二：
RecursionTest r1 = new RecursionTest();
int sum1 = r1.getsum(100);
System.out.println(sum1);
//例3：结果检验
int value = r1.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之间所有的自然数的积
public int getsum1(int n){
if(n == 1) {
return 1;
}else {
return n * getsum1(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 2*f(n - 1) + f(n - 2);
}
}
//例4：菲波那契数列
//例5：汉诺塔问题
//例6：快排
}