day05-方法

最新推荐文章于 2021-05-13 22:57:57 发布

qq_48076562

最新推荐文章于 2021-05-13 22:57:57 发布

阅读量62

点赞数

文章标签： java

本文链接：https://blog.csdn.net/qq_48076562/article/details/116210849

版权

学习目标

1.能够知道方法定义和通用格式    
    修饰符(public static) 返回值类型(任意类型|void) 方法名(参数列表){
        方法体;
        return 返回值;
    }
    public static int getSum(int a,int b){return a+b}
	public static void printAD(){sout("广告")}
能够知道形参和实参的区别
	形参:定义方法时写的参数getSum(int a,int b) 没有值
	实参:调用方法时传递的实际参数  getSum(10,20)  getSum(100,200)
能够使用方法完成两个较大数的获取并调用方法    
	public static int getMax(int a,int b){
		return a>b?a:b;
	}
	int max = getMax(10,20);
能够知道方法重载的特点          
	方法名相同,但是参数列表不同(1.个数2.类型3.顺序)
能够知道方法的参数是基本类型和引用类型的区别       
	基本数据类型:值传递,仅仅是一个简单的赋值   (int a,int b)
        	方法中的值改变和原来的值没有关系
	引用数据类型:地址值传递,结果就是多个数组变量指向堆内存中的同一个对象  (int[] arr)
		一个数组改变了对象的值,另外一个数组访问的就是改变后的
能够使用方法完成数组遍历并调用方法
	public static void printArray(int[] arr){
		for(int i=0; i<arr.length; i++){
			System.out.println(arr[i])
		}	
	}
	int[] arr = {1,2,3};
	printArray(arr);
能够使用方法完成获取数组最大值并调用方法
	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;
    }
    int[] arr = {1,2,3};
	int max = getMax(arr);

第一章：方法的定义和调用

1.1 什么是方法

什么是方法：做某件事所固有的一个流程

方法的特点：
1.流程相对固定
2.可以反复重用

1.2 Java中方法的概念

Java中的方法：可以将“一段功能代码”封装成一个独立的“代码块”，并且起个“名字” ，当其他的代码需要这段功能，就可以通过“名字”调用这段代码。

方法的好处：提高代码的重用性(重复使用多次)!

1.3 方法的定义和调用

1.定义格式:固定的格式

修饰符 返回值类型 方法名(参数列表){
	方法体;
	return 返回值;
}

方法定义格式的解释说明:

修饰符:固定写法 public static
返回值类型:和返回值的数据类型要保持一致
	1.可以使用任意的数据类型(基本数据类型:4类8种,引用数据类型:数组 int[],double[],String)
	2.使用void,说明这个方法没有返回值
方法名,使用标识符给方法起一个名字(小驼峰式:第二个单词首字母大写),调用方法的时候需要使用
	print,getMax,getSum
参数列表
	1.可以使用任意类型的变量(基本数据类型:4类8种,引用数据类型:数组 int[],double[],String)
	2.什么都不写(),没有参数
方法体:完成方法功能的实际代码
return:
	1.结束方法
	2.如果方法的返回值类型不为void,需要把返回值返回到方法的调用处

2.方法的调用格式:

方法名();
方法名(传递参数);
初学者一般都是在main中调用其他方法

1.4 基本方法练习

1.定义一个方法，打印3次手机广告

package com.itheima.demo01Method;

/*
    方法的定义和使用
    注意:
        1.所有的方法都是并列的,不能把一个方法定义在其他方法的内部(类中其他方法外部)
        2.方法的定义的先后顺序无所谓,先调用哪个方法,哪个方法就先执行
        3.初学者,一般都是在main方法中,来调用其他方法
    定义方法的好处:
        重用
 */
public class Demo01Method {
    /*
        定义一个打印三次广告的方法
     */
    public static void printAD(){
        for (int i = 0; i < 3; i++) {
            System.out.println("Au9999福字金条1g：417.30");
        }
    }

