Java基础之冒泡排序、二分查找、封装

Java基础

1.冒泡排序

public static void main(String[] args) {
    /*
        TODO 定义数组的 冒泡排序
     */
    int[] intAr = {3, 2, 1, 5, 6, 4, 2, 1, 8};
    bubbleSort(intAr);
    System.out.println(getArrStr(intAr));
}

public static int[] bubbleSort(int[] intArr) {
    /*
        冒泡排序：
            对相邻两个数据进行比较，将较小的数据前置，较大的数据后置，之后再去拿下一个数据进行比较

          第一层 2,1,3,5,6,4,2,1,8
          第二层 2,1,3,5,6,4,2,1,8
            ① 3 v 2 => 2 3
            ① 3 v 1 => 1 3
     */
    for (int i = 0; i < intArr.length - 1; i++) {
        for (int j = 0; j < intArr.length - i - 1; j++) {
            if (intArr[j] > intArr[j + 1]) {
                int tmp = intArr[j + 1];
                intArr[j + 1] = intArr[j];
                intArr[j] = tmp;
            }
        }
    }

    return intArr;
}

2.二分查找

public static void main(String[] args) {
    /*
        TODO 定义数组的 二分查找
     */
    int[] intAr = {3, 2, 1, 5, 6, 4, 2, 1, 8};
    int index = binarySearch(intAr, 0);
    System.out.println("获取到下标："+index);

}


/*
    二分查找：
        给定一个具体的数据，通过二分的方式在int类型的数组中进行遍历数据，如果遍历到，那么返回其下标
        如果没有遍历到则返回 -1
        [1, 1, 2, 2, 3, 4, 5, 6, 8]
        对于二分查找必须要求其数组为有序数组
        ① 先确定 开始下标 和结束下标
        ② 通过开始下标和结束下标确定 中间mid下标 通过mid 获取对应下标的值
        ③ 通过下标值和目标值进行比较
            1.如果相同则返回mid下标,程序结束
            2.如果当mid 小于 目标值那么需要将 开始下标设置为 mid + 1 再进行一轮比较
            3.如果当mid 大于 目标值那么需要将 结束下标设置为 mid - 1 再进行一轮比较
        注意：mid = 开始下标 + 结束下标 / 2 取整

 */
public static int binarySearch(int[] intArr, int search) {
    int startIndex = 0;
    int endIndex = intArr.length - 1;
    while (startIndex <= endIndex) {
        int mid = (startIndex + endIndex) / 2;
        if (intArr[mid] == search) {
            return mid;
        }else if (intArr[mid] < search){
            startIndex = mid + 1;
        }else {
            endIndex = mid - 1;
        }
    }
    return -1;
}

3. class（类）

 public static void main(String[] args) {
        /*
            在Java中使用class 修饰的成为类，如果当类中存在有main方法时，成为操作类或程序入口类
         */

        Person person = new Person(); //通过类可以获取到其对象
        person.name = "许康杰";
        person.age = 20;
        System.out.println(person.name);  // 通过对象.属性 可以获取到属性值
        System.out.println(person.age);  // 通过对象.属性 可以获取到属性值

        System.out.println(person.eat("金针菇")); // 对于成员方法可以直接通过对象进行调用
        person.play();

        Person person2 = new Person(); //通过类可以获取到其对象
        person2.name = "李国涛";
        person2.age = 18;
        System.out.println(person2.name);  // 通过对象.属性 可以获取到属性值
        System.out.println(person2.age);  // 通过对象.属性 可以获取到属性值

        Person person3 = person2; // 使用的是同一个内存地址中的数据
        System.out.println(person3.name);  // 通过对象.属性 可以获取到属性值
        System.out.println(person3.age);  // 通过对象.属性 可以获取到属性值

        useVar();

    }

    public static void useVar(){
        // 当{}中代码执行完成后，当前{}中所有变量都失效，会在特定时期被 垃圾回收器回收
        {
            int var = 10;
//            int var ;  对于局部变量来说，需要先定义赋值 后使用
            System.out.println(var);
        }

    }


Person类：
    
    public class Person {
    /*
        TODO 人类：
            属性：姓名 年龄 身高 体重 性别
            方法：吃 喝 玩 学习
           注意：
              1.类中的属性称为成员变量，定义在类中方法外
              2.对于成员变量，在定义时，可以不用给定其初始值，在构建对象时，会根据变量的类型初始化
                    引用类型 （String） => null
                    基本数据类型 (byte short int long) => 0
                               (float double) => 0.0
                               (char boolean) => ?
              3.类中的成员方法，在定义时，不能使用static修饰
     */
    String name;
    int age;
    double high;
    double weight;
    String gender;

    public String eat(String food){
        System.out.println(food+"被消化了一部分");
        return "消化过的食物";
    }

    public void drink(String drink){
        System.out.println("人类可以喝饮料...");
    }

    public void play(){
        System.out.println("人类可以玩游戏...");
    }


}

4.参数传递

