Java 学习系列（2）：面向对象编程（OOP）

Java 学习系列（2）：面向对象编程（OOP）

1. 什么是面向对象编程（OOP）？

面向对象编程（Object-Oriented Programming, OOP）是一种编程范式，它通过**类（Class）和对象（Object）**来组织代码，强调代码的重用性和可维护性。

OOP 的四大基本特性：

• 封装（Encapsulation）：将数据和方法封装在类内部，外部不能直接访问。
• 继承（Inheritance）：子类可以继承父类的属性和方法。
• 多态（Polymorphism）：相同的方法在不同对象上可以表现出不同的行为。
• 抽象（Abstraction）：通过抽象类或接口隐藏实现细节。

2. Java 类与对象

在 Java 中，类是对象的模板，对象是类的实例。

2.1 定义类和创建对象

// 定义一个简单的 Car 类
class Car {
    // 成员变量
    String brand;
    int speed;

    // 构造方法
    public Car(String brand, int speed) {
        this.brand = brand;
        this.speed = speed;
    }

    // 方法：显示汽车信息
    public void display() {
        System.out.println("品牌: " + brand + ", 速度: " + speed + " km/h");
    }
}

// 测试类
public class Main {
    public static void main(String[] args) {
        Car myCar = new Car("Tesla", 120);
        myCar.display(); // 输出: 品牌: Tesla, 速度: 120 km/h
    }
}

3. 封装（Encapsulation）

封装是指将数据（成员变量）隐藏在类内部，并通过getter和setter方法提供访问。

class Person {
    private String name;
    private int age;

    // 构造方法
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // Getter 方法
    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    // Setter 方法
    public void setAge(int age) {
        if (age > 0) {
            this.age = age;
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Person p = new Person("Alice", 25);
        System.out.println(p.getName() + " 的年龄是 " + p.getAge());
    }
}

4. 继承（Inheritance）

继承允许一个类（子类）获取另一个类（父类）的属性和方法。

class Animal {
    void makeSound() {
        System.out.println("动物发出声音");
    }
}

// Dog 类继承 Animal 类
class Dog extends Animal {
    void makeSound() {
        System.out.println("狗汪汪叫");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.makeSound(); // 输出: 狗汪汪叫
    }
}

5. 多态（Polymorphism）

多态允许相同的方法在不同对象上表现出不同的行为。

class Animal {
    void makeSound() {
        System.out.println("动物发出声音");
    }
}

class Cat extends Animal {
    void makeSound() {
        System.out.println("猫喵喵叫");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal myAnimal = new Cat(); // 向上转型
        myAnimal.makeSound(); // 输出: 猫喵喵叫
    }
}

6. 抽象（Abstraction）

抽象用于隐藏实现细节，只提供必要的接口。

abstract class Shape {
    abstract void draw();
}

class Circle extends Shape {
    void draw() {
        System.out.println("画一个圆");
    }
}

public class Main {
    public static void main(String[] args) {
        Shape shape = new Circle();
        shape.draw(); // 输出: 画一个圆
    }
}

7. 接口（Interface）

接口定义了一组方法，类可以实现多个接口。

interface Animal {
    void makeSound();
}

class Dog implements Animal {
    public void makeSound() {
        System.out.println("狗汪汪叫");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal dog = new Dog();
        dog.makeSound(); // 输出: 狗汪汪叫
    }
}

8. 总结

本篇博客介绍了 Java 的面向对象编程，包括类与对象、封装、继承、多态、抽象和接口。

在接下来的文章中，我们将深入学习 Java 的集合框架，敬请期待！

---

下一期：《Java 学习系列（3）：Java 集合框架详解》