01方法的概述

02方法的定义和调用

  1. package com.itheima.method1;
  3. public class Demo1Method {
  4.     /*
  5.        方法的定义格式:
  7.                public static void 方法名 (){
  8.                    方法体
  9.                }
  11.        方法的调用格式:
  13.                方法名();
  15.        注意: 方法与方法之间是平级关系, 不能嵌套定义
  16.     */
  17.     public static void main(String[] args) {
  18.         eat();
  19.     }
  21.     public static void eat (){
  22.         study();
  23.         System.out.println("吃饭");
  24.     }
  26.     public static void study(){
  27.         System.out.println("学习");
  28.     }
  30. }

03方法的调用过程

image.png

04方法练习-奇偶数判断

  1. package com.itheima.method1;
  3. public class Demo2Method {
  4.     /*
  5.         需求：设计一个方法method，方法中定义一个变量(数值随意)
  6.         判断这个变量是奇数还是偶数，并在main方法中调用method。
  8.         1. 定义method方法
  9.         2. 方法中定义变量, 使用if语句判断是奇数还是偶数
  10.         3. main方法中调用method
  11.      */
  12.     public static void main(String[] args) {
  13.         // 3. main方法中调用method
  14.         method();
  15.     }
  17.     // 1. 定义method方法
  18.     public static void method(){
  19.         //  2. 方法中定义变量, 使用if语句判断是奇数还是偶数
  20.         int num = 11;
  21.         if(num % 2 == 0){
  22.             System.out.println("偶数");
  23.         }else{
  24.             System.out.println("奇数");
  25.         }
  26.     }
  28. }

05带参方法的定义和调用

  1. package com.itheima.method2;
  3. public class Demo1Method {
  4.     /*
  6.         带参数方法的定义格式:
  7.                 public static void 方法名  ( 参数 )  { … … }
  8.                 public static void 方法名  ( 数据类型 变量名 )  { … … }
  10.         带参数方法的调用格式:
  11.                 方法名 ( 参数 ) ;
  12.                 方法名 ( 变量名/常量值 ) ;
  14.         tips: 参数可以是一个, 也可以是多个.
  16.         需求: 判断一个数是奇数还是偶数
  17.      */
  18.     public static void main(String[] args) {
  19.         isEvenNumber(10);
  20.     }
  22.     public static void isEvenNumber(int num){
  23.         if(num % 2 == 0){
  24.             System.out.println("偶数");
  25.         }else{
  26.             System.out.println("奇数");
  27.         }
  28.     }
  30. }

06形参和实参

image.png

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

  1. package com.itheima.method2;
  3. public class Demo2Method {
  4.     /*
  5.         需求：设计一个方法（print） 用于打印 n 到 m 之间所有的奇数
  7.         思路：
  8.         1：定义方法，名称为print
  9.         2：为方法添加两个int类型的形参，准备接受调用者传递过来的实参
  10.         3：方法中设计for循环，循环从n开始，到m结束
  11.         4：循环中加入if判断，是奇数，则打印
  12.         5：main方法中调用print方法，传入两个实际参数
  14.      */
  15.     public static void main(String[] args) {
  16.         // 5：main方法中调用print方法，传入两个实际参数
  17.         print(10,20);
  18.     }
  20.     //1：定义方法，名称为print
  21.     // 2：为方法添加两个int类型的形参，准备接受调用者传递过来的实参
  22.     public static void print(int n, int m){
  23.         System.out.println(n + "到" + m + "之间的奇数为:");
  24.         // 3：方法中设计for循环，循环从n开始，到m结束
  25.         for(int i = n; i <= m; i++){
  26.             // 4：循环中加入if判断，是奇数，则打印
  27.             if(i % 2 == 1){
  28.                 System.out.println(i);
  29.             }
  30.         }
  31.     }
  33. }

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

  1. package com.itheima.method3;
  3. public class Demo1Method {
  4.     /*
  5.         带返回值方法的定义格式:
  6.             public static 数据类型  方法名 ( 参数 ) {
  7.                     return 数据 ;
  8.             }
  10.            方法定义时return后面的返回值与方法定义上的数据类型要匹配，否则程序将报错
  12.         带返回值方法的调用格式:
  13.            数据类型 变量名 = 方法名 ( 参数 ) ;
  15.         需求: 定义一个方法, 计算两个整数相加的和
  16.      */
  17.     public static void main(String[] args) {
  18.         int num = add(10,20);
  19.         System.out.println(num);
  20.     }
  22.     public static int add(int a, int b){
  23.         int c = a + b;
  24.         return c;
  25.     }
  27. }