public static void main(String[] args) {
    /*
        在Java中使用class 修饰的成为类，如果当类中存在有main方法时，成为操作类或程序入口类
     */

    Person person = new Person(); //通过类可以获取到其对象
    person.name = "易政";
    //将引用类型变量person作为参数传递给usePerson()，以此实现了person对象中属性值的变化
    usePerson(person);
    System.out.println(person.name); // 汪雨
    System.out.println(person.age); // 18


    /*
            TODO 匿名对象:
                当对象在方法中有且只使用一次的场景
                前后两次System.out.println(inPerson);所输出的值不同
         */

    usePerson(new Person());

}

public static void usePerson(Person inPerson) {
    System.out.println(inPerson);
    inPerson.name = "汪雨";
    inPerson.age = 18;
}

5.封装

 public static void main(String[] args) {
        Student student = new Student();
        /*
           TODO 封装概述
                是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
            private 修饰成员(成员变量和成员方法) 对当前的变量或方法私有化
                    一旦修饰后，仅只能在当前的类中使用
            当在setAge中使用参数名和属性名称相同时，赋值失败，原因：
                1.在方法中定义的参数为局部变量，仅仅在当前方法中生效，
                2.当参数名称和属性相同时，根据就近原则，选择当前方法内的局部变量进行调用
            this => 指代当前的对象 this.可以使用属性或方法
         */
        student.setName("李四");
        student.setAge(18);
        student.setGender("不知道");
        student.printInfo(); // 方法可以被调用 因为该方法为public 而其中的属性虽然为私有但是，在当前对象类内调用的

        // 通过封装的方法可以对其中属性值进行获取
        System.out.println(student.getName());
        System.out.println(student.getAge());

        Phone phone = new Phone();
        phone.setNumber("183****8888");
        phone.setUser("王五");
        System.out.println(phone.getUser());
        System.out.println(phone.getNumber());

    }



Student类：
    
    public class Student {
    private String name;
    private int age;
    private String gender;

    public void setName(String inName) {
        name = inName;
    }

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

    public void setGender(String inGender) {
        if (inGender.equals("男") || inGender.equals("女")){
            gender = inGender;
        }else {
            System.out.println("性别只能为男或女，您输入的信息不正确...");
        }
    }

    public int getAge() {
        return age;
    }

    public String getName() {
        return name;
    }

    public String getGender() {
        return gender;
    }

    public void printInfo() {
        System.out.println("我叫：" + name + " 今年：" + age + " 性别是:" + gender);
    }

}

6.构造方法

 public static void main(String[] args) {
        /*
            TODO 构造方法
                1. new Phone(); 是使用 new 关键字 + 类名 + ()  => Java的方法中有() 表示 方法的调用
                2. 在定义类时，会默认给定一个当前类的无参构造方法
                        构造方法 作用是返回一个 当前类的一个对象 所以不需要指定其返回值类型
                   注意：
                       1.构造方法的格式 修饰符 类名(参数) {可以编写构造方法体}
                       2.对于显示定义构造方法，默认会覆盖无参构造

         */
        Phone phone = new Phone();
        phone.setNumber("183****8888");
        phone.setUser("陆玉龙");
        System.out.println(phone.getUser());
        System.out.println(phone.getNumber());

        Phone phone2 = new Phone("袁枫", "166****6666");
        System.out.println(phone2.getUser());
        System.out.println(phone2.getNumber());

        Phone phone3 = new Phone("汪雨");
        System.out.println(phone3.getUser());
        System.out.println(phone3.getNumber());

        // 对象调用方法
        phone2.call("188****8888");
        Phone phone4 = new Phone("袁枫女朋友", "188****8888");
        phone2.call(phone4);

        //非static的方法无法通过直接使用其方法名来调用该方法
        //usePhone(phone2);
        //以引用类型变量来作为传递参数
        useStaticPhone(phone2);
    }

    public void usePhone(Phone phone){
        System.out.println("手机号:"+phone.getNumber()+"正在被使用...");
    }
    public static void useStaticPhone(Phone phone){
        System.out.println( "Demo05中的代码:"+"手机号:"+phone.getNumber()+"正在被使用...");
    }



phone类：
    
    public class Phone {
    // public 表示公开的
    public Phone() {
        System.out.println("这是Phone的构造方法...");
    }

    /*
        有参构造方法
     */
    public Phone(String user, String number) {
        this.user = user;
        this.number = number;
        System.out.println("这是两个参数的Phone的构造方法...");
    }

    /*
      TODO 构造方法内部调用其他构造方法
          注意: 在当前类中构造方法调用需要使用 this([参数]) 进行调用
               同时，this([参数]) 需要放在当前构造方法的第一行
     */
    public Phone(String user) {
        this(user, "111****0000");
        System.out.println("这是1个参数的Phone的构造方法...");
//        this.user = user;
//        this.number = "111****0000";
    }


    private String user;
    private String number;

    public String getUser() {
        return user;
    }

    public void setUser(String user) {
        this.user = user;
    }

    public String getNumber() {
        return number;
    }

    public void setNumber(String number) {
        this.number = number;
    }

    public void call(String number) {
        System.out.println(this.number + "正在打电话给" + number);
    }


    //以引用类型变量来作为传递参数
    public void call(Phone phone) {
        System.out.println(this.user + "\t" + this.number + "正在打电话给" + phone.user + "\t" + phone.number);
    }


    public void show(){
        System.out.println("当前用户为:"+user+"其手机号码为:"+number);
    }

}

