Java基础—方法以及方法重载（从0到1完整详解，并附有代码+案例）

方法

7.1 方法定义

• 方法：程序中最小的执行单元

方法定义：把代码打包一起

方法调用：方法定义后不是直接运行的，需要手动调用

方法先定义后调用

public static void  方法名() {
        方法体（打包起来的代码）;
    }
如：
public static void playGame() {
        
    }

• 调用方法

public class demo5 {
    public static void main(String[] args) {
						playGame();//调用方法
    }

    public static void playGame() {

    }
}

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

//定义
public static void 方法( 参数1, 参数2,...) {
                
    }

如：
public static void method1( int a, int b,) {
                
    }

调用：

方法名（参数）；

范例1：

//方法名（参数）；
method1(10);
  
//方法( 参数1, 参数2)
method2( 10,20) ; 

7.3 形参/实参

形参：方法定义中的参数

实参：方法调用中的参数

形参和实参必须要一一对应

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

• 方法的返回值就是方法运行的最终结果。

  什么时候用到返回值的方法：

  在调用出要根据方法的结果 ，去编写另外一段代码

定义格式：

public static 返回值类型 方法名(参数) {
        方法体；
          return 返回值；
    }

范例 ；

public static int getSum(int a ,int b) {
					int c = a+b;
  				return c；
    }

调用：

直接调用：方法名（实参）；
赋值调用：整数类型 变量名 = 方法名（实参）；
输出调用：System.out.println(方法名 (实参));

 public static void main(String[] args) {
       // 1.直接调用   无输出结果
        // getSum(20,30, 40);
        
        // 2.赋值调用
       int num1= getSum(10,20,30);
       int num2= getSum(20,30, 40);
        System.out.println(num1);;
   
   			// 3.输出调用
        System.out.println(num2);

    }

    public static int getSum(int a ,int b ,int c){
        int res = a +b +c;
        return res;
    }

 //目标：要能区分出什么时候使用带返回值的方法
        //需求：定义方法，比较两个长方形的面积
        double area1= getArea(3.1, 3.2);
        double araea2 = getArea(1.3,1.3);
        // System.out.println(area1);
        // System.out.println(araea2);
        if (area1>araea2){

            System.out.println("第一个长方形面积大");
        }else {
            System.out.println("第二个长方形面积大");
        }
        
        
    }

    public static double getArea(double len , double with){
        double area = len*with;
        return area;
    }

7.5 方法小结

• 方法不调用就不执行

• 方法与方法之间是平级关系，不能嵌套定义

  public class MethodDemo {
      public static void main(String[] args) {
    
      }
    
      public static void methodOne() {
  		public static void methodTwo() {
         		// 这里会引发编译错误!!!
      	}
      }
  }
  

• 方法的编写顺序和执行顺序无关

• 方法的返回值类型为void，表示该方法没有返回值，没有返回值的方法可以省略return不写。如果要写return,后面不能跟具体数据

• return语句下面不能编写代码

return关键字：

• 方法没有返回值：可以省略不写，如果书写表示结束方法

• 方法有返回值：必须书写，表示结束方法和返回结果

7.6 方法重载

• 在同一个类中，定义了多个同名的方法，这些同名 的方法的具有同种功能

• 每个方法具有不同的参数类型或参数个数，这些同名的方法 就构成了重载关系

概括：

同一个类中，方法名相同，参数不同的方法，

与返回值、访问修饰符无关

参数不同：个数不同，类型不同，顺序不同。

错误示例：

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方法*/
        //方法体
    }
}

7.7 练习

7.7.1 数组遍历打印

• 需求：设计一个方法用于数组遍历，要求遍历的结果是在一行上的。例如：[11, 22, 33, 44, 55]

package code9;
public class methcode04 {
    public static void main(String[] args) {
        // 需求：设计一个方法用于数组遍历，要求遍历的结果是在一行上的。例如：[11, 22, 33, 44, 55]
        int[] arr = {11,22,33,44,55};
        printArr(arr);
    }

    public static void printArr(int[] arr){
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            if (i==arr.length-1){
                System.out.print(arr[i]);
            }else {
                System.out.print(arr[i]+",");
            }
        }
        System.out.print("]");
    }


}

7.7.2 数组最大值

• 需求：设计一个方法用于获取数组中元素的最大值

• 思路：

  • ①定义一个数组，用静态初始化完成数组元素初始化

  • ②定义一个方法，用来获取数组中的最大值，最值的认知和讲解我们在数组中已经讲解过了

  • ③调用获取最大值方法，用变量接收返回结果

  • ④把结果输出在控制台

package code8;

public class methcode05 {
    public static void main(String[] args) {
        int[] arr={11,54,78,12,3,8,7};
        int max = getMax(arr);
        System.out.println(max);

    }

    public static int getMax(int[] arr){
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i]>max){
                max=arr[i];
            }
        }
        return max;

    }

}

7.7.3 判断数组中是否存在该数据

• 定义一个方法 判断一个数 在数组中是否存在 将结果返回给调用处

package code7;

public class metbcode06 {
    public static void main(String[] args) {
        //定义一个方法 判断一个数 在数组中是否存在 将结果返回给调用处
        int[] arr = {11,54,78,12,3,8,7};
        boolean res =contains(arr,89);
        System.out.println(res);
    }
    public static boolean contains(int[] arr,int number){
        // int number =arr[0];
        for (int i = 0; i < arr.length; i++) {
            if (arr[i]==number){
                return true;
            }
        }
        return false;

    }
// return braeak关键字区别
//return:跟循环无关，跟方法有关，表示：1.结束方法 2.返回结果
//     如果执行到return 那么整个方法全部结束，方法里面的循环也随之结束
//break:跟方法无关，结束循环或者switch的。




}

