Java 类和对象

         在 Java 编程中，类和对象是面向对象编程（OOP）的核心支柱。理解类与对象的本质、掌握它们的使用方法，是学好 Java 的关键一步。本文将结合实例，从面向对象思想出发，详细讲解类的定义、对象的创建、核心特性及实战技巧，帮助你彻底掌握这一基础且重要的知识点。

一、面向对象：编程思想的核心

1.1 什么是面向对象？

        Java 是一门纯面向对象的语言（Object Oriented Program, OOP），在面向对象的世界里，一切皆为对象。它是一种解决问题的思想，通过对象之间的交互完成任务，这种方式更符合人类对事物的认知规律，对于大型程序的设计、扩展和维护非常友好。

1.2 面向对象与面向过程的对比

• 面向过程：关注完成任务的具体步骤。例如传统做饭，需要手动完成 “买菜、洗菜、切菜、开火、翻炒、调味” 等一系列步骤，每个步骤都不能省略，且不同菜品的步骤差异很大，扩展或修改起来很麻烦。
• 面向对象：关注参与任务的对象及交互。现代做饭中，有 “人、食材、电饭煲、炒锅” 等对象，人只需将米和水放入电饭煲并启动，电饭煲会自动完成煮饭过程，无需关注其内部如何加热、保温，通过对象交互即可完成任务。

注意：两种思想没有绝对的好坏，面向过程适合简单场景，面向对象更适合复杂系统的开发。

二、类：对象的抽象描述

2.1 类的概念

        类是对现实实体（对象）的抽象描述，它定义了实体的属性（特征）和功能（行为）。例如 “电饭煲” 这一实体，属性包括品牌、容量、颜色等，功能包括煮饭、保温、定时等。通过类，计算机才能识别和处理现实世界的实体。

2.2 类的定义格式

        在 Java 中，使用 class 关键字定义类，语法如下：        

class 类名 {
    字段; //成员变量（属性）
    方法; //成员方法（功能）
}

示例：定义电饭煲类

class RiceCooker {
    //属性：品牌、容量、颜色、功率
    public String brand; 
    public double capacity; //单位：升
    public String color; 
    public int power; //单位：瓦
    
    //功能：煮饭、保温、定时
    public void cookRice() { 
        System.out.println(brand + "电饭煲开始煮饭");
    }
    public void keepWarm() { 
        System.out.println("进入保温模式");
    }
    public void setTimer(int minutes) { 
        System.out.println("定时" + minutes + "分钟后开始工作");
    }
}

定义规范：

• 类名采用大驼峰命名法（如 RiceCooker）；
• 成员变量和方法前暂用 public 修饰（后续讲解权限控制）；
• 方法不要添加 static 关键字（非静态方法属于对象）。

三、对象：类的具体实例

3.1 对象的实例化

        类是抽象的 “设计图纸”，而对象是根据图纸创建的 “实体”。用类创建对象的过程称为实例化，在 Java 中通过 new 关键字实现。

示例：实例化电饭煲对象

public class Main {
    public static void main(String[] args) {
        //实例化电饭煲对象
        RiceCooker cooker = new RiceCooker();
        
        //给对象属性赋值
        cooker.brand = "美的";
        cooker.capacity = 5.0;
        cooker.color = "白色";
        cooker.power = 800;
        
        //调用对象方法
        cooker.setTimer(30); //输出：定时30分钟后开始工作
        cooker.cookRice(); //输出：美的电饭煲开始煮饭
        cooker.keepWarm(); //输出：进入保温模式
    }
}

3.2 类与对象的关系

• 类是抽象模板，仅描述实体的属性和功能，不占用物理空间；
• 对象是类的具体实例，存储实际的属性数据，占用物理空间；
• 一个类可以实例化多个对象，就像一张图纸可以建造多栋房子。

四、this 引用：对象的自我指向

4.1 为什么需要 this？

        当方法的形参名与成员变量名相同时，会产生歧义。例如在设置图书信息时：

