Java面向对象 - 技术栈

1. 怎么理解面向对象？

面向对象编程（OOP，Object-Oriented Programming）是一种编程范式，它基于"对象"这一概念来设计软件系统。对象是现实世界实体的抽象，封装了数据（属性）和行为（方法）。OOP主要通过封装、继承、多态这三大核心特性来提高软件的灵活性、可维护性和可扩展性。

2. 封装、继承、多态

封装： 封装是将对象的属性（数据）和方法（行为）封装在一起，对外界只暴露必要的接口，隐藏内部实现细节。通过封装，程序可以限制外部对对象数据的直接访问，确保数据的完整性和安全性。

优点：封装提高了代码的模块化，使得代码易于维护和扩展。通过封装，外部调用者不需要知道对象的内部实现，只需了解公开的方法。

示例：

java 复制代码

public class Person {
    private String name; // 私有属性，外部无法直接访问
    private int age;

    // 提供公共的getter和setter方法来访问私有属性
    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if (age > 0) { // 控制数据有效性
            this.age = age;
        }
    }
}

继承： 继承允许一个类继承另一个类的属性和方法，从而实现代码的重用。子类可以扩展或修改父类的功能，这样就可以基于已有的类创建新的类，而不需要重复编写相同的代码。

示例

java 复制代码

class Animal {
    public void eat() {
        System.out.println("This animal is eating.");
    }
}

class Dog extends Animal {
    // 子类可以继承父类的方法，也可以进行重写
    @Override
    public void eat() {
        System.out.println("The dog is eating.");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.eat(); // 输出 "The dog is eating."
    }
}

多态： 多态性允许同一方法在不同对象上表现出不同的行为。多态主要通过方法重写和方法重载来实现。

方法重写：子类可以重写父类的方法，提供自己的实现版本。

方法重载：在同一个类中，方法名相同，但参数列表不同。

优点：多态使代码更具灵活性和扩展性，允许用同一个接口处理不同类型的对象。

示例：

java 复制代码

class Animal {
    public void makeSound() {
        System.out.println("Some animal sound");
    }
}

class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Bark");
    }
}

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

public class Main {
    public static void main(String[] args) {
        Animal myAnimal = new Dog(); // 父类引用指向子类对象
        myAnimal.makeSound(); // 输出 "Bark"

        myAnimal = new Cat(); // 引用重新指向另一个子类对象
        myAnimal.makeSound(); // 输出 "Meow"
    }
}

接口与抽象类

接口（Interface）：接口是抽象类的进一步抽象，定义了行为的规范，而不提供具体实现。一个类可以实现多个接口，从而实现多重继承的效果。

抽象类（Abstract Class）：抽象类是不能实例化的类，必须通过子类继承并实现其中的抽象方法。它可以包含抽象方法和具体方法。

示例：

java 复制代码

interface Flyable {
    void fly();
}

abstract class Bird {
    abstract void makeSound();
    void layEggs() {
        System.out.println("Laying eggs.");
    }
}

class Sparrow extends Bird implements Flyable {
    @Override
    void makeSound() {
        System.out.println("Chirp chirp");
    }

    @Override
    public void fly() {
        System.out.println("Flying in the sky");
    }
}

public class Main {
    public static void main(String[] args) {
        Sparrow sparrow = new Sparrow();
        sparrow.makeSound(); // 输出 "Chirp chirp"
        sparrow.fly(); // 输出 "Flying in the sky"
        sparrow.layEggs(); // 输出 "Laying eggs."
    }
}

面向对象编程的优势

可维护性：通过封装，内部细节对外部隐藏，便于维护和更新。

可重用性：通过继承和多态，代码可以被重用，提高了开发效率。

扩展性：通过继承和接口，可以轻松地扩展已有功能。

灵活性：多态使代码在不同的上下文中表现出不同的行为，增加了系统的灵活性。