Java面向对象编程基础语法

1. 对象 (Object)

概念：

对象是类的实例，是面向对象编程的基本单位
对象具有状态(属性)和行为(方法)
对象在内存中占据独立的空间

特点：

每个对象都有唯一的标识(内存地址)
对象之间通过消息传递进行交互
对象是类的具体实现

示例：

java

1	Person person1 = new Person(); // person1是一个Person类的对象

2. 封装 (Encapsulation)

概念：

将数据(属性)和行为(方法)包装在一个单元(类)中
隐藏对象的内部实现细节，仅暴露必要的接口

实现方式：

使用访问修饰符控制可见性：
- private：仅本类可见
- protected：本包和子类可见
- public：所有类可见
- (默认)：本包可见

优点：

提高代码安全性
降低耦合度
便于修改和维护

示例：

java

public class BankAccount {
    private double balance; // 私有属性，外部不可直接访问
    
    // 公有方法，提供受控的访问方式
    public void deposit(double amount) {
        if(amount > 0) {
            balance += amount;
        }
    }
    
    public double getBalance() {
        return balance;
    }
}

3. 构造器 (Constructor)

概念：

一种特殊的方法，用于创建和初始化对象
方法名与类名相同，没有返回类型(连void也没有)

特点：

在创建对象时自动调用(new时)
可以重载(多个不同参数的构造器)
如果没有显式定义构造器，编译器会提供默认无参构造器
一旦定义了构造器，默认构造器就不再自动提供

分类：

无参构造器
带参构造器

示例：

java

public class Person {
    private String name;
    private int age;
    
    // 无参构造器
    public Person() {
        this.name = "未知";
        this.age = 0;
    }
    
    // 带参构造器
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

4. this关键字

作用：

指代当前对象
在构造器中调用其他构造器(必须放在第一行)
区分成员变量和局部变量

使用场景：

当局部变量与成员变量同名时
在方法中需要返回当前对象时
在构造器中调用其他构造器时

示例：

java

public class Student {
    private String name;
    private int score;
    
    public Student(String name) {
        this(name, 0); // 调用另一个构造器
    }
    
    public Student(String name, int score) {
        this.name = name; // 区分成员变量和参数
        this.score = score;
    }
    
    public Student getCurrentObject() {
        return this; // 返回当前对象
    }
}

5. 封装 (Encapsulation) - 补充说明

封装的核心原则：

将数据和对数据的操作绑定在一起
对外隐藏实现细节，只暴露必要的接口
通过访问控制实现信息隐藏

封装的具体实现：

java

public class Student {
    // 私有属性 - 实现封装
    private String name;
    private int age;
    private double score;
    
    // 公开的getter方法 - 提供受控的读访问
    public String getName() {
        return name;
    }
    
    // 公开的setter方法 - 提供受控的写访问
    public void setName(String name) {
        if(name != null && !name.isEmpty()) {
            this.name = name;
        }
    }
    
    // 其他业务方法
    public void printInfo() {
        System.out.println("姓名：" + name + "，年龄：" + age);
    }
}

封装的好处：

防止外部代码随意修改对象内部状态
可以在setter方法中添加验证逻辑
修改内部实现不影响外部代码
提高代码的可维护性和安全性

6. 实体类 (Entity Class)

概念：

用于表示现实世界中的实体或概念的类
通常对应数据库中的表或业务领域中的对象

实体类特点：

主要包含属性和对应的getter/setter方法
通常实现Serializable接口以支持序列化
可能包含简单的业务逻辑方法
一般会重写equals()、hashCode()和toString()方法

典型实体类示例：

java

public class User implements Serializable {
    // 属性
    private Long id;
    private String username;
    private String password;
    private Date createTime;
    
    // 构造方法
    public User() {}
    
    public User(String username, String password) {
        this.username = username;
        this.password = password;
        this.createTime = new Date();
    }
    
    // getter和setter
    public Long getId() {
        return id;
    }
    
    public void setId(Long id) {
        this.id = id;
    }
    
    // 其他方法...
    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", createTime=" + createTime +
                '}';
    }
    
    @Override
    public boolean equals(Object o) {
        // 实现equals方法...
    }
    
    @Override
    public int hashCode() {
        // 实现hashCode方法...
    }
}

实体类的使用场景：

数据传输对象(DTO)
持久化对象(对应数据库表)
业务模型对象

7. static 关键字

static 的用途：

静态变量（类变量）
静态方法（类方法）
静态代码块
静态内部类

7.1 静态变量（类变量）

特点：

属于类，不属于任何对象实例
所有对象共享同一份静态变量
在类加载时初始化
可以通过类名直接访问

示例：

java

public class Employee {
    private String name;
    private int id;
    
    // 静态变量 - 记录员工总数
    private static int nextId = 1;
    
    public Employee(String name) {
        this.name = name;
        this.id = nextId++;
    }
    
    public static int getNextId() {
        return nextId;
    }
}

7.2 静态方法（类方法）

特点：

属于类，不属于对象实例
不能直接访问实例变量和实例方法
可以通过类名直接调用
常用于工具类方法

示例：

java

public class MathUtils {
    // 静态方法
    public static double calculateCircleArea(double radius) {
        return Math.PI * radius * radius;
    }
    
    public static int max(int a, int b) {
        return a > b ? a : b;
    }
}

// 使用
double area = MathUtils.calculateCircleArea(5.0);
int maxNum = MathUtils.max(10, 20);

7.3 静态代码块

特点：

在类加载时执行，且只执行一次
用于初始化静态变量或执行只需一次的初始化操作
可以有多个静态代码块，按顺序执行

示例：

java

public class DatabaseConfig {
    private static Properties props;
    
    // 静态代码块
    static {
        props = new Properties();
        try {
            props.load(DatabaseConfig.class.getResourceAsStream("/db.properties"));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
    public static String getConfig(String key) {
        return props.getProperty(key);
    }
}

7.4 静态内部类

特点：

不依赖于外部类的实例
只能访问外部类的静态成员
常用于与外部类密切相关但又不需要访问外部类实例的情况

示例：

java

public class OuterClass {
    private static String staticField = "Static Field";
    
    // 静态内部类
    public static class StaticNestedClass {
        public void print() {
            System.out.println("访问外部类的静态字段：" + staticField);
            // 不能访问非静态字段
        }
    }
}

// 使用
OuterClass.StaticNestedClass nested = new OuterClass.StaticNestedClass();
nested.print();

static 使用注意事项

静态方法中不能使用 this 和 super 关键字
静态方法只能直接调用其他静态方法
静态方法只能直接访问静态变量
静态方法不能被重写（但可以隐藏）
静态成员在类加载时初始化，早于实例成员的初始化