【JAVA 笔记】06 车辆属性抽象类

🕗 发布于 2024-09-27 20:48 java 笔记 开发语言

要求

写出一个抽象类Car，具有Brand、PowerMode、MaxSpeed、Price四个保护属性，分别为String、String、整型和双精度浮点型，且具有公有的getPrice和getPowerMode方法（用于返回Price和PowerMode变量的值）和一个无参的抽象方法Start；以Car类为父类派生出一个子类NEV，NEV类具有属性NEDC（续航里程，为整型），且实现无参Start方法，功能是在屏幕上输出字符串：走起！然后再设计一个测试类(CarTest.java)，在main方法中创建一个NEDC为800公里、Brand为BYD、PowerMode为PHEV、MaxSpeed为220公里、Price为36万NEV类的对象Whale，并执行它的Start方法。

下面是一个包含抽象类 Car 和其子类 NEV 的 Java 示例代码，以及一个测试类 CarTest 来验证这些类的功能。

抽象类 Car

首先定义一个抽象类 Car，它包含四个受保护的属性，并提供公共的 getPrice 和 getPowerMode 方法。同时定义了一个抽象方法 Start。

public abstract class Car {
    protected String brand; // 品牌
    protected String powerMode; // 动力模式
    protected int maxSpeed; // 最高速度
    protected double price; // 价格

    public Car(String brand, String powerMode, int maxSpeed, double price) {
        this.brand = brand;
        this.powerMode = powerMode;
        this.maxSpeed = maxSpeed;
        this.price = price;
    }

    public double getPrice() {
        return price;
    }

    public String getPowerMode() {
        return powerMode;
    }

    // 抽象方法，由子类实现
    public abstract void Start();
}

子类 NEV

接下来定义一个继承自 Car 的子类 NEV，增加一个 nedc 属性表示续航里程，并实现 Start 方法。

public class NEV extends Car {
    private int nedc; // 续航里程

    public NEV(String brand, String powerMode, int maxSpeed, double price, int nedc) {
        super(brand, powerMode, maxSpeed, price);
        this.nedc = nedc;
    }

    // 实现抽象方法
    @Override
    public void Start() {
        System.out.println("走起！");
    }

    public int getNEDC() {
        return nedc;
    }
}

测试类 CarTest

最后编写一个测试类 CarTest，在 main 方法中创建一个 NEV 类的对象，并调用它的 Start 方法。

public class CarTest {
    public static void main(String[] args) {
        // 创建一个NEV对象
        NEV whale = new NEV("BYD", "PHEV", 220, 360000, 800);
        
        // 调用Start方法
        whale.Start();
    }
}

说明

抽象类 Car:
- 定义了品牌、动力模式、最高速度和价格四个属性。
- 提供了获取价格和动力模式的公共方法。
- 定义了一个抽象方法 Start，需要子类实现。
子类 NEV:
- 继承自 Car 类。
- 增加了一个续航里程 nedc 属性。
- 实现了 Start 方法，输出“走起！”。
测试类 CarTest:
- 创建了一个 NEV 类的对象，并设置了相应的属性。
- 调用了 Start 方法来测试是否正确输出。

这样就完成了一个简单的汽车类的定义及其测试。在这个例子中，NEV 是一个新能源车，通过 Start 方法模拟启动车辆的行为。

好的，我们来详细分析一下如何设计这个程序，包括抽象类 Car、派生类 NEV 和测试类 CarTest。

设计思路

1. 抽象类 Car 的设计

目的：定义所有类型汽车共有的属性和行为。
属性：品牌 (brand)、动力模式 (powerMode)、最高速度 (maxSpeed) 和价格 (price)。
方法：
- getPrice()：返回汽车的价格。
- getPowerMode()：返回汽车的动力模式。
- Start()：抽象方法，由子类具体实现，用于模拟汽车启动的行为。

2. 子类 NEV 的设计

目的：定义新能源汽车特有的属性和行为。
新增属性：续航里程 (nedc)。
方法：实现父类 Car 中定义的抽象方法 Start()，用于模拟新能源汽车启动的行为。

3. 测试类 CarTest 的设计

目的：测试 NEV 类的功能。
行为：创建一个 NEV 类的实例，并调用其 Start() 方法。

代码实现

1. 抽象类 Car

public abstract class Car {
    // 受保护的属性，可以被子类访问
    protected String brand; // 品牌
    protected String powerMode; // 动力模式
    protected int maxSpeed; // 最高速度
    protected double price; // 价格

