Java的类和对象

一、核心基础：类与对象的本质关系

1. 类：抽象的图纸

类是对同一类事物的抽象描述，不占用实际内存，仅定义事物的属性（成员变量）和行为（成员方法）。
类比生活：类就像汽车设计图，规定了汽车有品牌、颜色、排量等属性，有启动、加速、刹车等行为，但图纸本身不是具体汽车。
代码定义：类通过 class 关键字声明，遵循大驼峰命名法（如 WashMachine 、 Dog 每个单词的首字母都大写，其余字母小写，单词之间没有空格 / 下划线，方法是小驼峰，注意区分），一个Java文件中通常只定义一个 public 类，且 public 类名必须与文件名一致。

// 示例：定义洗衣机类（类名与文件名WashMachine.java一致）
public class WashMachine {
    // 成员变量（属性：描述事物特征）
    public String brand; // 品牌
    public double weight; // 重量
    
    // 成员方法（行为：描述事物功能）
    public void washClothes() {
        System.out.println(brand + "洗衣机正在洗衣服");
    }
}

2. 对象：根据图纸做出的具体产物

对象是类的具体实例，占用堆内存，拥有类定义的所有属性和行为，且每个对象的属性值独立（互不干扰）。
类比生活：对象是根据设计图生产的具体洗衣机，有具体的品牌（如海尔）、重量（如8kg），能实际执行洗衣服操作。
核心关系：类是模板，对象是实例；一个类可创建多个对象，所有对象共享类的方法逻辑，但属性值独立。

二、对象的实例化（new关键字）

1. 实例化语法

通过 new 关键字触发类的构造方法，完成对象的创建与初始化，核心语法为：

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

拆解说明：

1. 类名 对象名 ：在栈内存中声明一个引用变量（存储对象的内存地址），默认值为 null （不指向任何内存）。
2. new 类名(参数) ：在堆内存中分配空间，初始化对象属性，调用构造方法完成初始化，最后将地址赋值给栈中的引用变量。
   

public class Test {
    public static void main(String[] args) {
        // 1. 实例化Dog对象（无参构造）
        Dog dog = new Dog();
        dog.name = "大黄"; // 给对象属性赋值
        dog.age = 3;
        dog.eat(); // 调用对象方法
    }
}
// 定义狗类
class Dog {
    public String name;
    public int age;   
    public void eat() {
        System.out.println(name + "正在吃饭");
    }
}

2.数组的特殊实例化

对于二维数组，需区分规则数组与不规则数组的实例化方式：

// 规则二维数组：直接指定行列长度
int[][] array1 = new int[2][3];

// 不规则二维数组：先指定行，再逐行初始化列长度
int[][] array2 = new int[2][];
array2[0] = new int[]{1,2,3}; // 第一行3个元素
array2[1] = new int[]{4,5,6,7,8,9}; // 第二行6个元素
 

三、核心语法二：构造方法（对象初始化核心）

1. 构造方法的定义与特点

构造方法是与类同名、无返回值（连void都不写）的特殊方法，核心作用是创建对象时初始化属性，由JVM自动调用（通过new触发）。
核心特点：
1. 方法名必须与类名完全相同（如类名 Dog ，构造方法名 Dog() ）。
2. 无返回值类型，不能写void。
3. 支持重载（参数列表不同：个数、类型、顺序）。
4. 若类中未显式定义构造方法，Java会自动生成一个无参默认构造方法；若在类中定义了构造方法，Java不再生成默认构造方法。

2. 构造方法的分类

（1）无参构造方法

public class Student {
    public String name;
    // 无参构造方法
    public Student() {
        System.out.println("调用了无参构造方法");
    }
}

（2）有参构造方法

public class Student {
    public String name;
    public int age;
    // 有参构造方法：初始化属性
    public Student(String name, int age) {
        this.name = name; // 此处this关键字的作用，this能明确指向当前对象的成员变量，避免命名冲突。
        this.age = age;
        System.out.println("调用了有参构造方法");
    }
}

3. 构造方法的重载示例

public class Phone {
   public String brand;
   public double price;
   // 无参构造
   public Phone() {}
   // 单参构造（仅品牌）
   public Phone(String brand) {
       this.brand = brand;
   }
   // 双参构造（品牌+价格）
   public Phone(String brand, double price) {
       this.brand = brand;
       this.price = price;
   }
}