    public static void main(String[] args) {
        //调用打印广告的方法
        printAD();
        printAD();
        printAD();
    }
}

2.定义两个打印广告的方法,交替3次调用两个方法

1).定义方法可以循环3次打印一个"手机广告":“华为手机，Mate40 RS ，保时捷设计，致敬时代！零售价：11999元”
2).再定义方法可以循环2次打印一个"笔记本电脑广告":“苹果电脑，Apple MacBook Pro 16寸，高能，召唤高手！零售价：18999元”
3).定义main()方法，交替3次调用两个方法

package com.itheima.demo01Method;

/*
     1).定义方法可以循环3次打印一个“手机广告”： “华为手机，Mate40 RS ，保时捷设计，致敬时代！零售价：11999元”
     2).再定义方法可以循环2次打印一个“笔记本电脑广告”： “苹果电脑，Apple MacBook Pro 16寸 ，高能，召唤高手！零售价：18999元”；
     3).定义main()方法，交替3次调用两个方法
 */
public class Demo02Method {
    public static void main(String[] args) {
        //交替3次调用两个方法
        //printPhoneAD();
        //printComputerAD();
        //System.out.println("------------------------------------------");
        //printPhoneAD();
        //printComputerAD();
        //System.out.println("------------------------------------------");
        //printPhoneAD();
        //printComputerAD();
        for (int i = 0; i < 3; i++) {
            printPhoneAD();
            printComputerAD();
        }
    }

    /*
        循环2次打印一个“笔记本电脑广告”的方法
     */
    public static void printComputerAD(){
        for (int i = 0; i < 2; i++) {
            System.out.println("苹果电脑，Apple MacBook Pro 16寸 ，高能，召唤高手！零售价：18999元");
        }
    }

    /*
        循环3次打印一个"手机广告"的方法
     */
    public static void printPhoneAD(){
        for (int i = 0; i < 3; i++) {
            System.out.println("华为手机，Mate40 RS ，保时捷设计，致敬时代！零售价：11999元");
        }
    }
}

1.5 方法的参数

前面我们定义的方法相对比较固定，只能打印固定的信息以及固定的次数；
我们可以让方法从外部“接收数据”，提高方法重用性：

定义方法时的参数叫：形参
调用方法时的传递的真正数据叫：实参

package com.itheima.demo01Method;

/*
    定义一个含有参数的方法
    含参数方法的作用:为了提高方法的重用性
 */
public class Demo03Method {
    public static void main(String[] args) {
        printAD("华为","Mate40 RS ，保时捷设计，致敬时代！",8888.88,3);
        printAD("小米","为发烧而生！",4999,2);
        printAD("OPPO","为拍照音乐而生！",3999,10);
    }

    /*
        定义一个打印广告的方法
        方法的参数:
            String brand:品牌
            String slogan:口号
            double price:价格
            int count:打印的次数
     */
    public static void printAD(String brand,String slogan,double price,int count){
        for (int i = 0; i < count; i++) {
            System.out.println("品牌:"+brand+" 口号:"+slogan+" 价格:"+price);
        }
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UhW5Axbj-1619530701136)(img/1617845534824.png)]

1.6 带参方法练习

定义类：Test01，
1).定义一个方法getMax，可以求两个整数的最大值，并打印结果；
2).定义一个main()方法，调用getMax()方法测试。

package com.itheima.demo01Method;

/*
    1).定义一个方法getMax，可以求两个整数的最大值，并打印结果；
	2).定义一个main()方法，调用getMax()方法测试。
 */
public class Demo04MethodTest {
    public static void main(String[] args) {
        getMax(10,20);
    }

    /*
        方法的参数: int a,int b
     */
    public static void getMax(int a,int b){
        //求两个整数的最大值
        int max = a>b?a:b;
        System.out.println("max:"+max);
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8u3toydF-1619530701138)(img/1617847121538.png)]

定义类：Test02
1).定义一个方法printStudent，可以打印一个学生的姓名(String)、性别(String)、年龄(int)
2).定义一个main()方法，调用pintStudent()方法测试。

