Java基础学习day05

01 - 方法的基本概述

什么是方法？

• 方法是将具有独立功能的代码组成一个整体，使其成为具有特殊功能的代码块.

 

方法的两个注意：

• 方法必须先定义才能使用。（方法定义）

• 方法定义后不会自动运行，需要手动调用才能执行方法的功能。（方法调用）

 

小结:

 

了解方法的基本概念？（方法的作用） 

• 方法(函数)的作用 : 将一个具备固定功能的代码封装起来，提高功能代码复用性

/*
目前存在的问题：
    1. 没有符合我的需求。
    2. 冗余代码多，代码没有任何的复用性。

体验：自定义方法。


方法(函数)的作用 : 将一个具备固定功能的代码封装起来，让功能代码可以被复用。

 */
public class Demo1 {

    public static void main(String[] args) {
     /*   //需求：计算两个数据的总和
        int a = 3;
        int b =5;
        int sum = a+b;
        System.out.println("总和："+sum);


         a = 6;
         b =7;
         sum = a+b;
        System.out.println("总和："+sum);


        a = 7;
        b =8;
        sum = a+b;
        System.out.println("总和："+sum);*/

        //调用方法
        sum(1,1);
        sum(6,7);

    }

//  方法：将加法求和的功能封装到一个方法中。
    public static void sum(int a , int b){
        int result = a+b;
        System.out.println("结果："+ result);
    }
}

 

 

方法具备什么特点？

• 方法是需要调用才会执行的，唯独main方法除外，main方法是属于jvm调用的。

• 方法必须要先定义才能使用。

 

 

 

02-方法的定义格式

public static void 方法名(){
    方法体代码; //需要在方法内完成的代码
}

 

调用格式：在main方法中，通过方法名调用

方法名();

---------------------------------------------------------

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

    定义格式：
        public static void 方法名 ( ) {
            //方法体
        }

    调用格式：
        方法名();
 */
public class MethodDemo {
    public static void main(String[] args) {
        //调用方法
        isEvenNumber();
    }

    //需求：定义一个方法，在方法中定义一个变量，判断该数据是否是偶数
    public static  void isEvenNumber() {
        //定义变量
        int number = 10;
        number = 9;

        //判断该数据是否是偶数
        if(number%2 == 0) {
            System.out.println(true);
        } else {
            System.out.println(false);
        }
    }
}//注意：方法名的命名规范只要符合标识符的命名规范即可。建议使用小驼峰命名规范//在main方法中调用。 调用格式：  方法名();

 

 

03-方法的练习

 

/*
    需求：
        设计一个方法用于打印两个数中的较大数

    思路：
        1:定义一个方法，用于打印两个数字中的较大数，例如getMax()
        2:方法中定义两个变量，用于保存两个数字
        3:使用分支语句分两种情况对两个数字的大小关系进行处理
        4:在main()方法中调用定义好的方法
 */
public class MethodTest {
    public static void main(String[] args) {
        //在main()方法中调用定义好的方法
        getMax();
    }

    //定义一个方法，用于打印两个数字中的较大数，例如getMax()
    public static void getMax() {
        //方法中定义两个变量，用于保存两个数字
        int a = 10;
        int b = 20;

        //使用分支语句分两种情况对两个数字的大小关系进行处理
        if(a > b) {
            System.out.println(a);
        } else {
            System.out.println(b);
        }
    }

}

 

 

 

 

04-带参数的方法

 

 

定义带参方法的格式

 

public static void 方法名( 参数类型1 参数名1, 参数类型2 参数名2, ...){
    方法体代码; 
}

注意：
    方法的参数，可以是一个，也可以是多个，如果是多个，中间需要以逗号分隔。

 

 

调用格式：

 

在main方法中，通过方法名调用，并传入对应的参数值

方法名(参数值);

 

调用带参方法的注意事项:

 

• 调用带参方法，传入方法括号里的参数，无论个数和类型，都必须和方法定义时的个数和类型匹配。

• 传入方法的参数，可以是变量，也可以是常量。

/*
    带参数方法的定义和调用

    定义格式：
        public static void 方法名(参数) { … … }

    调用格式：
        方法名(参数);
 */
public class MethodDemo {
    public static void main(String[] args) {
        //常量值的调用
        isEvenNumber(10);

        //变量的调用
        int number = 10;
        isEvenNumber(number);
    }

    //需求：定义一个方法，该方法接收一个参数，判断该数据是否是偶数
    public static void isEvenNumber(int number) {
        if(number%2 == 0) {
            System.out.println(true);
        } else {
            System.out.println(false);
        }
    }

}

 

