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

相关推荐
Shimiy22 分钟前
第六章 面向对象编程------进阶
java
来自旧金山的勇士25 分钟前
WSL->Ubunut安装Redis
后端
大葱白菜26 分钟前
Java Set 集合详解:从基础语法到实战应用,彻底掌握去重与唯一性集合
java·后端
大葱白菜28 分钟前
Java Map 集合详解:从基础语法到实战应用,彻底掌握键值对数据结构
java·后端
添乱28 分钟前
「Java案例」判断是否是闰年的方法
java
FG.32 分钟前
Day22
java·面试
小猪乔治爱打球33 分钟前
[Golang修仙之路] 算法专题:回溯(递归)
后端·面试
菜鸟的迷茫34 分钟前
Redis 缓存雪崩、穿透、击穿面试题深度解析与 Spring Boot 实战代码示例
java
昵称为空C41 分钟前
SpringBoot数据存储时区选择,符合国际化和特定时区方案
spring boot·后端
珹洺1 小时前
C++算法竞赛篇:DevC++ 如何进行debug调试
java·c++·算法