sixmethod

/*
    需求:
        1.定义一个获取两个int数字之和的方法
        2.定义一个获取三个int数字之和的方法
        3.定义一个获取两个double数字之和的方法
        4.定义一个获取三个double数字之和的方法

    定义一个获取两个int数字之和的方法
        三要素:
            1.方法名称:                 getSum1
            2.是否有未知数据参加运算:    int a,int b
            3.是否产生结果数据:          int

    发现问题:
        以下四个方法都是在完成求和功能,在参数列表上已经有区别了,但是我们起了四个不同的的名字,
        这样导致程序员学习和使用的成本增加(记不住)

    解决方案:
        方法重载
 */
public class Demo01MethodProblem {
    public static void main(String[] args) {
        //输出调用
        System.out.println(getSum1(10, 20));
        System.out.println(getSum2(10, 20, 30));
        System.out.println(getSum3(10.0, 20.0));
        System.out.println(getSum4(10.0, 20.0, 30.0));
    }

    //1.定义一个获取两个int数字之和的方法
    public static int getSum1(int a, int b) {
        System.out.println("两个int方法被调用了");
        return a + b;
    }

    //2.定义一个获取三个int数字之和的方法
    public static int getSum2(int a, int b, int c) {
        System.out.println("三个int方法被调用了");
        return a + b + c;
    }

    //3.定义一个获取两个double数字之和的方法
    public static double getSum3(double a, double b) {
        System.out.println("两个double方法被调用了");
        return a + b;
    }

    //4.定义一个获取三个double数字之和的方法
    public static double getSum4(double a, double b, double c) {
        System.out.println("三个double方法被调用了");
        return a + b + c;
    }
}
/*
    方法重载:
        1.概念:
            在同一个类中,多个功能相同,但是参数列表不同的方法,可以使用相同的名称
            这种同名不同参的多个方法可以同时存在于一个类中的现象,就叫做方法的重载

        2.作用:
            (1)减少的方法名称的数量
            (2)降低了程序员的学洗和记忆成本

        3.如果找到对应的方法
            (1)根据方法名称确定
            (2)根据方法参数的数量确定
            (3)根据方法参数的类型确定
                a.做类型的完全匹配(优先调用类型一模一样的)
                b.做类型的自动类型提升匹配(发生自动类型转换的)

 */
public class Demo02MethodOverLoad {
    public static void main(String[] args) {
        //输出调用
        System.out.println(getSum(10, 20));
        System.out.println(getSum(10, 20, 30));
        System.out.println(getSum(10.0, 20.0));
        System.out.println(getSum(10.0, 20.0, 30.0));
    }

    //1.定义一个获取两个int数字之和的方法
    public static int getSum(int a, int b) {
        System.out.println("两个int方法被调用了");
        return a + b;
    }

    //2.定义一个获取三个int数字之和的方法
    public static int getSum(int a, int b, int c) {
        System.out.println("三个int方法被调用了");
        return a + b + c;
    }

    //3.定义一个获取两个double数字之和的方法
    public static double getSum(double a, double b) {
        System.out.println("两个double方法被调用了");
        return a + b;
    }

    //4.定义一个获取三个double数字之和的方法
    public static double getSum(double a, double b, double c) {
        System.out.println("三个double方法被调用了");
        return a + b + c;
    }
}
/*
    参数列表不同有哪些情况,可以构成重载?
        1.参数的数量不同
        2.参数的类型不同
        3.多个类型顺序不同

    方法重载关键看:
        在方法名称相同的前提下,参数列表必须要有本质(名称不算)的区别
 */
public class Demo03OverLoadNotice {
    public static void main(String[] args) {

    }
    //1.没有参数
    public static void method() {

    }
    //2.有1个int参数
    //方法1没有参数,方法2有一个int参数,参数的数量不同,可以构成重载
    public static void method(int a) {

    }
    //3.有1个double参数
    //方法1没有参数,方法3有一个double参数,参数的数量不同,可以构成重载
    //方法2有一个int参数,方法3有一个double参数,参数的类型不同,可以构成重载
    public static void method(double a) {

    }
    //4.有1个double参数和1个int参数(先double,后int)
    public static void method(double a,int b) {

    }
    //5.有1个int参数和1个double参数(先int,后double)
    //方法4和5,参数数量相同,但是类型顺序不同,可以构成重载
    public static void method(int a,double b) {

    }
}
/*
    方法重载与哪些因素无关?
        1.与返回值类型无关
        2.与参数名称无关
        3.与修饰符无关
 */
