Java 面向对象编程：7大特征及代码体现

Java 是一种面向对象的编程语言，其核心思想是将数据和操作数据的行为封装在一起，形成一个个独立的单元，即对象。这使得代码更加模块化、可维护、可扩展，并易于重用。下面将介绍 Java 面向对象编程的七大特征，并以代码示例展示如何在实际开发中体现这些特征。

封装 (Encapsulation)

封装是指将数据和操作数据的方法封装在一个类中，对外提供接口，隐藏内部实现细节。例如：

public class Account {
    private String name; // 私有属性，只能在类内部访问
    private double balance;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getBalance() {
        return balance;
    }

    public void deposit(double amount) {
        balance += amount;
    }

    public void withdraw(double amount) {
        if (balance >= amount) {
            balance -= amount;
        } else {
            System.out.println("余额不足");
        }
    }
}

在 Account 类中，name 和 balance 属性被声明为私有 (private)，只能在类内部访问。通过 get 和 set 方法可以访问和修改这些属性，对外隐藏了内部实现细节。

继承 (Inheritance)

继承是指从现有类派生出新类，新类可以继承现有类的属性和方法，从而提高代码的复用性。例如：
```
public class SavingsAccount extends Account {
    private double interestRate;

    public SavingsAccount(String name, double balance, double interestRate) {
        super(name, balance); // 调用父类构造方法
        this.interestRate = interestRate;
    }

    public void calculateInterest() {
        balance += balance * interestRate;
    }
}
```
SavingsAccount 类继承了 Account 类，并添加了 interestRate 属性和 calculateInterest 方法。SavingsAccount 对象可以继承 Account 类的方法 (如 deposit 和 withdraw)，并拥有自己的特殊行为。

多态 (Polymorphism)

多态是指同一种类型的对象，在不同的情况下可以表现出不同的行为。例如：

public class Shape {
    public void draw() {
        System.out.println("绘制形状");
    }
}

public class Circle extends Shape {
    @Override
    public void draw() {
        System.out.println("绘制圆形");
    }
}

public class Rectangle extends Shape {
    @Override
    public void draw() {
        System.out.println("绘制矩形");
    }
}

public class Main {
    public static void main(String[] args) {
        Shape circle = new Circle();
        Shape rectangle = new Rectangle();

        circle.draw(); // 输出 "绘制圆形"
        rectangle.draw(); // 输出 "绘制矩形"
    }
}

Shape 类定义了一个 draw 方法，Circle 和 Rectangle 类分别重写了 draw 方法，实现不同的绘制行为。通过 Shape 类型的引用可以指向不同的子类对象，调用 draw 方法时会执行对应子类的实现。

类与对象 (Class and Object)

Java 是面向对象的语言，一切皆对象。程序中的数据和操作数据的方法都是对象的属性和方法。例如：

public class Car {
    String model;
    int year;

    public void start() {
        System.out.println("汽车启动");
    }

    public void stop() {
        System.out.println("汽车停止");
    }
}

public class Main {
    public static void main(String[] args) {
        Car myCar = new Car(); // 创建 Car 对象
        myCar.model = "宝马"; // 设置属性
        myCar.year = 2023;
        myCar.start(); // 调用方法
        myCar.stop();
    }
}

Car 类定义了汽车的属性 (model, year) 和方法 (start, stop)，通过 new Car() 创建了 Car 对象，并通过对象访问属性和方法。

接口与抽象类 (Interface and Abstract Class)

接口和抽象类可以定义一些规范和约束，提高代码的可维护性、可扩展性和可读性。例如：
```
public interface Drawable {
    void draw();
}

public abstract class Shape {
    public abstract void draw(); // 抽象方法，子类必须实现

    public void move() {
        System.out.println("形状移动");
    }
}
```
Drawable 接口定义了一个 draw 方法，Shape 类定义了一个抽象方法 draw，子类必须实现该方法。通过接口和抽象类可以定义规范，提高代码的灵活性。

就近原则 (Proximity Principle)

Java 中的成员变量和方法都有访问权限修饰符，通过就近原则可以控制代码的访问权限，提高代码的安全性。例如：

public class MyClass {
    private int privateVar; // 私有变量，只能在类内部访问
    protected int protectedVar; // 保护变量，只能在类内部和子类中访问
    public int publicVar; // 公共变量，可以在任何地方访问

    public void method() {
        System.out.println(privateVar); // 可以访问私有变量
        System.out.println(protectedVar); // 可以访问保护变量
        System.out.println(publicVar); // 可以访问公共变量
    }
}

就近原则指的是，在访问成员变量和方法时，优先访问当前类中定义的，如果当前类中没有定义，则向上查找父类，直到找到匹配的成员。通过控制访问权限，可以保护代码的内部细节。

异常处理 (Exception Handling)

Java 中的异常处理机制可以捕获程序中出现的异常，从而避免程序崩溃，增强程序的健壮性。例如：
```
public class Main {
    public static void main(String[] args) {
        try {
            int result = 10 / 0; // 可能出现异常
        } catch (ArithmeticException e) {
            System.out.println("除数不能为零！");
        }
    }
}
```
在代码中可能出现除数为零的异常，通过 try-catch 语句捕获异常，并处理异常情况，避免程序崩溃。

通过学习和运用这些面向对象的特征，可以编写出更加模块化、可维护、可扩展和健壮的 Java 代码