SE整理4

SE整理(4)

数组常见操作

遍历

遍历就是输出数组中所有的元素

如果要遍历的数据过大呢？

不可能一条条输出的。。。

这个时候就需要用到循环：

0~4，每个依次＋1，循环4次

因此：

小于5，也就是说到4，而0依次加到4，刚好循环5次

而这里的5，也就是**设置为数组中元素的个数 **

{5<的那一次，和从0开始计数抵消。这里的数字设置的和数组中元素一样就可以了}

只要知道了元素的个数就可以遍历了

那如果不知道数组元素个数呢？

java提供了 length方法：

之前的 x<具体数也就可以被 x<数组名.length替代了

因此数组遍历的通用格式为：

代码演示：

 /**推荐这种静态初始化*/
        int [] arr2 = {1,2,3};
        /**System.out.println(arr2[0]);
        System.out.println(arr2[1]);
        System.out.println(arr2[2]);*/

        for (int x =0;x<arr2.length;x++){
            /**x代表索引为x，因此该数组每次都是循环输出索引为x的元素，
             * 而每次循环x都在自增，因此输出的元素也就在不断的变，知道遍历完整个数组*/
            System.out.println(arr2[x]);
        }
        /**
         * 打印结果依然是：
         * 1
         * 2
         * 3
         */

获取最值：{擂台模型} 基础不扎实的建议每天手写一遍

可以看出图中的最值就是 171和81

为什么它们是最值？

因为它们和每一个值都进行了比较，都还是最大的

擂台模型：

如何确定全场最强？

它们都打一次擂台即可

擂台分为攻擂方和守擂方，两方进行打擂{比较}，胜者自动变成下一场的守擂方，留在场上，{整场比赛}所有都上擂台比较一次，最后还留在场上的就是胜者

擂台模型，比较的就是最值。所有的值都(和“留在场上的”)进行比较，留下来的就是最值

以下的代码，建议手写完成

/**定义数组*/
int [] arr= {152,150,163,171,128,130,81,168};
/**定义最初守擂方,一般用数组中的第一个值*/
int max = arr[0];
/**定义擂台，让所有的数进行循环比较*/
for(int x=0;x<arr.length;x++){
/**开始让攻擂方和守擂方进行打擂台,胜者留在场上成为守擂方*/
    if(max<arr[x]){
        /**攻擂方胜*/
        max=arr[x];
    }else{
        /**守擂方胜，不进行任何操作*/
        
    }
}
/**循环结束后打印值*/
System.out.println("max:"+max);

结果:{粘贴到机器上运行}

进行比较

方法

形参和实参

方法参数传递

可以看到无论实参number{也就是change方法中的number}怎么变化,都没有影响形参number{也就是main方法中定义 int number =100；时的number}最后输出的还是形参的100

main方法中有形参和实参两种number,而change只有实参一种number

而在change方法中，number则是形参{参数列表中有int number}，因此number变化直接影响change方法，无论输出还是返回，这个number都是200

形参可以通过赋值的方式影响实参，实参却影响不了形参

定义一个方法的2个明确：返回值类型和参数

有返回值才能用.var快捷键一键赋值给变量

方法参数传递

数组遍历

/**
 * 数组遍历
 *
 * 需求：设计一个方法用于数组遍历，需求遍历的结果在在一行上的。
 * 例如：{11，22，33，44，55}
 */
public class MethodTest01 {
    public static void main(String[] args) {
        int [] arr = {44,33,11,22,55};
        
        /**最后调用方法，传入数组，打印数组*/
         getMax(arr);
    }
    public static void getMax(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.print("}");
    }
    /**打印结果：
         * {44,33,11,22,55}
         */
}

数组最大值

代码实现：

/**
 * 数组最大值
 *
 * 需求：
 *      设计一个方法用于获取数组中元素的最大值，调用方法并输出结果
 */