public class Demo04OverLoadNotice {
    public static void main(String[] args) {

    }
    //1
    public static int method(int a,double b) {
        return 0;
    }
    //2
    //错误: 方法重载和返回值类型无关
    /*public static double method(int a,double b) {
        return 0;
    }*/

    //3
    //错误: 方法重载与修饰符无关
    /*private static int method(int a,double b) {
        return 0;
    }*/

    //4
    //错误: 方法重载和参数名称无关
    /*public static int method(int m,double n) {
        return 0;
    }*/

}
/*
    方法重载练习
        1.方法3和方法8,只有参数名称不同,无法构成重载,把方法8注释掉
        2.方法5和方法6,只有参数名称不同,无法构成重载,把方法6注释掉
        3.方法7虽然不报错,但是和其它方法不是重载关系,因为方法名称都不一样
 */
public class Demo05OverLoadTest {
    //1
    public static void open() {
    }

    //2
    public static void open(int a) {
    }

    //3
    static void open(int a, int b) {
    }

    //4
    public static void open(double a, int b) {
    }

    //5
    public static void open(int a, double b) {
    }

    //6
   /* public void open(int i, double d) {
    }*/

    //7
    public static void OPEN() {
    }

    //8
    /*public static void open(int i, int j) {
    }*/
}
/*
    使用步骤:
        1.在代码的第一行左侧空白(行号后面)处单击鼠标左键,添加断点
        2.右键选择"debug...",进入断点调试界面
 */
public class Demo01DeBugSum {
    public static void main(String[] args) {

        System.out.println("main...start....");
        int a = 10;
        int b = 20;

        int sum = a + b;

        System.out.println("sum="+sum);

        System.out.println("main...end....");
    }
}
/*
    参数传递概念:
        当我们要调用一个方法时，我们会把指定的数值，传递给方法中的参数，
        这样方法中的参数就拥有了这个指定的值，可以使用该值，在方法中运算了。
        这种传递方式，我们称为参数传递。

    形式参数:
        在定义方法时,()中定义的变量,称为形式参数,定义时必须不能有值,方法被调用时,才会有值

    实际参数:
        在调用方法时,()中给定的参数(常量/变量),称为实际参数,如果是变量,则必须要有值

    基本类型作为方法的形式参数
    特点:
        形式参数的改变,不会影响实际参数

    原因:
        基本类型作为参数,传递的是具体的数据值
        每个方法都有自己的内存空间,所以每个方法内部的变量也有自己的内存空间,
        即便是不同的方法内部定义了同名的变量,他们的内存空间不同,它们之间互不影响,互不干扰

 */
public class Demo03BaseVar {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println("ms..a="+a);//10
        System.out.println("ms..b="+b);//20

        //调用方法
        change( a, b );//调用方法时,()中给出的参数,称为实际参数

        System.out.println("me..a="+a);//10
        System.out.println("me..b="+b);//20
    }

    //定义方法
    public static void change(int a, int b) {//方法定义时,()中定义的变量,称为形式参数
        System.out.println("cs..a="+a);//10
        System.out.println("cs..b="+b);//20
        a = a * 10;
        b = b * 10;
        System.out.println("ce..a="+a);//100
        System.out.println("cd..b="+b);//200

        return ;//结束方法,返回到调用处
    }
}
/*
    参数传递概念:
        当我们要调用一个方法时，我们会把指定的数值，传递给方法中的参数，
        这样方法中的参数就拥有了这个指定的值，可以使用该值，在方法中运算了。
        这种传递方式，我们称为参数传递。

    形式参数:
        在定义方法时,()中定义的变量,称为形式参数,定义时必须不能有值,方法被调用时,才会有值

    实际参数:
        在调用方法时,()中给定的参数(常量/变量),称为实际参数,如果是变量,则必须要有值

    引用类型作为方法的形式参数
    特点:
        形式参数的改变,会影响实际参数
        通过形参找到堆内存空间的数组,修改元素值后,再通过实参看到的是修改后的数组内容

    原因:
        引用变量保存的是堆内存空间的地址值,调用方法传递的是地址值,
        导致多个变量指向同一个数组,只要有一个变量修改的数组的元素,
        其它变量看到的都是修改后的元素

 */