小结

什么时候定义带参的方法？

 

定义一个功能的时候，如果该功能方法有未知的数据，那么我们即可把未知的数据定义成形式参数。

 

/*

形式参数

第一个问题：未知的数据应该定义为形式参数。

需求 :  定义一个方法打印多行******给我。

未知的数据： 行数？

*/

public class Demo3 {

    public static void main(String[] args) {
        //未知的数据我们需要交给调用方法的时候确定的。
        print(1000);
    }

    public static void print(int rows){ //因为多少行是未知，所以定义为形式参数。
        for (int i = 0; i <rows ; i++) {
            System.out.println("*******");
        }
    }
}

 

调用带参的方法需要注意哪些事项？

• 形式参数的个数要与实际参数的个数一致

• 形式参数的类型要与实际参数的类型一致。

 

05-形参与实参

• 形参，也叫形式参数，指的是定义方法的时候，方法小括号中定义的参数。
• 实参，也叫实际参数，指的是调用方法的时候，传入小括号中的常量或变量。

 

 

/*
    需求：
        设计一个方法用于打印两个数中的较大数，数据来自于方法参数

    思路：
        1:定义一个方法，用于打印两个数字中的较大数，例如getMax()
        2:为方法定义两个参数，用于接收两个数字
        3:使用分支语句分两种情况对两个数字的大小关系进行处理
        4:在main()方法中调用定义好的方法（使用常量）
        5:在main()方法中调用定义好的方法（使用变量）
 */
public class MethodTest {
    public static void main(String[] args) {
        //在main()方法中调用定义好的方法（使用常量）
        getMax(10,20);
        //调用方法的时候，人家要几个，你就给几个，人家要什么类型的，你就给什么类型的
        //getMax(30);
        //getMax(10.0,20.0);

        //在main()方法中调用定义好的方法（使用变量）
        int a = 10;
        int b = 20;
        getMax(a, b);
    }

    //定义一个方法，用于打印两个数字中的较大数，例如getMax()
    //为方法定义两个参数，用于接收两个数字
    public static void getMax(int a, int b) {
        //使用分支语句分两种情况对两个数字的大小关系进行处理
        if(a > b) {
            System.out.println(a);
        } else {
            System.out.println(b);
        }
    }

}

//方法可以接收两个整数，在方法内进行逻辑判断，打印出两个数中的较大值。

 

05-带返回值的方法

 

定义格式：

 

public static 数据类型 方法名(参数列表){
    方法体代码;
    return 数据值;
}

 

 

1-格式要求

 

有返回值类型，就必须要有return语句。

 

返回值必须和返回值类型相匹配。

 

2-return语句的作用

 

return语句用于将方法的运算结果返回给调用者。

 

return语句一旦执行，方法的调用就结束了。

 

 

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

    定义格式：
        public static 数据类型 方法名(参数) {
            return 数据;
        }

    调用格式：
        1:方法名(参数);
        2:数据类型 变量名 = 方法名(参数);
 */
public class MethodDemo {
    public static void main(String[] args) {
        //1:方法名(参数);
        //isEvenNumber(10);
        //true;

        //2:数据类型 变量名 = 方法名(参数);
        boolean flag = isEvenNumber(10);
        //boolean flag = true;
        System.out.println(flag);
    }

    //需求：定义一个方法，该方法接收一个参数，判断该数据是否是偶数，并返回真假值
    public static boolean isEvenNumber(int number) {
        if(number%2 == 0) {
            return true;
        } else {
            return false;
        }
    }

}

 

小结:

 

         1-返回值类型与return返回的数据有什么关系

               return 返回的数据应该要与返回值类型一致。

 

 

          2-返回的数据给谁？

               返回的数据是给调用者。

 

               注意：如果一个方法不需要返回值，那么返回值类型必须使用void关键字

          3-不带返回值的方法调用形式

 

               直接调用

 

　　   4-带返回值的方法的调用形式

　　　　直接调用

　　　　定义变量接收结果

　　　　直接使用返回值的结果

 

/*
练习：定义一个方法比较两个参数的最大值，并且把最大值返回给调用者

定义方法需要两个明确：

    - 明确是否有未知的数据---形参
    - 明确是否要返回值与返回值类型  int a, int b

需求分析：
    1. 未知数据： 到底是那两个数据。
    2. 返回值类型是： int

 */
public class Demo6 {

    public static void main(String[] args) {
        //调用方法
        int max = getMax(4,8);
        System.out.println(max);
    }

    public static int getMax(int a, int b){
        if(a>b){
            return a;
        }else{
            return b;
        }
    }


}

 