public class MethodTest02 {
    public static void main(String[] args) {
        /**定义数组*/
        int [] arr ={12,45,98,73,60};
        /**调用getMax方法，传入数组，返回出max，并赋值给变量*/
        int max = getMax(arr);
        /**打印变量得到最大值*/
        System.out.println("max:"+max);
        /**打印结果
         * max：98
         */
    }
    public static int getMax(int [] arr){
        /**定义一个代表最大值的变量*/
        int max =arr[0];
        /**循环遍历数组*/
        for (int x = 0;x < arr.length;x++){
            /**遍历时，如果当前索引的值比max大，则将索引的值赋值给max*/
            if (arr[x]>max){
                max = arr[x];
            }else{
            }
        }
        /**最后返回最大值*/
        return max;
    }
}

Debug

一次性删除所有断点

Debug循环求偶数和

1~10求偶数和

/**
 * 需求：循环求1~10偶数和
 */
public class MethodTest03 {
    public static void main(String[] args) {
        /**调用求和函数，打印sum的值*/
        int bahkanDan = BahkanDan();

        /**打印和*/
        System.out.println("bahkanDan:"+bahkanDan);
    }
    public static int BahkanDan(){
        /**定义一个变量sum，来装偶数和*/
        int sum =0;
        for (int x =0;x<11;x++){
            /**如果是偶数则求和,判断偶数{该数对2求余，是否为0}*/
            if (x%2 ==0){
                /**每次在前一个和值的基础上，加一个x的值，就是求和*/
                sum = sum+x;
            }else{

            }
        }
        return sum ;
    }

}

在Debug中，显示的值是程序走到这一步时的值，并不是走完这一步后的值

基础练习

减肥计划实现：

Crtl+Alt+Shift+L 格式排版

代码实现：

/**
 * 需求: 输入星期数，显示今天的减肥活动
 * 周1： 跑步
 * 周2： 游泳
 * 周3： 动感单词
 * 周4： 拳击
 * 周5： 爬山
 * 周日： 好好吃一顿
 * <p>
 * 思路：
 * 1.键盘录入一个星期数，用一个变量接收 {导包}
 * 2.对星期数进行判断，这里if 语句实现
 * 3.在对应的语句中输出对应的减肥活动
 */
public class MenurunkanBeratBadan {
    public static void main(String[] args) {
        //键盘录入一个星期数，用一个变量接收
        /**创建一个键盘录入对象*/
        Scanner scanner = new Scanner(System.in);

        /**给出提示，并用变量week接收*/
        System.out.println("请输入一个星期数： ");
        int week = scanner.nextInt();

        //对星期数进行判断，这里使用if语句实现
        if (week < 1 || week > 7) {
            System.out.println("你输入的星期数非法，请重新输入： ");

        } else if (week == 1) {
            System.out.println("跑步");
        } else if (week == 2) {
            System.out.println("游泳");
        } else if (week == 3) {
            System.out.println("慢走");
        } else if (week == 4) {
            System.out.println("动感单车");
        } else if (week == 5) {
            System.out.println("拳击");
        } else if (week == 6) {
            System.out.println("爬山");
        } else {
            System.out.println("好好吃一顿");
        }

    }
}

导包：

1:手动导包 import java.util.Scanner;
2:快捷键导包选中+alt+回车自动导包
3：自动导包

用switch循环实现

/**
 * 需求: 输入星期数，显示今天的减肥活动
 * 周1： 跑步
 * 周2： 游泳
 * 周3： 动感单词
 * 周4： 拳击
 * 周5： 爬山
 * 周日： 好好吃一顿
 * <p>
 * 思路：
 * 1.键盘录入一个星期数，用一个变量接收
 * 2.对星期数进行判断，这里if 语句实现
 * 3.在对应的语句中输出对应的减肥活动
 *
 * 导包：
 *      1:手动导包 import java.util.Scanner;
 *      2:快捷键导包 选中+alt+回车  自动导包
 *      3：自动导包
 *
 */