public class Demo04RefVar {
    public static void main(String[] args) {

        int[] a = new int[] {10,20};//数组变量a保存数组在堆内存空间的地址
        System.out.println("ms..a[0]="+a[0]);//10
        System.out.println("ms..a[1]="+a[1]);//20

        //调用方法: 传递的是地址值
        change( a );//调用方法时,()中给出的参数,称为实际参数

        System.out.println("me..a[0]="+a[0]);
        System.out.println("me..a[1]="+a[1]);
    }

    //定义方法
    public static void change(int[] a) {//方法定义时,()中定义的变量,称为形式参数

        System.out.println("cs..a[0]="+a[0]);//10
        System.out.println("cs..a[1]="+a[1]);//20
        a[0] = a[0] * 10;
        a[1] = a[1] * 10;
        System.out.println("ce..a[0]="+a[0]);//100
        System.out.println("ce..a[1]="+a[1]);//200

        return ;//结束方法,返回到调用处
    }
}
/*
    java.util.Random类: 就是用来帮助我们产生随机数字的,也是引用类型,使用有3个固定的步骤
        1.导包:
            import 包名.类名;
            Random类导包: import java.util.Random;

        2.创建对象:
            类名 对象名 = new 类名(参数...);
            键盘录入对象: Scanner sc = new Scanner(System.in);
                注意: System.in目前是固定写法
            随机数Random类的对象: Random r = new Random();
                注意:右侧()中什么都不用写,目前是固定写法

        3.使用:
            r.nextInt(): 产生一个int范围(正负21亿)内的随机数字
            r.nextInt(整数常量或者int类型变量 n): 产生一个0(包含)到n(不包含n)之间的随机数字
            举例:
                r.nextInt(10): 产生一个0(包含0)到10(不包含10)之间的随机数字  [0,10) 等价于 [0,9]
                r.nextInt(100): 产生一个0(包含0)到100(不包含10)之间的随机数字  [0,100) 等价于 [0,99]

        4.练习:
            (1)产生10个int范围内的随机数字
            (2)产生10个1(包含1)到100(包含100)之间的随机数字
                r.nextInt(100): 0,1,2,3......99
                r.nextInt(100) + 1:
                    0,1,2,3......99
                                + 1
                  --------------------
                    1,2,3......99,100


 */
public class Demo04Random {
    public static void main(String[] args) {
        //创建产生随机数字的Random类的对象
        Random r = new Random();
        //(1)产生10个int范围内的随机数字
        for (int i = 0; i < 10; i++) {
            //产生1个int范围内的随机数字,保存int变量num中
            int num = r.nextInt();
            System.out.println(num);
        }
        System.out.println("----------");
        //(2)产生10个1(包含1)到100(包含100)之间的随机数字
        for (int i = 0; i < 10; i++) {
            //产生1个1(包含1)到100(包含100)之间的随机数字,保存int变量num中
            int num = r.nextInt(100) + 1;
            System.out.println(num);
        }
        System.out.println("----------");
        //证明上面的代码确实可以产生能[1,100]之间的数字
        while(true) {
            //产生1个1(包含1)到100(包含100)之间的随机数字,保存int变量num中
            int num = r.nextInt(100) + 1;
            System.out.println(num);
            if (num == 1 || num == 100) {
                break;
            }
        }
        System.out.println("----------");
        //证明上面的代码不可以产生<1的和>100的随机数字
        while(true) {
            //产生1个1(包含1)到100(包含100)之间的随机数字,保存int变量num中
            int num = r.nextInt(100) + 1;
            System.out.println(num);
            if (num < 1 || num > 100) {
                break;
            }
        }
    }
}
import java.util.Random;
import java.util.Scanner;

