008-Java方法

目录

回顾main方法

方法的定义

方法的调用

变量的作用域

局部变量的作用域

示例

说明

提升变量的作用域

可变参数

方法的值传递

形参与实参

值传递

基本数据类型值传递

 引用类型值传递

String类型值传递

方法重载(overload)

回顾main方法

public static void main(String[] args) {
     // 方法体
}

访问修饰符：main函数是固定的public，还有其他访问修饰符：private、protected、default等，后续在讲解面向对象的时候再详细说。

关键字修饰符：main函数还是固定的static，还有其他如final。我们也是在面向对象的时候再详细介绍。

返回值类型：其实就是我们返回的数据的类型，基本数据类型或引用数据类型或void，void表示没有返回值。main是固定写法void

方法名称：main函数的方法名称就是mian，如果不是main它就不是main方法（废话）。方法名称的定义规则与变量名称定义规则一样。

在 Java中，方法名以下划线、字母、$符号开头，并且后跟下划线、字母、$符号以及数字。不能以数字开头。采用驼峰式命名，首字母小写，之后的每个单词的首字母大写，如：userName、getUserName

参数列表：main函数此处是一个String类型的数组做为参数。也是固定写法。

综上我们可以看到main函数的定义几乎是定死的，完全按照要求写就ok了。

main函数是我们java程序的入口，程序执行时从main函数开始执行。

方法的定义

访问修饰符 [关键字修饰符] 返回值类型 方法名([参数类型1 参数名1,参数类型2 参数名2，...]){
    //方法体
    return 返回值;// 如果返回值类型为void，此行不写
}

[]括号表示该项可有可无，关键字修饰符可以没有，方法可以没有参数，也可以有一个参数，两个参数。。。N个参数

Java方法是语句的集合，它们在一起执行一个功能，比如定义一个方法实现整数加法的功能。

public static int add(int x,int y){
    return x + y;
}

到目前为止我们的访问修饰符就是public，定义的时候就用public即可，其余的我们后面再说。static修饰符也一样。

我们要定义一个整型的加法的方法，所以既然是加法必然有返回值，所以我们返回值类型就是int类型，加法必然有两个数相加，所以我们的参数有2个，返回x+y。

方法的调用

我们上面说过，java程序的入口是main函数，所以我们自定义的函数需要执行时，需要在main函数中调用。调用方式为：方法名(实际参数列表);

public static void main(String[] args) {
    int x = add(1,2);
    System.out.println(x);// 打印出结果3
}

public static int add(int x,int y){
    return x + y;
}

那么问题来了，main函数中有定义变量x，add方法上有定义参数变量x，变量名称是一样的，它们实际上一样吗？（不一样） 

变量的作用域

变量的作用域是我们定义的变量只能在某些范围内使用，这个范围跟我们定义的变量的位置有关。目前我们接触到的变量都叫局部变量。

局部变量的作用域

• 在方法中定义的变量是局部变量，如上面的主方法中定义的int x。其作用域在main方法表示的括号内。
• 方法的参数变量其实也是局部变量，如上面的add方法定义的x和y。其作用域在add方法表示的括号内。
• if语句内定义的变量，其作用域在if语句的括号内。
• for等循环内定义的变量，其作用域在其对应的for循环内。
• 同一作用域下（其实就是同一个花括号内），变量不能重复定义。
• 变量定义后必须赋值才能使用，否则编译错误。
• 不同且不相交的作用域下变量的名称可以相同，如方法的调用一节我们的示例程序，两个x的作用域不同而且两个作用域不相交，所以这两个x名称相同但不是一个值。

示例

public static void main(String[] args) {
    int a = 10;
    if(a > 10){
        //int a = 0;// 编译错误，重复定义a
        int b = a;// 正确
    }else {
        //int a = 0;// 编译错误
        int b = a - 6;// 正确，与上一个b不在一个作用域且不相交

        a = 5; // 正确，局部变量是可以修改值的
    }
    //System.out.println(b);// 编译错误，超出b的作用域
}

说明

1.  变量a所在作用域是整个main方法，if语句也在main方法内，所以if语句中可以使用变量a，但不能再定义变量a，因为名称重复了。
2. 两个变量b，作用域不同且不包含，所以可以定义变量b。
3. 在最后打印变量b报错，因为打印的地址超出了变量b的作用域。如果我们需要在此打印变量b的值，我们就需要提升变量b的作用域

提升变量的作用域

就是把变量的声明放在我们需要使用它的作用域中