package com.itheima.demo01Method;

/*
    1).定义一个方法printStudent，可以打印一个学生的姓名(String)、性别(String)、年龄(int)
	2).定义一个main()方法，调用pintStudent()方法测试。
 */
public class Demo05MethodTest {
    public static void main(String[] args) {
        printStudent("柳岩","女",18);
        printStudent("杨颖","女",18);
    }

    /*
        方法名:printStudent
        方法的参数列表:String name,String sex,int age
     */
    public static void printStudent(String name,String sex,int age){
        System.out.println("姓名:"+name+",性别:"+sex+",年龄:"+age);
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LO2VKDvj-1619530701139)(img/1617847397467.png)]

1.7 方法的形参是“数组”

package com.itheima.demo01Method;

/*
    方法一个参数是数组的方法
    方法的参数可以是任意的数据类型:基本数据类型:4类8种,引用数据类型:数组
 */
public class Demo06Method {
    public static void main(String[] args) {
        int[] arr1 = {10,0,-5,88,99};
        System.out.println(arr1);//[I@4554617c
        //调用getMax方法
        getMax(arr1);
    }

    /*
        定义一个计算数组中元素最大值的方法
        方法名: getMax
        参数列表:int[] arr2
     */
    public static void getMax(int[] arr2){
        int max = arr2[0];
        for (int i = 0; i < arr2.length; i++) {
            if(arr2[i]>max){
                max = arr2[i];
            }
        }
        System.out.println("数组中的最大值为:"+max);
    }
}

方法的参数是数组的内存图:传递的数组的地址值

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qNOqYMdj-1619530701141)(img/1617848241070.png)]

1.8 参数是数组方法练习

定义类Test03：
1).定义方法getSum()，可以求出一个整数数组的累加和，并打印结果；
2).定义main()方法，调用getSum()方法测试。

package com.itheima.demo01Method;

/*
    1).定义方法getSum()，可以求出一个整数数组的累加和，并打印结果；
	2).定义main()方法，调用getSum()方法测试。
 */
public class Demo07MethodTest {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};
        getSum(arr);
    }

    /*
        方法名字: getSum
        参数列表: int[] arr
     */
    public static void getSum(int[] arr){
        int sum=0;
        for (int i = 0; i < arr.length; i++) {
            sum+=arr[i];
        }
        System.out.println("数组中的元素的和为:"+sum);
    }
}

定义类Test04：
1).定义方法getAvg()，可以求出一个整数数组的平均值，并打印结果；
2).定义main()方法，调用getAvg()方法测试。

package com.itheima.demo01Method;

/*
    1).定义方法getAvg()，可以求出一个整数数组的平均值，并打印结果；
	2).定义main()方法，调用getAvg()方法测试。
 */
public class Demo08MethodTest {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};
        getAvg(arr);
    }

    /*
        方法名字: getAvg
        参数列表: int[] arr
     */
    public static void getAvg(int[] arr){
        int sum=0;
        for (int i = 0; i < arr.length; i++) {
            sum+=arr[i];
        }
        System.out.println("数组中的元素的平均值为:"+sum/arr.length);
    }
}

1.9 方法的返回值

定义一个方法，可以求两个整数的最大值，并返回结果：

package com.itheima.demo01Method;

/*
    定义一个方法，可以求两个整数的最大值，并返回结果
 */
public class Demo09Method {
    public static void main(String[] args) {
        int m = getMax(10,20);
        System.out.println("最大值:"+m);
    }

    /*
        定义一个计算两个整数最大值的方法
        明确定义方法的三要素:
            1.方法名: getMax
            2.参数列表: int a,int b
            3.返回值类型: int
        方法的返回值类型不在是void,那么方法内部必须返回一个值
        return关键字的作用: 1.把值返回到方法的调用处 2.结束方法
     */
    public static int getMax(int a,int b){
        int max = a > b ? a : b;
        return max;
    }
}

