Java面向对象课程总结性博客

Java面向对象课程总结性博客

课程内容与结构

本课程的教学内容主要包括以下几个方面：

  1. 面向对象基本概念：面向对象编程的核心理念、类与对象的关系、面向对象的三大特征（封装、继承、多态）以及抽象类和接口的设计与应用。
  2. Java语言基础：包括Java语言的基本语法、数据类型、控制结构、数组等基础元素。
  3. 面向对象设计原则：如单一职责原则（SRP）、开闭原则（OCP）、里氏替换原则（LSP）等设计原则在实际项目中的应用。
  4. 集合框架：学习Java提供的List、Set、Map等集合接口及其具体实现类，如ArrayList、LinkedList、HashSet、TreeSet、HashMap等。
  5. 异常处理：Java中的异常机制、try-catch-finally结构的使用、自定义异常的创建等。
  6. 图形用户界面设计：使用JavaFX进行用户界面开发，包括界面组件的使用、事件处理机制和布局管理等。

课程作业与实验

在课程学习过程中，我们有以下几类作业和实验：

  1. Blog作业：课程共有3次Blog作业，分别总结不同的知识点。第一次作业主要总结封装特性及编程思维的培养，第二次作业总结继承与多态知识点，而本次是对整门课程的总结。
  2. PTA作业：课程共设置了11次PTA（Programing Teaching Assistant）作业，这些作业设计了不同的编程问题，要求学生通过编程实践来巩固所学知识。其中，题目集5、6、7的主要难题是单部电梯调度程序问题，难度较大，主要难点在于算法的设计；而题目集8、9的主要难题是航空货运管理系统问题，难度同样较大，主要难点在于系统的设计和实现（这里很难确定自己的设计有没有漏洞，如果只是拿分当然不难）。
  3. 实验项目：课程安排了多个实验项目，都是关于大象装冰箱的，其中包括图形用户界面设计实验（使用JavaFX）。

课程特点与挑战

