面向对象day01

面向对象

面向对象三大特征：封装、继承、多态

类：具有相同的状态和相同的行为的一组对象的集合

对象：真实存在的具体个体

类与对象的关系：抽象和具体，对象是类的一个实例，类是多个对象进行综合抽象的结果，是实体对象的概念模型

定义类

[修饰符] class 类名{

成员变量; //类的字段

成员方法; //类的行为

}

一个类中只能含有一个public修饰的类，且类名要与文件名相同

类的字段：类的属性

[修饰符] 数据类型 字段名;

类的方法：类的行为

创建对象

类名 对象名 = new 类名();

• 类名为对象的数据类型

• new 为实例化

• 类名() 构造方法

对象的字段不赋值，会默认对应的值

对象的指针分配在栈中，对象的实例分配在堆中，对象有多少属性就分配多大内存

成员变量：

类的字段直接定义在类的内部，方法的外部的变量，为成员变量

局部变量：定义在方法的内部

成员变量与局部变量的区别：

• 作用域不同：局部变量仅在定义它的方法内部使用，成员变量可以在整个类中使用

• 初始值不同：局部变量没有赋值时，java不会赋值，因此在使用前必须初始化，成员变量在类中定义时没有赋值，java会给他默认的初始值

• 在同一个方法中不允许有同名的局部变量

• 在一个类中，局部变量名可以与成员变量名相同，且在使用时局部变量有更高的优先级

构造方法：

生成实例对象的唯一方法

与类名相同，没有返回值

作用：为成员变量初始化

在类中没有定义构造方法，系统会默认创建一个无参构造，该构造方法没有参数和方法体，生成对象的属性值也为零或空，若定义构造方法，系统会自动屏蔽掉无参构造方法，构造方法不能继承

所以在定义时，最好无参构造和带参构造都定义

定义：

[访问修饰符] 方法名([参数列表]){

//方法体

}

构造方法与方法的区别：

• 构造方法在定义时，无返回值类型，无返回值，方法可以有返回值

• 构造方法方法名必须与类名相同，方法的方法名只需遵循标识符命名规则

• 构造方法在调用时，要创建对象，使用new 方法名(参数列表)，方法在调用时，方法名(参数列表)

无参构造与带参构造区别：

在进行初始化时，带参构造会直接把值赋值给对应字段

无参构造需要调用对应字段进行赋值，不赋值，默认为该字段的初始值

public class Person {
    //面向对象
    String name;
    String gender;
    int age;
    public void sleep(){
        System.out.println(name + "睡觉");
    }
    public void eat(){
        System.out.println("吃饭");
    }
    public void play(){
        System.out.println("玩游戏");
    }
    public void play(String name,int age){
        this.name = name;
        this.age  = age;
    }
    public Person(String name,int age){ //带参构造
        this.name = name;
        this.age = age;
    }
    public Person(){ //空参构造
​
    }
​
    public static void main(String[] args){
        Person p = new Person(); //空参构造
        p.eat();
        p.sleep(); //没有赋值，默认为数据初始值
        p.name = "张三";
        p.sleep();
        Person p1 = new Person("李四",20); //带参构造
        System.out.println(p1.name);
        System.out.println(p1.age);
    }
}

​

this关键字

this关键字是对一个对象的默认引用。

使用场景：

• 使用this调用成员变量，解决成员变量与局部变量同名问题，成员变量与局部变量同名，this.字段名表示成员变量，字段名表示局部变量；局部变量与成员变量不同名时，this可省略

• 使用this调用成员方法，this可省略

• this调用重载的构造方法，只能在构造方法使用，且必须是构造方法的第一条语句，这是因为在创建对象时，必须首先初始化对象的状态，然后才能进行其他操作。this() 表示构造方法，里面的参数对应构造方法的参数

public class Person {
    private String name;
    private int age;
    // 构造方法1：接收名字和年龄
    public Person(String name, int age) {
    this.name = name;
    this.age = age;
    }
​
    // 构造方法2：接收名字，默认年龄为0
    public Person(String name) {
        this(name, 0); // 调用构造方法1
    }
​
    // 构造方法3：无参构造方法
    public Person() {
        this("Unknown", 0); // 调用构造方法1
    }
​
    // 其他成员方法...
}

快速排序

首先，定义一个基准数，给定两个起始值，一个从最左边开始，一个从最右边开始

若左边索引不等于右边索引，先从最右边开始向左边找，找到小于基数的跳出循环，左边向右找，找到比基数大的，跳出循环，若左边的值小于右边的值，两个数交换位置，

若左边索引等于右边索引，将索引与基数比较，小于基数，交换位置

使用递归

若左边数据大于等于右边数据，递归结束

public static void main(String[] args) {
​
        int[] arr = {3, 2, 6, 4, 27, 7};
    
        quickSort(arr, 0, arr.length - 1);
    
        for (int i = 0; i < arr.length; i++) {
    
            System.out.print(arr[i] + " ");
    
        }
    
    }
    
    public static void quickSort(int[] arr,int start,int end){
    
        if (start >= end){ //递归结束条件
    
            return;
    
        }
    
        int i = start;
    
        int j = end;
    
        int current = arr[i];
    
        while (i != j){
       
            //找出比基数小的
            while (j > i && arr[j] >= current){
    
                j--;
    
            }
            //找出比基数大的
            while (j > i && arr[i] <= current){
    
                i++;
    
            }
    
            if(i < j){
    
                arr[i] = arr[i] ^ arr[j];
    
                arr[j] = arr[i] ^ arr[j];
    
                arr[i] = arr[i] ^ arr[j];
    
            }
    
        }
    
        if(arr[i] < current){
    
            arr[start] = arr[i];
    
            arr[i] = current;
    
        }
​
        //调用自身
        quickSort(arr,start,i - 1);
    
        quickSort(arr,i + 1,end);
​
}