【JAVA基础01】——类和对象

类和对象

一、基本概念

1. 对象（Object）

类的一个实例，包含状态和行为
- 状态：变量（属性）
- 行为：方法（操作）

2. 类（Class）

创建对象的模板
描述一类对象的行为和状态

二、类的组成

1. 变量（Variable）

变量类型	声明位置	生命周期	特点
局部变量	方法内部	方法调用时创建，结束后销毁	短期使用
成员变量	类中，方法外	随对象创建而创建	对象的个性属性（如：姓名"吴彦祖"）
类变量	类中，方法外，带 `static`	类加载时创建	所有对象共有属性

2. 方法（Method）

方法即函数，描述对象的行为、功能和业务逻辑。

方法的结构：

复制代码

返回值类型 方法名(传参类型 参数名) {
    // 方法体
}

返回值类型：

无返回值 ：void
基本类型 ：int、char、boolean 等
引用类型 ：String、自定义类、数组

传参类型：

有参数方法：接收外部数据
无参数方法：不接收外部数据

方法体内容：

定义变量、赋值
判断、循环
调用其他方法（嵌套）
打印、计算逻辑
返回值（非空类型）：return xxx

3. 构造方法（Constructor）

创建对象时用于初始化对象属性
一个类可以有多个构造方法（方法重载）
Java 会提供默认的无参构造方法

构造方法的规则：

要素	要求
返回类型	不写，写 `void` 也不行
方法名	必须与类名一致
传参类型	根据需要初始化哪些属性
方法体	给对象赋值：`this.name = xxx`

构造方法可以做的事：

给对象属性赋值：this.name = xxx
调用本类/父类的其他构造方法
注意：只做初始化，不写业务逻辑

4. 内部类（Inner Class）

在类里面嵌套另一个类：

成员内部类：在类里面，方法外面
静态内部类 ：使用 static 修饰的内部类

三、代码示例

示例 1：基础类定义

java 复制代码

public class Dog {
    String breed;   // 品种
    int size;       // 大小
    String colour;  // 颜色
    int age;        // 年龄

    void eat() {
    }

    void run() {
    }

    void sleep() {
    }

    void name() {
    }
}

示例 2：构造方法与普通方法

java 复制代码

public class Student {
    // ========== 成员变量 ==========
    private String name;
    private int age;

    // ========== 1. 构造方法 ==========

    // 无参构造（手动编写，覆盖默认构造）
    public Student() {
        System.out.println("无参构造执行：初始化对象");
    }

    // 有参构造（方法重载）
    public Student(String name, int age) {
        this.name = name;  // 初始化属性
        this.age = age;
        System.out.println("有参构造执行：初始化姓名和年龄");
    }

    // ========== 2. 普通方法 ==========

    // 无返回值普通方法
    public void study() {
        System.out.println(name + " 正在学习");
    }

    // 有返回值普通方法
    public int getAge() {
        return age;
    }

    // ========== 测试 ==========
    public static void main(String[] args) {
        // 1. 创建对象 → 自动调用构造方法（不能手动调 student.Student()）
        Student student = new Student("小明", 18);

        // 2. 手动调用普通方法
        student.study();
        int age = student.getAge();
        System.out.println("年龄：" + age);
    }
}

运行结果：

text 复制代码

有参构造执行：初始化姓名和年龄
小明 正在学习
年龄：18

四、对象的创建与使用

1. 创建对象

使用 new 关键字创建对象，包含三个步骤：

步骤	说明	示例
声明	声明对象名称和类型	`Dog myDog;`
实例化	使用 `new` 创建对象	`new Dog();`
初始化	调用构造方法初始化	自动执行构造方法

完整示例：

java 复制代码

// 声明 + 实例化 + 初始化
Puppy myPuppy = new Puppy("Tommy");

2. 访问成员变量和方法

通过已创建的对象来访问：

java 复制代码

/* 实例化对象 */
Object referenceVariable = new Constructor();

/* 访问类中的变量 */
referenceVariable.variableName;

/* 访问类中的方法 */
referenceVariable.methodName();

3. 完整示例

java 复制代码

public class Puppy {
    private int age;
    private String name;

    // 构造器
    public Puppy(String name) {
        this.name = name;
        System.out.println("小狗的名字是 : " + name);
    }

    // 设置 age 的值
    public void setAge(int age) {
        this.age = age;
    }

    // 获取 age 的值
    public int getAge() {
        return age;
    }

    // 获取 name 的值
    public String getName() {
        return name;
    }

    // 主方法
    public static void main(String[] args) {
        // 创建对象
        Puppy myPuppy = new Puppy("Tommy");

        // 通过方法来设定 age
        myPuppy.setAge(2);

        // 调用另一个方法获取 age
        int age = myPuppy.getAge();
        System.out.println("小狗的年龄为 : " + age);

        // 也可以直接访问成员变量（通过 getter 方法）
        System.out.println("变量值 : " + myPuppy.getAge());
    }
}

五、源文件与包

1. 源文件声明规则

当一个源文件中定义多个类，还包含 import 语句和 package 语句时：

规则	说明
public 类限制	一个源文件中只能有一个 `public` 类
非 public 类	一个源文件可以有多个非 public 类
文件名	源文件的名称必须和 `public` 类名一致
package 语句	如果类在某个包中，`package` 语句应在源文件首行
import 语句	应放在 `package` 语句和类定义之间；没有 `package` 时放在最前面
作用范围	`import` 和 `package` 语句对源文件中所有类都生效

2. Java 包（Package）

包的本质是文件夹
主要对类和接口进行分类管理
一个项目中可能包含成百上千个类

3. import 语句

用于引入外部包的类或接口

六、完整实战示例

在该例子中，我们创建两个类：Employee 和 EmployeeTest。

Employee.java

java 复制代码

import java.io.*;

public class Employee {
    private String name;
    private int age;
    private String designation;
    private double salary;

    // Employee 类的构造器
    public Employee(String name) {
        this.name = name;
    }

    // 设置 age 的值
    public void setAge(int age) {
        this.age = age;
    }

    // 获取 age 的值
    public int getAge() {
        return age;
    }

    // 设置 designation 的值
    public void setDesignation(String designation) {
        this.designation = designation;
    }

    // 获取 designation 的值
    public String getDesignation() {
        return designation;
    }

    // 设置 salary 的值
    public void setSalary(double salary) {
        this.salary = salary;
    }

    // 获取 salary 的值
    public double getSalary() {
        return salary;
    }

    // 打印信息
    public void printEmployee() {
        System.out.println(this);
    }

    // 重写 toString 方法
    @Override
    public String toString() {
        return "名字: " + name + "\n" +
               "年龄: " + age + "\n" +
               "职位: " + designation + "\n" +
               "薪水: " + salary;
    }
}

EmployeeTest.java

java 复制代码

import java.io.*;

public class EmployeeTest {
    public static void main(String[] args) {
        // 使用构造器创建两个对象
        Employee empOne = new Employee("RUNOOB1");
        Employee empTwo = new Employee("RUNOOB2");

        // 调用这两个对象的成员方法
        empOne.setAge(26);
        empOne.setDesignation("高级程序员");
        empOne.setSalary(1000);
        empOne.printEmployee();

        empTwo.setAge(21);
        empTwo.setDesignation("菜鸟程序员");
        empTwo.setSalary(500);
        empTwo.printEmployee();
    }
}