四、核心语法三：this关键字

this 是Java中的隐式引用变量，指向当前正在调用方法/构造方法的对象，核心解决变量命名冲突、简化代码逻辑，是类与对象中最常用的关键字之一。

1. this的三大核心用法

（1）区分成员变量与局部变量

当方法参数/局部变量与成员变量同名时，默认遵循“就近原则”（优先使用局部变量），此时需用 this.成员变量名 明确访问类的成员变量。

public class Person {
    public String name; // 成员变量
    // 有参构造：参数name与成员变量同名
    public Person(String name) {
        this.name = name; // this.name指代成员变量，name指代参数
    }
}

（2）调用本类其他构造方法

在一个构造方法中， 可通过 this(参数) 调用本类的其他构造方法，必须放在构造方法的第一行 ，避免代码冗余。

public class Person {
    public String name;
    public int age;
    // 双参构造
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    // 单参构造：调用双参构造，默认age为0
    public Person(String name) {
        this(name, 0); // 必须放在第一行
    }
    // 无参构造：调用双参构造，默认name为"未知"，age为0
    public Person() {
        this("未知", 0); // 必须放在第一行
    }
}   

this()（带括号）只能在构造方法中使用，调用本类其他构造方法
使用this()时必须放在构造方法的第一行，这是编译器强制要求

（3）访问当前对象的成员/返回当前对象

访问成员：在成员方法中， this.成员 可访问当前对象的属性/方法
返回当前对象：方法返回 this

public class Builder {
    private String name;
    private int age;
    public Builder setName(String name) {
        this.name = name;
    }
    public Builder setAge(int age) {
        this.age = age;
    }
    // 打印信息
    public void show() {
        System.out.println("姓名：" + this.name + "，年龄：" + this.age);
    }
}
public class Test {
    public static void main(String[] args) {
         Builder builder = new Builder()
        builder.show(); // 输出：姓名：张三，年龄：20
    }
}

2. this关键字的注意事项

1. 只能在成员方法/构造方法中使用，不能在静态方法（static修饰）中使用（静态方法属于类，this属于对象）。
2. this 只能指代当前对象，不能指代其他对象。
3. 用 this(参数) 调用其他构造方法时，必须放在构造方法的第一行，且只能调用一次。

五、内存原理：类与对象的存储逻辑

理解内存模型，能帮你彻底搞懂“对象引用与实际对象的关系”，避免空指针异常（NullPointerException）。

对象的内存分布

Java中对象的存储涉及栈内存和堆内存：
栈内存（Stack）：存储对象引用变量（如 Dog dog 中的dog），存储的是堆内存中对象的地址，默认值为null。
堆内存（Heap）：存储对象的实际数据（成员变量的值），每次new一个对象，都会在堆中开辟一块新空间，存储该对象的属性值。

Dog dog1 = new Dog();
Dog dog2 = new Dog();

执行过程：
栈中创建 dog1 和 dog2 两个引用变量，初始值为null。
执行 new Dog() ：堆中开辟两块独立空间，分别存储两个Dog对象的属性（如name、age）。将两个堆内存的地址分别赋值给 dog1 和 dog2 ，此时 dog1 和 dog2 指向不同的对象，修改其中一个的属性，不会影响另一个。

引用传递的特殊情况

Dog dog3 = dog1; // 引用赋值
dog3.name = "小白";

结果： dog1 和 dog3 指向堆中同一个Dog对象，修改 dog3 的name， dog1 的name也会变为“小白”（因为共享同一个内存地址）。

六、总结

结合以上知识点，编写一个完整的Java程序，涵盖类定义、对象实例化、构造方法、this关键字、数组实例化：
类与对象是Java面向对象编程的起点，核心在于理解“类是模板，对象是实例”的关系，掌握 new 关键字的实例化逻辑、构造方法的初始化作用、 this 关键字的核心用法，从笔记中的基础语法，到实战中的内存原理，每一个知识点都需要结合代码练习巩固。后续学习中，封装、继承、多态三大特性均基于类与对象展开，打好这部分基础，才能更轻松地进阶Java高级开发。