public class MenurunkanBeratBadan {
    public static void main(String[] args) {
        //键盘录入一个星期数，用一个变量接收
        /**创建一个键盘录入对象*/
        Scanner scanner = new Scanner(System.in);

        /**给出提示，并用变量week接收*/
        System.out.println("请输入一个星期数： ");
        int week = scanner.nextInt();

        /**对星期数进行判断，这里用switch 语句进行判断*/
        switch (week){
            case 1:
                System.out.println("跑步");
                break;
            case 2:
                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;
            default:
                System.out.println("输出的星期数非法");
        }
    }
}

逢七过实现：

/**
 * 需求： 1~100之间的数字{个位是7，或者10位是7，或者被7整除} 时，打印过
 * x%10==7 x/10%10==7 x%7==7
 *
 * 思路：1~100,循环遍历数据
 * 根据规则，用if语句，按照上面3条判断
 * 最后控制台输出满足规则的数据 {每次都打印一次}
 *
 */
public class Test03 {
    public static void main(String[] args) {
        for (int x=1;x<=100;x++){
            if (x%10 == 7 || x/10%10 == 7 || x%7 ==0){
                System.out.println(x+":过");
            }else{
            }
        }
    }

}

不死神兔实现：

从第2个月开始循环，前面的手动赋值

/**
 * 斐波拉契，不死神兔实现
 * 第20个月总共多少只兔子
 */
public class Test04 {
    public static void main(String[] args) {
        /**创建一个长度为20的数组*/
        int[] arr = new int[20];

        /**第1，2个月的兔子数量是已知的，手动赋值*/
        arr[0] = 1;
        arr[1] = 1;

        /**开始从2循环遍历到20，赋值*/
        for (int x = 2; x < arr.length; x++) {
            /**前2个数之和为第3个数*/
            arr[x] = arr[x-2] +arr[x-1];
        }
        /**打印第20个数{也就是索引值为19}*/
        System.out.println("第20个月，兔子总数为： "+arr[19]);
        /**打印结果：
         * 第20个月，兔子总数为： 6765
         * 
         */
    }
}

百钱百鸡实现：

循环嵌套来做

大概类似于：

x	y	z	sum
1	1	1	8.33
1	1	2	8.66
1	1	3	9

.....................

3层嵌套，循环求和

满足：
$$
【x+y+z =100】和

【 5x+3y+z/3=100】
$$
跳出循环

代码实现：

/**
 * 百钱百鸡，问题实现
 * x,y,z分别表示公鸡，母鸡，鸡雏
 * 其中 z%3=0,5*x+3*Y+x/3=100 {两个表达式，成立时跳出循环}
 */
public class Test05 {
    public static void main(String[] args) {
        //第1层嵌套循环，用于表示公鸡,定义x=0,范围为x<=20
        for (int x=0;x<=20;x++){
            //第2层嵌套循环，用于表示母鸡,定义y=0,范围为y<=33
            for (int y=0;y<=33;y++){
                //用于表示鸡雏,定义z=100-x-y
                int z =100-x-y;
                //判断跳出循环的两个表达式是否成立
                if (z%3==0 && 5*x+3*y+z/3==100 ) {
                    System.out.println("x:"+x+"-"+"y:"+y+"-"+"z:"+z);
                }else {

                }
            }
        }
 }
    /**打印结果
     * x:0-y:25-z:75
     * x:4-y:18-z:78
     * x:8-y:11-z:81
     * x:12-y:4-z:84
     */
}

数组元素求和实现：

/**对数组元素求和： {68，27，95，88，171，996，51，210}
 * 判断该元素是否满足条件，满足条件就累加
 *
 * 求和元素个位和十位都不能是7，并且只能是偶数
 * arr[x]%10!=7 {对10取余，也就是除10只后的余数，也就是个位数}
 * arr[x]/10%10!=7 {除10后，再对10取余，也就是10位数}
 * arr[x]%2==0 {对2取余为0，这里为偶数}
 *
 */