这门课程有几个显著的特点：

  1. 理论与实践相结合：课程不仅讲解面向对象编程的理论知识，还通过大量的编程实践帮助理解和掌握这些知识。
  2. 题目驱动学习：通过电梯调度系统和航空货运管理系统等题目，学生能够将所学知识应用于实际问题的解决，培养解决哪些接近实际问题的能力。
  3. 难度递进：课程内容从简单到复杂，从基础到应用，循序渐进。
  4. 代码质量要求高：课程特别强调代码的可读性、可维护性和可扩展性(准确的说是类设计和设计模式的应用），要求我们在编写代码时遵循良好设计原则。
    总体而言，这门课程工作量较大，难度适中，但通过系统的理论学习和丰富的题目，我对面向对象编程有了全面而深入的理解，收获颇丰。

面向对象技术总结：从概念到实践

在本课程中，面向对象技术的学习贯穿始终，从基础概念到实际应用，我经历了从理解到掌握的过程。以下是我对面向对象技术的总结，结合各个教学环节，特别是PTA作业和实验项目中的实践经验。

封装：数据与行为的统一

封装是面向对象编程的三大特征之一，它将对象的状态（属性）和行为（方法）结合在一起，并限制对这些内部细节的直接访问。这有助于保护对象的完整性，同时也提供了一种使用对象的简洁方式。

封装的实现方式

在Java中，封装通常通过以下方式实现：

  1. 访问修饰符：使用private关键字将类的属性设为私有，禁止外部直接访问。
  2. getter和setter方法：提供public的getter和setter方法，以控制对私有属性的访问。例如：
public class Person {
    private String name;
    private int age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

在航空货运管理系统中，我们为Customer类封装了客户基本信息：ID、姓名、电话、地址，并提供了完整的getter和setter方法。这种封装方式不仅保护了对象的内部状态，还提高了代码的可维护性和安全性。

封装的价值

封装带来了以下几个方面的价值：

  1. 提高类的可理解性和可维护性：封装使得类的内部实现细节对外部隐藏，外部只需了解接口即可使用该类。
  2. 减少类之间的耦合，增强内聚性：封装使得类之间的依赖减少，提高了系统的灵活性和可维护性。
    例如，在航空货运管理系统中，我们通过封装客户、货物和航班等对象的属性和行为，构建了一个结构清晰、易于维护的系统。然而，在初次接触封装概念时，我也曾遇到一些困难，例如不知道如何合理设计getter和setter方法，或者不清楚封装与访问控制的关系。通过不断的实践和学习，我逐渐掌握了封装的精髓，理解了它在面向对象编程中的重要地位。

继承：代码复用的桥梁

继承是面向对象编程的第二个重要特征，它允许一个类（子类）继承另一个类（父类）的属性和方法，从而实现代码的重用。通过继承，子类可以扩展父类的功能，增加新的属性和方法，或者重写父类的方法。

继承的语法与实现

在Java中，通过使用"extends"关键字来实现继承：

class Animal {
    public void eat() {
        System.out.println("动物吃东西");
    }
}
class Dog extends Animal {
    public void bark() {
        System.out.println("狗叫");
    }
}

继承的优势

继承带来了以下几个方面的优势：

  1. 代码复用：子类拥有父类的所有属性和方法（除了private修饰的属性不能拥有），从而实现了代码的复用。
  2. 系统扩展：通过继承，可以方便地扩展系统的功能，而不需要修改现有代码。
  3. 层次结构：继承使得类之间形成层次结构，反映了现实世界中的类属关系。
    然而，继承也带来了一些潜在的问题，如耦合度过高、继承链过长等。在实际项目中，我们需要合理使用继承，避免过度依赖继承而导致系统复杂性增加。

多态：灵活的行为表现

多态是指同一个方法在不同对象上表现出不同的行为。多态的实现依赖于继承和方法重写。通过多态，可以在运行时根据对象的实际类型调用相应的方法，从而提高代码的灵活性和可扩展性。

多态的实现方式

在Java中，多态主要通过以下几种方式实现：

  1. 方法重写：子类重写父类的方法，实现不同的行为。
  2. 向上转型：将子类对象赋值给父类引用变量。
  3. 接口实现：通过实现不同的接口，实现不同的行为。
    在航空货运管理系统中，我们设计了Payment抽象类，让AliPay和WeChatPay分别实现这个接口，实现了不同的支付方式。这种设计遵循了开闭原则，便于扩展新的支付方式。

多态的价值

多态带来了以下几个方面的价值：

  1. 代码灵活性：多态使得代码更加灵活，能够适应不同的情况。
  2. 代码可扩展性：多态使得系统更容易扩展，只需要添加新的子类即可实现新的功能。
  3. 代码简洁性：多态使得代码更加简洁，可以使用统一的接口处理不同的实现。
    在实际项目中，我通过多态实现了航空货运管理系统中的不同支付方式，体会到了多态在提高代码灵活性和可扩展性方面的巨大用处。

抽象类与接口：抽象思维的体现

抽象类和接口是面向对象编程中用于抽象的重要工具，它们帮助我们定义类的行为规范，而不关心具体的实现细节。

（发自真心的说，虽然在写一些小的程序时C/C++更好写，但是一但说到做大项目，还是Java更简单，相对来说结构清晰，利用接口也可以很方便地实现和设计功能。）

抽象类

抽象类是含有抽象方法的类。抽象方法只有方法声明，没有方法体。抽象类不能用于实例化对象，只能作为其他类的父类。
在Java中，抽象类的定义方式如下：

abstract class Animal {
    abstract void eat();
    abstract void move();
}

抽象类的主要作用是提供一个统一的行为规范，要求子类实现这些行为。在航空货运管理系统中，我们设计了Payment抽象类，定义了支付接口，让具体的支付方式（如支付宝、微信支付）实现这个接口。

接口

接口可以理解为一种特殊的抽象类，它只包含方法的声明，没有方法的实现。接口的主要目的是定义一组行为规范，任何实现该接口的类都必须实现这些行为。
在Java中，接口的定义方式如下：

interface Payment {
    void pay(double amount);
}

接口与抽象类的主要区别在于：

  1. 实现方式：类可以通过implements关键字实现接口，而通过extends关键字继承抽象类。
  2. 多继承：一个类可以实现多个接口，但只能继承一个抽象类。
    在航空货运管理系统中，我们不仅使用了Payment接口，还使用了其他接口来定义系统中的各种行为规范。例如，我们定义了一个OrderProcessing接口，用于处理订单的核心流程；定义了一个OrderPrinter接口，用于订单信息的打印输出。

集合框架：数据结构的高效管理

集合框架是Java编程语言中用于处理数据集合的一组接口和类。它提供了一种统一的方式来表示和操作数据集合，简化了数据结构的创建和使用。

集合框架的主要接口

集合框架的接口举例：

  1. Collection接口：这是集合框架中的顶级接口，表示一个包含一组对象的集合。常见的子接口包括List和Set。
  2. List接口：表示有序集合，支持索引访问元素。常见的实现类包括ArrayList和LinkedList。

在整个学习过程中，用的比较多的还是Arraylist，还有一部分的数据结构对应的接口都是期末才讲，如果没用过也不是特别熟。
在航空货运管理系统中，我们使用了集合框架来管理各种数据。例如，我们使用ArrayList来存储货物信息，使用HashSet来存储航班信息，使用HashMap来存储客户信息。

集合框架的优势

集合框架带来了以下几个方面的优势：

  1. 高效的数据操作：集合框架提供了高效的数据操作方法，如添加、删除、查找等。
  2. 统一的接口：集合框架提供了一组统一的接口，使得数据操作更加方便和一致。
  3. 丰富的实现类：集合框架提供了多种实现类，可以根据具体需求选择合适的实现类。
    在实际项目中，我通过集合框架实现了航空货运管理系统中的各种数据管理功能，体会到了集合框架在数据处理方面的强大功能。

异常处理：程序健壮性的保障

异常处理是Java编程中一个重要的方面，它用于处理程序执行过程中可能出现的错误或异常情况。有效的异常处理可以提高程序的健壮性和稳定性。

异常处理的机制

Java提供了try-catch-finally结构来处理异常：

try {
    // 可能抛出异常的代码
} catch (ExceptionType1 e1) {
    // 处理ExceptionType1类型的异常
} catch (ExceptionType2 e2) {
    // 处理ExceptionType2类型的异常
} finally {
    // 无论是否发生异常，都会执行的代码
}

此外，Java还提供了throw关键字用于手动抛出一个异常，以及throws关键字用于在方法声明中声明可能抛出的异常。
在实际项目中，我通过合理的异常处理机制，提高了程序的健壮性和可靠性。例如，在航空货运管理系统中，我们处理了各种可能的异常情况，如客户信息输入错误、货物信息不完整等（虽然说其实可以利用更朴素的方式:))。

