类基本知识及最大值，最小值，逆置数组元素、查表工具类编写

1. 定义一个表示学生信息的类Student，要求如下：
   　（1）类Student的成员变量：
   id表示学号；name表示姓名；gender表示性别；age表示年龄；java表示Java课程成绩。
   （2) 在定义一个print()方法，输出student对象的 name，gender，age，java的值(即输出学生信息)

（3）根据类Student的定义，创建五个该类的对象，输出每个学生的信息，计算并输出这五个学生Java语言成绩的平均值，

   提示： 数组既可以存储基本数据类型的值，也可以存储引用数据类型的值
          因此，5个Student对象可以放在一个Student数组中
          Student[] students = new Student[5];
          students[1] = student对象的引用

         //求平均值，都可以通过循环遍历 students数组来完成

package com.homework.homework0718;

/**
 * @Author kinmon
 * @Date 2020/7/18 19:21
 * @Version 1.0
 */
public class Student {
    int id;
    String name;
    boolean gender;
    int age;
    double java;

    public  void print(){
        System.out.println(this.name + "-" + (this.gender ? "男" : "女") + "-" + this.age +"-"+ this.java);
    }

    public Student(){

    }
    public Student(int id,String name,boolean gender,int age,double java){
        this.id = id;
        this.name = name;
        this.gender = gender;
        this.age = age;
        this.java = java;
    }
}

package com.homework.homework0718;

/**
 * @Author kinmon
 * @Date 2020/7/18 19:32
 * @Version 1.0
 *  * 1. 定义一个表示学生信息的类Student，要求如下：
 *  * （1）类Student的成员变量：
 *  * id表示学号；name表示姓名；gender表示性别；age表示年龄；java表示Java课程成绩。
 *  * （2) 在定义一个print()方法，输出student对象的 name，gender，age，java的值(即输出学生信息)
 *  * （3）根据类Student的定义，创建五个该类的对象，输出每个学生的信息，计算并输出这五个学生Java语言成绩的平均值，
 *  *        提示： 数组既可以存储基本数据类型的值，也可以存储引用数据类型的值
 *  *               因此，5个Student对象可以放在一个Student数组中
 *  *               Student[] students = new Student[5];
 *  *               students[1] = student对象的引用
 *  *              //求平均值，都可以通过循环遍历 students数组来完成
 */
public class PrintStuInfo {
    public static void main(String[] args) {
        //创建Student类数组接收Student的new对象
        Student[] stu = new Student[5];
        //定义double类型接收总成绩
        double sum = 0;
        //初始化数组对象，感觉可以优化，暂时想不到
        stu[0] = new Student(1,"student1",true,25,84);
        stu[1] = new Student(2,"student2",true,24,86);
        stu[2] = new Student(3,"student3",false,26,89);
        stu[3] = new Student(4,"student4",true,25,94);
        stu[4] = new Student(5,"student5",false,23,98);
        for (int i = 0; i < stu.length; i++) {
            stu[i].print();
            sum += stu[i].java;
        }
        System.out.println("java平均成绩为：" + sum / stu.length);
    }

}

2. 写一个数组的工具类ArrayTool, 要求提供
   遍历，求最大值，最小值，逆置数组元素，查表(在数组中查找指定元素，若不存在，待查找元素返回-1，若存在返回元素在数组中首次出现的位置)，找元素在int类型数组(int[])中最后出现的索引等操作。

   提示：
   a. 所谓工具类，就是一个类中定义的都是静态方法，这样的类称为工具类。
   b. 工具类中定义的静态方法 就是工具方法，所谓工具方法，简单来说，就是该方法实现了一些公用的功 能，为了方便使用，定义为工具方法
   比如我们之前用过的Arrays.toString(数组)，就是一个工具方法，工具方法处理的都是方法参数传递的数据。
   比如定义一个查找数组最大值的方法，在工具类中就可以这样定义
   class ArrayTool{
   /*
   查找数组中的最大值
   */
   public static int max(int[] a) {
   }
   }

