面向对象方法举例

面向对象编程（Object-Oriented Programming，简称OOP）是一种编程范式，它使用“对象”来设计软件。对象可以包含数据（通常称为属性或字段）和代码（通常称为方法或函数）。面向对象方法的核心概念包括封装、继承、多态和抽象。以下是这些概念的一些具体例子。

封装

封装是将对象的数据（属性）和行为（方法）组合在一起的过程，同时隐藏内部细节，只暴露有限的操作界面。这有助于减少系统的复杂性，并保护数据不被外部直接访问。

例子： 假设我们有一个BankAccount类，它封装了账户余额和一些操作账户的方法。

public class BankAccount {
    private double balance; // 私有属性，外部无法直接访问

    public BankAccount(double initialBalance) {
        this.balance = initialBalance;
    }

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

    public void withdraw(double amount) {
        if (amount <= balance) {
            balance -= amount;
        } else {
            System.out.println("Insufficient funds");
        }
    }

    public double getBalance() {
        return balance;
    }
}

在这个例子中，balance属性是私有的，外部代码不能直接访问它，而是通过公共方法deposit、withdraw和getBalance来操作。

继承

继承允许一个类（子类）继承另一个类（父类或超类）的属性和方法。这有助于代码复用，并可以创建层次结构。

例子： 假设我们有一个Vehicle类，它定义了所有车辆共有的属性和方法。然后，我们可以创建一个Car类，它继承自Vehicle类，并添加一些特有的属性和方法。

public class Vehicle {
    protected String make;
    protected String model;

    public Vehicle(String make, String model) {
        this.make = make;
        this.model = model;
    }

    public void start() {
        System.out.println("Vehicle started");
    }
}

public class Car extends Vehicle {
    private int doors;

    public Car(String make, String model, int doors) {
        super(make, model); // 调用父类的构造器
        this.doors = doors;
    }

    public void lockDoors() {
        System.out.println("Doors locked");
    }
}

在这个例子中，Car类继承了Vehicle类的make和model属性，以及start方法，并添加了自己的doors属性和lockDoors方法。

多态

多态允许同一个接口接受不同的数据类型。在Java中，多态可以通过重载（方法名相同，参数不同）和重写（子类重写父类的方法）来实现。

例子： 继续使用上面的Vehicle和Car类，我们可以创建一个方法，它接受Vehicle类型的对象，并根据对象的实际类型调用不同版本的start方法。

public void startVehicle(Vehicle vehicle) {
    vehicle.start(); // 多态调用，实际调用哪个start方法取决于对象的实际类型
}

// 调用
Vehicle myCar = new Car("Toyota", "Corolla", 4);
startVehicle(myCar); // 输出 "Vehicle started"，但Car类中的start方法可能会被重写

如果Car类重写了start方法，那么在调用startVehicle方法时，将执行Car类中的start方法。

抽象

抽象是将复杂现实世界中的对象简化为代码中的基本特征的过程。抽象类和接口是实现抽象的两种方式。

例子： 我们可以创建一个抽象类Animal，它定义了一些所有动物共有的抽象方法，然后让具体的动物类实现这些方法。

public abstract class Animal {
    protected String name;

    public Animal(String name) {
        this.name = name;
    }

    public abstract void makeSound(); // 抽象方法
}

public class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }

    @Override
    public void makeSound() {
        System.out.println("Woof woof");
    }
}

public class Cat extends Animal {
    public Cat(String name) {
        super(name);
    }

    @Override
    public void makeSound() {
        System.out.println("Meow");
    }
}

在这个例子中，Animal类是一个抽象类，它有一个抽象方法makeSound。Dog和Cat类继承自Animal类，并提供了makeSound方法的具体实现。