JavaFX：图形用户界面的实现

JavaFX是Java平台上的一个现代图形用户界面（GUI）工具包，用于构建富客户端应用程序。在课程的后期，我们学习了使用JavaFX进行用户界面设计。

JavaFX的基本组件

JavaFX提供了一系列基本组件，如按钮、文本框、标签等，以及布局管理器，如HBox、VBox、GridPane等，用于构建用户界面。
在实验五中，我修改了大象装冰箱的代码，将控制台代码转换成图形界面的形式。通过这个实验，我了解了JavaFX的基本原理和基本组件，学习了如何使用JavaFX组件进行界面设计。

JavaFX的事件驱动机制

JavaFX采用事件驱动机制来处理用户交互。通过注册事件处理器，可以响应用户的操作，如点击按钮、输入文本等。
在大象装冰箱的图形界面实现中，我们使用了按钮点击事件来控制游戏的进行。通过事件驱动机制，我们实现了用户与程序之间的交互。

JavaFX的形状类

JavaFX提供了各种形状类，如Circle、Rectangle、Line等，用于在界面上绘制图形。在大象装冰箱的图形界面中，我们使用了这些形状类来表示元素。
通过JavaFX的学习，我掌握了图形用户界面设计的基本方法，理解了如何使用JavaFX构建现代、美观的用户界面。然而，在初次接触JavaFX时，我也曾遇到一些困难，例如不知道如何合理设计界面布局，或者不清楚事件处理机制。通过不断的实践和学习，我逐渐掌握了JavaFX的精髓，理解了它在图形用户界面设计中的重要地位。

设计原则的应用：从理论到实践

