今日内容

1.方法的定义

格式:
    修饰符  返回值类型  方法名 (参数类型 参数名){
        方法体;
    }
    
    
没有返回值:
    返回值类型写void,也可以出现return,只不过return后面不能写值,这个return表示结束方法

有返回值:
    如果有返回值类型,方法内必须要使用return 值; 用来返回一个结果

2.方法的调用

没有返回值:
    直接调用: 
        方法名(参数);
    
有返回值:
    赋值调用: 
        数据类型 变量名 = 方法名(参数);
    输出调用: 
        System.out.println(方法名(参数));

3.方法的参数

参数:
    是方法中需要的数据,方法中需要什么未知数就定义成参数

注意事项:
    1.形参要什么类型,实参就给什么类型
    2.形参要几个,实参就给几个
    3.定义方法的时候参数可以定义任何类型,任何个数,具体写什么要根据方法的功能决定
    
形参和实参:
    形参就是形式参数,在定义方法时的参数就是形参
    实参就是实际参数,在调用方法时的参数就是实参
public class Demo03 {
    public static void main(String[] args) {
        //调用方法
        getSum(10,20);

        //调用方法
        getSum(11,22);
    }

    //定义方法求两个整数的和
    public static void getSum(int a,int b){
        int c = a + b;
        System.out.println(c);
    }

}

4.方法的返回值

返回值: 
    返回值就是方法给调用者返回的结果,返回值可以是任意类型

注意事项:
     如果没有返回值就要写void
     如果有返回值写对应的返回值类型,如果有返回值,就要使用return来返回结果
public class Demo06 {
    public static void main(String[] args) {
        //调用
        int sum = getSum(10,20);
        //打印
        System.out.println(sum);
    }

    //定义方法  求两个整数的和
    public static int getSum(int a,int b){
        //求和
        int c = a + b;
        //返回结果
        return c;
    }
}

5.方法的好处

方法可以减少重复编写代码,提高代码的复用性
但是不能提高效率

6.参数返回值的练习

package com.itheima01;

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

        //调用方法
        String s = getGift(100);
        //输出
        System.out.println(s);

        //调用方法
        System.out.println(getGift(59));
    }

    /*
    方法的功能: 根据小明考试的分数得到对应的奖励
                  95 ~ 100    自行车一辆
                  90 ~ 94     游乐园一天
                  80 ~ 89     玩具一个
                  0  ~ 79     打一顿
     */
    public static String getGift(int n){
        if(n>=95 && n<= 100){
            return "自行车一辆";
        }else if(n>=90 && n<=94){
            return "游乐园一天";
        }else if(n>=80 && n<=89){
            return "玩具一个";
        }else if(n>=0 && n<=79){
            return "打一顿";
        }else {
            return "分数有误";
        }
    }

}

7.方法的重载

概念:
    在一个类中,可以出现方法名相同的多个方法,要求参数不同(类型不同,或数量不同),和返回值无关.
    
好处:
    功能相同的方法名字就相同,减轻程序员的记忆负担...
package com.itheima02;

public class Demo01 {

    public static void main(String[] args) {
        //调用方法
        int result1 = getSum(10,20);
        System.out.println(result1);

        int result2 = getSum(10,20,30);
        System.out.println(result2);

        double result3 = getSum(2.14,1.32);
        System.out.println(result3);
    }

    //定义方法,求两个整数的和
    public static int getSum(int a, int b){
        int c = a + b;
        return c;
    }

    //定义方法,求三个整数的和
    public static int getSum(int a,int b ,int c){
        int d = a + b + c;
        return d;
    }

    //定义方法,求两个小数的和
    public static double getSum(double a, double b){
        double c = a + b;
        return c;
    }
}
判断下面哪个方法和题干是重载:

​ public static int getSum(int a, double b){} (A B C )

A.public static void getSum(double b, int a){}

B.public static int getSum(double a, int b){}

C.public static int getSum(){}

D.public static void getSum(int b , double a){}

8.数据类型