方法执行的流程图

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mJ13vP2y-1619530701143)(img/1617851001352.png)]

2.0 有返回值的方法练习

定义类Test05：
1).定义方法getSum()，可以求出一个小数数组的累加和，并返回；
2).定义main()方法，调用getSum()方法，接收返回值并打印。

package com.itheima.demo01Method;

/*
    1).定义方法getSum()，可以求出一个整数数组的累加和，并和返回；
	2).定义main()方法，调用getSum()方法，接收返回值并打印。
 */
public class Demo11MethodTest {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};
        int sum = getSum(arr);
        System.out.println("sum:"+sum);
        //System.out.println(sum/arr.length);
    }

    /*
        定义方法的三要素:
            1.方法名: getSum
            2.参数列表: int[] arr
            3.返回值类型: int
     */
    public static int getSum(int[] arr){
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum+=arr[i];
        }
        //把和返回
        return sum;
    }
}

定义类Test06：
1).定义方法getAvg()，可以求出一个整数数组的平均值，并返回；
2).定义main()方法，调用getAvg()方法，接收返回值并打印。

package com.itheima.demo01Method;

/*
    1).定义方法getAvg()，可以求出一个整数数组的平均值，并平均值返回；
	2).定义main()方法，调用getAvg()方法，接收返回值并打印。
 */
public class Demo12MethodTest {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};
        int avg = getAvg(arr);
        System.out.println("avg:"+avg);
    }

    /*
        定义方法三要素
            1.方法名: getAvg
            2.参数列表: int[] arr
            3.返回值类型: int
     */
    public static int getAvg(int[] arr){
        int sum=0;
        for (int i = 0; i < arr.length; i++) {
            sum+=arr[i];
        }
        return sum/arr.length;
    }
}

2.1 方法的几种调用形式

一般我们现在都是在main方法中调用其他方法
固定的格式: 方法名(参数);

1.直接调用:适用于没有返回值的方法,方法的返回值类型是void
    方法名(参数);
2.输出调用:适用于方法有返回值,并且返回值只使用一次
    System.out.println(方法名(参数));
3.赋值调用:适用于方法有返回值,而且返回值多次使用
    方法的返回值类型 变量名  = 方法名(参数);
    System.out.println(变量名);

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mmGGbA7A-1619530701143)(img/1617854040617.png)]

定义一个方法，可以求三个整数的最大值：
          参数：？？？  int a,int b,int c
          返回值：？？？int
public static int getMax(int a,int b,int c){
	int temp = a >b? a :b;
	int max = temp>c? temp:c;
	return max;
}		  

定义一个方法，可以求一个整数数组的最大值：
          参数：？？？  int[] arr
          返回值：？？？int 
		  
public static int getMax(int[] arr){
	int max = arr2[0];
	for (int i = 0; i < arr2.length; i++) {
		if(arr2[i]>max){
			max = arr2[i];
		}
	}
	return max;
}


定义一个方法，可以求三个小数的最大值；
          参数：？？？  double a,double b,double c
          返回值：？？？ double
		  
public static double getMax(double a,double b,double c){
	double temp = a >b? a :b;
	double max = temp>c? temp:c;
	return max;
}				  

定义一个方法，可以求一个整数数组的所有元素累加和：
          参数：？？？ int[] arr
          返回值：？？？int
public static int getSum(int[] arr){
	int sum=0;
	for (int i = 0; i < arr.length; i++) {
		sum+=arr[i];
	}
	return sum;
}

第二章：方法的重载

1.方法重载的基本使用

package com.itheima.demo02Overload;

/*
    方法重载:在同一个类中,出现了方法名相同,但是参数列表不同的方法,叫方法重载
    参数列表不同:
        1.参数个数不同
        2.参数类型不同
        3.参数类型顺序不同
 */
