简单的案例，了解面向对象

 1.定义一个学生类，属性有学号，姓名，年龄。

使用alt+insert 快捷，生成空参，带参，get和set方法。

package com.ooptest.t4;

public class Student {
    private int id;
    private String name;
    private int age;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

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

    public Student() {
    }
}

 2.有五个要求，依次完成

package com.ooptest.t4;

public class StudentTest {
    public static void main(String[] args) {
        // 创建一个数组用来存储学生对象
        Student[] arr = new Student[3];

        // 创建学生对象并添加到数组当中
        Student s1 = new Student(1, "xinYuan", 17);
        Student s2 = new Student(2, "Pxy", 18);
        Student s3 = new Student(3, "Yuan", 19);

        // 把学生对象放到数组中
        arr[0] = s1;
        arr[1] = s2;
        arr[2] = s3;

        Student s4 = new Student(4, "Yn", 20);
        // 要求1：再次添加一个学生对象，并在添加的时候进行学号的唯一性判断
        boolean flag = contains(arr, s4.getId());

        if (flag) {// true执行，打印id重复
            // 已存在，不添加
            System.out.println("当前id重复，请修改id后再进行添加");
        } else { //false，添加
            // 不存在，则添加
            int count = getCount(arr);
            if (count == arr.length) {
                // 已经存满 方法创建一个新数组的方法，讲老数组拷贝到新数组
                Student[] newArr = createNewArr(arr);

                newArr[count] = s4;

                /** 要求2：添加完毕之后，遍历所有学生信息 */
                printArr(newArr); //(遍历新数组)

            } else {
                // 没有存满
                // [stu1,stu2,null]
                // getCount获取到的是2，表示数组中已经有了2个元素
                // 还有一层意思：如果下一次要添加数据，就是添加到2索引的位置
                arr[count] = s4;
                // 要求2：添加完毕之后，遍历所有学生信息
                printArr(arr); //(遍历老数组)
            }
        }


        /** 要求3：通过id删除学生信息，如果存在，则删除，如果不存在，则删除失败*/
        int index = getIndex(arr, 2);
        if(index >= 0){
            arr[index] =null;
            /** 要求4：删除完毕之后，要求遍历所有学生的信息*/
            printArr(arr);
        }else{
            System.out.println("当前id不存在，删除失败");
        }


        /**要求5：查询数组id为“02” 的学生，如果存在，就将它的年龄+9岁*/
        int index1 = getIndex(arr, 2);
        if(index1 >= 0){
            Student student = arr[index1];
            int newAge = student.getAge() + 9;
            student.setAge(newAge);
            printArr(arr);
        }else{
            System.out.println("当前id不存在，修改失败");
        }

    }

    /**
     * 方法6：找到数组中的索引
     */
    public static int getIndex(Student[] arr,int id){
        for (int i = 0; i < arr.length; i++) {
            Student stu = arr[i];
            if(stu != null){
                int sid = stu.getId();
                if(sid == id){
                    return i;   // 返回索引的位置
                }
            }
        }
        return -1;      // 如果没有找到相同的id，则返回-1，数组中不可能存在-1的索引
    }


    /** 方法4遍历数组中的元素
     * @param arr
     */
    public static void printArr(Student[] arr) {
        for (int i = 0; i < arr.length; i++) {
            Student stu = arr[i];
            if (stu != null) {
                System.out.println(stu.getId() + "." + stu.getName() + "." + stu.getAge());
            }
        }
    }

    /**
     * 方法3创建一个新数组的方法，讲老数组拷贝到新数组
     * 数组已经存满，新建一个数组，新数组的长度 = 老数组 + 1
     * 数组没有存满，直接添加
     *
     * @param arr
     * @return
     */
    public static Student[] createNewArr(Student[] arr) {
        Student[] newArr = new Student[arr.length + 1];
        // 循环遍历老数组中的每一个元素
        for (int i = 0; i < arr.length; i++) {
//            把老数组中的元素添加到新数组中
            newArr[i] = arr[i];
        }
        // 返回新数组
        return newArr;
    }

    /**
     * 方法2判断数组中已经存了几个元素
     *
     * @param arr
     * @return
     */
    public static int getCount(Student[] arr) {
        int count = 0;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] != null) {
                count++;
            }
        }
        // 当循环结束，可以知道数组中一共有几个元素
        return count;
    }

    /**
     * 方法1判读学号唯一性
     * 1.我要干嘛？
     * 2.我干这件事情需要什么才能完成              (数组 id)。
     * 3.调用处是否需要继续使用方法的结果？        (必须返回)
     */
    public static boolean contains(Student[] arr, int id) {
        for (int i = 0; i < arr.length; i++) {
            Student stu = arr[i];
            // 获取数组中对象的id
            int sid = stu.getId();

            if (stu != null) {
                // 比较id
                if (sid == id) {
                    return true;
                }
            }

        }
        // 需要去遍历数组中每一个id进行比较，如果id不重复，就返回false
        return false;
    }
}