Java后端——方法

1方法概述

1.1方法的概念

方法（method）是将具有独立功能的代码块组织成为一个整体，使其具有特殊功能的代码集

注意：

        方法必须先创建才能使用，该过程是方法的定义

        方法创建按后并不能直接运行，需要手动使用后才能执行，该过程是方法的调用

2方法的定义和调用

2.1 无参数方法定义和调用

        定义格式

public static void 方法名（）{
    方法体;
}
例：
public static void example (){
    System.out.println("welcome");
}

        调用格式

方法名（）;
例：
example ();

注意
         方法必须先定义，后调用，否则会报错

2.2方法的调用过程

总结：每个方法在被调用的时候， 都会进入栈内存，并且拥有自己独立的空间，方法内部代码调用完毕之后，会从栈内存弹出消失。

2.3方法练习——奇偶判断

需求：判断一个数是奇数还是偶数

代码：

public class Main {
    public static void main(String[] args) {
        int a=10;
        pan_duan(a);
    }
    public static void pan_duan (int num){
        if (num %2 == 0){
            System.out.println("偶数");
        }
        else {
            System.out.println("奇数");
        }
    }
}

3带参数方法的定义和调用 

3.1带参数方法的定义和调用

        定义格式

public static void 方法名 (参数1) {
	方法体;
}

public static void 方法名 (参数1, 参数2, 参数3...) {
	方法体;
}

例子：
public static void isEvenNumber(int number){
    ...
}
public static void getMax(int num1, int num2){
    ...
}

 注意：方法定义时，参数中的数据类型与变量名都不能缺少，缺少任意一个程序都将报错

方法定义多个时，多个参数之间需要用逗号（，）隔开

        调用格式：

方法名 （参数）；

方法名（参数1，参数2）；

例：

isEvenNumber(10);
​getMax(10,20);

         方法调用的时候，参数的数量与类型必须要与方法定义的类型匹配，不然就会报错

3.2形参和实参

1、形参：

方法定义中的参数

等同于变量定义格式：例如 int number

2、实参：

方法调用中的参数

等同于使用变量或者常量：例如 10 number

3.3带参数方法的练习——打印n-m之间所有的奇数

需求：设计一个方法（print） 用于打印 n 到 m 之间所有的奇数

思路：

1、定义方print（）

2、为方法添加两个int类型的形参，准备接受调用者传递过来的实参

3、方法中设计for循环，从n开始，到m结束

4、循环中加入if判断，如果奇数，则打印

5、main方法中调用print（）方法

代码：

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("输入n: ");
        int n = sc.nextInt();
        System.out.println("输入n: ");
        int m = sc.nextInt();
        print(n,m);
    }
    public static void print(int n,int m){
        for(int i=n;i<=m;i++){
            if (i % 2 != 0 ){
                System.out.print(i+",");
            }
        }
    }
}

4.带返回值方法的调用

4.1带返回值方法的定义和调用

        定义格式

public static 数据类型 方法名 ( 参数 ) { 
	return 数据 ;
}

例：

public static boolean isEvenNumber( int number ) {           
	return true ;
}
public static int getMax( int a, int b ) {
	return  100 ;
}

注意：方法定义时 return 后面的返回值与方法定义上的数据类型要一致，不然会报错

        调用格式

方法名 ( 参数 ) ;
数据类型 变量名 = 方法名 ( 参数 ) ;

例：

isEvenNumber ( 5 ) ;
boolean  flag =  isEvenNumber ( 5 ); 

注意： 方法的返回值通常会使用变量来接受，否则返回值将无意义

4.2带返回值方法的练习——求两个数的最大值

需求：设计一个方法可以获取两个数的较大值，数据来自于参数

思路：

1、定义一个返回值方法，申明两个参数接受计算的值，求出结果并返回

2、使用 if 语句来判断 a ，b 的最大值，然后根据 return 具体结果

3、在 main （）方法中调用

代码：

public class Main {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int max = gexMax(a,b);
        System.out.println(max);
    }
    public static int gexMax(int a,int b){
        return a>b?a:b;
    }
}

5方法的注意事项 

方法中不能嵌套定义

public class MethodDemo {
    public static void main(String[] args) {

    }