package com.homework.homework0718;

/**
 * @Author kinmon
 * @Date 2020/7/18 20:05
 * @Version 1.0
 * 2. 写一个数组的工具类ArrayTool, 要求提供
 *    遍历，求最大值，最小值，逆置数组元素，查表(在数组中查找指定元素，若不存在，待查找元素返回-1，若存在返回元素在数组中首次出现的位置)，
 *    找元素在int类型数组(int[])中最后出现的索引等操作。
 *    提示：
 *     a. 所谓工具类，就是一个类中定义的都是静态方法，这样的类称为工具类。
 *     b. 工具类中定义的静态方法  就是工具方法，所谓工具方法，简单来说，就是该方法实现了一些公用的功能，为了方便使用，定义为工具方法
 *      比如我们之前用过的Arrays.toString(数组)，就是一个工具方法，工具方法处理的都是方法参数传递的数据。
 *          比如定义一个查找数组最大值的方法，在工具类中就可以这样定义
 *          class ArrayTool{
 *                查找数组中的最大值
 *      public static int max(int[]a){
        *}
        *}
 */
public class ArrayTool {
    //测试main方法
//    public static void main(String[] args) {
//        int[] nums = {1,2,3,4,5,6,7,8,9};
//        ArrayTool.throughArrays(nums);
//        int numMax = ArrayTool.maxValueOfArrays(nums);
//        System.out.println(numMax);
//        int numMin = ArrayTool.minValueOfArrays(nums);
//        System.out.println(numMin);
//        int[] reNums = ArrayTool.reverseArrays(nums);
//        System.out.println(Arrays.toString(reNums));
//        int index = ArrayTool.findValueIndex(nums,8);
//        System.out.println(index + " " + (index+1));
//    }
    /*
        遍历
     */
    public static void throughArrays(int[] arr){
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }
    /*
        返回int数组最大值
     */
    public static int maxValueOfArrays(int[] arr){
        int maxValue = arr[0];
        //防止大小为1的数组栈溢出
        for (int i = 0; i < arr.length; i++) {
            if(arr[i] > maxValue){
                maxValue = arr[i];
            }
        }
        return maxValue;
    }
    /*
        返回int数组最小值
     */
    public static int minValueOfArrays(int[] arr){
        int minValue = arr[0];
        //防止大小为1的数组栈溢出
        for (int i = 0; i < arr.length; i++) {
            if(arr[i] < minValue){
                minValue = arr[i];
            }
        }
        return minValue;
    }
    /*
        逆置数组元素 头尾交换
     */
    public static int[] reverseArrays(int[] arr) {
        int temp = 0;
        for (int i = 0; i < arr.length / 2; i++) {
            temp = arr[i];
            arr[i] = arr[arr.length-1-i];
            arr[arr.length-1-i] = temp;
        }
        return arr;
    }
    /*
        在数组中查找指定元素元素，返回第一次出现的位置
     */
    public static int findValueIndex(int[] arr,int num) {
        int index = -1;
        for (int i = 0; i < arr.length; i++) {
            if(arr[i] == num){
                index = i;
                break;
            }
        }
        return index;
    }
}

3. 在com.cskaoyan.a包下，定义一个名为MyClass的类如下

   public class MyClass {
   public void hello() {
   System.out.println(“a包”);
   }
   }
   同时，在com.cskaoyan.b包下，一个类名也为MyClass
   public class MyClass {
   public void hello() {
   System.out.println(“b包”);
   }
   }
   同时在com.cskaoyan.b包下定义一个Test类如下：
   public class Test {
   public void static main(String[] args) {
   MyClass myClass = new MyClass();
   myClass.hello();
   }
   }
   毫无疑问，当执行Test中的main方法的时候输出的是: b包
   先要求，在不改变Test main方法中代码的情况下，让main方法运行之后输出 a包，应该怎么做？

import com.cskaoyan.a.MyClass;

import的优先级高于调用同个package下的同类名