public class Test06 {
    public static void main(String[] args) {
        //定义数组
        int[] arr ={68,27,95,88,171,996,51,210};
        //定义一个和
        int sum =0;

        //循环遍历数组中的元素
        for(int x=0;x<arr.length;x++){
            /**判断是否符合3个条件*/
            if (arr[x]%10!=7 && arr[x]/10%10 !=7&&arr[x]%2==0){
                /**符合则相加*/
                sum+=arr[x];
            }else{

            }
        }
        System.out.println("总和为："+sum);
           /**打印结果：
         * 总和为：1362
         */

    }
}

比较两个数组的内容是否相同

定义方法的关键：返回值类型和参数

相同时

/**设计一个判断两个数组是否相同的方法
 *关键点，先比较数组的长度，再比较对应的索引值
 */
public class Test07 {
    public static void main(String[] args) {
        /**定义两个数组*/
        int[] arr ={11,22,33,44,55};
        int[] arr2 ={11,22,33,44,55};
        boolean compeara = compeara(arr, arr2);
        System.out.println("数组内容相等 "+compeara);


    }
    public static boolean compeara(int[] arr,int[] arr2){
        /**首先比较数组的长度*
         *
         */
        if (arr.length == arr2.length){
            //遍历整个数组
            for (int x=0;x<arr.length;x++){
                //如果有索引值不相等，则为内容不同
                if(arr[x] !=arr2[x]){
                    System.out.println("两个数组内容不同");
                    return false;
                }else{
                    //System.out.println("数组内容相同");
                }
            }
        }else{
            return false;
        }
        /**所有循环结束则为true*/
        return true;

        /**打印结果：
         * 数组内容相等 true
         */
    }

不同时，改进版：

public class Test07 {
    public static void main(String[] args) {
        /**定义两个数组*/
        int[] arr ={11,22,33,44,558};
        int[] arr2 ={11,22,33,44,55};
        boolean compeara = compeara(arr, arr2);
        if (compeara == true){
            System.out.println("数组内容相等 "+compeara);
        }else{
            System.out.println("数组内容不相等 "+compeara);
        }


    }
    public static boolean compeara(int[] arr,int[] arr2){
        /**首先比较数组的长度*
         *
         */
        if (arr.length == arr2.length){
            //遍历整个数组
            for (int x=0;x<arr.length;x++){
                //如果有索引值不相等，则为内容不同
                if(arr[x] !=arr2[x]){
                    System.out.println("两个数组内容不同,且不相同的值为的索引位置是 "+x);
                    return false;
                }else{
                    //System.out.println("数组内容相同");
                }
            }
        }else{
            return false;
        }
        /**所有循环结束则为true*/
        return true;

        /**打印结果：
         * 两个数组内容不同,且不相同的值为的索引位置是 4
         * 数组内容不相等 false
         */
    }

}

数组中查找

代码实现：

/**
 * 需求： 已知一个数组 arr ={19,28,37,46,50};键盘录入一个数据，查找该数据对应的索引
 */
public class Test08 {
    public static void main(String[] args) {
        //定义数组
        int[] arr ={19,28,37,46,50};
        //创建键盘录入的对象
        Scanner scanner = new Scanner(System.in);
        //给出提示
        System.out.println("请输入要查找的数据： ");
        //使用变量来接收录入的数据
        int week = scanner.nextInt();
        //定义索引变量
        int index =-1;
        /**循环遍历数组*/
        for (int x =0;x<arr.length;x++){
            /**判断该数据是否在数组中*/
            if (week == arr[x]){
                /**如果在，则将x赋值给index*/
                index =x;
                /**找到了break跳出循环*/
                break;
            }else{
            }
        }
        /**判断索引值，看是否找到了该数据*/
        if (index !=-1){
            //如果在，则打印索引值
            System.out.println("索引值为： "+index+"，已找到该数据");
        }else{
            //如果不再则返回打印
            System.out.println("索引值为： "+index+"找不到该数据，请重新输入 ");
        }
        /***运行结果：{找到时}
         *
         * 请输入要查找的数据：
         * 37
         * 索引值为： 2，已找到该数据
         *
         * 运行结果{找不到时}
         *请输入要查找的数据：
         * 98
         * 索引值为： -1找不到该数据，请重新输入
         */
    }
}

改进版，进行方法复用

写方法两个明确，返回的是索引，数据类型是int,参数就是要查找的元素week

/**
 * 需求： 已知一个数组 arr ={19,28,37,46,50};键盘录入一个数据，查找该数据对应的索引
 */
public class Test08 {
    public static void main(String[] args) {
        //定义数组
        int[] arr ={19,28,37,46,50};
        //创建键盘录入的对象
        Scanner scanner = new Scanner(System.in);
        //给出提示
        System.out.println("请输入要查找的数据： ");
        //使用变量来接收录入的数据
        int week = scanner.nextInt();
        /**传入数组和录入值，用变量接收索引*/
        //getIndex(int[] arr,int week)
        int index = getIndex(arr, week);
        /**判断索引值，看是否找到了该数据*/
        if (index !=-1){
            //如果在，则打印索引值
            System.out.println("索引值为： "+index+"，已找到该数据");
        }else{
            //如果不再则返回打印
            System.out.println("索引值为： "+index+"找不到该数据，请重新输入 ");
        }
    }
    public static int getIndex(int [] arr,int week){
        //定义索引变量
        int index =-1;
        /**循环遍历数组*/
        for (int x =0;x<arr.length;x++){
            /**判断该数据是否在数组中*/
            if (week == arr[x]){
                /**如果在，则将x赋值给index*/
                index =x;
                /**找到了break跳出循环*/
                break;
            }else{
            }
        }
        return index;
    }
    /***运行结果：{找到时}
     *
     * 请输入要查找的数据：
     * 28
     * 索引值为： 1，已找到该数据
     *
     * 运行结果{找不到时}
     *请输入要查找的数据：
     * 77
     * 索引值为： -1找不到该数据，请重新输入
     */
}

方法调用方法名(参数名) 即可，参数前面不用加数据类型{不加数据类型这点很重要}

数据反转

关键点还是索引反转+盒子理论

一次循环赋值3次,得到x时，也就可以得到与之相对的arr.length-x

临时空间=x
x=arr.length-x
arr.length-x=临时空间

循环时，长度减半{判断数组的长度是奇还是偶？？？}

这个的思路和原先所想的不同，它同时定义了两个变量

交换部分

遍历部分

仅仅是索引数交换，并没有和数组联系起来，毫无意义

