用 Java 破解 OOP：一个你想要的 PIE

用 java 破解 oop：一个你想要的 pie

在这篇文章中，我们将探讨 java 中面向对象编程 (oop) 的四个基本支柱。这些核心原则有助于构建模块化、可重用和可维护的代码。这篇文章作为介绍，即将推出的条目将通过细致入微的讨论和示例深入探讨每个概念。

为了便于记忆，请使用缩写词“a pie”：a抽象，p多态，i继承，以及e封装。

面向对象意味着什么？

java 通常被描述为面向对象的语言，但它并不是 100% 面向对象的。 为什么？虽然 java 中的大多数元素都围绕对象（如类、对象和方法），但它也使用 原始类型（如 int、boolean 和 double），它们是 不是物体。

在 java 中保留原始类型是一个经过深思熟虑的设计选择。原因如下：

内存效率： 与对应的对象（如 integer 或 boolean）相比，原始类型占用 更少的内存。
性能提升：基元上的操作更快，因为它们避免了对象创建和引用管理的开销。
方便：原始类型使简单情况下的代码更加简洁，尤其是在处理算术和逻辑运算时。

简而言之，java 通过提供性能和内存效率的原语来实现平衡，同时还提供包装类（如 integer），以便您需要将这些值视为对象时。

1. 抽象：隐藏不必要的细节

抽象意味着隐藏内部逻辑并仅向用户公开基本功能。它允许用户在高层与对象交互，而无需担心底层复杂性。可以将其视为使用atm——您只需输入要取款的金额，而不需要知道atm如何与您的银行交互来处理交易。

在java中，抽象类和接口通过定义基本方法并将内部细节留给子类或父类来帮助实现抽象但对用户隐藏。

例子：

abstract class payment {
    // a method with concrete logic, hidden from the user.
    private void authenticate() {
        system.out.println("authenticating payment...");
    }

    // abstract method that child classes must implement.
    abstract void processpayment(double amount);

    // public method exposing only the necessary details.
    public void makepayment(double amount) {
        authenticate();  // hidden complexity
        processpayment(amount);  // exposed to child classes
        system.out.println("payment completed.");
    }
}

// concrete class implementing the abstract method.
class creditcardpayment extends payment {
    @override
    void processpayment(double amount) {
        system.out.println("processing credit card payment of ₹" + amount);
    }
}

public class testabstraction {
    public static void main(string[] args) {
        payment payment = new creditcardpayment(); // polymorphism in action.
        payment.makepayment(1000.00);  // only high-level interaction.
    }
}

解释：

复杂性隐藏在哪里？
- authenticate() 方法代表内部逻辑（例如，用户验证、加密），对于子类和用户来说都是私有且隐藏的。
- makepayment() 方法是唯一可供用户使用的公共方法，提供了一种与支付系统交互的简单方法。
抽象类有什么帮助？
- 它强制子类（如creditcardpayment）实现核心逻辑（processpayment()），但子类不需要了解身份验证逻辑——它在父类中处理。
用户看到了什么？
- 从用户的角度来看，他们只与 makepayment() 交互——他们不关心 身份验证或信用卡付款内部如何工作。

2. 多态性：相同的动作，不同的形式

多态允许对象在不同情况下表现不同。java 支持两种类型的多态：

1。编译时多态（方法重载）：通过定义多个同名但参数不同的方法来实现。

例子：

class calculator {
    // compile-time polymorphism (overloading)
    int add(int a, int b) {
        return a + b;
    }
    int add(int a, int b, int c) {
        return a + b + c;
    }

    public static void main(string[] args) {
        calculator calc = new calculator();
        system.out.println(calc.add(2, 3));  // output: 5
        system.out.println(calc.add(2, 3, 4));  // output: 9
    }
}

2。运行时多态性（方法重写）： 当子类提供父类中声明的方法的特定实现时实现。

例子：

class animal {
    void sound() {
        system.out.println("animals make sounds.");
    }
}

class dog extends animal {
    @override
    void sound() {
        system.out.println("dog barks.");
    }
}

public class testpolymorphism {
    public static void main(string[] args) {
        animal animal = new dog();  // runtime polymorphism
        animal.sound();  // output: dog barks
    }
}

解释：

编译时多态性通过重载add()方法来演示，而运行时多态性通过重写sound()方法来演示。

sound() 方法 根据对象类型的不同，其行为也有所不同。虽然animal是animal类型，但在运行时，会执行dog中重写的方法。

3. 继承：通过父子关系实现代码可重用

继承允许类（子）重用另一个类（父）的属性和行为。这可以提高代码可重用性并在类之间建立is-a关系。 java 不支持通过类多重继承以避免歧义，但允许通过接口实现。

例子：

class animal {
    void eat() {
        system.out.println("this animal eats food.");
    }
}

class dog extends animal {
    void bark() {
        system.out.println("dog barks.");
    }
}

public class testinheritance {
    public static void main(string[] args) {
        dog dog = new dog();
        dog.eat();  // inherited method from animal
        dog.bark(); // dog’s own method
    }
}

解释：

在此示例中：

狗继承自 animal，这意味着狗既能吃又吠。
这演示了代码重用——我们不需要重写 dog 类的 eat() 方法。

4. 封装：通过访问控制保护数据

封装意味着将数据（字段）和操作它的方法捆绑到一个单元（类）中。它还通过将字段设为私有并公开它们来确保数据隐藏通过 getter 和 setter。

例子：

class Student {
    private String name;

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

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

public class TestEncapsulation {
    public static void main(String[] args) {
        Student student = new Student();
        student.setName("John");  // Setting data through setter
        // Accessing data through getter
        System.out.println(student.getName());
    }
}

解释：

名称字段是私有的，这意味着不能从类外部直接访问它。
通过公共 getter 和 setter 提供访问权限，强制数据隐藏。

结论

java 的 oop 原则—抽象、多态、继承和封装—构成了编写模块化、可维护和高效代码的基础。掌握了这些概念，您将能够更好地准备设计和理解复杂的系统。

在接下来的文章中，我们将通过更细致的示例、最佳实践和以面试为重点的技巧，更深入地探讨这些原则。敬请关注！