一、选择排序和快速排序
1、选择排序
    原理：给定一个数组，第一个值与后面的每个值比较，要是比它小就调换位置，
            然后第二个值与后面的值比较，比它小就调换位置，依次类推
    代码实现：
        public static void main(String[] args) {
        int[] arr = new int[]{12, 5, 8, 9, 3, 7, 45, 12, 32, 14};
        System.out.println("原始数组为：");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "\t");
        }
        for (int i = 0; i < arr.length; i++) {
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[i] >= arr[j]) {
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        System.out.println();
        System.out.println("冒泡排序之后的数组为：");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "\t");
        }
    }
2、冒泡排序
    原理：
        1)比较相邻的元素。如果第一个比第二个大，就交换它们两个
        2）对每一对相邻的元素都进行比较，等所有的比较完后最后一个数字是这堆数据里的最大数字
        3）重复步骤一，直到排序完成
    代码：
        public static void main(String[] args) {  
            int[] arr = new int[]{12, 5, 8, 9, 3, 7, 45, 12, 32, 14};
            System.out.println("原始数组为：");
            for (int i = 0; i < arr.length; i++) {
                System.out.print(arr[i] + "\t");
            }
            for (int i=0;i<arr.length-1;i++){
                for (int j=0;j<arr.length-1-i;j++){
                    int temp = 0;
                    if (arr[j]>arr[j+1]) {
                        temp = arr[j];
                        arr[j] = arr[j+1];
                        arr[j+1] = temp;
                    }
                }
            }
            System.out.println();
            System.out.println("冒泡排序之后的数组为：");
            for (int i = 0; i < arr.length; i++) {
                System.out.print(arr[i] + "\t");
            }
        }
3、二分查找
    作用对象
        已经排好序的数组（正序逆序都可以）
    原理
        每次取中间位置的值与待查关键字比较，如果中间位置的值比待查关键字大，则在前半部分循环这个查找的过程，
        如果中间位置的值比待查关键字小，则在后半部分循环这个查找的过程。直到查找到了为止，否则序列中没有待查的关键字
    查找的部分代码
    public static int biSearch(int []array,int a){
        int lo=0;
        int hi=array.length-1;
        int mid;
        while(lo<=hi){
            mid=(lo+hi)/2;
            if(array[mid]==a){
                return mid+1;
            }else if(array[mid]<a){
                lo=mid+1;
            }else{
                hi=mid-1;
            }
        }
        return -1;
    }

二、方法传递参数时需要注意的点
1、基本数据类型传递参数
    public class Demo1{
        public static void main(String[] args){
            a = 10;
            b = 20;
            int c = sum(a,b);
            System.out.println(a);
            System.out.println(b);
            System.out.println(c);
        }

        public static int sum(int a,int b){
            a = b;
            b = a +b;
            return a + b;
        }
    }
    ****输出时a=10,b=20,c=60****
    总结：
        基本数据类型传递的是实际变量的数值，对方法外部变量本身没有任何影响    
2、引用数据类型
    public class Demo2{
        public static void main(String[] args){
            int[] arr = new int[]{1,2,3,4,5};
            change(arr);
            System.out.println(arr[1]);
        }
        
        public static void change(int[] array){
            for(int i=0;i<=array.length;i++){
                if(array[i]%2==0){
                    array[i] *= 2
                }
            }
        }
    }
    ****输出为4****
    总结：
        引用数据类型当作实际参数传递的时候，传递的是该引用数据类型的地址值，方法中的操作会影响到其他内存中的数据

三、面向对象编程
1、什么是面向对象的思想
    面向对象的思想是基于面向过程思想发展而来的

    面向过程：强调的是实现功能每一个步骤，前面的学习也属于面向过程的编程范围
    面向对象：强调的是对象，然后由这个对象去调用功能
2、面向对象的特点：
    1) 是一种更符合我们思想习惯的思想
    2) 可以将复杂的事情简单化
    3) 将我们从执行者变成了指挥者
    举例：
        吃饭：
        面向过程的思想：先去菜市场买菜--洗菜--切菜--做菜--装盘--吃
        面向对象的思想：你（点菜）--厨师（做菜）--等外卖小哥（送餐）--吃（以点外卖为例）

    需求：将大象装进冰箱里
    面向过程的思想：
        分析过程：
            1、打开冰箱门
            2、把大象装进冰箱
            3、关闭冰箱门
        伪代码实现：
            class Demo{
                public static void main(String[] args){
                    System.out.println("打开冰箱门");
                    //为了完成这个过程简单使用三个方法执行他们，只代表面向过程编程的意思
                    //把打开冰箱门、把大象装进冰箱、关闭冰箱门封装成三个方法，然后调用

                    open();
                    put();
                    close();
                }

                public static void open(){
                    //写打开冰箱门的功能实现代码
                }

                public static void put(){
                    //写把大象装进冰箱的功能实现代码
                }

                public static void close(){
                    //写关闭冰箱门的功能实现代码
                }
            }
    面向对象的思想：
        使用面向对象的思想去实现该需求：
            1、我们需要考虑该需求中有哪些类？
            2、每一个类中都有些什么呢？
            3、类与类之间的关系又是什么呢？

        1、我们需要考虑该需求中有哪些类？
            如何分析有哪些类，
                方式1：需要用到UML这门课的知识
                方式2：名词提取法
            有哪些类呢？
                通过名词提取法，我们知道有大象类，冰箱类外加一个测试类

        2、每一个类中都有些什么呢？
            大象类：
                属性：体积，鼻子，脚掌，耳朵...
                功能：被装进冰箱，喝水，叫....
            冰箱类：
                属性：立方体，材质，功率...
                功能：打开冰箱门，关闭冰箱门，冷藏，保鲜....
            测试类：
                main方法，实现需求

        3、类与类之间的关系又是什么呢？
            测试类中使用大象类和冰箱类的功能

        伪代码实现：
            //大象类
            class Elephant{
                体积；
                鼻子；
                脚掌；
                耳朵；

                被装进冰箱();
                喝水();
                叫();
            }

            //冰箱类
            class IceBox{
                立方体;
                材质;
                功率;

                打开冰箱门()
                关闭冰箱门()
                冷藏()
                保鲜()
            }

            //测试类
            class Demo2{
                public static void main(String[] args){
                    调用冰箱类中的打开冰箱门的方法;
                    调用大象类中的被装进冰箱的方法;
                    调用冰箱类中的关闭冰箱门的方法;
                }
            }