public class Demo01Overload {
    public static void main(String[] args) {
        //调用两个int整数求和的方法
        int s1 = getSum(10, 20);
        System.out.println("s1:"+s1);
        //调用三个int整数求和的方法
        int s2 = getSum(1, 2, 3);
        System.out.println("s2:"+s2);
        //调用计算int类型数组中元素求和的方法
        int[] arr = {10,20,30,40,50};
        int s3 = getSum(arr);
        System.out.println("s3:"+s3);
        //调用先int后double变量求和的方法
        double s4 = getSum(10, 5.5);
        System.out.println("s4:"+s4);
        //调用先double后int变量求和的方法
        double s5 = getSum(5.5, 100);
        System.out.println("s5:"+s5);
    }

    /*
        定义一个计算先double后int变量求和的方法
     */
    public static double getSum(double a,int b){
        System.out.println("先double后int变量求和的方法");
        return a+b;
    }

    /*
        定义一个计算先int后double变量求和的方法
     */
    public static double getSum(int a,double b){
        System.out.println("先int后double变量求和的方法");
        return a+b;
    }

    /*
        定义一个计算int类型数组中元素求和的方法
     */
    public static int getSum(int[] arr){
        System.out.println("计算int类型数组中元素求和的方法");
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum+=arr[i];
        }
        return sum;
    }

    /*
        定义一个计算三个int整数求和的方法
     */
    public static int getSum(int a,int b,int c){
        System.out.println("三个int整数求和的方法");
        return a+b+c;
    }

    /*
        定义一个计算两个int整数求和的方法
     */
    public static int getSum(int a,int b){
        System.out.println("两个int整数求和的方法");
        return a+b;
    }
}

2.方法重载的注意事项

1.方法的重载,只和参数类型有关,和方法的返回值类型没有关系
2.方法的重载,只和参数类型有关,和方法参数的名字没有关系
3.JVM(java虚拟机)会根据方法传递的参数不同,而调用不同的方法

3.方法重载练习

package com.itheima.demo02Overload;

/*
    方法重载的练习:
    1.定义一个计算两个byte类型整数求和的方法
    2.定义一个计算两个short类型整数求和的方法
    3.定义一个计算两个int类型整数求和的方法
    4.定义一个计算两个long类型整数求和的方法
    5.定义一个计算两个double类型小数求和的方法
    在main方法调用以上5个方法,并获取方法的返回值打印
    注意:
        直接写整数10,20,整数默认是int类型
        byte,short,char类型的数据参与计算,会把自己提升为int类型
 */
public class Demo02Overload {
    public static void main(String[] args) {
        //两个byte类型整数求和的方法
        int s1 = getSum((byte)10, (byte)20);
        System.out.println("s1:"+s1);
        //两个short类型整数求和的方法
        short a = 10;
        short b = 20;
        int s2 = getSum(a, b);
        System.out.println("s2:"+s2);
        //两个int类型整数求和的方法
        int s3 = getSum(100, 200);
        System.out.println("s3:"+s3);
        //两个long类型整数求和的方法
        long s4 = getSum(1000L, 2000L);
        System.out.println("s4:"+s4);
        //两个double类型小数求和的方法
        double s5 = getSum(1.1, 2.2);
        System.out.println("s5:"+s5);
    }

    /*
        5.定义一个计算两个double类型小数求和的方法
        方法名: getSum
        参数列表: double a,double b
        返回值类型: double
     */
    public static double getSum(double a,double b){
        System.out.println("两个double类型小数求和的方法");
        double sum = a+b;
        return sum;
    }

    /*
        4.定义一个计算两个long类型整数求和的方法
        方法名: getSum
        参数列表: long a,long b
        返回值类型: int
     */
    public static long getSum(long a,long b){
        System.out.println("两个long类型整数求和的方法");
        long sum = a+b;
        return sum;
    }

    /*
        3.定义一个计算两个int类型整数求和的方法
        方法名: getSum
        参数列表: int a,int b
        返回值类型: int
     */
    public static int getSum(int a,int b){
        System.out.println("两个int类型整数求和的方法");
        int sum = a+b;
        return sum;
    }

