0019 Java学习笔记-面向对象-方法

方法属于谁

• 方法要么属于类，要么属于对象
• 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);
    	}
    }
}