OOP - Java 的 4 个最重要的特性

一般来说，OOP 是什么？

OOP 代表面向对象编程。面向对象这个词是两个术语的组合：对象和面向。对象的字典含义是"现实世界中存在的实体"，定向意味着"对特定种类的事物或实体感兴趣"。因此，从根本上来说，OOP 是一种围绕对象和实体构建的编程模式，因此被称为 OOP。

面向对象编程的结构

OOP的结构由4部分组成：类、属性、方法和对象。类是对象、属性和方法的蓝图，它们就像对象的模板。属性是表示对象状态的类的属性，它们定义了对象的特征。方法是在类范围内定义的函数，它们表示对象的行为。最后，对象是使用类作为模板创建的类的实例。每个对象都有自己的一组属性，并且可以使用类中定义的方法。例如，假设我们有一个 Car类。它可以具有颜色、型号、速度等属性。 它可以有startEngine()、stopEngine()、brake() 等方法。最后，它可以有Car1、Car2、Car3 等实例。

您可以在下面看到强调 OOP 结构特点的 Java 示例代码。

csharp 复制代码

public class Car {
    private String color;
    private String model;
    private int speed;
    private boolean engineStarted;

    public Car(String color, String model, int speed) {
        this.color = color;
        this.model = model;
        this.speed = speed;
        this.engineStarted = false;
    }

    public void startEngine() {
        if (!engineStarted) {
            System.out.println("Engine started.");
            engineStarted = true;
        } else {
            System.out.println("Engine is already running.");
        }
    }

    public void stopEngine() {
        if (engineStarted) {
            System.out.println("Engine stopped.");
            engineStarted = false;
        } else {
            System.out.println("Engine is already off.");
        }
    }

    public void brake() {
        if (speed > 0) {
            System.out.println("Brake applied. Slowing down.");
            speed = 0;
        } else {
            System.out.println("Car is already stationary.");
        }
    }

##　OOP 的 4 个重要支柱特性

OOP 的 4 个特性是继承、多态性、封装和抽象。

继承允许一个类（子类或派生类）继承另一个类（超类或基类）的属性和行为。它促进代码的可重用性并建立类之间的关系。例如，假设我们有一个 Animal 类。Dog、Cat 和 Cow 类可以从 Animal 继承（子类）并获得其所有属性（方法和属性），因为它们都是动物。

您可以在下面看到一个 Java 示例代码，强调OOP 中的继承。

scala 复制代码

// Superclass
class Animal {
    private String name;

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

    public void eat() {
        System.out.println(name + " is eating.");
    }

    public void sleep() {
        System.out.println(name + " is sleeping.");
    }
}

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

    public void bark() {
        System.out.println("Woof! Woof!");
    }
}

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

    public void meow() {
        System.out.println("Meow!");
    }
}

// Subclass 3
class Cow extends Animal {
    public Cow(String name) {
        super(name);
    }

    public void moo() {
        System.out.println("Moo!");
    }
}

多态性 允许将不同类的对象视为公共基类的对象。这使得单个接口能够表示不同类型的对象，从而提高灵活性和可扩展性。使用上一点中的示例，您可以在下面看到一个经过修改的 Java 代码示例，强调多态性。

scala 复制代码

// Superclass
class Animal {
    private String name;

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

    public void makeSound() {
        System.out.println(name + " makes a generic animal sound.");
    }
}

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

    @Override
    public void makeSound() {
        System.out.println(name + " barks: Woof! Woof!");
    }
}

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

    @Override
    public void makeSound() {
        System.out.println(name + " meows: Meow!");
    }
}

// Subclass 3
class Cow extends Animal {
    public Cow(String name) {
        super(name);
    }

    @Override
    public void makeSound() {
        System.out.println(name + " moos: Moo!");
    }
}

封装是将数据（属性）和对数据进行操作的方法（函数）捆绑到称为类的单个单元中。我们使用访问修饰符（public、private、protected）来控制对属性和方法的访问。

您可以在下面看到一个强调封装的 Java 示例代码。

arduino 复制代码

public class Car {
    private String model;
    private int year;

    public Car(String model, int year) {
        this.model = model;
        this.year = year;
    }

    public String getModel() {
        return model;
    }

    public int getYear() {
        return year;
    }
}

在这里，Car 类通过将数据（型号和年份）设为私有来封装它们，并提供公共方法（getModel()、getYear()）来访问这些属性。这样，您就可以控制对对象内部状态的访问。

抽象就是隐藏复杂的现实，只暴露本质的部分。抽象类和接口用于实现抽象。例如，普通汽车用户并不真正关心汽车是如何制造的、汽车移动需要什么力或者制动器如何构造才能正常工作。然而，汽车工程师确实关心所有这些事情，只是因为这是他们的工作。

您可以在下面看到一个强调抽象的 Java 代码示例。

csharp 复制代码

public abstract class Shape {
    abstract double area();
}

public class Circle extends Shape {
    private double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

    @Override
    double area() {
        return Math.PI * radius * radius;
    }
}

这里，Shape类是抽象的，并且有一个抽象方法area()。Circle 类扩展了 Shape 并提供了 area() 方法的具体实现。抽象允许您定义一个公共接口（Shape），同时将具体的实现细节留给子类。

结束语

在这篇文章中，我们介绍了面向对象编程的概念、其结构和 4 个支柱的特性，包括继承、多态性、封装和抽象。概念性的东西虽然理解起来很抽象飘渺但是只有真正的理解了这些最基本的概念,我们的开发才会更加如鱼得水.