Java 面向对象

面向对象编程（Object-Oriented Programming，OOP）是 Java 的核心编程范式。Java 是一门完全面向对象的编程语言，所有代码都必须写在类中。

面向对象的核心概念

1. 类（Class）和对象（Object）

类是对象的模板，定义了对象的属性和行为。对象是类的实例，是具体存在的实体。

// 定义一个类
public class Person {
    // 属性（成员变量）
    private String name;
    private int age;
    
    // 构造方法
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    // 方法（成员方法）
    public void introduce() {
        System.out.println("我是" + name + "，今年" + age + "岁");
    }
}

// 创建对象
Person person = new Person("张三", 25);
person.introduce();

2. 封装（Encapsulation）

封装是将数据和方法包装在类中，隐藏内部实现细节，只暴露必要的接口。

public class BankAccount {
    private double balance; // 私有属性，外部不能直接访问
    
    // 提供公共方法访问私有属性
    public double getBalance() {
        return balance;
    }
    
    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
        }
    }
    
    public void withdraw(double amount) {
        if (amount > 0 && amount <= balance) {
            balance -= amount;
        }
    }
}

3. 继承（Inheritance）

继承允许一个类继承另一个类的属性和方法，实现代码复用。

// 父类
public class Animal {
    protected String name;
    
    public Animal(String name) {
        this.name = name;
    }
    
    public void eat() {
        System.out.println(name + "正在吃东西");
    }
}

// 子类
public class Dog extends Animal {
    public Dog(String name) {
        super(name); // 调用父类构造方法
    }
    
    public void bark() {
        System.out.println(name + "在叫");
    }
}

4. 多态（Polymorphism）

多态允许同一个接口使用不同的实例执行不同的操作。

// 父类引用指向子类对象
Animal animal = new Dog("旺财");
animal.eat(); // 多态调用

// 方法重写
public class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println(name + "在吃鱼");
    }
}

5. 抽象（Abstraction）

抽象类和方法用于定义接口规范，不能直接实例化。

// 抽象类
public abstract class Shape {
    protected String color;
    
    // 抽象方法，子类必须实现
    public abstract double getArea();
    
    // 普通方法
    public void setColor(String color) {
        this.color = color;
    }
}

// 实现抽象类
public class Circle extends Shape {
    private double radius;
    
    public Circle(double radius) {
        this.radius = radius;
    }
    
    @Override
    public double getArea() {
        return Math.PI * radius * radius;
    }
}

6. 接口（Interface）

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

// 接口
public interface Flyable {
    void fly();
}

public interface Swimmable {
    void swim();
}

// 实现接口
public class Duck implements Flyable, Swimmable {
    @Override
    public void fly() {
        System.out.println("鸭子会飞");
    }
    
    @Override
    public void swim() {
        System.out.println("鸭子会游泳");
    }
}

访问修饰符

• public：公共的，任何地方都可以访问
• protected：受保护的，同一包内或子类可以访问
• default（包访问）：默认的，同一包内可以访问
• private：私有的，只有本类可以访问

关键字

• this：指向当前对象
• super：指向父类对象
• static：静态的，属于类而不是实例
• final：最终的，不可修改
• abstract：抽象的
• interface：接口

总结

面向对象编程是 Java 的核心特性，通过类、对象、封装、继承、多态等概念，可以构建更加模块化、可维护、可扩展的代码结构。深入理解面向对象编程对于掌握 Java 开发至关重要。