　06-方法使用注意的事项

1. 方法与方法之间是平级关系，不允许嵌套定义。

2. 方法有明确返回值类型时，必须要有return语句返回对应的数据。

3. 返回值类型为void，则代表无返回值，可以省略return语句，也可以单独使用return关键字，用于结束方法，但是return后面不能跟任何数值。

4. 方法有形参时，调用时必须传递实参，传递的实参个数和类型必须和形参匹配。

5. return语句后面不能直接跟其他代码。

//定义方法，求两个整数的较大值，并返回较大的值。
public class MethodDemo2 {
    public static void main(String[] args) {
    }

    // 定义方法，求两个整数的较大值，并返回较大的值。
  
    // 该方法会编译报错，因为编译器认为只要是if语句，就有可能不执行，方法就有可能没有return语句。
    public static int getMax(int a, int b){
        if(a>b){
            return a;
        }
        
        if(a<=b){
            return b;
        }
       
    }
}

 

/*
return 关键字的作用：
    1. 在方法内部返回数据给调用者。
    2. 结束一个方法。

break关键字与return关键字的区别：
    1. break关键字的作用是结束当前的循环语句。
    2. return关键字的作用是可以结束当前的方法。

 */
public class Demo7 {

    public static void main(String[] args) {
        print();
    }

    //该方法是没有返回值类型的，但是也可以出现return关键字，这时候return关键字的作用：结束方法。
    public static void print(){
        for (int i = 0; i <4 ; i++) {
            if(i==2){
                return;  //return 关键字的作用：结束当前所在的方法。
               // break;
            }
            System.out.println("i="+i); //0 1
        }
        System.out.println("haha");

    }
}

 

07-方法通用格式

public static  返回值类型  方法名(参数类型  参数名1, 参数类型  参数名2, ...){
    方法体代码;
    return 返回值;
}

 

格式说明:

1. public static：public和static都是关键字，具有特殊的含义。

2. 返回值类型：方法有返回值时写返回值类型（基本数据类型、引用数据类型），没有返回值时写void。

3. 方法名：用于方法调用时使用。

4. ( )：括号里面写参数列表，多个参数使用逗号隔开，没有参数时直接写 ( ) 即可。

5. 参数类型：限定传入方法的参数的数据类型。（基本数据类型、引用数据类型）

6. 参数名：用于接收传入方法的数据。

7. { }：大括号和里面的代码称为方法体。

8. return：方法有返回值时需要使用return关键字，返回对应的类型的数据, 没有返回值（void）时不用写return语句。

 

定义方法的两个明确

 

定义方法的两个明确：

1. 明确返回值类型：确定方法是否需要返回值，以及返回值的类型。
2. 明确参数：明确参数的类型和个数。

 

//两个明确
1. 未知数据，int类型的数组
2. 返回值类型  int


public static  int   sum(int[] arr){
    //定义一个变量用于保存数据的总和
    int sum = 0;
    for(int  i = 0; i<arr.length ; i++){
        //把每一个元素都加到sum中。
        sum+=arr[i];
    
    }
    //由于需要返回给调用者
    return sum；

}

 

小结

　　方法定义的两个明确？

• 明确返回值类型，如果没有返回值使用void关键字，如果有返回值则写上对应的数据类型

• 是否有未知的数据，如果有未知的数据则定义为形式参数。

 

08-什么是方法的重载

 

什么是方法重载

• 同一个类中，出现了多个同名的方法，叫做方法重载。

 

构成方法重载的条件（重要)

1. 多个方法在同一个类中。
2. 多个方法名称相同。
3. 多个方法的参数列表不同（个数或者类型不同）。

注意：
    方法重载与返回值和参数名称无关。
    
简单总结： 
    同一类中，方法名称相同，参数列表不同，即构成方法重载。

 

方法重载的作用

方便程序员对参数不同，但是功能相同或相似的方法进行统一的命名和调用。

调用重载的方法

调用时，虚拟机会根据参数列表的不同来区分调用对应的重载方法。

 

/*
    方法重载：
        多个方法在同一个类中
        多个方法具有相同的方法名
        多个方法的参数不相同，类型不同或者数量不同

        与返回值无关
        在调用的时候，Java虚拟机会通过参数的不同来区分同名的方法
 */
public class MethodDemo {
    public static void main(String[] args) {
        //调用方法
        int result = sum(10,20);
        System.out.println(result);

        double result2 = sum(10.0,20.0);
        System.out.println(result2);

        int result3 = sum(10,20,30);
        System.out.println(result3);
    }