09带返回值方法的练习-求两个数的最大值

  1. package com.itheima.method3;
  3. public class Demo2Method {
  4.     /*
  5.         需求：设计一个方法可以获取两个数的较大值，数据来自于参数
  7.         1. 定义一个方法，声明两个形参接收计算的数值，求出结果并返回
  8.         2. 使用 if 语句 得出 a 和 b 之间的最大值，根据情况return具体结果
  9.         3. 在main()方法中调用定义好的方法并使用 【 变量保存 】
  10.      */
  11.     public static void main(String[] args) {
  12.         // 3. 在main()方法中调用定义好的方法并使用 【 变量保存 】
  13.         System.out.println(getMax(10,20));  // 输出调用
  15.         int result = getMax(10,20);
  16.         System.out.println(result);
  18.         for(int i = 1; i <= result; i++){
  19.             System.out.println("HelloWorld");
  20.         }
  22.     }
  24.     // 方法可以获取两个数的较大值
  25.     public static int getMax(int a, int b){
  26.         if(a > b){
  27.             return a;
  28.         }else{
  29.             return b;
  30.         }
  31.     }
  33. }

10方法通用格式

image.png

11方法的注意事项

  1. package com.itheima.method4;
  2. public class Demo1Method {
  3.     public static void main(String[] args) {
  4.         print(10,20);
  5.     }
  6.     public static void print(int n, int m){
  7.         if(m < n){
  8.             System.out.println("您传入的数据有误, 请检查");
  9.             // return; 可以用于结束方法, 也就是将方法从栈内存中弹出去, 该过程称之为方法的弹栈
  10.             return;
  11.             // System.out.println();  无法执行的代码, 无效代码
  12.             // 问题: return语句下面, 不是不能写代码吗?
  13.         }
  14.         System.out.println(n + "到" + m + "之间的奇数为:");
  15.         for(int i = n; i <= m; i++){
  16.             if(i % 2 == 1){
  17.                 System.out.println(i);
  18.             }
  19.         }
  20.     }
  21. }

12方法重载

方法名相同,同一位上参数列表不同

13方法重载练习

  1. package com.itheima.overload;
  3. public class Demo1Overload {
  4.     /*
  5.             需求：使用方法重载的思想，设计比较两个整数是否相同的方法，兼容全整数类型（byte,short,int,long）
  6.      */
  7.     public static void main(String[] args) {
  8.         short a = 10;
  9.         short b = 20;
  10.         System.out.println(compare(a,b));
  11.     }
  13.     public static boolean compare (int a, int b){
  14.         return a == b;
  15.     }
  17.     public static boolean compare (byte a, byte b){
  18.         return a == b;
  19.     }
  21.     public static boolean compare (short a, short b){
  22.         return a == b;
  23.     }
  25.     public static boolean compare (long a, long b){
  26.         return a == b;
  27.     }
  29. }

14方法参数传递基本数据类型

  1. package com.itheima.param;
  3. public class Test1 {
  4.     /*
  5.          方法参数传递为基本数据类型 :
  7.                 传入方法中的, 是具体的数值.
  8.      */
  9.     public static void main(String[] args) {
  10.         int number = 100;
  11.         System.out.println("调用change方法前:" + number);
  12.         change(number);
  13.         System.out.println("调用change方法后:" + number);
  14.     }
  16.     public static void change(int number) {
  17.         number = 200;
  18.     }
  20. }

15方法参数传递引用数据类型

  1. package com.itheima.param;
  3. public class Test2 {
  4.     /*
  5.          方法参数传递为引用数据类型 :
  7.                 传入方法中的, 是内存地址.
  8.      */
  9.     public static void main(String[] args) {
  10.         int[] arr = {10, 20, 30};
  11.         System.out.println("调用change方法前:" + arr[1]);
  12.         change(arr);
  13.         System.out.println("调用change方法后:" + arr[1]);
  14.     }
  16.     public static void change(int[] arr) {
  17.         arr[1] = 200;
  18.     }
  20. }