在课程学习过程中，我们不仅学习了面向对象的基本概念和Java编程技术，还学习了一些重要的设计原则。

单一职责原则（SRP）

单一职责原则指出，一个类应该只有一个引起其变化的原因，即一个类只负责一项职责。在航空货运管理系统中，我们遵循了单一职责原则，将不同的功能分配给不同的类。例如，Customer类负责客户信息管理，Goods类负责货物信息管理，Flight类负责航班信息管理，Order类负责订单信息管理。这种设计使得每个类的职责单一，易于理解和维护。

开闭原则（OCP）

开闭原则指出，软件实体（类、模块、函数等）应该对扩展开放，对修改关闭。在航空货运管理系统中，我们通过抽象类和接口实现了开闭原则。例如，我们定义了Payment抽象类，让AliPay和WeChatPay实现这个接口。当需要添加新的支付方式时，只需要添加一个新的类实现Payment接口即可，而不需要修改现有代码。

里氏替换原则（LSP）

里氏替换原则指出，如果S是T的子类，那么程序中所有以T出现的地方，都必须能够替换成S的对象。在航空货运管理系统中，我们遵循了里氏替换原则，确保子类能够正确地替换父类。例如，在Payment接口的实现类中，我们确保每个实现类都正确地实现了pay方法，能够被统一处理。

迪米特法则（LoD）

迪米特法则指出，一个对象应当对其他对象有尽可能少的了解。在航空货运管理系统中，我们遵循了迪米特法则，避免了对象之间的过度耦合。例如，在Order类中，我们只与直接相关的类（如Customer、Goods、Flight）交互，而不是与所有可能相关的类直接交互。
通过这些设计原则的应用，我体会到了良好的软件设计的重要性，理解了如何编写更好的代码，设计更好的系统。然而，在初次接触这些设计原则时，我也曾感到困惑，不知道如何在实际项目中应用它们。通过不断的实践和学习，我逐渐掌握了这些设计原则的精髓，理解了它们在软件设计中的重要地位。

采坑心得：学习过程中的弯路与经验教训

在学习Java面向对象课程的过程中，我经历了一些困难和挫折(一半都在电梯调度:)），也积累了一些宝贵的经验和教训。以下是我在学习过程中踩过的一些坑以及从中获得的经验教训。

从面向过程到面向对象的思维转变

在学习这门课程之前，我已经学习了C语言，习惯了面向过程的编程思维。然而，Java是一种面向对象的语言，思维方式完全不同。在开始学习Java面向对象时，没有那种顾全大局的设计思想（我抓起电梯猛猛就是写,一提交猛猛就是错）。

经验教训

通过不断的实践和学习，我逐渐掌握了面向对象的思维方式，理解了面向对象编程的核心理念。以下是我的一些经验教训：

  1. 从实际问题出发：从实际问题出发，思考如何用面向对象的方法解决这些问题。
  2. 实践是最好的老师：通过实际编程练习，不断应用面向对象的概念和原则，加深理解。
  3. 循序渐进：不要急于求成，而是循序渐进地学习面向对象的概念和原则，逐步提高自己的水平。

项目开发中的常见问题与解决方法

在课程的项目开发中，我遇到了各种各样的问题，有些问题甚至让我感到沮丧。以下是我在项目开发中遇到的一些常见问题以及解决方法。

问题与解决方法

  1. 需求理解不准确（又是你，电梯调度）

    • 问题：在开始编码之前，没有准确理解项目需求，导致开发过程中方向偏离，需要反复修改代码。

    • 解决方法：在开始编码之前，认真分析项目需求，明确项目的功能和要求，必要时可以画出项目的流程图或类图，帮助自己更好地理解项目结构。

  2. 类设计不合理

    • 问题：在设计类时，没有遵循单一职责原则，导致类的职责不明确，功能混杂，难以维护。

    • 解决方法：在设计类时，遵循单一职责原则，确保每个类只负责一项职责。如果一个类的功能太多，可以考虑将其拆分成多个类。

  3. 代码耦合度过高

    • 问题：类之间的耦合度过高，一个类的修改可能导致多个类需要修改，增加了维护的复杂性。

    • 解决方法：降低类之间的耦合度，使用接口或抽象类来定义类之间的依赖关系，而不是直接依赖具体的实现类。