数据类型
    基本数据类型:
        byte  short   int   long
        float  double
        char
        boolean
    
    引用数据类型:
        数组
            int[]   String[]   double[]...
        类
            String ....
        接口
        枚举
    
基本类型和引用类型的区别:
        基本类型变量里面保存的是值
            int a = 10;
        引用类型变量里面保存的是地址值,所有的引用类型都可以赋值null,null代表空地址值
            int[] arr = new int[4];
            

9.练习引用类型作为方法参数

9.1 定义方法遍历数组

package com.itheima02;

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

        //定义数组
        int[] arr = {11,22,33,44};
        //调用方法
        printArr(arr);
    }


    //定义方法
    //方法可以遍历一个数组
    public static void printArr(int[] arr){

        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

9.2方法求数组最大值

package com.itheima02;

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

        //定义数组
        int[] arr = {123,2,4,35,4,76,8,78};
        //调用方法
        int max = getMax(arr);
        //输出
        System.out.println(max);

    }


    //定义方法,方法可以求一个整数数组的最大值并返回
    public static int getMax(int[] arr){
        //定义max变量
        int max = arr[0];
        //遍历数组
        for (int i = 1; i < arr.length; i++) {
            //判断比较
            if(arr[i] > max){
                //把较大值赋值给max
                max = arr[i];
            }
        }
        //返回结果
        return max;

    }
}

10.基本类型和引用类型作为参数的区别

package com.itheima02;

import java.util.Arrays;

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

        //基本数据类型  和  引用数据类型的区别
        //基本类型变量里面保存的是值,引用类型变量里面保存的是地址值
        //基本类型
        int a = 10;
        int b = a;

        //改变a的值
        a = 20;
        //打印
        System.out.println(a);  //20
        System.out.println(b);  //10


        //引用类型
        int[] arr = {10,10,10};
        int[] brr = arr;

        //改变arr的元素
        arr[0] = 20;
        //打印
        System.out.println(Arrays.toString(arr)); // 20 10 10
        System.out.println(Arrays.toString(brr)); // 20 10 10
    }
}

类型区别

public class Demo07 {
    public static void main(String[] args) {
        //定义变量
        int a = 10;
        //调用方法
        method(a);
        //打印变量
        System.out.println(a);    // 10
    }


    //定义方法
    public static void  method(int b){
        //修改变量
        b = 20;
    }
}

import java.util.Arrays;
public class Demo08 {
    public static void main(String[] args) {
        //定义数组
        int[] arr = {11,22,33};
        //调用方法
        method(arr);
        //输出数组
        System.out.println(Arrays.toString(arr)); // 100 22 33
    }

    //定义方法
    public static void method(int[] brr){
        brr[0] = 100;
    }
}

类型区别2

知识点

题目1(训练)

定义一个方法,该方法能够找出两个小数中的较小值并返回。在主方法中调用方法进行测试。

训练提示

  1. 根据方法的功能描述,方法的参数应该是两个小数。
  2. 要返回两个小数的较小值,所以返回值类型也是小数类型。

解题方案

操作步骤

  1. 定义方法getMin(),方法的参数是double a ,double b。
  2. 在方法中对两个数字进行判断,返回较小值。
  3. 在主方法中调用getMin()方法并接受返回值。
  4. 在主方法中打印结果。

参考代码

public class Demo1 {
    public static void main(String[] args) {
        //调用方法
        double min = getMin(3.14, 4.13);
        //打印结果
        System.out.println("较小值是" + min);
    }

    //定义求较小值的方法
    public static double getMin(double a ,double b){
        //对两个小数进行判断
        if(a < b){
            return a;
        }else{
            return b;
        }
    }
}

题目2(训练)

定义一个方法,该方法能够找出三个整数中的最大值并返回。在主方法中调用方法测试执行。

训练提示

  1. 根据题意,方法中需要使用三个整数,所以方法参数应该是三个整数类型。
  2. 方法需要有返回值,返回值的类型也是整数类型。

解题方案