    //需求1：求两个int类型数据和的方法
    public static int sum(int a, int b) {
        return a + b;
    }

    //需求2：求两个double类型数据和的方法
    public static double sum(double a, double b) {
        return a + b;
    }

    //需求3：求三个int类型数据和的方法
    public static int sum(int a, int b, int c) {
        return a + b + c;
    }

}

 

小结

1. 函数重载的概念？

   在同一类中定义两个或者两个以上的同名方法称作为函数的重载。

2. 函数重载的作用？

   同一个方法名可以定义多个方法，适用于不同类型的参数，满足不同的需求。

3. 函数重载的条件？

   • 同一个类

   • 同一个方法名

   • 不同的形式参数列表(形式参数的个数不一致或者是形式参数的类型不一致)

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

    思路：
        1:定义比较两个数字的是否相同的方法compare()方法，参数选择两个int型参数
        2:定义对应的重载方法，变更对应的参数类型，参数变更为两个long型参数
        3:定义所有的重载方法，两个byte类型与两个short类型参数
        4:完成方法的调用，测试运行结果
 */
public class MethodTest {
    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));
    }

    //int
    public static boolean compare(int a, int b) {
        System.out.println("int");
        return a == b;
    }

    //byte
    public static boolean compare(byte a, byte b) {
        System.out.println("byte");
        return a == b;
    }

    //short
    public static boolean compare(short a, short b) {
        System.out.println("short");
        return a == b;
    }

    //long
    public static boolean compare(long a, long b) {
        System.out.println("long");
        return a == b;
    }

}

 

 

09-值传递

 

基本数据类型

/*
    对于基本数据类型的参数，形式参数的改变，不影响实际参数的值
 */
public class ArgsDemo01 {
    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;
    }
}

 

引用数据类型

/*
    对于引用类型的参数，形式参数的改变，影响实际参数的值
 */
public class ArgsDemo02 {
    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;
    }
}

 

10-数组遍历

/*
    数组遍历

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

    思路：
        1:因为要求结果在一行上输出，所以这里需要在学习一个新的输出语句System.out.print(“内容”);
            System.out.println(“内容”); 输出内容并换行
            System.out.print(“内容”); 输出内容不换行
            System.out.println(); 起到换行的作用
        2:定义一个数组，用静态初始化完成数组元素初始化
        3:定义一个方法，用数组遍历通用格式对数组进行遍历
        4:用新的输出语句修改遍历操作
        5:调用遍历方法
 */
public class MethodTest01 {
    public static void main(String[] args) {
//        System.out.println("hello");
//        System.out.println("world");
//        System.out.print("hello");
//        System.out.print("world");
//        System.out.println();

        //定义一个数组，用静态初始化完成数组元素初始化
        int[] arr = {11, 22, 33, 44, 55};

        //调用方法
        printArray(arr);
    }

    //定义一个方法，用数组遍历通用格式对数组进行遍历
    /*
        两个明确：
            返回值类型：void
            参数：int[] arr
     */
    /*
    public static void printArray(int[] arr) {
        for(int x=0; x<arr.length; x++) {
            System.out.println(arr[x]);
        }
    }
    */
    public static void printArray(int[] arr) {
        System.out.print("[");
        for(int x=0; x<arr.length; x++) {
            if(x == arr.length-1) {
                System.out.print(arr[x]);
            } else {
                System.out.print(arr[x]+", ");
            }
        }
        System.out.println("]");
    }
}

 

11-获取数组的最大值

/*
    数组最大值

    需求：
        设计一个方法用于获取数组中元素的最大值，调用方法并输出结果

    思路：
        1:定义一个数组，用静态初始化完成数组元素初始化
        2:定义一个方法，用来获取数组中的最大值
        3:调用获取最大值方法，用变量接收返回结果
        4:把结果输出在控制台
 */
public class MethodTest02 {
    public static void main(String[] args) {
        //定义一个数组，用静态初始化完成数组元素初始化
        int[] arr = {12, 45, 98, 73, 60};

        //调用获取最大值方法，用变量接收返回结果
        int number = getMax(arr);

        //把结果输出在控制台
        System.out.println("number:" + number);
    }

    //定义一个方法，用来获取数组中的最大值
    /*
        两个明确：
            返回值类型：int
            参数：int[] arr
     */
    public static int getMax(int[] arr) {
        int max = arr[0];

        for(int x=1; x<arr.length; x++) {
            if(arr[x] > max) {
                max = arr[x];
            }
        }

        return max;
    }

}

 

来源：https://www.cnblogs.com/ctw-C/p/11441209.html