    public static void methodOne() {
		public static void methodTwo() {
       		 这里会引发编译错误!!!
    	}
    }
}

 void表示无返回值，可以省略return，也可以单独的书写return，后面不加数据

public class MethodDemo {
    public static void main(String[] args) {

    }
    public static void methodTwo() {
        return 100; 编译错误，因为没有具体返回值类型
        return;	
        System.out.println(100); return语句后面不能跟数据或代码
    }
}

6方法重载 

 6.1方法重载

方法重载概念

        方法重载指同一个类中定义的多个方法之间的关系，满足下列条件的多个方法相互构成重载

                多个方法在同一个类中

                多个方法具有相同的方法名

                多个方法的参数不同，类型不同或者数量不同

注意：重载仅对应方法的定义，与方法的调用无关，调用方法参照标准格式。

重载仅针对同一个类中方法的名称与参数进行识别，与返回值无关，换句话说不能通过返回值来判定两个方法是否相互构成重载

正确示例：

public class MethodDemo {
	public static void fn(int a) {
    	方法体
    }
    public static int fn(double a) {
    	方法体
    }
}

public class MethodDemo {
	public static float fn(int a) {
    	方法体
    }
    public static int fn(int a , int b) {
    	方法体
    }
}

错误示例： 

public class MethodDemo {
	public static void fn(int a) {
    	方法体
    }
    public static int fn(int a) { 	错误原因：重载与返回值无关
    	方法体
    }
}

public class MethodDemo01 {
    public static void fn(int a) {
        方法体
    }
} 
public class MethodDemo02 {
    public static int fn(double a) { 错误原因：这是两个类的两个fn方法
        方法体
    }
}

6.2方法重载练习 

需求：使用方法重载的思想， 设计比较两个整数是否相同的方法，兼容全整数类型（byte,short,int,long）

思路：

1、定义比较两个整数是否相同的 compare（）方法，参数选择两个 int 类型

2、定义对应的重载方法，变更对应的参数类型，参数变更为两个 long 类型

3、定义所有的重载方法，两个byte类型与两个short类型参数

4、完成方法的调用

代码：

public class Main {
    public static void main(String[] args) {
        System.out.println(compare(10, 20));
        System.out.println(compare((byte) 10, (byte) 20));
        System.out.println(compare((short) 10, (short) 20));
        System.out.println(compare(10L, 20L));
    }
    public static byte compare (byte a, byte b) {
        if (a == b) {
         return 0;
        }
        else  {
            return -1;
        }
    }
    public static byte compare (short a, short b) {
        if (a == b) {
            return 0;
        }
        else  {
            return -1;
        }
    }
    public static byte compare (int a, int b) {
        if (a == b) {
            return 0;
        }
        else  {
            return -1;
        }
    }
    public static byte compare (long a, long b) {
        if (a == b) {
            return 0;
        }
        else  {
            return -1;
        }
    }
}

7方法的参数传递

7.1 方法参数传递——基本类型

测试代码：

package com.wedu.param;

public class Test1 {
    /*
         方法参数传递为基本数据类型 :

                传入方法中的, 是具体的数值.
     */
    public static void main(String[] args) {
        int number = 100;
        System.out.println("调用change方法前:" + number);
        change(number);
        System.out.println("调用change方法后:" + number);
    }

    public static void change(int number) {
        number = 200;
    }
}

结果：

结论：

        基本类型的参数，形式参数的改变，不会影响实际参数

结论依据 ：

        每个方法在栈内存中，都有独立的栈空间，方法运行结束后就弹出消失，因此不会影响

7.2方法参数传递——引用类型

测试代码：

package com.wedu.param;

public class Test2 {
    /*
         方法参数传递为引用数据类型 :

                传入方法中的, 是内存地址.
     */
    public static void main(String[] args) {
        int[] arr = {10, 20, 30};
        System.out.println("调用change方法前:" + arr[1]);
        change(arr);
        System.out.println("调用change方法后:" + arr[1]);
    }

    public static void change(int[] arr) {
        arr[1] = 200;
    }
}

结果：

 

 结论：
        对于引用类型参数，形式参数的改变，会影响实际参数的值

结论依据：

        引用数据类型的传参，传入的是地址值，内存会造成两个引用指向同一个内存，所以即使弹出方法栈，堆内存中的数据也是修改以后的结果