08-面向对象1

1. POP 与 OOP#

二者都是一种思想，面向对象是相对于面向过程而言的。
- 面向过程，强调的是功能行为，以“函数”为最小单位，考虑怎么做。
- 面向对象，将功能封装进对象，强调的是具备了功能的对象，以“类/对象”为最小单位，考虑谁来做。
例子：人把大象装进冰箱

2. 类和对象#

用引用操纵对象（对象是实际存在的该类事物的每个个体，因而也称为实例）
永远不需要销毁对象
创建新的数据类型：类（类是对一类事物的描述，是抽象的、概念上的定义）
一切皆对象
- 在 Java 语言范畴中，我们都将功能、结构封装到类中，通过类的实例化来调用具体的功能结构。
- 涉及到 Java 语言与前端 HTML、后端的 DB 交互时，前后端的结构映射到 Java 层面，都体现为类和对象。

3. 类及类的成员#

面向对象程序设计的重点是类的设计，而类的设计，其实就是类的成员的设计。在类中可设置两种类型的元素：字段（成员变量）和方法（成员函数）
- 字段可以是任何类型的对象，可以通过其引用与其进行通信
- 方法决定了一个对象能够接受什么样的消息，调用方法的行为通常被称为"发送消息给对象" // 面向对象的程序设计通常简单地归纳为"向对象发送消息"
类的语法格式
对象的创建和使用
为对象赋值
- 在对一个对象进行操作时，我们真正操作的是对对象的引用
- 倘若"将一个对象赋值给另一个对象"，实际上是将"引用"从一个地方复制到另一个地方
- 相同的引用指向相同的对象，如下代码中 p3 = p1，那么 p3 和 p1 都指向原本只有 p1 指向的那个对象

// 举例
public class PersonTest {
    public static void main(String[] args) {
        // 创建对象
        Person p1 = new Person();
        Person p2 = new Person();
        // 将p1所引用的对象的地址赋值给p3, 此时p1和p3引用同一个对象
        Person p3 = p1;
        // 调用对象的属性
        p1.name = "tom";
        p1.isMale = true;
        System.out.printf("%s, %d, %b\n", p1.name, p1.age, p1.isMale);
        System.out.printf("%s, %d, %b\n", p2.name, p2.age, p2.isMale);
        p3.age = 10;
        System.out.printf("%s, %d, %b\n", p1.name, p1.age, p1.isMale);
        // 调用对象的方法
        p1.eat();
        p1.talkTo("jerry");
    }
}

class Person {
    String name;
    int age = 1;
    boolean isMale;

    public void eat() {
        System.out.println("eat chips");
    }

    public void talkTo(String name) {
        System.out.println("和" + name + "说话");
    }
}

4. 内存解析#

5. 局部变量和成员变量的区别#

在类中的位置不同
- 成员变量：在类中方法外
- 局部变量：方法内部、方法声明、代码块内
在内存中的位置不同
- 成员变量：在堆内存(! static) // staticVar 在方法区
- 局部变量：在栈内存
生命周期和管理方式不同
- 成员变量：随着对象的创建而存在，随着对象的消失而消失
- 局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
初始化值不同
- 成员变量：有默认初始化值
  - 基本类型
  - 引用类型(类、数组、接口)：null
- 局部变量：没有默认初始化值，必须显式赋值才能使用，否则会在编译时报错
局部变量名称可以和成员变量名称一样，在方法中使用的时候，采用的是就近原则
小结

6. 对象数组#

定义类 Student，包含三个属性：学号 number(int)，年级 state(int)，成绩 score(int)。创建 20 个学生对象，学号为 1 到 20，年级和成绩都由随机数确定
- Q1：打印出 3 年级(state 值为 3）的学生信息
- Q2：使用冒泡排序按学生成绩排序，并遍历所有学生信息
引用类型的元素组成的数组在使用过程中存在二级的指向关系

public class StudentTest {
    public static void main(String[] args) {
    // 这仅仅是在堆中为10个Student类型引用！开辟了存储空间(不是对象！)
    Student[] stuArr = new Student[20];
    int score, state;
    for (int i = 0; i < stuArr.length; i++) {
        state = (int) (Math.random()*4)+1;
        score = (int) (Math.random()*101);
        // 给数组元素赋值
        stuArr[i] = new Student();
        // 给元素属性赋值
        stuArr[i].number = i+1;
        stuArr[i].state = state;
        stuArr[i].score = score;
        if (stuArr[i].state == 3) System.out.println(stuArr[i].getInfo());
    }

    for (int i = stuArr.length - 1; i>0; i--)
        for (int j = 0; j < i; j++)
            if (stuArr[j].score > stuArr[j+1].score) {
                Student stu = stuArr[j];
                stuArr[j] = stuArr[j+1];
                stuArr[j+1] = stu;
        }
    for(int i = 0; i < stuArr.length; i++)
        System.out.println(stuArr[i].getInfo());
    }
}

class Student {
    int number;
    int state;
    int score;

    public String getInfo() {
        return "number=" + number + ", state=" + state + ", score=" + score;
    }
}