public void setBookInfo(String name, String author, double price) {
    name = name; //无法区分是给成员变量还是形参赋值
    author = author;
    price = price;
}

        此时需要 this 引用明确指向当前对象的成员变量。

4.2 this 的本质

  this 是成员方法中隐藏的第一个参数，指向调用该方法的对象。编译器会自动传递对象引用，无需手动处理。

示例：用 this 解决歧义

public class Book {
    public String name;
    public String author;
    public double price;
    
    public void setBookInfo(String name, String author, double price) {
        this.name = name; //this.name 指向对象的成员变量
        this.author = author;
        this.price = price;
    }
}

4.3 this 的特性

• this 的类型与当前类一致；
• 仅能在成员方法中使用；
• 只能引用当前对象，不能引用其他对象；
• 是方法隐藏的第一个参数，由编译器自动传递。

五、构造方法：对象的初始化器

5.1 构造方法的概念

        构造方法是一种特殊的成员方法，用于对象的初始化。它在创建对象时由编译器自动调用，且在对象的生命周期内仅调用一次。

语法特征：

• 名字与类名完全相同；
• 没有返回值类型（即使 void 也不能写）；
• 一般用 public 修饰。

示例：图书类的构造方法

public class Book {
    public String name;
    public String author;
    public double price;
    
    //构造方法
    public Book(String name, String author, double price) {
        this.name = name;
        this.author = author;
        this.price = price;
    }
    
    public static void main(String[] args) {
        //创建对象时自动调用构造方法
        Book book = new Book("Java编程思想", "Bruce Eckel", 108.0);
    }
}

5.2 构造方法的特性

1. 重载特性：可定义多个参数不同的构造方法，满足不同初始化需求。

//无参构造方法
public Book() {
    this.name = "未知书名";
    this.author = "未知作者";
    this.price = 0.0;
}

//有参构造方法
public Book(String name, String author, double price) {
    this.name = name;
    this.author = author;
    this.price = price;
}

        2.默认构造方法：若未显式定义构造方法，编译器会自动生成无参构造方法；一旦手动定义，编译器不再生成。

        3.this 调用其他构造方法：通过 this(参数) 可在一个构造方法中调用另一个，但必须是第一条语句，且不能形成循环调用。

public Book() {
    this("未知书名", "未知作者", 0.0); //调用有参构造方法
}

六、封装：数据安全的保障

6.1 封装的概念

        封装是面向对象三大特性之一，指将数据和操作数据的方法结合，隐藏内部细节，仅对外公开接口。例如手机通过外壳隐藏内部芯片等硬件，仅提供屏幕、按键等交互接口。

6.2 访问限定符

        Java 通过访问限定符控制成员的可见性，共四种：

限定符	同一类	同一包	不同包子类	不同包非子类
private	✔️	❌	❌	❌
default（默认）	✔️	✔️	❌	❌
protected	✔️	✔️	✔️	❌
public	✔️	✔️	✔️	✔️

最佳实践：成员变量用 private 隐藏，通过 public 方法暴露访问接口。

public class Phone {
    private String brand; //私有属性，外部无法直接访问
    private double size; //屏幕尺寸
    
    //公开方法：获取品牌
    public String getBrand() {
        return brand;
    }
    
    //公开方法：设置品牌
    public void setBrand(String brand) {
        this.brand = brand;
    }
}

6.3 包：类的组织方式

包是管理类的目录结构，用于避免类名冲突和控制访问权限。

• 导入包：用 import 语句导入其他包的类，如 import java.util.Scanner；
• 自定义包：在类顶部用 package 声明，如 package com.demo.book；
• 常见包：java.lang（自动导入）、java.util（工具类）、java.io（I/O 操作）等。

七、static 成员：类的共享资源

7.1 静态成员变量

被 static 修饰的成员变量属于类，而非某个对象，所有对象共享该变量。

特性：