7.成员方法

public class Demo06UseObjectFunction {
    
    public static void main(String[] args) {
        /*
            TODO 成员方法
                定义：属于对象的，在类中定义，格式为：
                    修饰符 返回值类型 方法名(参数列表) {方法体}
                调用：
                    成员方法的调用，必须要通过对象进行
                    静态方法是属于类的，其调用方式：
                        1.如果在当前类中的static方法中使用 可以直接通过方法名调用
                        2.如果在其他类中的静态方法内调用，可以通过类名.方法名调用
                        3.对于对象也可以调用类中的静态方法，但是不合规
                    注意：
                        1. 静态方法内部，只能调用静态方法，或者通过其对象调用成员方法

         */

        Phone phone2 = new Phone("袁枫", "166****6666");
        System.out.println(phone2.getUser());
        System.out.println(phone2.getNumber());

//        usePhone(phone2); //不能使用

        //创建本类对象
        Demo06UseObjectFunction demo06UseObjectFunction = new Demo06UseObjectFunction();
        //通过本类对象调用其成员方法usePhone()
        demo06UseObjectFunction.usePhone(phone2);

        useStaticPhone(phone2);  // 静态方法，可以直接被调用
        Demo05GetObject.useStaticPhone(phone2);
        //可以调用类中的静态方法，但是不合规
        demo06UseObjectFunction.useStaticPhone(phone2);

        phone2.show();

    }

    public void usePhone(Phone phone){
        System.out.println("手机号:"+phone.getNumber()+"正在被使用...");
//        useStaticPhone(phone);  // 成员方法中可以直接调用类中的静态方法
    }

    // static 修饰的成为静态方法
    public static void useStaticPhone(Phone phone){
//        usePhone(phone);  // 不可以
        System.out.println("Demo06中的代码:"+"手机号:"+phone.getNumber()+"正在被使用...");
    }

}

8. static

package com.shujia.Day04_packaging;

public class Demo07StaticVar {
    static int value;
    static int data = 20;

    int var = 1;

    public static void main(String[] args) {
        /*
            TODO static 修饰成员变量
                1. 提供了一种全局的方式，可以在多个静态方法中进行调用变量
                2. 对于成员变量只能在成员方法中使用，不能在静态方法中使用
                3. 对于成员方法中，可以使用静态变量
                4. 对于成员变量使用static修饰，那么该变量为静态变量 -> 属于类的 -> 是所有对象共有的 ->
                        内存中的存储位置是在方法区(元空间中) -> jdk7之后存在堆空间中  -> 在全局有且仅有一个
         */
        Demo07StaticVar.value = 10;
        System.out.println(value);
        System.out.println(data);
        useVar();
        
//        var = 10;
//        Demo07StaticVar demo07StaticVar = new Demo07StaticVar();
//        demo07StaticVar.objectVar();
        //匿名对象
        new Demo07StaticVar().objectVar();


        Per per1 = new Per("张三", "美国");
        per1.show();
        Per per2 = new Per("李四", "中国");
        per2.show();
        // 现象 ：由于nationality属性为static，
        // 第二次创建Per对象时输入的nationality"中国"覆盖了第一次输入的张三的nationality"美国"
        per1.show();  


    }

    public static void useVar() {
        //静态方法中无法使用非静态方法中定义的变量
//        var = 10;
        System.out.println("获取到Value:" + value);
        System.out.println("获取到data:" + data);
    }

    public void objectVar() {
        var = 10;
        data = 30;
        System.out.println("当前data:" + data);
        System.out.println("当前var:" + var);
    }

}


Per类：
    
public class Per {
    String name;
    static String nationality;

    // alt + insert 按键  快捷方式(快速创建get、set方法)
    // select None
    public Per() {
    }

    public Per(String name, String nationality) {
        this.name = name;
        this.nationality = nationality;
    }

    public void show() {
        System.out.println("姓名：" + name + "\t" + "国籍:" + nationality);
    }
}

9. main方法

public class Demo08Main {
    public static void main(String[] args) {
        // String[] args => 是一个字符串数组
        /*
            String[] args 表示在程序运行时传入的一些参数
              类似于  mysql -uroot -p123456
            参数之间使用空格隔开
         */
        int length = args.length;
        System.out.println(length);
        if (length > 0){
            for (String arg : args) {
                System.out.println("argument:"+arg);
            }
        }
    }
}


public class Demo08UseMain {
    public static void main(String[] args) {
        String[] arguments = {"1","2"};
        /*
            main方法是属于类的 就可以使用类.main进行调用
         */
        Demo08Main.main(arguments);
    }
}