java方法，方法调用机制

1. 方法使用

   public class Target1{
   	public static void main(String[] args) {
   		//方法使用
   		Person jia = new Person();
   		jia.speak();//调用方法
   		jia.cal01();
   		jia.cal02(5);//给n一个5；
   		jia.cal02(10);
   		int returnRes = jia.getSum(1,2);
   		System.out.println("getSum方法返回的值="+returnRes);
   	}
   }
   class Person{
   	int age;
   	String name;
   	//1.public 表示方法是公开的，
   	//2.void：表示方法没有返回值。
   	//3.speak():speak是方法名，()形参列表
   	//4.{}：方法体，可以写我们要执行的代码
   	public void speak(){
   		System.out.println("我是一个好人");
   	}
   	public void cal01(){
   		int sum=0;
   		for(int i=1;i<=1000;i++){
   			sum+=i;
   		}
   		System.out.println("cal01的计算结果："+sum);
   	}
   	public void cal02(int n){
   		//(int n)形参列表，表示当前有一个形参，可以接收用户输入
   		int sum=0;
   		for(int i=1;i<=n;i++){
   			sum+=i;
   		}
   		System.out.println("cal02的计算结果："+sum);
   	}
   	//1.int:表示方法执行后，返回一个int值
   	public int getSum(int a,int b){
   		int res = a+b;
   		return res;//表示把res值返回。
   		//System.out.println(a+"+"+b+"的和为"+(a+b));
   	}
   
   }
   

2. 方法调用机制
3. 方法调用小结
   1. 当程序执行到方法时，就会开辟一个独立的空间（栈空间）。
   2. 当方法执行完毕，或者执行到return语句时，就会返回。
   3. 返回到调用方法的地方
   4. 返回后，继续执行方法后面的代码
   5. 当main方法（栈）执行完毕，整个程序退出。

4. 成员方法的好处

   1. 提高代码的复用性

   2. 可以将实现的细节封装起来，然后供其他用户来调用即可。

5. 返回数据类型

   1. public class Method02{
      	public static void main(String[] args) {
      
      		addAndsub num = new addAndsub();
      		int res[] = num.getSumAndSub(2,3);
      		System.out.println("和："+res[0]);
      		System.out.println("差："+res[1]);
      		
      	}
      }
      
      class addAndsub{
      	//1.一个方法最多有一个返回值
      	//【思考，如何返回多个结果，返回数组】
      	public int[] getSumAndSub(int n1,int n2){
      		int arr[] = new int[2];
      		arr[0] = n1+n2;
      		arr[1] = n1-n2;
      		return arr;
      	}
      }

   2. 如果方法要求有返回数据类型，则方法体中最后的执行语句必须为return 值；二且要求返回值类型必须和return的值类型一致或兼容。

   3. 如果方法是void，则方法体中可以没有return语句，或者只写return；

   4. 方法名：getSum,驼峰命名法。

6. 形参列表细节

   1. 一个方法可以有0个参数，也可以有多个参数，中间用逗号隔开。

   2. 参数类型可以为任意类型，包含基本类型或引用类型。

   3. 调用参数的方法时，一定对应着参数列表传入相同类型或兼容类型的参数。

   4. 方法定义时的参数称为形式参数，简称形参，方法调用时传入参数称为实际参数，简称实参。实参和形参的类型要一致或兼容，个数，顺序必须一致

   5. 方法体里面不能在定义方法。方法不能嵌套定义。

7. 方法调用细节说明

   public class Method03{
   	public static void main(String[] args) {
   
   		A a = new A();
   		//a.seeOk();//同一个类中的方法调用：直接调用即可。
   		a.m1();
   		
   	}
   }
   
   class A{
   	public void print(int n){
   		System.out.println("执行print()方法。n="+n);
   	}
   	public void seeOk(){
   		print(10);
   		System.out.println("执行完print()方法又回到seeOk");
   	}
   	//跨类中的方法A类调用B类方法：需要通过对象名调用。
   	public void m1(){
   		System.out.println("m1()方法被调用");
   		//创建B类对象，然后调用方法即可。
   		B b = new B();
   		b.inBi();//========================
   		System.out.println("又回到了A类中的m1方法。");
   	}
   	
   
   }
   class B{
   	public void inBi(){
   		System.out.println("执行B类中的inBi方法。");
   	}
   }

8. 成员方法传参机制（重要）

   1. public class Method05{
      	public static void main(String[] args) {
      		int a = 1;
      		int b = 2;
      		change jia = new change();
      		jia.swap(a,b);
      		//基本数据类型传递的是值（值拷贝），形参的任何改变不影响实参。
      		System.out.println(a+"\t"+b);//1       2
      	}
      }
      class change{
      	public void swap(int a,int b){
      		System.out.println("交换前的a="+a+",b="+b);//交换前的a=1,b=2
      		int temp = a;
      		a = b;
      		b = temp;
      		System.out.println("交换后的a="+a+",b="+b);//交换后的a=2,b=1
      		//这里只是修改的是swap栈里的a，b。
      		//调用方法之后会开辟一块独立的空间。
      		//mian和swap是两块独立的空间，
      		
      	} 
      }

   2. 

       基本数据类型传递的是值（值拷贝），形参的任何改变不影响实参。

9. 引用数据类型的传参机制

   1. public class Method06{
      	public static void main(String[] args) {
      
      		B b = new B();
      		int arr[] = {1,2,3,5};
      		System.out.println(arr[0]);
      		b.test100(arr);
      		System.out.println(arr[0]);
      	}
      }
      class B{
      	public void test100(int arr[]){
      		arr[0] = 200;
      		System.out.println(arr[0]+"test100方法中");
      	}
      }
      /*输出
      1
      200test100方法中
      200
       */

      引用类型传递的是地址（传递也是值，但是值是地址），可以通过形参影响实参。

   2. 

       

   3. 类中的基本数据类型放在堆中，引用数据类型放在方法区

   4. 

       

       是把新开辟的test空间里的p的地址给赋null

10. 练习，克隆

    public class Method08{
    	public static void main(String[] args) {
    		//克隆，得到的新对象和原来的对象是两个独立的对象，
    		//只是他们的属性相同。
    		abb hang = new abb();
    		Person jing = new Person();
    		jing.name = "张晶";
    		jing.age = 23;
    		jing.weight = 100.9;
    		Person zhang = hang.copyPerson(jing);
    		//jing和zhang是两个独立的对象，只是属性相同。
    		System.out.println("zhang的属性 age="+zhang.age);
    		System.out.println("jing的属性 age="+jing.age);
    
    		
    	}
    }
    
    
    class abb{
    	public Person copyPerson(Person p){
    		Person jia = new Person();
    		jia.name = p.name;
    		jia.age = p.age;
    		jia.weight = p.weight;
    		return jia;
    	}
    }
    class Person{
    	String name;
    	int age;
    	double weight;
    }

11. 方法递归调用

    1. 递归调用机制

        

    2. 执行一个方法时，就创建一个新的受保护的独立空间（栈空间）

    3. 如果方法中使用的是引用类型变量（数组，对象），就会共享该引用类型的数据

    4. 方法的局部变量是独立的，不会相互影响，比如n变量。

    5. 递归必须向退出递归的条件逼近，否则就是无限递归。

    6. 当一个方法执行完毕，或者遇到return，就会返回，遵守谁调用，就将结果返回给谁，同时当方法执行完毕或者返回时，该方法也就执行完毕。