    /*
        2.定义一个计算两个short类型整数求和的方法
        方法名: getSum
        参数列表: short a,short b
        返回值类型: int
     */
    public static int getSum(short a,short b){
        System.out.println("两个short类型整数求和的方法");
        int sum = a+b;
        return sum;
    }

    /*
        1.定义一个计算两个byte类型整数求和的方法
        方法名: getSum
        参数列表: byte a,byte b
        返回值类型: int
     */
    public static int getSum(byte a,byte b){
        System.out.println("两个byte类型整数求和的方法");
        int sum = a+b;
        return sum;
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-20yUSD7w-1619530701144)(img/1617867343547.png)]

第三章：基本类型参数和引用类型参数

1.“基本类型参数”执行原理：值传递

方法中把值改变,不影响原来的值

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UA99wQnj-1619530701145)(img/1614957623346.png)]

2.“引用类型参数”执行原理：地址值传递

结果:多个引用变量执行同一个堆内存中的地址值,一个引用变量修改了对象的内容,另外一个访问的就是修改后的

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lzIht3gX-1619530701146)(img/1614957671702.png)]

综合案例

综合案例1-学员考试管理系统

分析学员的成绩，计算：平均分、最高分、最低分

package com.itheima.demo03Test;

/*
    综合案例1-学员考试管理系统
    系统读取了本次参加考试的10位同学的分数，并存储到以下数组中：
            int[] scores = {90,91,78,65,86,80,79,88,67,46};
           请分别定义方法，求出以下几个值：
                1).平均分；
                2).最高分；
                3).最低分；
    分析:
        1、定义main()方法，定义一个数组，对这10个同学的数学成绩进行保存
        2、定义方法，可以计算一个数组的平均值；参数？返回值？
        3、定义方法，可以计算一个数组的最高分；参数？返回值？
        4、定义方法，可以计算一个数组的最低分；参数？返回值？
        5、在main()方法中分别调用这三个方法，并接收、打印返回值。
 */
public class Demo01Test {
    public static void main(String[] args) {
        //1、定义main()方法，定义一个数组，对这10个同学的数学成绩进行保存
        int[] scores = {90,91,78,65,86,80,79,88,67,46};
        // 5、在main()方法中分别调用这三个方法，并接收、打印返回值。
        int max = getMax(scores);
        int min = getMin(scores);
        int avg = getAvg(scores);
        System.out.println("最高分:"+max);
        System.out.println("最低分:"+min);
        System.out.println("平均分:"+avg);
    }

    /*
        4、定义方法，可以计算一个数组的最低分；参数？返回值？
        方法定义三要素:
            方法名: getMin
            参数列表: int[] arr
            返回值类型: int
        shift+f6 项目,模块,包,类重命名,也可以批量修改变量的名称
     */
    public static int getMin(int[] arr){
        int min = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if(min>arr[i]){
                min = arr[i];
            }
        }
        return min;
    }

    /*
        3、定义方法，可以计算一个数组的最高分；参数？返回值？
        方法定义三要素:
            方法名: getMax
            参数列表: int[] arr
            返回值类型: int
     */
    public static int getMax(int[] arr){
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if(max<arr[i]){
                max = arr[i];
            }
        }
        return max;
    }

    /*
        2、定义方法，可以计算一个数组的平均值；参数？返回值？
        方法定义三要素:
            方法名: getAvg
            参数列表: int[] arr
            返回值类型: int
     */
    public static int getAvg(int[] arr){
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum+=arr[i];
        }
        return sum/arr.length;
    }
}

综合案例2-双十一销售统计