/*
    Random练习-猜数字
        需求：程序自动生成一个1-100(包含1和100)之间的数字，使用程序实现猜出这个数字是多少？
        效果：
            如果猜的数字比真实数字大，提示你猜的数据大了
            如果猜的数字比真实数字小，提示你猜的数据小了
            如果猜的数字与真实数字相等，提示恭喜你猜中了

        实现步骤:
            1.创建产生随机数字的Random类的对象
            2.生成一个1-100(包含1和100)之间的数字,保存int变量guessNum中,以供猜测
            3.创建键盘录入Scanner类的对象
            4.猜测次数不确定,使用while死循环
            4.1 获取用户猜测键盘录入的数字,保存int变量inputNum中
            4.2 判断用户输入的数字inputNum 大于 产生的随机数字guessNum 提示"大了"
            4.3 判断用户输入的数字inputNum 小于 产生的随机数字guessNum 提示"小了"
            4.4 判断用户输入的数字inputNum 等于 产生的随机数字guessNum 提示"恭喜你猜中了",结束循环

 */
public class Demo05GuessNum {
    public static void main(String[] args) {
        //1.创建产生随机数字的Random类的对象
        Random r = new Random();
        //2.生成一个1-100(包含1和100)之间的数字,保存int变量guessNum中,以供猜测
        int guessNum = r.nextInt(100) + 1;
        //3.创建键盘录入Scanner类的对象
        Scanner sc = new Scanner(System.in);
        //4.猜测次数不确定,使用while死循环
        while (true) {
            //4.1 获取用户猜测键盘录入的数字,保存int变量inputNum中
            System.out.println("请输入您猜测的1到100之间的整数数字: ");
            int inputNum = sc.nextInt();
            if (inputNum > guessNum) {
                //4.2 判断用户输入的数字inputNum 大于 产生的随机数字guessNum 提示"大了"
                System.out.println("你猜的数据大了");
            } else if (inputNum < guessNum) {
                //4.3 判断用户输入的数字inputNum 小于 产生的随机数字guessNum 提示"小了"
                System.out.println("你猜的数据小了");
            } else {
                //4.4 判断用户输入的数字inputNum 等于 产生的随机数字guessNum 提示"恭喜你猜中了",结束循环
                System.out.println("恭喜你猜中了");
                break;
            }

        }
    }
}

/*
    switch语句: switch是开关的意思
        1.格式:
            switch(表达式){
                case 常量值1:
                    语句体1;
                    break;
                case 常量值2:
                    语句体2;
                    break;
                ...
                case 常量值n:
                    语句体n;
                    break;
                default:
                    语句体n+1;
                    break;
            }
            其它语句;
        2.执行流程:
            (1)首先计算出表达式的值
            (2)其次，和case依次比较，一旦有对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结束。
            (3)最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉。
        3.注意事项:
            (1)switch语句()中表达式的类型: byte/short/char/int 	String/枚举	---最重要的---
            (2)case后面必须写常量,而且不能重复,常量的类型要和表达式的结果类型匹配
            (3)switch和后面的(),以及()和{}之间都没有分号,case后面常量值的后面是冒号不是分号
            (4)break是用来结束switch语句的,一旦遇到break,直接结束switch语句,
                继续执行switch后面的其它语句
            (5)default是用来兜底的,如果所有的case的常量值和表达式的结果都不相同,直接执行default中的代码
            (6)如果每个case和default后面都有break,那么case和default的顺序可以任意调整,不影响结果
            (7)如果default放在最后的话,那么可以省略default中的break
            (8)语句体: 一条/多条语句(根据题目需求确定)
 */
public class Demo05Switch {
    public static void main(String[] args) {
        int num = 5;
        switch (num) {
            case 1:
                System.out.println("你好");
                break;
            case 2:
                System.out.println("我好");
                break;
            case 3:
                System.out.println("大家好,才是真的好!");
                break;
            case 4:
                System.out.println("他/她好,我也好");
                break;
            default:
                System.out.println("一切都好");
                break;//建议省略
        }
        System.out.println("其它语句....");
    }
}
import java.util.Scanner;

