并不是一个技术，而是一种编程的指导思想

• 以什么形式组织代码
• 以什么思路 解决问题

重点是：自己如何设计对象、已有的对象如何使用

1. 类和对象

Java 中想要创建对象，必须先要有类的存在

类 指的是一组相关属性和行为的集合，我们将其理解为是一张对象的设计图

类和对象的关系：

• Java 中需要根据类、创建对象
• 一个类，可以创建多个对象

2. 类的组成、创建对象、使用对象

属性 + 行为

成员变量：跟之前定义变量的格式一样，只不过位置需要放在方法的外面

成员方法：跟之前定义方法的格式一样，只不过需要去掉 static 关键字

public class Student {
    String name = "homesmark";
    int age = 23;

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

创建对象、使用对象：

public class Demo01 {
    public static void main(String[] args) {
        // 创建对象格式
        // 类名 对象名 = new 类名();
        Student student = new Student();

        // 使用成员变量格式
        // 对象名.变量名
        System.out.println(student.name);
        System.out.println(student.age);

        // 使用成员方法格式
        student.study();
    }
}

3. 类和对象内存图

3.1. 单个对象内存图

1、测试类的字节码文件，填进方法区（里面有个主方法）

2、主方法被虚拟机自动执行，调入到栈内存中

字节码用到才加载

3、然后 student 类的字节码文件进入方法去，里面有成员变量、方法

4、然后 Student stu 在栈内存中声明一个变量

5、new 关键字 在堆内存，开辟一个空间，给成员变量自动分配空间 初始值，同时下方有一个成员方法引用地址，方便我们找到方法区中的成员方法，将空间地址 传送给栈内存

创建在堆，引用在栈（存的是堆地址），类信息在方法区

3.2. 两个对象内存图

两个引用指向相同的内存图

4. 成员变量和局部变量区别

区别	成员变量	局部变量
类中位置不同	方法外	方法中
初始化值不同	有默认初始化值	没有，使用之前需要完成赋值
内存位置不同	堆内存	栈内存
生命周期不同	随着对象的创建而存在，随着对象的消失而消失	随着方法的调用而存在，随着方法的运行结束而消失
作用域	在自己所属的大括号中	在自己所属的大括号中

内存位置不同示例图：

作用域不同：

5. this 关键字

当局部变量和成员变量出现了重名的情况，Java 使用的是就近原则

public class Demo02 {
    public static void main(String[] args) {
        Student stu = new Student();
        stu.name = "西门";
        stu.age = 23;
        stu.sayHello("nihao"); // nihao
    }
}

public class Student {
    String name;
    int age;

    public void sayHello(String name) {
        System.out.println("局部变量: " + name);  // nihao
        System.out.println("成员变量: " + this.name);  // "西门"
    }
}

this 代表的是当前类对象的引用地址。

6. 构造方法

作用：用于初始化一个新建的对象

格式：

1、方法名与类名相同，大小写也要一致

2、没有返回值类型，连void都没有

3、没有具体的返回值(不能由return带回结果数据)

执行时机：

1、创建对象的时候调用，每创建一次对象，就会执行一次构造方法

2、不能手动调用构造方法

注意事项：

1、 构造方法的创建

• 如果没有定义构造方法，系统将给出一个默认的无参数构造方法
• 如果定义了构造方法，系统将不再提供默认的构造方法

2、构造方法的重载

• 构造方法也是方法，允许重载关系出现

3、推荐方式

• 无参数构造方法，和带参数构造方法，都自己手动给出

class Student {
    int age;
    
    public Student(){}
    
    public Student(int age) {
        this.age = 18;
    }
}

6.1. 执行流程

7. 封装

封装就是将数据（属性）和操作数据的方法捆绑在一起

组成一个整体，也就是类

同时，通过访问修饰符来控制对类中属性和方法的访问权限，从而实现信息隐藏

优点：

• 更好的维护数据
• 使用者无需关心内部实现,只要知道如何使用即可

例子：

• 计算出每一名学生的总成绩
• 展示学生的所有信息

public class Test {
    public static void main(String[] args) {
        Student01 student = new Student01(1, "张三", 23, 90, 87);
        student.showStudentInfo();

        Student01 student1 = new Student01(2, "李四", 24, 69, 97);
        student1.showStudentInfo();
    }
}

public class Student01 {
    int id;
    String name;
    int age;
    double mathScore;
    double chineseScore;

    public Student01(int id, String name, int age, double mathScore, double chineseScore) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.mathScore = mathScore;
        this.chineseScore = chineseScore;
    }

    public double getTotalScore() {
        return mathScore + chineseScore;
    }

    public void showStudentInfo() {
        System.out.println("学号: " + id);
        System.out.println("姓名: " + name);
        System.out.println("年龄: " + age);
        System.out.println("数学成绩: " + mathScore);
        System.out.println("语文成绩: " + chineseScore);
    }
}

之前用过的 Random、Scanner 都是采用了封装的思想

【合理隐藏、合理暴露】

8. 权限修饰符

private、default、protected、public

9. JavaBean

实体类只负责数据存取，而对数据的处理交给其他类来完成，以实现数据和数据业务处理相分离

定义了成员变量之后，alt+insert 插入 setter 和 getter 方法

构造器也可以这个方法

10. static 关键字

static 是静态的意思，可以修饰成员变量，也可以修饰成员方法

特点：

• 被其修饰的成员, 被该类的所有对象所共享
• 多了一种调用方式, 可以通过类名调用
• 随着类的加载而加载, 优先于对象存在

staitic 成员变量一般用于共享数据

staitic 成员方法一般用于工具类

例子：

编写一个类 ArrayTools 内部编写三个方法

1、从数组中找最大值

2、最小值

3、打印数组所有元素

public class ArrayTools {
    // 1、从数组中找最大值
    public static int getMax(int[] arr) {
        int max = arr[0];
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];
            }
        }
        return max;
    }

    // 2、从数组中找最小值
    public static int getMin(int[] arr) {
        int min = arr[0];
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] < min) {
                min = arr[i];
            }
        }
        return min;
    }

    // 3、打印数组所有元素
    public static void printArray(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            if (i == arr.length - 1) {
                System.out.print(arr[i]);
            } else {
                System.out.print(arr[i] + " ");
            }
        }
    }
}

public class TestArrayTools {
    public static void main(String[] args) {
        int[] arr = {12, 45, 3, 67, 9};

        System.out.println("最大值: " + ArrayTools.getMax(arr));
        System.out.println("最小值: " + ArrayTools.getMin(arr));

        System.out.print("数组元素: ");
        ArrayTools.printArray(arr);
    }
}

注意事项：

1、static 方法中，只能访问静态成员（直接访问）

2、static 中不允许使用 this 关键字

11. 重新认识 main 方法