7.7.4 获取指定索引数据复制到新数组

package code6;

public class meth07 {
    public static void main(String[] args) {
  //需求：定义一个方法copyOfRange(int[]arr,int from ,int to)
  //功能：将数组arr中从索引from（包含from）开始到索引to结束（不包含同）
   //的元素复制到新数组中，将新数组返回

        int[] arr={1,2,3,4,5,6,7,8,9};

        // 调用方法拷贝数据
        int[]  copy=copyOfRange(arr,3 ,7);

        for (int i = 0; i < copy.length; i++) {
            System.out.print(copy[i]+" ");
        }
    }

    public static int[] copyOfRange(int[]arr,int from ,int to){
        //伪造索引思想
        int index=0;

        // 定义新数组的长度
        int[] newArr= new int[to-from];
        for (int i = from; i <to; i++) {
            newArr[index]=arr[i];
            index++;
        }
        return newArr;

    }
}

7.8 方法的内存原理

7.8.1方法调用的基本内存原理

方法被调用之后就会进栈执行，方法执行结束后将会出栈。

先进后出

7.8.2引用和基本类型内存图

基本数据内存图：

变量中存储的是真实的数据值

（此图来自黑马）

引用数据类型内存图：

new出来的都是引用数据类型

如果一个变量存储的是其他空间地址值时，则称这个变量为引用数据类型。

当 arr[1] 修改了内存空间中的数据时，如图将 arr[1]改成20，则 arr2[1]访问时结果也会变成 arr[1] 修改的，因为 arr1 和 arr2 指向同一个内存空间地址值。

7.9 方法的值传递

7.9.1方法传递基本数据类型的内存原理

change( )方法执行后出栈

传递基本数据类型时，传递的是真实的数据，形参的改变，不影响实际参数的值。

7.9.2方法传递引用数据类型的内存原理

传递引用数据类型时，传递的是地址值，形参的改变，影响实际参数的值。

7.10 综合练习

7.10.1 买飞机票

   /* 机票价格按照淡季旺季、头等舱和经济舱收费、输入机票原价、月份和头等舱或经济舱。
    按照如下规则计算机票价格：旺季（5-10月）头等舱9折，经济舱8.5折，淡季（11月到来年4月）头等舱7折，经济舱6.5折。*/

package code3;

import java.util.Scanner;

public class code08 {
    public static void main(String[] args) {
              /* 机票价格按照淡季旺季、头等舱和经济舱收费、输入机票原价、月份和头等舱或经济舱。
        按照如下规则计算机票价格：旺季（5-10月）头等舱9折，经济舱8.5折，淡季（11月到来年4月）头等舱7折，经济舱6.5折。*/

        Scanner sc = new Scanner(System.in);
        System.out.println("请输入机票原价");
        int ticket = sc.nextInt();
        System.out.println("请输入当前月份");
        int month = sc.nextInt();
        System.out.println("请输入仓位：0头等舱 1经济舱");
        int seat = sc.nextInt();

        if (month >= 5 && month <= 10) {
            // 旺季
            if (seat == 0) {
                ticket = (int) (ticket * 0.9);
            } else if (seat == 1) {
                ticket = (int) (ticket * 0.85);
            } else {
                System.out.println("没有这个舱位");
            }

        } else if ((month >= 1 && month <= 4) || (month >= 11 && month <= 12)) {
            // 淡季
            if (seat == 0) {
                ticket = (int) (ticket * 0.7);
            } else if (seat == 1) {
                ticket = (int) (ticket * 0.65);
            } else {
                System.out.println("没有这个舱位");
            }
        } else {
            System.out.println("月份不符合条件");
        }

        System.out.println(ticket);
    }
}

• 优化后

package code2;

import java.util.Scanner;

public class code08_2 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("输入票价");
        int ticket = sc.nextInt();
        System.out.println("输入月份");
        int month = sc.nextInt();
        System.out.println("输入舱位 0头等舱 1经济舱");
        int seat = sc.nextInt();
        if (month >= 5 && month <= 10) {
            // 旺季
            ticket = getPrice(ticket, seat, 0.9, 0.85);

        } else if ((month >= 1 && month <= 4) || (month >= 11 && month <= 12)) {
            // 淡季
            ticket = getPrice(ticket, seat, 0.75, 0.65);

        } else {
            System.out.println("月份不符合");
        }
        System.out.println(ticket);
    }

  //方法
 public static int getPrice(int ticket, int seat, double v0, double v1) {
        if (seat == 0) {
            ticket = (int) (ticket * v0);
        } else if (seat == 1) {
            ticket = (int) (ticket * v1);
        }
        return ticket;
    }

}

• ctrl+alt+m可以自动抽取方法

7.10.2 找质数

• 判断 101 ~ 200 之间有多少个素数，并打印所有素数

package code1;

public class code09 {
    public static void main(String[] args) {
        int count = 0;
     //外循环：遍历101~200这个范围，依次得到这个范围之内的每一个数字
        for (int i = 101; i <= 200; i++) {

            boolean flag = true;
          //内循环:判断当前数字是否为一个质数。
            for (int j = 2; j < i; j++) {
                if (i % j == 0) {
                    flag = false;
                    // System.out.println("不是质数");
                    break;//跳出单层循环 内循环
                }

            }
            if (flag) {
                System.out.println("当前数字" + i + "是质数");
                count++;
            }

        }


    }
}

（此图来自黑马）