/*
    需求：
        一年有12个月，分属于春夏秋冬4个季节，键盘录入一个月份，请用程序实现判断该月份属于哪个季节，并输出。
    演示效果
        输入： 1、2、12	输出：冬季
        输入： 3、4、5	输出：春季
        输入： 6、7、8	输出：夏季
        输入： 9、10、11	输出：秋季
        输入：其它数字	输出：数字有误
    实现步骤:
        1.创建键盘录入Scanner类的对象
        2.获取键盘录入的1到12之间的代表月份的整数数字,保存到int变量month中
        3.因为month中的值有12+1种情况,使用switch判断month中的值,输出对应的季节
 */
public class Demo06SwitchMonth {
    public static void main(String[] args) {
        //1.创建键盘录入Scanner类的对象
        Scanner sc = new Scanner(System.in);
        //2.获取键盘录入的1到12之间的代表月份的整数数字,保存到int变量month中
        System.out.println("请输入1到12之间的代表月份的整数数字: ");
        int month = sc.nextInt();
        //3.因为month中的值有12+1种情况,使用switch判断month中的值,输
        switch (month) {
            case 1:
                System.out.println("冬季");
                break;
            case 2:
                System.out.println("冬季");
                break;
            case 12:
                System.out.println("冬季");
                break;
            case 3:
                System.out.println("春季");
                break;
            case 4:
                System.out.println("春季");
                break;
            case 5:
                System.out.println("春季");
                break;
            case 6:
                System.out.println("夏季");
                break;
            case 7:
                System.out.println("夏季");
                break;
            case 8:
                System.out.println("夏季");
                break;
            case 9:
                System.out.println("秋季");
                break;
            case 10:
                System.out.println("秋季");
                break;
            case 11:
                System.out.println("秋季");
                break;
            default:
                System.out.println("您输入的月份不存在,火星来的吧,哥屋恩....");
                break;//建议省略
        }
        System.out.println("game...over...");
    }
}
/*
    switch语句练习-春夏秋冬
    发现问题:
        多个连续的case中,有相同的代码和break,此时可以优化
    解决方案:
        只保留最后一个case中的代码和break,前面的若干个case中的代码和break,全部省略

    case穿透:
        找到第一个常量值和表达式值相同的case后,从该case中的代码一直向下执行,直到遇到break才会结束switch语句
 */
public class Demo07SwitchMonthCase {
    public static void main(String[] args) {
        //1.创建键盘录入Scanner类的对象
        Scanner sc = new Scanner(System.in);
        //2.获取键盘录入的1到12之间的代表月份的整数数字,保存到int变量month中
        System.out.println("请输入1到12之间的代表月份的整数数字: ");
        int month = sc.nextInt();
        //3.因为month中的值有12+1种情况,使用switch判断month中的值,输
        switch (month) {//3
            case 1:
            case 2:
            case 12:
                System.out.println("冬季");
                break;
            case 3:
            case 4:
            case 5:
                System.out.println("春季");
                break;
            case 6:
            case 7:
            case 8:
                System.out.println("夏季");
                break;
            case 9:
            case 10:
            case 11:
                System.out.println("秋季");
                break;
            default:
                System.out.println("您输入的月份不存在,火星来的吧,哥屋恩....");
                break;//建议省略
        }
        System.out.println("game...over...");
    }
}
public class Demo08 {
    public static void main(String[] args) {
        int i = 5, j = 10, x = 15;
        switch (j - i) {//10-5: 5 byte/short/int/char String/枚举
            case 4:
                x += 16;
            case 5:
                x++;
            case 6:
                x += 2;
            case 7:
                x += 3;
            default:
                --x;
        }
        System.out.println(x);//?

       /* int x = 1, a = 0, b = 0;
        switch (x) {//1
            case 0:
                b++;
            case 1:
                a++;
            case 2:
                a++;
                b++;
        }
        System.out.println("a=" + a);
        System.out.println("b=" + b);*/
    }
}
/*
    引用数据类型作为方法参数练习-评委打分

    案例需求
        在编程竞赛中，有6个评委为参赛的选手打分，分数为0-100的整数分。
        int[] array = {50,60,70,80,90,100};
        选手的最后得分为：去掉一个最高分和一个最低分后 的4个评委平均值 (不考虑小数部分)。

    方法定义的实现步骤:
        1.定义方法getArray,获取长度为6的int数组,代表6个评委的评分,元素值通过键盘录入
        2.定义方法printArray,遍历输出一个int数组中的所有元素
        3.定义方法getArrayAvg,计算一个int数组的平均分(总分-最高分-最低分后的平均分)

    main方法的实现步骤:
        1.调用getArray方法,获取int数组,保存到int数组变量array中
        2.调用printArray方法,打印6个评委的评分
        3.调用getArrayAvg方法,获取平均分结果,保存到int变量avg中
        4.打印avg的值

 */
