方法
方法的概念
将一个功能抽取出来，放在类中的大括号中， 形成一个独立的功能 ， 当需要使用该功能时，则调用它， 这样可以增强代码的复用性（重复利用） ，并解决代码的冗余现象。
方法的语法：
[访问修饰符] 返回值类型 方法名( [参数类型 参数名1 , 参数类型 参数名2 ...] ){
方法体
}
详解：
访问修饰符： 用于修饰这个方法的调用范文 目前默认 public static
返回值类型： 无返回值就写void 或者 方法执行后返回的结果的数据类型 ，方法执行完之后会将结果返回
方法名 ： 给方法取名， 准寻标识符的规则
参数类型 、参数名： 它们是同时定义 ，方法在执行时未知的数据，需要在调用方法时进行传递值。 参数类型表示 这个参数的数据类型 ，参数名就是一个参数名称 这个参数名可以在方法体中使用。
方法体： 这个方法具有的功能（代码块）
定义一个方法
public static int add（int num1 ， int num2）{
return num1+num2;
}
根据方法的参数 不同，返回值不同，可以将方法分为四类：
1、无参无返回值方法
语法：
public static void 方法名(){
方法体
}
2、无参有返回值方法
语法：
public static 返回值类型 方法名 (){
方法体
}
结果在n中
3、有参无返回值方法
语法：
public static void 方法名(参数列表 ){
方法体
}
情况一、 当参数中是基本数据类型 ，将实参的值赋值给 形参
public static void add(int num){
num++;
System.out.println("方法中 num 的值："+num);
}
调用方法： num的改变不会改变n 的值 ，因为是两个独立的内存
int n =10;
System.out.println(n);
add(n);
System.out.println("方法外面 实参的值："+n);
结果输出：
方法中 num 的值： 11
方法外面 实参的值：10
情况二： 当参数的数据类型是引用数据类型
例如 数组 、类
// 方法的比对 参数是数组
public static void add(int [] arr){
arr[0]++;
System.out.println("方法中 arr[0]="+arr[0]);
}
调用：
int [] array ={10,20};
add(array);// 会调用 参数是数组的add方法
System.out.println("方法外面的 arr[0]="+ array[0]);
结果：
方法中 arr[0]=11
方法外面的 arr[0]=11
类的调用：
public static void addAge(Student student){
// 将学生的年龄 获取 自加
int age = student.age;
age++;
// 在重新赋值
student.age=age;
}
调用
Student student = new Student(); // age默认为 18
System.out.println("方法调用之前： "+student.age); // 18
addAge(student); // 传的地址
System.out.println("方法外面 学生的年龄："+student.age);
结果输出： 方法调用之前： 18
方法外面 学生的年龄：19
/**
* 以上方法调用 的结论： 对于参数为引用数据类型，方法外面和方法内部公用同一块内存，
* 也就是说 参数再传递时，将引用类型的地址赋值给 方法的形参
* 对于基本数据类型 ，方法的参数将 值的副本赋值给形参，这样形参的改变
* 不会影响实参的值
* 原因： 引用数据类型在参数传递时 是地址 （JVM对于堆内存的大小不可控）
* 基本数据类型在参数传递时 是值
*
*/
情况三、 当参数是String类型时 ，String是引用数据类型 ，但是在参数传递时，是与基本类型一样
public static void main(String[] args) {
// 参数是字符串
String uname ="朱正康";
sayHello(uname);
System.out.println("我最后对"+uname+"sayHello");
}
public static void sayHello(String name){
name="王丽杨";
System.out.println("我对"+name+"sayHello");
}
结果：
我对王丽杨sayHello
我最后对朱正康sayHello
4、有参有返回值方法
语法：
public static 返回值类型 方法名(参数列表){
方法体
}
例如 ：
public static String sayHello(String name){
name="王丽杨";
System.out.println("我对"+name+"sayHello");
return name ;
}
调用
public static void main(String[] args) {
// 参数是字符串
String uname ="朱正康";
// 将返回值接收 ，这是 uname 才被改变 ，如果不接受，则不改变
uname = sayHello(uname);
System.out.println("我最后对"+uname+"sayHello");
}
结果：
我对王丽杨sayHello
我最后对王丽杨sayHello
二、方法的调用以及方法参数传递
1、方法的定义：
访问修饰符 返回值类型 方法名 （[参数列表]）{
方法体
}
如果方法体中需要一些未知的数据作为执行条件，那么这些数据可以作为参数。
如果方法需要返回数据，在定义有返回值的方法，且需要明确返回值类型
方法调用两种方式：
1、 对象名.方法名(参数)
2、直接写方法名调用 ，但必须是static修饰的
// 获取这个字符串的第一个字符
public static char method1(String str){
return str.charAt(0); //获取字符串的第一个字符
}
//方式一： 调用方法
对象名.method1()
//方式二： 调用静态方法 （static修饰的）
String s ="abc";
char c = method1（s）// s将赋值给 方法的形参 str ，那么方法执行时str有值
// c 就是方法调用后的返回值
1、方法的参数是基本数据类型 ，它传递的是 值
// 计算一个数的平方
public static int pow(int a){
a=a+2; // 6
return a*a; // 6*6 = 36
}
main:
int num=4;
int sum = pow(num); //num实参 num赋值给a
System.out.println(num); // 4
System.out.println(sum); // 36
2、方法的参数是引用数据类型，它传递的是地址 （String类型除外）
//参数 是数组类型
public static int pow(int [] arr){
arr[0]=arr[0]+2; //根据地址 改变数组的第一个元素值 arr[0]=4;
return arr[0]*arr[0]; // 4*4
}
调用
// 调用另一个pow
int [] array = {2,3};
int sum2 = pow(array) ; // array中存放数组的地址 ，将地址赋值给 arr形参
System.out.println(array[0]);// 4
System.out.println(sum2 ); // 16
方法的重载：
在一个类中，存在相同方法名的两个及以上的方法，且他们的参数列表不同（参数类型不同 ，参数个数不同，参数顺序不同），不考虑参数名，不考虑返回值类型
一个类中不能存在完全相同的方法，他们是重复的方法 JVM编译不通过
例如：
public int add(int a ,int b){
return a+b;
}
public int add(long a,long b){
return (int)(a+b);
}
//与前两个 不重载
public void add(int c,int d){
}
// 能与 方法1 ，2 构成重载
public void add(int a){
}
// 能与 方法1 ，2 构成重载
public void add(int a ,long b){
}
// 能与 方法1 ，2 构成重载
public void add(long a ,int b){
}
把握： 方法名是否相同，同时 参数列表是否不同 （参数个数不同 或者参数类型不同或者参数顺序不同）
在一个方法可以调用其他的方法， 它们的执行流程
/**
* 程序入口
* @param args
*/
public static void main(String[] args) {
System.out.println("这里是main方法的开始");
method1();
System.out.println("这是main方法的结束");
}
// 在一个方法中可以调用另一个方法， 它们的执行顺序是这样的
public static void method1(){
System.out.println("这是method1 的开始语句块 ");
// 调用method2
method2();
System.out.println("这是method1的 结束语句块");
}
public static void method2(){
System.out.println("这是method2 的开始语句块 ");
// 调用method3
method3();
System.out.println("这是method2 的结束语句块");
}
public static void method3(){
System.out.println("这是method3的执行语句块");
}
三、方法的递归调用
1、定义
在一个方法中，运行方法自身调用，这样的调用称为方法的递归调用， 为了避免出现方法调用时出现死循环，递归调用中必须定义 方法结束调用的条件。
方法递归调用执行流程
public static void m3(int i){
if(i==5){
return ;
}
System.out.println("这是m3方法开始i :"+ i);
i++;
m3(i);
System.out.println("m3方法的结束 i:"+ i );
}
public static void main(String[] args) {
m3(0); //
}