方法属于谁
- 方法要么属于类，要么属于对象
- static修饰的方法属于类
- 没有static修饰的方法属于对象
- 方法只能定义在类里面，不能独立定义
- 不能独立的执行方法，要么通过类调用，要么通过方法调用
- 一个类里，一个方法调用另一个方法，看似没有调用者，实际上对于非static方法使用this调用，static方法使用类名调用
- 注意：static方法也可以通过对象调用，这符合语法，但不推荐
方法的参数传递
- Java里，参数的传递方式只有一种：值传递，就是将实际参数的副本传给方法，而参数本身不受影响
- 示例：对于基本类型的参数
public class SwapTest {
public static void main(String[] args) {
int a=3;
int b=7;
System.out.println("主方法里面，用swap(a,b)交换前：a="+a+" b="+b);
swap(a,b);
System.out.println("主方法里面，用swap(a,b)交换后：a="+a+" b="+b);
}
public static void swap(int a,int b){
System.out.println("swap(a,b)方法内部，交换前：a="+a+" b="+b);
int temp;
temp=a;
a=b;
b=temp;
System.out.println("swap(a,b)方法内部，交换后：a="+a+" b="+b);
}}
- 上面代码中，用swap()方法并没能对main方法的a和b实现交换，因为在调用swap方法时，栈内存中又开了个swap栈区，里面有两个变量a和b，这个ab跟main方法的ab毫无关系，接下来传递参数的值，也就是将main的3传给swap的a变量，将7传给b变量，然后swap方法内部将二者进行了交换，但这丝毫不影响main方法里的ab。这里的swap就像人睡觉一样，你在梦里中了500万，但这丝毫改变不了你的现实。
- 再看下面的代码，引用类型的参数：
public class T1 {
public static void main(String[] args) {
DataWrap dw=new DataWrap();
dw.a=3;
dw.b=7;
System.out.println("main方法里，交换前，dw.a="+dw.a+" dw.b="+dw.b);
swap(dw);
System.out.println("main方法里，交换后，dw.a="+dw.a+" dw.b="+dw.b);
}
public static void swap(DataWrap dw){
System.out.println("swap方法里，交换前，dw.a="+dw.a+" dw.b="+dw.b);
int temp;
temp=dw.a;
dw.a=dw.b;
dw.b=temp;
System.out.println("swap方法里，交换后，dw.a="+dw.a+" dw.b="+dw.b);
}
}
class DataWrap{
int a;
int b;
}- 对于引用类型的参数而言，依然是采用的值传递方式。但这里容易存在一个假象：调用swap()方法时，传进去的是dw这个对象本身，并没有复制一个dw。实际上传进去的是dw这个对象的引用的复制，而不是复制了一个dw对象，也就是说调用swap()方法后，内存中有两个引用指向dw对象，一个main方法的dw变量，另一个是swap方法的dw变量。
形参个数可变的方法
- 如果要传入某类型的参数个数不能确定，那可以用下面这种方式
methodName(int a,float b,String…strings);
- 规则：
- 个数可变的形参只能放在参数列表的最后
- 一个方法只能有一个个数可变的形参
- 调用这种方法时，可以传入一个对应类型的数组
- 参数数组
- 个数可变的形参实际上就是个数组，下面的定义与上面的相同
methodName(int a,float b,String[] strings);
- 个数可变的形参实际上就是个数组，下面的定义与上面的相同
方法的重载
- 方法名+形参列表构成了方法签名
- Java里，即使方法名相同，只要形参列表不想同，就是不同的方法
- 同一个类中，方法名相同，形参列表不同，这就叫做方法的重载，overload
- 在调用方法的时候，JVM会根据方法名和传入的参数的类型自动匹配对应的方法
- 重载方法中包含个数可变的形参，看示例代码：
public class Test {
public static void main(String[] args) {
test("A"); //输出：有一个String参数
test("B","C"); //输出：有两个String参数
test("D","E","F"); //输出：有三个String参数
test("G","H","I","J","K"); //输出：有很多个String参数
String[] str={"A"};
test(str); //输出：有很多个String参数
}
public static void test(String str){
System.out.println("有一个String参数");
}
public static void test(String str1,String str2){
System.out.println("有两个String参数");
}
public static void test(String str1,String str2,String str3){
System.out.println("有三个String参数");
}
public static void test(String...strs){
System.out.println("有很多个String参数");
}
}
- 从上面的代码可以看出，总是先匹配精确的个数，匹配不到再匹配个数可变的；
- 如果传入的是数组，直接匹配个数可变的
- 一般不推荐用个数可变的形参，意义不大，可读性差
递归方法
- 简单的说，递归方法就是在方法里面调用自身，然后可能产生循环调用，最后在某种条件下退出
- 使用原则：
- 向已知的方向递归
- 要设置某种条件能让递归调用退出来，
- 看下面的示例代码
public class T1 {
public static void main(String[] args) {
System.out.println("0~-50的和= "+sum(-50));
}
public static int sum(int num){
if (num==0){
return 0;
}else if(num>0){
return num+sum(num-1);
}else{
return num+sum(num+1);
}
}
}
