2022年2月8日

麻了，昨天的代码有点瑕疵。
bubble adj.冒泡的 bubble sort 冒泡排序
sparse adj.稀疏的 sparse array 稀疏数组
我给混了

面向对象编程OOP

Object Oriented Programing

package Preparation;

//Demo_1 类
public class Demo_1 {
    //main 方法

    //方法的定义

    public static void main(String[] args) {
        //属性+方法->类
        //以类的方式组织代码，以对象的方式组织(封装)数据

        //break 和 return 的区别
        /*
        break  跳出switch，结束循环
        return 结束方法
         */
    }

    /*
    修饰符 返回值类型 方法名(){
        //方法体
        //return
    }
     */
    public static String sayHello(){
        return "Hello";
    }

    public static int max(int a, int b){
        return a > b ? a : b;
    }
    //数组下标越界 Arrayindexoutofbounds
}

关于静态方法和非静态方法的一个区别
1、静态方法是和类一起加载的
2、非静态方法在类实例化(new)后才存在

package Preparation;

public class Demo_2 {
    //方法的调用
    public static void main(String[] args) {

        /*
        在另一个类写的方法，想要在这个类调用，两种方式：
        1、如果是静态(static)：类名.方法
        2、如果是非静态：类的实例化，通过new进行实例化
               对象类型 对象名 = 对象值
         */

        //静态方法 static
        //与类Demo_2一起加载的
        Student.say1();

        //非静态方法
        //类实例化后(new)才存在的
        new Student().say2();
        //或
        Student student = new Student();
        student.say2();
    }
}
class Student {
    //方法
    //静态方法
    public static void say1(){
        System.out.println("学生上课说话1");
    }
    //非静态方法
    public void say2(){
        System.out.println("学生上课说话2");
    }
}

形参和实参

package Preparation;

public class Demo_3 {
    //形参和实参
    public static void main(String[] args) {
        int a = 1, b = 2;
        //对象类型 对象名 = 对象值
        //类是对象的模板
        Demo_3 demo_3 = new Demo_3();//创建对象
        System.out.println(demo_3.add1(a,b));
        System.out.println(Demo_3.add2(a,b));
        System.out.println(add2(a,b));
    }
    //非静态方法
    public int add1(int a, int b){
        return a + b;
    }
    //静态方法
    public static int add2(int a, int b){
        return a + b;
    }
}

值传递和引用传递

值传递：传递的是对象的值，而不是对象，因此不能修改对象的值
引用传递：传递的是对象的地址，因此能修改对象的值

值传递

package Preparation;

public class Demo_4 {
    public static void main(String[] args) {
        //值传递
        //Java都是值传递
        int a = 1;
        System.out.println(a);//1
        Demo_4.change(a);
        System.out.println(a);//1
    }

    //返回值为空
    public static void change(int a){
        a = 10;
    }
}

引用传递

package Preparation;

public class Demo_5 {
    public static void main(String[] args) {
        //引用传递:传递的是对象，但本质还是值传递
        Person person = new Person();
        System.out.println(person.name);//null
        System.out.println(person.age);//0

        Demo_5.change(person);
        System.out.println(person.name);//小石榴
        System.out.println(person.age);//19
    }

    public static void change(Person person){
        person.name = "小石榴";
        person.age = 19;
    }
}
//class Student 错误：已经有Student了
//定义了一个Person类，有一个属性：name
class Person{
    String name; //默认值为null
    int age;     //默认值为0
}

某弹幕评论：
值传递—>修改的是拿到的副本，原值并没有发生变化
引用传递—> 指针修改，因为引用指向原对象在在内存中的区域，所有可以修改原对象的值

类与对象的创建

类与对象的关系