    // 构造函数
    public Car(String brand, String powerMode, int maxSpeed, double price) {
        this.brand = brand;
        this.powerMode = powerMode;
        this.maxSpeed = maxSpeed;
        this.price = price;
    }

    // 获取价格
    public double getPrice() {
        return price;
    }

    // 获取动力模式
    public String getPowerMode() {
        return powerMode;
    }

    // 抽象方法，由子类实现
    public abstract void Start();
}

2. 子类 NEV

public class NEV extends Car {
    // 新增属性，续航里程
    private int nedc;

    // 构造函数
    public NEV(String brand, String powerMode, int maxSpeed, double price, int nedc) {
        super(brand, powerMode, maxSpeed, price);
        this.nedc = nedc;
    }

    // 获取续航里程
    public int getNEDC() {
        return nedc;
    }

    // 实现抽象方法 Start
    @Override
    public void Start() {
        System.out.println("走起！");
    }
}

3. 测试类 CarTest

public class CarTest {
    public static void main(String[] args) {
        // 创建一个NEV对象
        NEV whale = new NEV("BYD", "PHEV", 220, 360000, 800);

        // 输出车辆信息
        System.out.println("品牌：" + whale.brand);
        System.out.println("动力模式：" + whale.getPowerMode());
        System.out.println("最高速度：" + whale.maxSpeed + "公里");
        System.out.println("价格：" + whale.getPrice() + "万元");
        System.out.println("续航里程：" + whale.getNEDC() + "公里");

        // 调用Start方法
        whale.Start();
    }
}

解释

抽象类 Car:
- 定义了四个受保护的属性：brand, powerMode, maxSpeed, price。
- 提供了一个构造函数，用于初始化这些属性。
- 提供了两个公共方法 getPrice() 和 getPowerMode() 用于获取价格和动力模式。
- 定义了一个抽象方法 Start()，由子类具体实现。
子类 NEV:
- 继承自 Car 类。
- 添加了一个私有属性 nedc 表示续航里程。
- 提供了一个构造函数，用于初始化父类和自身的新属性。
- 实现了 Start() 方法，输出 “走起！” 表示汽车启动。
测试类 CarTest:
- 在 main 方法中创建了一个 NEV 类的对象 whale。
- 输出了对象的一些基本信息。
- 调用了 Start() 方法来模拟汽车启动。

这样我们就完成了整个程序的设计与实现。通过这种方式，我们可以很容易地扩展其他类型的汽车，只需要继承 Car 类并实现 Start() 方法即可。

完整运行代码整理

抽象类 Car

public abstract class Car {
    // 受保护的属性，可以被子类访问
    protected String brand; // 品牌
    protected String powerMode; // 动力模式
    protected int maxSpeed; // 最高速度
    protected double price; // 价格

    // 构造函数
    public Car(String brand, String powerMode, int maxSpeed, double price) {
        this.brand = brand;
        this.powerMode = powerMode;
        this.maxSpeed = maxSpeed;
        this.price = price;
    }

    // 获取价格
    public double getPrice() {
        return price;
    }

    // 获取动力模式
    public String getPowerMode() {
        return powerMode;
    }

    // 抽象方法，由子类实现
    public abstract void Start();
}

子类 NEV

public class NEV extends Car {
    // 新增属性，续航里程
    private int nedc;

    // 构造函数
    public NEV(String brand, String powerMode, int maxSpeed, double price, int nedc) {
        super(brand, powerMode, maxSpeed, price);
        this.nedc = nedc;
    }

    // 获取续航里程
    public int getNEDC() {
        return nedc;
    }

    // 实现抽象方法 Start
    @Override
    public void Start() {
        System.out.println("走起！");
    }
}

测试类 CarTest

public class CarTest {
    public static void main(String[] args) {
        // 创建一个NEV对象
        NEV whale = new NEV("BYD", "PHEV", 220, 360000, 800);

        // 输出车辆信息
        System.out.println("品牌：" + whale.brand);
        System.out.println("动力模式：" + whale.getPowerMode());
        System.out.println("最高速度：" + whale.maxSpeed + "公里");
        System.out.println("价格：" + whale.getPrice() + "万元");
        System.out.println("续航里程：" + whale.getNEDC() + "公里");

        // 调用Start方法
        whale.Start();
    }
}

说明