• 存储在方法区，不随对象创建而分配空间；
• 可通过类名直接访问（推荐）或对象访问；
• 生命周期与类一致（随类加载而创建，卸载而销毁）。

7.2 静态成员方法

        被 static 修饰的方法是类方法，用于操作静态成员。静态方法中不能访问非静态成员变量或方法（无 this 引用）。

示例：班级共享的学校名称

public class Class {
    private String className; //班级名称（每个班级不同）
    private static String schoolName = "阳光中学"; //学校名称（所有班级共享）
    
    //静态方法：获取学校名称
    public static String getSchoolName() {
        return schoolName;
    }
}

// 访问静态成员
public class Test {
    public static void main(String[] args) {
        System.out.println(Class.getSchoolName()); //输出：阳光中学
    }
}

八、代码块：初始化的补充机制

        代码块是用 {} 定义的代码片段，用于初始化成员变量，分为以下几类：

8.1 静态代码块

        用 static 修饰，用于初始化静态成员变量，类加载时执行一次（无论创建多少对象）。

public class Pet {
    private static String type; //宠物类型（所有宠物共享）
    
    //静态代码块
    static {
        type = "哺乳动物";
        System.out.println("静态代码块执行：初始化宠物类型");
    }
}

8.2 构造代码块（实例代码块）

        定义在类中，用于初始化实例成员变量，每次创建对象时执行。

public class Pet {
    private String name;
    private int age;
    
    //构造代码块
    {
        name = "无名";
        age = 1;
        System.out.println("构造代码块执行：初始化宠物基本信息");
    }
    
    //构造方法
    public Pet() {
        System.out.println("构造方法执行");
    }
}

执行顺序：静态代码块 → 构造代码块 → 构造方法。

九、内部类：类中的嵌套结构

        内部类是定义在另一个类中的类，用于描述仅为外部类服务的结构，是封装的一种体现。

9.1 实例内部类

        未被 static 修饰，依赖外部类对象存在，可访问外部类所有成员。

class Family {
    private String address; //家庭住址
    
    //实例内部类：家庭成员
    class Member {
        private String name;
        
        public void showFamilyInfo() {
            //可访问外部类的私有成员
            System.out.println("家庭住址：" + address);
            System.out.println("成员姓名：" + name);
        }
    }
}

//创建实例内部类对象
Family family = new Family();
Family.Member member = family.new Member();

9.2 静态内部类

        被 static 修饰，不依赖外部类对象，仅能访问外部类静态成员。

class Family {
    private static String familyName; //姓氏（静态成员）
    
    //静态内部类：家庭资产
    static class Asset {
        private double money;
        
        public void showFamilyName() {
            //仅能访问外部类的静态成员
            System.out.println("家庭姓氏：" + familyName);
        }
    }
}

//创建静态内部类对象
Family.Asset asset = new Family.Asset();

十、对象打印：自定义输出格式

        默认打印对象会输出 “类名 @哈希值”（如 Book@1b6d3586），需重写 toString() 方法自定义格式。

示例：重写 toString ()

public class Movie {
    private String name;
    private double score;
    
    //重写 toString()
    @Override
    public String toString() {
        return "电影{名称='" + name + "', 评分=" + score + "}";
    }
    
    public static void main(String[] args) {
        Movie movie = new Movie();
        movie.name = "流浪地球2";
        movie.score = 9.8;
        System.out.println(movie); //输出：电影{名称='流浪地球', 评分=9.8}
    }
}

总结

        类和对象是 Java 面向对象编程的基础，从抽象的类定义到具体的对象实例化，从封装特性到 static 成员、代码块、内部类，每个知识点都贯穿于 Java 开发的全过程。掌握这些概念不仅能帮助你写出更规范、易维护的代码，更为后续学习继承、多态等高级特性奠定坚实基础。希望通过本文的讲解，你能对类和对象有更清晰的理解，在 Java 编程之路上稳步前行！