public class Demo06Score {
    public static void main(String[] args) {
        //定义int数组array,并初始化
        int[] array = {50, 60, 70, 80, 90, 100};
        //调用方法printArray,打印数组内容
        printArray(array);
    }

    //2.定义方法printArray,遍历输出一个int数组中的所有元素
    //打印格式: [50, 60, 70, 80, 90, 100]
    public static void printArray(int[] array) {
        //1.输出"[",不换行
        System.out.print("[");
        //2.遍历int数组array
        for (int i = 0; i < array.length; i++) {
            //2.1 输出当前元素,不换行
            System.out.print(array[i]);
            //2.2 判断如果步骤2.1中输出的元素不是最后一个元素
            if (i != array.length - 1) {
                //2.2 输出", ",不换行
                System.out.print(", ");
            }
        }
        //3.输出"]",换行(方便后续的代码进行其它输出)
        System.out.println("]");
    }
}
/*
    引用数据类型作为方法参数练习-评委打分

    案例需求
        在编程竞赛中，有6个评委为参赛的选手打分，分数为0-100的整数分。
        int[] array = {50,60,70,80,90,100};
        选手的最后得分为：去掉一个最高分和一个最低分后 的4个评委平均值 (不考虑小数部分)。

    方法定义的实现步骤:
        1.定义方法getArray,获取长度为6的int数组,代表6个评委的评分,元素值通过键盘录入
        2.定义方法printArray,遍历输出一个int数组中的所有元素
        3.定义方法getArrayAvg,计算一个int数组的平均分(总分-最高分-最低分后的平均分)

    main方法的实现步骤:
        1.调用getArray方法,获取int数组,保存到int数组变量array中
        2.调用printArray方法,打印6个评委的评分
        3.调用getArrayAvg方法,获取平均分结果,保存到int变量avg中
        4.打印avg的值

 */
public class Demo07Score {
    public static void main(String[] args) {
        //定义int数组array,并初始化
        int[] array = {50, 60, 70, 80, 90, 100};
        //调用方法printArray,打印数组内容
        System.out.print("所有评委的原始评分: ");
        printArray(array);
        //调用方法计算平均分
        int avg = getArrayAvg(array);
        System.out.println("所有评委去掉最高分和最低分后的评分: " + avg);
    }

    //2.定义方法printArray,遍历输出一个int数组中的所有元素
    //打印格式: [50, 60, 70, 80, 90, 100]
    public static void printArray(int[] array) {
        //1.输出"[",不换行
        System.out.print("[");
        //2.遍历int数组array
        for (int i = 0; i < array.length; i++) {
            //2.1 输出当前元素,不换行
            System.out.print(array[i]);
            //2.2 判断如果步骤2.1中输出的元素不是最后一个元素
            if (i != array.length - 1) {
                //2.2 输出", ",不换行
                System.out.print(", ");
            }
        }
        //3.输出"]",换行(方便后续的代码进行其它输出)
        System.out.println("]");
    }