抽象类 Car:
- 定义了四个受保护的属性：brand, powerMode, maxSpeed, price。
- 提供了一个构造函数，用于初始化这些属性。
- 提供了两个公共方法 getPrice() 和 getPowerMode() 用于获取价格和动力模式。
- 定义了一个抽象方法 Start()，由子类具体实现。
子类 NEV:
- 继承自 Car 类。
- 添加了一个私有属性 nedc 表示续航里程。
- 提供了一个构造函数，用于初始化父类和自身的新属性。
- 实现了 Start() 方法，输出 “走起！” 表示汽车启动。
测试类 CarTest:
- 在 main 方法中创建了一个 NEV 类的对象 whale。
- 输出了对象的一些基本信息。
- 调用了 Start() 方法来模拟汽车启动。

编译和运行

为了编译和运行上述代码，你需要将它们保存在三个不同的文件中：

Car.java 文件中包含 Car 类。
NEV.java 文件中包含 NEV 类。
CarTest.java 文件中包含 CarTest 类。

然后，可以在命令行中使用以下命令编译这些类：

javac Car.java NEV.java CarTest.java

编译完成后，可以使用以下命令运行 CarTest 类：

java CarTest

运行结果应该如下所示：

品牌：BYD
动力模式：PHEV
最高速度：220公里
价格：360000.0万元
续航里程：800公里
走起！

好的，我们将进一步拓展这篇文章的内容，深入探讨面向对象编程（OOP）的核心概念，并结合具体代码示例进行详细解释。

面向对象编程的核心概念

1. 封装（Encapsulation）

封装是面向对象编程的一个基本特性，它指的是将数据和操作数据的方法捆绑在一起，形成一个整体（即对象）。封装还包括隐藏内部状态和实现细节，只暴露必要的接口给外部使用。

在代码示例中，Car 类的属性都是受保护的（protected），这意味着它们只能被类本身及其子类访问。而 getPrice() 和 getPowerMode() 方法则提供了访问这些属性的方式，这是封装的一个典型应用。

2. 继承（Inheritance）

继承允许一个类继承另一个类的属性和方法。继承使得代码复用成为可能，并且可以建立类之间的层次关系。

在本例中，NEV 类继承了 Car 类，因此它自动获得了 Car 类的所有非私有属性和方法。此外，NEV 类还可以定义自己的新属性和方法，如 nedc 和 getNEDC() 方法。

3. 多态（Polymorphism）

多态是指允许不同类的对象对同一消息作出响应的能力。简单来说，就是“一种接口，多种实现”。在 Java 中，多态可以通过方法覆盖（overriding）和方法重载（overloading）来实现。

在代码示例中，Car 类定义了一个抽象方法 Start()，而 NEV 类实现了这个方法。这意味着虽然 Start() 方法在 Car 类中是抽象的，但在 NEV 类中它有了具体的实现。这就是多态的一种体现。

更深入的技术细节

1. 抽象类与接口的区别

尽管在前面的示例中我们使用了抽象类，但在某些情况下，接口可能是更好的选择。接口与抽象类的区别在于：

抽象类 可以包含具体实现的方法，而接口只能包含抽象方法。
接口支持多重继承，而 Java 中的类只能继承单一的抽象类。
抽象类 可以拥有构造函数，而接口不可以。

在实际应用中，如果需要强制多个类遵守相同的协议，而不关心它们的实现细节，那么接口是一个更好的选择。

2. 构造函数与初始化

在 NEV 类中，我们定义了一个构造函数来初始化父类的属性和自身的属性。构造函数是对象创建时被自动调用的方法，用于设置初始状态。

public NEV(String brand, String powerMode, int maxSpeed, double price, int nedc) {
    super(brand, powerMode, maxSpeed, price); // 调用父类构造器
    this.nedc = nedc;
}

这里 super 关键字用于调用父类的构造函数，确保父类的属性被正确初始化。

3. 方法覆盖与方法重载

方法覆盖（Overriding） 发生在子类中，子类重写了父类的方法，以提供具体的实现。在我们的例子中，NEV 类覆盖了 Car 类的 Start() 方法。

@Override
public void Start() {
    System.out.println("走起！");
}

方法重载（Overloading） 则是指在同一类中定义多个同名方法，但参数列表不同。这在当前示例中没有体现，但在实际开发中非常常见。

4. 访问修饰符的作用

在 Java 中，有四种访问修饰符：public、protected、private 和默认（无修饰符，也称为包级访问）。这些修饰符决定了类、方法或属性的可见性范围。

public：在任何地方都可以访问。
protected：只有在同一包内或者子类可以访问。
private：只有在定义它的类内部可以访问。
默认：只有在同一包内可以访问。

