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

一般来说，OOP 是什么？

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

面向对象编程的结构

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

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

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 中的继承。

// 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 代码示例，强调多态性。

// 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 示例代码。

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 代码示例。

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 个支柱的特性，包括继承、多态性、封装和抽象。概念性的东西虽然理解起来很抽象 飘渺 但是只有真正的理解了这些最基本的概念,我们的开发才会更加如鱼得水.