操作步骤

  1. 定义方法getMax(),方法的参数是三个int类型变量a,b,c,方法的返回值是int类型。
  2. 在方法中使用多分支if...else...判断出最大值并返回。
  3. 在主方法中调用getMax()方法并接受返回值。
  4. 在主方法中打印结果。

参考代码

public class Demo2 {
    public static void main(String[] args) {
        //调用方法传入参数
        int max = getMax(33, 44, 11);
        //打印最大值
        System.out.println("最大值是" + max);


    }
    //定义获取最大值的方法
    public static int getMax(int a ,int b ,int c){
        //判断出最大值并返回
        if(a >= b && a >= c){
            return a;
        }else if(b >= a && b >= c){
            return b;
        }else{
            return c;
        }
    }
}

题目3(训练)

我们知道数学中有九九乘法表。请定义一个方法,方法的功能是打印nn乘法表。在主方法中键盘录入取值范围为[1-9]的变量n,测试方法。执行效果如下:

请输入一个1-9之间的整数:
4
乘法表:
1×1=1    
1×2=2    2×2=4    
1×3=3    2×3=6    3×3=9    
1×4=4    2×4=8    3×4=12    4×4=16

训练提示

  1. 方法需要一个整数变量n,那么方法的参数如何定义?
  2. 方法的目的是做打印,那么方法的返回值类型是什么?

解题方案

操作步骤

  1. 创建键盘录入对象。
  2. 通过键盘输入一个整数变量n。
  3. 定义乘法表的方法,方法参数是int类型参数n,返回值类型void。

3.1. 方法内部定义嵌套循环,外层循环从1开始,到n结束,代表打印n行。

3.2.内层循环从1开始,到i结束,代表每行打印i个式子。

3.3.每行最后打印换行。

  1. 在主方法中对方法进行调用。

参考答案

public class Demo4 {
    public static void main(String[] args) {
        //创建键盘录入对象
        Scanner sc = new Scanner(System.in);
        //键盘录入一个整数
        System.out.println("请输入一个1-9之间的整数:");
        int n = sc.nextInt();
        //调用方法
        method(n);
    }
    //定义乘法表方法
    public static void method(int n) {
        System.out.println("乘法表:");
        //外层循环n次
        for (int i = 1; i <= n; i++) {
            //内存循环i次
            for (int j = 1; j <= i; j++) {
                System.out.print(j + "×" + i + "=" +j*i + "\t");
            }
            //每行结尾执行换行
            System.out.println();
        }
    }
}

题目4(训练)

数字是有绝对值的,负数的绝对值是它本身取反,非负数的绝对值是它本身。请定义一个方法,方法能够得到小数类型数字的绝对值并返回。请定义方法并测试。

训练提示

  1. 方法的功能是得到一个小数的绝对值,参数应该是一个小数类型。
  2. 绝对值需要被返回,返回值类型应该也是小数类型。

解题方案

操作步骤

  1. 定义一个小数变量num。
  2. 定义获取绝对值的方法,方法的参数是一个double类型,返回值类型是double。
  3. 在方法内部使用if..else..判断。

3.1. 如果是负数则对负数取反并返回。

3.2. 如果不是负数则直接返回数字本身。

  1. 在主方法中调用绝对值方法,传入参数num,并接受返回值。
  2. 打印返回的结果。

参考答案

public class Demo6 {
    public static void main(String[] args) {
        double num = -3.14;
        //调用方法
        double abs = abs(num);
        //打印结果
        System.out.println(num +"的绝对值是" + abs);
    }
    //定义绝对值方法
    public static double abs(double num){
        if(num < 0){
            //如果数字是负数则取反
            return -num;
        }else{
            //如果是非负数则返回本身
            return num;
        }
    }
}

题目5(训练)

请定义方法,方法寻找一个数字在一个数组中对应的位置, 如果存在返回对应的索引, 如果不存在则返回-1

最后修改:2021 年 06 月 29 日 07 : 40 PM
如果觉得我的文章对你有用,请随意赞赏