在 Car 类中，我们使用了 protected 修饰符来保护属性不被外部直接访问。

实际应用中的考虑

1. 异常处理

在实际应用中，你可能需要处理各种异常情况，比如输入非法的数据。可以通过抛出异常或进行条件检查来保证代码的健壮性。

2. 日志记录

对于复杂的系统，记录日志可以帮助跟踪程序的状态和调试问题。例如，可以在 Start() 方法中添加日志记录：

public void Start() {
    System.out.println("走起！");
    // 记录日志
    System.out.println("NEV " + getBrand() + " 已经启动.");
}

3. 国际化与本地化

如果应用程序需要支持多种语言和地区，那么就需要考虑如何在不同的环境中正确地显示信息。例如，可以使用资源文件来管理不同的语言文本。

原文地址：https://blog.csdn.net/shaozheng0503/article/details/142553420

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：Sql Developer日期显示格式设置
下一篇：Python | 第五章节 | 进制

linux网络编程9
readyState（请求状态）：0为未初始化，1为正在加载，2为已经加载，3为交互中，4为完成；其是HTTP服务器与其他程序进行“交谈”的工具，通过CGI接口能在服务器端运行其他的程序；其最大的优点
阅读更多2024-09-27
springboot 工程读取自定义的xml文件
springboot 读 xml文件
阅读更多2024-09-27
Vulhub TheEther_1.0.1靶机详解
靶机TheEther_1.0.1速刷
阅读更多2024-09-27
JAVA MySQL或SQLSERVER处理大量update语句优化
在 MySQL 或者SQLSERVER 中处理大量 UPDATE 语句时，性能优化是一个关键问题。1、使用 CASE 语句进行批量更新。2、使用 JOIN 进行批量更新。
阅读更多2024-09-27
MySQL 之索引详解
索引是 MySQL 数据库中非常重要的一个概念，合理地使用索引可以大大提高数据库的查询效率。在设计和使用索引时，需要根据实际情况选择合适的索引类型，并尽量避免索引失效的情况。
阅读更多2024-09-27
CTF入门教程（非常详细）从零基础入门到竞赛，看这一篇就够了！
CTF（Capture The Flag）中文一般译作夺旗赛，在网络安全领域中指的是网络安全技术人员之间进行技术竞技的一种比赛形式。CTF起源于1996年DEFCON全球黑客大会，以代替之前黑客们通过
阅读更多2024-09-27
ST188单光束反射式红外光电传感器心率测量原理
由于脉搏跳动时，血液的体积和压力会发生变化，导致血液的透光性也随之变化。传感器中的光敏元件（如光敏三极管）会接收到反射回来的红外光，并将其转换为电信号。由于脉搏跳动引起的血液透光性变化，导致光敏元件接
阅读更多2024-09-27
浙大数据结构：06-图3 六度空间
bfs稍难题
阅读更多2024-09-27
C++多态的实现方式
编译时多态（函数重载和模板）提供了高度的灵活性和类型安全，且没有运行时开销，但它们在需要动态类型判断的场景中力不从心。运行时多态（基于继承的虚函数、函数指针）允许程序在运行时根据对象类型做出决策，非常
阅读更多2024-09-27
【移植】一种快速移植OpenHarmony Linux内核的方法
本文面向希望将 OpenHarmony 移植到三方芯片平台硬件的开发者，介绍一种借助三方芯片平台自带 Linux 内核的现有能力，快速移植 OpenHarmony 到三方芯片平台的方法。不知道学习鸿蒙
阅读更多2024-09-27

【JAVA 笔记】06 车辆属性抽象类

要求

抽象类 Car

子类 NEV

测试类 CarTest

说明

设计思路

1. 抽象类 Car 的设计

2. 子类 NEV 的设计

3. 测试类 CarTest 的设计

代码实现

1. 抽象类 Car

2. 子类 NEV

3. 测试类 CarTest

解释

完整运行代码整理

抽象类 Car

子类 NEV

测试类 CarTest

说明

编译和运行

面向对象编程的核心概念

1. 封装（Encapsulation）

2. 继承（Inheritance）

3. 多态（Polymorphism）

更深入的技术细节

1. 抽象类与接口的区别

2. 构造函数与初始化

3. 方法覆盖与方法重载

4. 访问修饰符的作用

实际应用中的考虑

1. 异常处理

2. 日志记录

3. 国际化与本地化

相关文章