本年双11活动已结束,平台要求统计以下六种手机的销量,手机名称已记录到一个数组中:
String[] phoneNames = {“华为Mate40RS”,“华为Mate30E”,“IPhone12ProMax”,
“华为荣耀麒麟9000”,“小米10双模5G”,“OPPOK7x双模5G”};
请在main方法中
1).定义以上手机名称数组;
2).定义一个存储六种手机销量的数组,分别存储六种手机的对应销量:
int[] sales = {8799,8001,9210,9800,10246,10232};
3).定义一个方法,可以找出最高销量,并调用这个方法,获取最高销量
4).定义一个方法,可以找出最高销量的"索引值",并调用这个方法,获取这个索引值;
5).使用这个索引,获取对应的"手机名称",并打印:手机名称:销量 xxxx 部
例如:小米10双模5G:销量 10246 部

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LTFuGEDP-1619530701147)(img/1617869946085.png)]

package com.itheima.demo03Test;

/*
    综合案例2-双十一销售统计
    本年双11活动已结束，平台要求统计以下六种手机的销量，手机名称已记录到一个数组中：
            String[] phoneNames = {”华为Mate40RS”,”华为Mate30E”,”IPhone12ProMax”,”华为荣耀麒麟9000”,”小米10双模5G”，”OPPOK7x双模5G”};
   请在main方法中
        	1).定义以上手机名称数组；
	        2).定义一个存储六种手机销量的数组，分别存储六种手机的对应销量：
 		        int[] sales = {8799,8001,9210,9800,10246,10232};
            3).定义一个方法，可以找出最高销量，并调用这个方法，获取最高销量
            4).定义一个方法，可以找出最高销量的”索引值”，并调用这个方法，获取这个索引值；
            5).使用这个索引，获取对应的”手机名称”，并打印：手机名称：销量 xxxx 部
                        例如：小米10双模5G：销量 10246 部
 */
public class Demo02Test {
    public static void main(String[] args) {
        //1).定义以上手机名称数组；
        String[] phoneNames = {"华为Mate40RS","华为Mate30E","IPhone12ProMax",
                "华为荣耀麒麟9000","小米10双模5G","OPPOK7x双模5G"};
        //2).定义一个存储六种手机销量的数组，分别存储六种手机的对应销量
        int[] sales = {8799,8001,9210,9800,10246,10232};
        int max = getMax(sales);
        System.out.println("最高的销量为:"+max);
        int index = find2(sales, max);
        System.out.println("最高销量对应的索引为:"+index);
        //5).使用这个索引，获取对应的”手机名称”，并打印：手机名称：销量 xxxx 部
        System.out.println(phoneNames[index]+": 销量 " +max+" 部");
    }

    /*
        4).定义一个方法，可以找出最高销量的”索引值”，并调用这个方法，获取这个索引值；
        方法定义的三要素:
            方法名: find
            参数列表: int[] arr(存储销量的数组),int max(最高销量)
            返回值类型: int
        注意:
            一个方法中可以写多个return,必须保证只能执行一个
     */
    public static int find1(int[] arr,int max){
        //遍历数组,获取数组中的每一个元素
        for (int i = 0; i < arr.length; i++) {
            //使用遍历得到的元素和最大值比较是否一致
            if(arr[i]==max){
                //找到,返回元素的索引
                return i;
            }
        }
        //循环结束了,还没有找到,返回-1
        return -1;
    }

    public static int find2(int[] arr,int max){
        int index = -1;
        //遍历数组,获取数组中的每一个元素
        for (int i = 0; i < arr.length; i++) {
            //使用遍历得到的元素和最大值比较是否一致
            if(arr[i]==max){
                //找到,返回元素的索引
                index = i;
                break;//结束循环
            }
        }
        //循环结束了,返回index;
        return index;
    }

    /*
        3).定义一个方法，可以找出最高销量，并调用这个方法，获取最高销量
     */
    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;
    }
}

qq_48076562

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
day05-方法

学习目标1.能够知道方法定义和通用格式修饰符(public static) 返回值类型(任意类型|void) 方法名(参数列表){ 方法体; return 返回值; } public static int getSum(int a,int b){return a+b} public static void printAD(){sout("广告")}能够知道形参和实参的区别形参:定义方法时写的参数getSum(int a,int b)
复制链接

扫一扫