〔005〕Java 基础之面向对象

Java 面向对象基础

面向对象编程（OOP）是一种编程范式，它以“对象”为中心，将数据和方法结合在一起。Java 作为一种纯面向对象的编程语言，其核心概念就是围绕对象进行设计。本篇文章将简要介绍 Java 面向对象的基本概念，并给出示例代码。

对象与类

在 Java 中，对象是类的一个实例。类是对一组对象的抽象，定义了对象的属性和行为。我们可以将类比作蓝图，而对象就是基于这个蓝图建造的具体“房子”。

// 定义一个类
class Dog {
    // 属性
    String name;
    int age;

    // 方法
    void bark() {
        System.out.println(name + " is barking!");
    }
}

// 在主程序中使用
public class Main {
    public static void main(String[] args) {
        // 创建 Dog 类的对象
        Dog dog1 = new Dog();
        dog1.name = "Buddy";
        dog1.age = 3;

        // 调用对象的方法
        dog1.bark();  // 输出: Buddy is barking!
    }
}

在上面的例子中，我们定义了一个 Dog 类，具有 name 和 age 两个属性，以及一个 bark() 方法。在 main 方法中，我们创建了 Dog 类的一个对象 dog1，并通过对象来修改属性和调用方法。

封装

封装是面向对象编程的一个重要特性。它通过将数据和操作数据的方法封装在类内部，限制外部访问，从而保护对象的状态。我们可以通过访问修饰符（如 private、protected、public）来控制访问权限。

class BankAccount {
    private double balance; // 私有属性

    // 构造方法
    public BankAccount(double initialBalance) {
        this.balance = initialBalance;
    }

    // 提供公共方法以安全地访问私有属性
    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
        }
    }

    public void withdraw(double amount) {
        if (amount > 0 && amount <= balance) {
            balance -= amount;
        }
    }

    public double getBalance() {
        return balance;
    }
}

public class Main {
    public static void main(String[] args) {
        BankAccount account = new BankAccount(1000);
        account.deposit(500);
        account.withdraw(200);
        System.out.println("Current Balance: " + account.getBalance()); // 输出: Current Balance: 1300.0
    }
}

在上述代码中，BankAccount 类的 balance 属性被私有化，无法直接访问。我们使用 deposit()、withdraw() 和 getBalance() 方法来控制对余额的访问，从而实现了数据的封装。

继承

继承是面向对象编程的另一个重要特性，它允许一个类继承另一个类的属性和方法，从而实现代码复用。子类可以通过扩展父类来增加新的功能。

// 定义一个父类
class Animal {
    void eat() {
        System.out.println("This animal eats food");
    }
}

// Dog 类继承自 Animal 类
class Dog extends Animal {
    void bark() {
        System.out.println("The dog barks");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.eat(); // 输出: This animal eats food
        dog.bark(); // 输出: The dog barks
    }
}

在这个例子中，Dog 类继承了 Animal 类，所以 Dog 对象可以调用 Animal 类的方法 eat()。

多态

多态是指同一操作作用于不同的对象，可以产生不同的结果。Java 中的多态主要体现在方法重载和方法重写上。

class Animal {
    void sound() {
        System.out.println("Animal makes sound");
    }
}

class Dog extends Animal {
    @Override
    void sound() {
        System.out.println("Dog barks");
    }
}

class Cat extends Animal {
    @Override
    void sound() {
        System.out.println("Cat meows");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal myDog = new Dog();
        Animal myCat = new Cat();

        myDog.sound(); // 输出: Dog barks
        myCat.sound(); // 输出: Cat meows
    }
}

在这里，Dog 和 Cat 类重写了 Animal 类的 sound() 方法。根据不同的对象类型，调用同一方法将产生不同的输出。

总结

Java 的面向对象编程提供了清晰、模块化和可重用的代码结构，通过对象、类、封装、继承和多态等特性，使得程序开发更加灵活和高效。掌握这些基本概念，将为后续的 Java 编程打下坚实的基础。