面向对象设计原则的应用难点与突破

在学习面向对象设计原则时，我遇到了一些难点，这些难点让我感到困惑，但也促使我深入思考和学习。以下是我遇到的一些主要难点以及我是如何突破这些难点的。

单一职责原则（SRP）的应用

  1. 难点：如何确定一个类的职责范围，避免职责过多或过少。

  2. 突破方法：

    • 学习单一职责原则的定义和意义，理解它的核心思想：一个类应该只有一个引起其变化的原因。

    • 分析优秀的代码示例，观察它们如何应用单一职责原则。

在航空货运管理系统中，我通过单一职责原则的设计，将不同的功能分配给不同的类，如Customer类负责客户信息管理，Goods类负责货物信息管理，Flight类负责航班信息管理，Order类负责订单信息管理。这种设计使得每个类的职责单一，易于理解和维护。

开闭原则（OCP）的应用

  1. 难点：如何设计系统，使其对扩展开放，对修改关闭。

  2. 突破方法：

    • 学习开闭原则的定义和意义，理解它的核心思想：软件实体（类、模块、函数等）应该对扩展开放，对修改关闭。

    • 学习如何使用抽象类和接口来实现开闭原则。

在航空货运管理系统中，我通过定义Payment抽象类，让AliPay和WeChatPay实现这个接口，实现了开闭原则。当需要添加新的支付方式时，只需要添加一个新的类实现Payment接口即可，而不需要修改现有代码。

里氏替换原则（LSP）的应用

  1. 难点：如何确保子类能够正确地替换父类。

  2. 突破方法：

    • 学习里氏替换原则的定义和意义，理解它的核心思想：如果S是T的子类，那么程序中所有以T出现的地方，都必须能够替换成S的对象。

    • 在设计类继承关系时，确保子类的行为与父类一致，或者至少不破坏父类的行为。

在航空货运管理系统中，我通过设计Payment接口，确保每个实现类都正确地实现了pay方法，能够被统一处理，实现了里氏替换原则。

迪米特法则（LoD）的应用

  1. 难点：如何控制对象之间的依赖关系，减少对象之间的耦合。

  2. 突破方法：

    • 学习迪米特法则的定义和意义，理解它的核心思想：一个对象应当对其他对象有尽可能少的了解。

    • 在设计类时，尽量减少类之间的直接依赖，使用接口或抽象类来定义依赖关系。

在航空货运管理系统中，我通过合理设计类之间的依赖关系，确保每个类只与必要的类交互，避免了过度耦合，实现了迪米特法则。
通过这些难点的突破，我不仅理解了这些设计原则的理论知识，还学会了如何在实际项目中应用它们。这些经验不仅帮助我完成了课程的项目，还将在我未来的软件开发工作中发挥重要作用。

代码质量与复杂度控制

在面向对象编程中，代码质量与复杂度控制是至关重要的。代码质量高、复杂度低的代码不仅易于理解和维护，还具有更好的可扩展性和可复用性。在学习过程中，我遇到了一些关于代码质量与复杂度控制的挑战，也积累了一些宝贵的经验。

代码复杂度控制

  1. 问题：代码复杂度过高，导致代码难以理解和维护。

  2. 解决方法：

    • 使用代码分析工具（如SourceMonitor）评估代码复杂度，识别复杂的方法和类。

    • 将复杂的方法拆分成多个简单的方法，每个方法只负责一项功能。

    • 避免过深的嵌套结构，如过多的if-else嵌套、循环嵌套等，保持代码结构扁平。

    • 使用面向对象的封装和多态特性，将复杂的逻辑分解为简单的对象交互。
      在电梯调度系统中，我最初写了一个复杂度高达81的方法Elevator.move()，通过分析代码复杂度，我将这个方法拆分成多个简单的方法，降低了复杂度，提高了代码的可读性和可维护性。