 for (int start=0,end =arr.length-1;start<=end;start++,end--){
            /**声明盒子*/
            int temp = start;
            /**接着首位索引的值，被末尾索引的值覆盖*/
            start = end;
            /**最后末尾索引的值，被盒子{里的首位所覆盖}*/
            end = temp;
        }

交换的是数组中索引所对应的数值！！！需要交换数值！！！

第2个，地方GG

 int[] arr = {19,28,37,46,50};
        /**循环遍历 arr[start],arr[end]  start和end都是int类型的，
         * 不用加int分隔
         * arr.length是长度，索引应该比长度少1位
         * 每次首位的索引加1，末尾的所有减1.直到首位小于等于末位
         *
         */
        for (int start=0,end =arr.length-1;start<=end;start++,end--){
            int temp =0;
            /**声明盒子，交换索引下的数值！！！*/
            arr [temp] = arr [start];
            /**接着首位索引的值，被末尾索引的值覆盖*/
            arr [start] = arr[end];
            /**最后末尾索引的值，被盒子{里的首位所覆盖}*/
            arr [end] = arr [temp];
        }

结果：

[37,46,37,28,50]

请好好看看方法传参引用数据类型这一部分，将盒子直接作为索引和数组直接挂钩，这样的交换就没有声明意义！！！盒子作为索引值又没有改变，当数组首部的元素被尾部元素覆盖时，盒子里得到值也是跟着变。如果不是盒子的固定值被设定为0了，那么根本就不会有任何反转

arr[0] =arr[0] 
/**这一步使 arr[0]=50*/
arr[0]=arr[4]
/**然后 arr[4]=arr[0]=50*/
arr[4]=arr[0]

盒子作为变量的意义是用来装元素的值，而不是索引的{请记清楚}

正确的代码演示：

/**数组反转
 * arr{19,28,37,46,50}
 * 声明变量 temp {盒子} start{开始时的索引} end{结束时的索引}
 */
public class Test09 {
    public static void main(String[] args) {
        //定义数组
        int[] arr = {19,28,37,46,50};
        /**循环遍历 arr[start],arr[end]  start和end都是int类型的，
         * 不用加int分隔
         * arr.length是长度，索引应该比长度少1位
         * 每次首位的索引加1，末尾的所有减1.直到首位小于等于末位
         *
         */
        for (int start=0,end =arr.length-1;start<=end;start++,end--){
            
            /**声明盒子，交换索引下的数值！！！*/
            int temp = arr [start];
            /**接着首位索引的值，被末尾索引的值覆盖*/
            arr [start] = arr[end];
            /**最后末尾索引的值，被盒子{里的首位所覆盖}*/
            arr [end] = temp;
        }
        /**最后调用输出方法*/
        printArray(arr);
        /**打印结果：
         * [50,46,37,28,19]
         */
    }


