Java面向对象编程基础：类与对象

概述

面向对象编程（OOP）是一种编程范式，它使用对象来组织代码。Java是一种纯面向对象的编程语言，几乎所有代码都必须写在类中。

1. 类的定义

基本类结构

// 定义一个学生类
public class Student {
    // 成员变量
    private String name;
    private int age;
    private double score;
    
    // 构造方法
    public Student() {
        // 无参构造方法
    }
    
    public Student(String name, int age, double score) {
        this.name = name;
        this.age = age;
        this.score = score;
    }
    
    // 成员方法
    public String getName() {
        return name;
    }
    
    public void setName(String name) {
        this.name = name;
    }
    
    public int getAge() {
        return age;
    }
    
    public void setAge(int age) {
        this.age = age;
    }
    
    public double getScore() {
        return score;
    }
    
    public void setScore(double score) {
        this.score = score;
    }
    
    // 其他方法
    public void study() {
        System.out.println(name + "正在学习");
    }
    
    public void displayInfo() {
        System.out.println("姓名: " + name + ", 年龄: " + age + ", 成绩: " + score);
    }
}

使用类创建对象

public class StudentTest {
    public static void main(String[] args) {
        // 创建对象
        Student student1 = new Student();
        student1.setName("张三");
        student1.setAge(20);
        student1.setScore(85.5);
        
        Student student2 = new Student("李四", 21, 92.0);
        
        // 使用对象
        student1.displayInfo();
        student2.displayInfo();
        
        student1.study();
        student2.study();
    }
}

2. 构造方法

构造方法重载

public class Person {
    private String name;
    private int age;
    private String email;
    
    // 无参构造方法
    public Person() {
        this.name = "Unknown";
        this.age = 0;
        this.email = "";
    }
    
    // 单参数构造方法
    public Person(String name) {
        this.name = name;
        this.age = 0;
        this.email = "";
    }
    
    // 双参数构造方法
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
        this.email = "";
    }
    
    // 全参数构造方法
    public Person(String name, int age, String email) {
        this.name = name;
        this.age = age;
        this.email = email;
    }
    
    public void display() {
        System.out.println("Name: " + name + ", Age: " + age + ", Email: " + email);
    }
    
    public static void main(String[] args) {
        Person p1 = new Person();
        Person p2 = new Person("John");
        Person p3 = new Person("Jane", 25);
        Person p4 = new Person("Bob", 30, "bob@example.com");
        
        p1.display();
        p2.display();
        p3.display();
        p4.display();
    }
}

3. 封装

访问修饰符

public class AccessModifiers {
    public String publicVar = "Public";      // 任何地方都可访问
    protected String protectedVar = "Protected";  // 同包和子类可访问
    String defaultVar = "Default";          // 同包可访问
    private String privateVar = "Private";  // 只有本类可访问
    
    public void testAccess() {
        System.out.println(publicVar);      // 可访问
        System.out.println(protectedVar);   // 可访问
        System.out.println(defaultVar);     // 可访问
        System.out.println(privateVar);     // 可访问
    }
}

Getter和Setter

public class BankAccount {
    private String accountNumber;
    private double balance;
    
    public BankAccount(String accountNumber, double initialBalance) {
        this.accountNumber = accountNumber;
        this.balance = initialBalance;
    }
    
    // 只读属性（没有setter）
    public String getAccountNumber() {
        return accountNumber;
    }
    
    // 带验证的setter
    public void setBalance(double balance) {
        if (balance < 0) {
            throw new IllegalArgumentException("余额不能为负数");
        }
        this.balance = balance;
    }
    
    public double getBalance() {
        return balance;
    }
    
    // 业务方法
    public void deposit(double amount) {
        if (amount <= 0) {
            throw new IllegalArgumentException("存款金额必须大于0");
        }
        this.balance += amount;
        System.out.println("存款成功，当前余额: " + balance);
    }
    
    public void withdraw(double amount) {
        if (amount <= 0) {
            throw new IllegalArgumentException("取款金额必须大于0");
        }
        if (amount > balance) {
            throw new IllegalArgumentException("余额不足");
        }
        this.balance -= amount;
        System.out.println("取款成功，当前余额: " + balance);
    }
}