    //3.定义方法getArrayAvg,计算一个int数组的平均分(总分-最高分-最低分后的平均分)
    public static int getArrayAvg(int[] array) {
        //1.定义int变量sum,初始值0,用来累加求和
        int sum = 0;
        //2.假设索引0元素是最大的,保存int变量max中
        int max = array[0];
        //3.假设索引0元素是最小的,保存int变量min中
        int min = array[0];
        //4.遍历数组array
        for (int i = 0; i < array.length; i++) {
            //4.1 把当前元素累加到求和变量sum中
            sum += array[i];
            //4.2 计算最大值
            if (array[i] > max) {
                max = array[i];
            }
            //4.3 计算最小值
            if (array[i] < min) {
                min = array[i];
            }
        }
        //计算平均分,保存int变量avg中
        int avg = (sum - max - min) / (array.length - 2);
        System.out.println("所有评委的总评分: " + sum);
        System.out.println("所有评委的最高评分: " + max);
        System.out.println("所有评委的最低评分: " + min);
        //返回最终计算的平均分
        return avg;
    }
}
/*
    引用数据类型作为方法参数练习-评委打分

    案例需求
        在编程竞赛中，有6个评委为参赛的选手打分，分数为0-100的整数分。
        int[] array = {50,60,70,80,90,100};
        选手的最后得分为：去掉一个最高分和一个最低分后 的4个评委平均值 (不考虑小数部分)。

    方法定义的实现步骤:
        1.定义方法getArray,获取长度为6的int数组,代表6个评委的评分,元素值通过键盘录入
        2.定义方法printArray,遍历输出一个int数组中的所有元素
        3.定义方法getArrayAvg,计算一个int数组的平均分(总分-最高分-最低分后的平均分)

    main方法的实现步骤:
        1.调用getArray方法,获取int数组,保存到int数组变量array中
        2.调用printArray方法,打印6个评委的评分
        3.调用getArrayAvg方法,获取平均分结果,保存到int变量avg中
        4.打印avg的值

 */
public class Demo08Score {
    public static void main(String[] args) {
        //调用方法获取数组
        int[] array = getArray(8);
        //调用方法printArray,打印数组内容
        System.out.print("所有评委的原始评分: ");
        printArray(array);
        //调用方法计算平均分
        int avg = getArrayAvg(array);
        System.out.println("所有评委去掉最高分和最低分后的评分: " + avg);
    }
    /*
         1.定义方法getArray,获取指定长度int数组,代表评委的评分,元素值通过键盘录入
         三要素:
            1.方法名称: getArray
            2.是否有未知数据参加运算:
                int count  表示评委的数量(数组的长度)
            3.是否产生结果数据:
                int[]:  创建长度为count的数组,元素通过键盘录入,所以需要把数组返回,否则后面不能计算平均值
     */
    public static int[] getArray(int count) {
        //1.创建长度为count的int数组array
        int[] array = new int[count];
        //2.创建键盘录入Scanner类的对象
        Scanner sc = new Scanner(System.in);
        //3.遍历数组array
        for (int i = 0; i < array.length; i++) {
            System.out.println("请输入第"+(i+1)+"个评委的评分: ");
            //把获取到的当前评委的评分,存储到数组中的当前元素中
            array[i] = sc.nextInt();
        }
        return array;
    }


    //2.定义方法printArray,遍历输出一个int数组中的所有元素
    //打印格式: [50, 60, 70, 80, 90, 100]
    public static void printArray(int[] array) {
        //1.输出"[",不换行
        System.out.print("[");
        //2.遍历int数组array
        for (int i = 0; i < array.length; i++) {
            //2.1 输出当前元素,不换行
            System.out.print(array[i]);
            //2.2 判断如果步骤2.1中输出的元素不是最后一个元素
            if (i != array.length - 1) {
                //2.2 输出", ",不换行
                System.out.print(", ");
            }
        }
        //3.输出"]",换行(方便后续的代码进行其它输出)
        System.out.println("]");
    }

    //3.定义方法getArrayAvg,计算一个int数组的平均分(总分-最高分-最低分后的平均分)
    public static int getArrayAvg(int[] array) {
        //1.定义int变量sum,初始值0,用来累加求和
        int sum = 0;
        //2.假设索引0元素是最大的,保存int变量max中
        int max = array[0];
        //3.假设索引0元素是最小的,保存int变量min中
        int min = array[0];
        //4.遍历数组array
        for (int i = 0; i < array.length; i++) {
            //4.1 把当前元素累加到求和变量sum中
            sum += array[i];
            //4.2 计算最大值
            if (array[i] > max) {
                max = array[i];
            }
            //4.3 计算最小值
            if (array[i] < min) {
                min = array[i];
            }
        }
        //计算平均分,保存int变量avg中
        int avg = (sum - max - min) / (array.length - 2);
        System.out.println("所有评委的总评分: " + sum);
        System.out.println("所有评委的最高评分: " + max);
        System.out.println("所有评委的最低评分: " + min);
        //返回最终计算的平均分
        return avg;
    }
}