public static void main(String[] args) {
    int a = 10;
    int b;
    //System.out.println(b);// 编译错误，因为我们定义了变量，没有赋值，不能直接使用
    if(a > 10){
        //int a = 0;// 编译错误，重复定义a
        b = a;// 正确
    }else {
        //int a = 0;// 编译错误
        b = a - 6;// 正确，与上一个b不在一个作用域且不相交

        a = 5; // 正确，局部变量是可以修改值的
    }
    System.out.println(b);// 正确编译
}

可变参数

比如计算10个整数的和，我们来定义一个方法。这一下需要定义10个参数，一个一个定义太费劲了，而且它们都是int类型。如果没有可变参数的情况下我们这样定义：

public static int sum(int[] x){
    int sum = 0;
    for(int i = 0; i < x.length;i++){
        sum += i;
    }
    return sum;
}

定义成可变参数的形式呢？

public static int sum(int... x){
    int sum = 0;
    for(int i = 0; i < x.length;i++){
        sum += i;
    }
    return sum;
}

我们可以看到，其实没有什么不同，我们可以认为可变参数其实就是数组参数。

方法的值传递

形参与实参

public static void main(String[] args) {
    int x = add(1,2);
    System.out.println(x);// 打印出结果3
}

public static int add(int x,int y){
    return x + y;
}

此示例中，add方法的参数定义x、y就是形参，形参就是方法在定义时，规定方法接受的参数的类型，形参是没有具体的值的。

main方法中调用add方法时传入的值1和2就是实参，实参就是在形参规定的类型的实际的值。也就是add方法在调用的时候将1传给x，将2传给y。这叫做值传递。

值传递

基本数据类型值传递

public static void main(String[] args) {
    int x = 1;
    int a = add(x);
    System.out.println(x);// 1
    System.out.println(a);// 2
}

public static int add(int x){
    return ++x;
}

int是基本数据类型，add(x);是将x的值1传递到方法执行，上面我们提到了两个x不是同一个变量，那么在主函数中打印的变量x的值就是1。而a的值是1传入函数执行了++x的值，所以是2.

 引用类型值传递

public static void main(String[] args) {
    int[] x = {1};
    int[] a = add(x);
    System.out.println(x[0]);// 5
    System.out.println(a[0]);// 5
}

public static int[] add(int[] x){
    x[0] = 5;
    return x;
}

x是主函数中定义的x数组，其引用就是那个箭头指向的内存地址

x‘是add函数中的形式参数x数组，在方法被调用的时候，主函数中的x数组将其对应的引用地址传值给了x’使x‘的引用地址也指向了同一个地址。在方法中x’用这个地址修改了x[0]的值为5

由于x和x‘的引用指向的地址都没变，所以打印出来的值：x[0] = 5; a[0] = 5;

String类型值传递

public static void main(String[] args) {
    String x = "1";
    String a = add(x);
    System.out.println(x);// 1
    System.out.println(a);// 11
}

public static String add(String x){
    return x + "1";
}

String是一个特殊的引用类型，一旦定义不可更改。其实传值的时候是传入的引用地址，但在方法中返回的是改变了的字符串，字符串是不可更改的，所以在改变的过程中重新生成了一个字符串地址并返回了，作用a指向的引用地址不是x的引用地址了，而x还是指向的原来的地址，所以值是1 

在调用函数时，x将字符串"1"的引用传递给了x’，使x‘也指向字符串"1"。而在方法中我们执行了x+"1"。字符串一定定义不可修改，x+"1"会重新在堆空间创建一个字符"11"。x’会重新指向新创建的字符串“11”的地址。所以最后打印的结果为x="1"，a="11"

方法重载(overload)

• 方法名相同
• 参数个数不同 method(int a); method(int a,int b);
• 参数类型不同 method(int a);method(double a);
• 参数个数和类型都相同，但按顺序的参数类型不相同 method(int a,boolean b);method(boolean b,int a);
• 方法的返回值对方法的重载没有关系
• 访问修饰符与重载没有关系。

public void add(int x,int y){

}
// 参数类型不同，互为重载
public void add(double x,double y){

}
// 按顺序的参数类型不同，互为重载
public void add(double x,int y){

}
// 按顺序的参数类型不同，互为重载
public void add(int x,double y){

}

// 参数个数不同，互为重载
/*    
public void add(){

}
*/

// 返回值不同不是重载，此处编译错误
/*
public int add(){
    return 0;
}
*/

// 形参类型相同，参数名字并不影响重载，此处编译错误
/*    
public void add(int y,int x){

}
*/