3、面向对象开发,设计,特征
    1）、面向对象的开发：
        实际上就是不断创建对象，使用对象，指挥对象做事情的过程
    2）、面向对象的设计：
        其实就是管理和维护类与类之间的关系的过程
    3）、面向对象的特征：
        1、封装
        2、继承
        3、多态

4、使用java语言描述现实生活中的事物
    举例：
        人
        五官，姓名，性别，年龄...
        吃饭，学习，说话，敲代码...
    
        水杯
        颜色，形状，材质，容积...
        装水，泡茶...
        
        属性：用来描述事物的信息
        行为：用来描述事物能够做什么
    学习编程目的：
        我们学习编程语言的目的，其实就是用来模拟现实世界的事物的
        而我们现在所学习的语言叫做: java
        java中最基本的单位：类
            所以，我们通过java把现实世界的事物给描述出来，因此我们要学习如何用java去描述一个现实世界的事物
        由此得出一个对应关系：
        事物：                                   类：
            属性：用来描述事物的信息                  成员变量：用来描述事物的信息          
            行为：用来描述事物能够做什么              成员方法：用来描述事物能够做什么 

        类：是一组成员变量和成员方法的集合，其实是一个抽线的概念
        对象：是该类事物的具体表现，具体到某一个个体

        在Java中表现为
        事物：人                                 类：Person
            属性：五官，姓名，性别，年龄...           成员变量：facialFeatures,name,gender,age
            行为：吃饭，学习，说话，敲代码...          成员方法：eat(),study(),talk(),coding()

        对象：是该类事物的具体表现，具体到某一个个体
            学生，老师，医生，程序员...

5、具体实现过程举例（以学生基本信息举例）
    /*
        类是用来描述现实世界中的事物
        学生：
            属性：学号，姓名，年龄
            行为：吃饭，学习，睡觉
        类：
            Student:
                成员变量：id,name,age
                成员方法：eat(),study(),sleep()
    */
package com.day09;
    public class Student {
        /*定义该类中的成员变量
            格式：
            修饰符 数据类型 变量名;
            目前还没有系统地学习过修饰符，目前不加修饰符
        */
        int id;         //学号
        String name;    //姓名
        int age;        //年龄

        /*定义成员方法
          目前定义的格式：
          修饰符 返回值类型 方法名(参数列表){..}
          目前修饰符使用 public static
        */
        
        public static void eat(){
            System.out.println("吃饭");     //吃饭
        }

        public static void study(){         //学习
            System.out.println("学习");
        }

        
        public static void sleep(){
            System.out.println("睡觉");     //睡觉
        }
    }

********************测试********************

    /*
        测试学生类
            创建对象，调用成员变量和方法
    */
package com.day09;
    public class StudentDemo {
        public static void main(String[] args) {
            /*如何创建对象呢？
              格式： 类 对象名(自定义) = new 类名(...);
              创建一个学生对象
            */
            Student xiaoyang = new Student();

            /*如何获取成员变量呢？
              格式：
               对象名.成员变量名
            */
            System.out.println(xiaoyang.id);         //获取xiaoyang的学号
            System.out.println(xiaoyang.name);       //获取xiaoyang的姓名
            System.out.println(xiaoyang.age);        //获取xiaoyang的年龄

        //**********此时因为还没有赋值，所以输出是0**********//
        
            System.out.println("=================赋值后：=================");
            /*给成员变量赋值的格式：
              对象名.成员变量名 = 成员变量对应的数据类型的值;
            */
            xiaoyang.id = 10001;                    //给xiaoyang这个对象的学号进行赋值
            xiaoyang.name = "杨万里";                //给xiaoyang这个对象的姓名进行赋值
            xiaoyang.age = 18;                      //给xiaoyang这个对象的年龄进行赋值

            System.out.println(xiaoyang.id);        //获取xiaoyang的学号
            System.out.println(xiaoyang.name);      //获取xiaoyang的姓名
            System.out.println(xiaoyang.age);       //获取xiaoyang的年龄

            /*如何调用该对象中的方法
              格式：
              对象名.成员方法
            调用xiaozhu中的吃饭方法
            */
            xiaoyang.eat();
            xiaoyang.study();
            xiaoyang.sleep();
        }
    }