    /**现在arr的值已经变了，现在需要将数组一次性{，，，}的形式输出
     * 传入数组，返回出{，，，}形式
     */
    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.print("]");
    }

}

评委打分实现

/**
 * 需求：
 *  在编程竞赛，有6个评委为参数的选手评分，分数为0~100的整数分
 *  选手的最后得分为：去掉一个最高分和一个最低分后的4个评委平均值{不考虑小数部分}
 *
 */
public class Test11 {
    public static void main(String[] args) {
        //定义一个数组，动态初始化，长度为6{之后循环录入，然后给数组赋值}
        int[] arr =new int[6];
        /**先创建键盘录入对象
         * 【键盘录入的数据存储在这个对象中，后面的方法只是从这个对象中将数据的取出来】
         */
        Scanner  scanner = new Scanner(System.in);
        /**然后提示输入评委数据
        System.out.println("请输出第一个评委分数:  ");

        for (){
            //循环遍历给数组赋值
        }
         */
        //循环提示，然后录入给数组赋值
        for (int x =0;x<arr.length;x++){
            int y =x+1;
            System.out.println("请输出第"+y+"位评委的打分 ");
            //将录入的值，赋值给数组中的元素
            arr[x] = scanner.nextInt();
        }
        /**这样就得到了这个已赋值的数组
         * 然后调用获取最值的方法，得到最值，再调用求和的方法求和
         * 最后用求和值减最值，再求平均数
         */
        int max = getMax(arr);
        int min = getMin(arr);
        int sum = getSum(arr);
        //定义变量 average，代表平均分
        int average =(sum-max-min)/4;
        System.out.println("平均分 "+average);
    }
    public static int getMax(int [] arr){
        //获取数组中的最值，循环遍历比较 擂台模型
        //定义变量max，代表最大值，并将数组中的第一个元素赋值给它
        int max =arr[0];
        //循环遍历数组，并比较和max的大小，比max大则赋值给max
        for(int x=0;x<arr.length;x++){
            if(arr[x]>max){
                max = arr[x];
            }else{
            }
        }
        return max;
    }
    public static int getMin(int[] arr){
        /**
         * 获取数组中的最值，循环遍历比较 擂台模型
         * 定义变量min，代表最小值，并将数组中的第一个元素赋值给它
         */
        int min =arr[0];
        //循环遍历数组，并比较和min的大小，如果小于min则将该值赋给min
        for (int x=0;x<arr.length;x++){
            if(arr[x]<min){
                min =arr[x];
            }else{
            }
        }
        return min;
    }
    public static int getSum(int[] arr){
        /**
         *定义变量sum，然后循环遍历求和{前一个值加上遍历出来的值，等于求和值}
         */
        int sum =0;
        for(int x=0;x<arr.length;x++){
            sum+=arr[x];
        }
        return sum;
    }
}