代码质量评估指标(来自SourceMonitor)

  1. 代码行数：代码行数过多可能表明代码过于复杂或冗余。
  2. 语句数：语句数过多可能表明方法过于复杂。
  3. 分支语句百分比：分支语句过多可能导致代码难以理解和维护。
  4. 方法调用语句数：方法调用过多可能表明代码耦合度过高。
  5. 注释行百分比：注释过少可能表明代码缺乏必要的解释，难以理解。
  6. 不写了,还有很多相关参数.
    在航空货运管理系统中，我通过控制这些指标，确保代码的质量和可维护性。例如，我确保每个类的方法数适中，每个方法的语句数不多，注释适量等。

代码优化意识

  1. 问题：代码优化意识不足，导致代码质量不高。

  2. 解决方法：

    • 培养代码优化意识，认识到代码优化的重要性。

    • 学习代码优化的技术和方法，如代码重构、设计模式等。

    • 在编码过程中，不断反思和优化代码，提高代码的质量。

    • 参考优秀的代码示例，学习它们的代码风格和优化技巧。
      在电梯调度系统的代码优化中，我通过将不同的功能拆分到不同的方法中，降低了代码的复杂度，提高了代码的可读性和可维护性。这种代码优化意识的培养，不仅帮助我完成了课程的项目，还将在我未来的软件开发工作中发挥重要作用。

改进建议及总结：课程的综合性评价

经过一个学期的Java面向对象课程学习，我对这门课程有了全面而深入的理解。以下是我对这门课程的综合性评价以及对教师、课程、作业、实验、课上及课下组织方式等方面的改进建议。

课程的综合性评价

这门课程是一门理论与实践相结合的课程，旨在帮助学生掌握面向对象编程的基本思想和技能。课程内容涵盖了面向对象的三大特征（封装、继承、多态）、抽象类和接口、集合框架、异常处理、JavaFX等重要知识点。通过博客作业、PTA作业、实验项目等实践环节，学生能够将理论知识应用于实际问题的解决，培养解决实际问题的能力。
课程的教学方式采用了线上线下相结合的方式，线上部分通过网络教学平台提供课件和学习资源，线下部分通过课堂教学、实验操作和项目实践进行深入学习。这种教学方式既充分利用了网络资源的便利性，又保证了面对面教学的互动性和针对性。
课程的评估方式包括平时表现、实验报告、项目作业、期末考试等，全面评估学生的理论知识和实践能力。这种评估方式能够客观地反映学生的学习成果。

对课程的建议

  1. 优化课程结构：根据学生的反馈和学习效果，优化课程结构，调整各部分内容的比重，使课程更加合理和有效。
  2. 增加案例分析：增加一些实际项目案例的分析，让学生了解面向对象编程在实际项目中的应用，提高学习的实用性和针对性。

对作业的建议

  1. 增加开放性作业：设计一些开放性作业，没有固定的答案，鼓励学生发挥创造力和想象力，培养创新思维

  2. 及时反馈：对学生的作业及时给予反馈，指出优点和不足，似乎布置的题目从来没有直接讲过。

  3. 改变作业比重：虽然写这种博客有一定用处，但是整门课程这种报告总结性的作业太多了，写起来相当费时间，就比如写这么一篇文章，要确定结构，然后到网上一点点找内容充实,美化语言(没用大模型,确信:)),虽然也有反思,但是写起来花的时间比写代码还多,而且还有实验报告要写,肺腑之言:还不如多写点题

总结

这门Java面向对象课程是一门理论与实践相结合的课程，通过系统的学习和丰富的实践，我掌握了面向对象编程的基本思想和技能，理解了封装、继承、多态等核心概念，学会了使用抽象类和接口、集合框架、异常处理等技术，了解了JavaFX在图形用户界面设计中的应用。课程的博客作业、PTA作业、实验项目等实践环节，帮助我将理论知识应用于实际问题的解决，培养了解决实际问题的能力。
课程的教学方式采用了线上线下相结合的方式，既充分利用了网络资源的便利性，又保证了面对面教学的互动性和针对性。
通过这门课程的学习，我不仅掌握了面向对象编程的知识和技能，还培养了良好的编程习惯和问题解决能力，为后续的软件开发学习打下了坚实的基础。

参考资料

  1. OOP_BLOG_2
  2. OOP_BLOG_1
posted on 2025-06-19 16:53  Autine  阅读(29)  评论(0)    收藏  举报