4. this关键字

public class ThisKeywordExample {
    private String name;
    private int age;
    
    // 使用this区分成员变量和参数
    public ThisKeywordExample(String name, int age) {
        this.name = name;   // this.name是成员变量，name是参数
        this.age = age;
    }
    
    // 使用this调用其他构造方法
    public ThisKeywordExample() {
        this("Unknown", 0);  // 调用双参数构造方法
    }
    
    // 使用this返回当前对象
    public ThisKeywordExample setName(String name) {
        this.name = name;
        return this;  // 返回当前对象，支持链式调用
    }
    
    public ThisKeywordExample setAge(int age) {
        this.age = age;
        return this;
    }
    
    public void display() {
        System.out.println("Name: " + name + ", Age: " + age);
    }
    
    public static void main(String[] args) {
        // 链式调用
        ThisKeywordExample obj = new ThisKeywordExample()
            .setName("John")
            .setAge(25);
        
        obj.display();
    }
}

5. 静态成员

public class StaticMemberExample {
    // 静态变量
    private static int count = 0;
    private static final String SCHOOL_NAME = "Java University";
    
    // 实例变量
    private String studentName;
    
    // 构造方法
    public StaticMemberExample(String studentName) {
        this.studentName = studentName;
        count++;  // 每创建一个对象，计数加1
    }
    
    // 静态方法
    public static int getCount() {
        return count;
    }
    
    public static String getSchoolName() {
        return SCHOOL_NAME;
    }
    
    // 实例方法
    public void display() {
        System.out.println("Student: " + studentName + ", School: " + SCHOOL_NAME);
    }
    
    public static void main(String[] args) {
        // 通过类名访问静态成员
        System.out.println("School: " + StaticMemberExample.getSchoolName());
        
        // 创建对象
        StaticMemberExample s1 = new StaticMemberExample("Alice");
        StaticMemberExample s2 = new StaticMemberExample("Bob");
        StaticMemberExample s3 = new StaticMemberExample("Charlie");
        
        s1.display();
        s2.display();
        s3.display();
        
        // 通过类名访问静态方法
        System.out.println("Total students: " + StaticMemberExample.getCount());
    }
}

6. 实际应用示例

图书管理系统

public class Book {
    private String title;
    private String author;
    private double price;
    private boolean isAvailable;
    
    public Book(String title, String author, double price) {
        this.title = title;
        this.author = author;
        this.price = price;
        this.isAvailable = true;
    }
    
    // 借书
    public boolean borrow() {
        if (isAvailable) {
            isAvailable = false;
            System.out.println(title + " 已被借出");
            return true;
        } else {
            System.out.println(title + " 不可借出");
            return false;
        }
    }
    
    // 还书
    public void returnBook() {
        isAvailable = true;
        System.out.println(title + " 已归还");
    }
    
    // 显示图书信息
    public void display() {
        System.out.println("书名: " + title);
        System.out.println("作者: " + author);
        System.out.println("价格: " + price);
        System.out.println("状态: " + (isAvailable ? "可借" : "已借出"));
        System.out.println();
    }
    
    public static void main(String[] args) {
        Book book1 = new Book("Java编程思想", "Bruce Eckel", 108.0);
        Book book2 = new Book("Effective Java", "Joshua Bloch", 79.0);
        
        book1.display();
        book2.display();
        
        book1.borrow();
        book1.display();
        
        book1.returnBook();
        book1.display();
    }
}

最佳实践

1. 使用封装：将成员变量设为private，通过getter/setter访问
2. 使用this关键字：区分成员变量和参数，支持链式调用
3. 合理使用构造方法：提供多种构造方法满足不同需求
4. 使用静态成员：共享数据和工具方法应该定义为静态
5. 单一职责原则：每个类应该只负责一个功能

总结

面向对象编程是Java的核心特性。掌握类与对象的概念、封装、构造方法和静态成员的使用，是学习Java编程的重要基础。在实际编程中，要合理设计类结构，提高代码的可维护性和可扩展性。