int y =x+1;
            System.out.println("请输出第"+y+"位评委的打分 ");

这里可以改进为：

System.out.println("请输出第"+(x+1)+"位评委的打分 ");

还有这里可以改进

//循环遍历数组，并比较和min的大小，如果小于min则将该值赋给min
        for (int x=0;x<arr.length;x++){
            if(arr[x]<min){
                min =arr[x];
            }else{
            }
        }

之前已经定义过了min=arr[0],也就是说不被从0开始循环，而是从1开始循环。

同样的max,也是可以这样改进

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

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

还有这里也可以改进 int average =(sum-max-min)/4; ,实际开发中应该减少为被定义的数字，它被称为魔法值

 int average =(sum-max-min)/(arr.length-2);

面向对象

什么是对象的属性？

属性：对象具有的各种特征，每个对象的每个属性都用于特定的值

什么是对象的行为？

行为：对象能够执行的操作

对象的使用：

对象的成员变量的使用

对象.成员变量名

可以看做：对象的成员变量

对象的方法的使用

对象.成员方法

可以看做：对象调用成员方法

创建的类

package test1;

public class Phone {
    /**手机类的3个属性 品牌 价格 颜色*/
    String brand;
    int price;
    String color;
    /**手机类的两个方法，打电话和发短信*/
    public void call(){
        System.out.println("打电话");
    }
    public void sendMassage(){
        System.out.println("发短信");
    }
}

对象的创建和使用

package test1;

public class PhoneDemo {
    public static void main(String[] args) {
        //创建手机类的对象
        Phone p = new Phone();

        //使用成员变量
        System.out.println(p.brand);
        System.out.println(p.price);

        p.brand ="小米";
        p.price = 2999 ;
        //再次使用成员变量
        System.out.println(p.brand);
        System.out.println(p.price);

        //成员方法的使用，对象调方法
        p.call();
        p.sendMassage();

    }
}
/**打印结果：
 * null
 * 0
 * 小米
 * 2999
 * 打电话
 * 发短信
 */

对象的成员变量有默认值，为0或者null,或者false

使用时，可以给它们赋值

创建学生类

/**
 * 学生类
 */
public class Student {
    /**成员变量，姓名，年龄*/
    String name;
    int age;

    /**成员方法 学习和做作业*/
    public void study(){
        System.out.println("好好学习，天天向上");
    }
    public void doHomeword(){
        System.out.println("键盘敲烂，月薪过万");
    }
}

创建学生类对应的测试类

然后创建对象，使用对象

/**
 * 学生测试类
 */
public class StudentDemo {
    public static void main(String[] args) {
        /**创建学生对象*/
        Student s = new Student();

        /**使用对象 输出成员变量*/
        System.out.println(s.name+","+s.age);

        /**给成员变量赋值*/
        s.name ="林青霞";
        s.age  = 30;

        /**再次输出成员变量*/
        System.out.println(s.name+","+s.age);

        /**调用成员方法*/
        s.study();
        s.doHomeword();

    }

}
/**打印结果：
 * null,0
 * 林青霞,30
 * 好好学习，天天向上
 * 键盘敲烂，月薪过万
 */

对象创建的内存图：