16数组遍历

  1. package com.itheima.test;
  3. public class Test1 {
  4.     /*
  5.         需求：设计一个方法用于数组遍历，要求遍历的结果是在一行上的。例如：[11, 22, 33, 44, 55]
  6.         思路：
  7.             1.定义一个数组，用静态初始化完成数组元素初始化
  8.             2.定义一个方法，对数组进行遍历
  9.             3.遍历打印的时候，数据不换行
  10.             4.调用遍历方法
  11.      */
  12.     public static void main(String[] args) {
  13.         // 1.定义一个数组，用静态初始化完成数组元素初始化
  14.         int[] arr = {11, 22, 33, 44, 55};
  15.         // 4.调用遍历方法
  16.         printArray(arr);
  18.         System.out.println("另外一段代码逻辑 ");
  19.     }
  21.     /*
  22.         2.定义一个方法，对数组进行遍历
  24.         1, 参数           int[] arr
  25.         2, 返回值类型      void
  26.      */
  27.     public static void printArray(int[] arr){
  29.         System.out.print("[");
  31.         for (int i = 0; i < arr.length; i++) {
  33.             if(i == arr.length -1){
  34.                 // 如果满足条件, 说明是最后一个元素, 最后一个元素, 特殊处理
  35.                 System.out.println(arr[i] + "]");
  36.             }else{
  37.                 // 3.遍历打印的时候，数据不换行
  38.                 System.out.print(arr[i] + ", ");
  39.             }
  42.         }
  43.     }
  45. }

17获取数组最大值

  1. package com.itheima.test;
  3. public class Test2 {
  4.     /*
  5.         需求：设计一个方法用于获取数组中元素的最大值
  7.         思路：
  8.             1.定义一个数组，用静态初始化完成数组元素初始化
  9.             2.定义一个方法，用来获取数组中的最大值
  10.             3.调用获取最大值方法，用变量接收返回结果
  11.             4.把结果输出在控制台
  13.      */
  14.     public static void main(String[] args) {
  15.         // 1.定义一个数组，用静态初始化完成数组元素初始化
  16.         int[] arr = {11, 55, 22, 44, 33};
  17.         // 3.调用获取最大值方法，用变量接收返回结果
  18.         int max = getMax(arr);
  19.         //  4.把结果输出在控制台
  20.         System.out.println(max);
  21.     }
  23.     /*
  24.         2.定义一个方法，用来获取数组中的最大值
  26.         1, 参数       int[] arr
  27.         2, 返回值类型  int
  28.      */
  29.     public static int getMax(int[] arr){
  30.         int max = arr[0];
  31.         for (int i = 1; i < arr.length; i++) {
  32.             if(max < arr[i]){
  33.                 max = arr[i];
  34.             }
  35.         }
  36.         return max;
  37.     }
  39. }

18方法同时获取数组最大值和最小值

  1. package com.itheima.test;
  3. public class Test3 {
  4.     /*
  5.         需求：设计一个方法，该方法能够同时获取数组的最大值，和最小值
  7.         注意: return语句, 只能带回一个结果.
  8.      */
  9.     public static void main(String[] args) {
  11.         int[] arr = {11,55,33,22,44};
  13.         int[] maxAndMin = getMaxAndMin(arr);
  15.         System.out.println(maxAndMin[0]);
  16.         System.out.println(maxAndMin[1]);
  18.     }
  20.     public static int[] getMaxAndMin(int[] arr){
  21.         int max = arr[0];
  22.         for (int i = 1; i < arr.length; i++) {
  23.             if(max < arr[i]){
  24.                 max = arr[i];
  25.             }
  26.         }
  28.         int min = arr[0];
  29.         for (int i = 1; i < arr.length; i++) {
  30.             if(min > arr[i]){
  31.                 min = arr[i];
  32.             }
  33.         }
  35.         int[] maxAndMin = {min, max};
  37.         return maxAndMin;
  38.     }
  40. }