面向对象程序设计课程总结
面向对象程序设计课程总结
前言
经过一个学期的面向对象程序设计课程学习，我完成了从题目集2到题目集11共十个题目集的编程训练，涵盖了Java面向对象编程的核心内容。这门课程包含了理论学习、PTA编程作业、实验实践和Blog总结等多个教学环节，工作量大且富有挑战性。
课程工作量概述
PTA作业方面：总计完成了10个题目集，包含近40道编程题目。从早期的基础算法实现（如一元二次方程求解、身份证校验），到中期的复杂系统设计（如单部电梯调度程序的三次迭代），再到后期的大型项目开发（如航空货运管理系统），题目难度呈现阶梯式递进。每个题目集的完成时间约为15-25小时，包括需求分析、代码实现、调试测试和优化改进等环节。
实验实践方面：课程设置了多个综合性实验，特别是JavaFX图形界面开发实验，要求开发完整的桌面应用程序。这些实验不仅考察编程能力，更注重系统设计思维和用户体验设计，单个实验的工作量通常需要20-30小时。
Blog作业方面：每完成一个阶段的学习，都需要撰写技术总结Blog，分析设计思路、技术难点和学习收获。这要求我们不仅要"会做"，更要"会总结"和"会表达"，培养了技术写作和反思总结的能力。
线上线下课程方面：线下课程侧重理论讲解和案例分析，帮助建立面向对象程序设计的理论基础；线上资源提供了丰富的参考资料和扩展阅读，支持自主学习和深入探索。
课程难度评估
整体而言，课程难度设计合理且富有挑战性。前期题目集（2-4）主要涉及基础语法和简单算法，难度适中；中期题目集（5-8）引入复杂的系统设计和算法实现，如电梯调度的LOOK算法、航空货运的业务流程建模，难度显著提升；后期题目集（9-11）结合继承多态、集合框架、异常处理和GUI开发，要求综合运用多种技术，达到了高级编程的水平。
特别值得一提的是电梯调度问题的三次迭代设计，从单一类实现到多类协作，再到引入乘客类的完善设计，这种渐进式的学习方式既保证了学习的连续性，又体现了软件工程的演进思想，是课程设计的一大亮点。
面向对象技术总结
通过十个题目集的学习实践，我对面向对象程序设计的核心概念和技术有了深入的理解和掌握。
封装技术的掌握
理论认知：封装是面向对象编程的基本特征之一，通过将数据和操作数据的方法组合在一起，并隐藏对象的内部实现细节，实现信息隐藏和接口抽象。
实践应用：在电梯调度程序中，我设计了完善的电梯类封装：
public class Elevator {
private int currentFloor; // 当前楼层
private Direction direction; // 运行方向
private ElevatorState state; // 运行状态
private int minFloor, maxFloor; // 楼层范围
// 提供公有接口方法
public void moveUp() { /* 实现细节 */ }
public void moveDown() { /* 实现细节 */ }
public int getCurrentFloor() { return currentFloor; }
// 私有辅助方法
private void updateState() { /* 内部实现 */ }
}
通过private修饰符隐藏内部状态，通过public方法提供受控的访问接口，实现了良好的封装性。在航空货运系统中，同样运用封装技术设计了用户类、订单类、货物类等，每个类都有明确的职责边界和接口定义。
技术掌握情况：目前对封装的理解较为深入，能够熟练运用访问修饰符控制类成员的可见性，设计合理的类接口。但在复杂系统中，如何平衡封装性和灵活性仍需进一步学习，特别是在使用设计模式时如何保持良好的封装性。
继承技术的应用
理论认知：继承允许创建新类时重用现有类的属性和方法，实现代码复用和层次化设计。Java支持单继承，通过extends关键字实现类的继承关系。
实践应用：在图形处理题目中，我设计了完整的图形继承体系：
// 抽象基类
public abstract class Shape {
protected String color;
protected Point position;
public abstract double getArea();
public abstract double getPerimeter();
// 通用方法
public void move(int dx, int dy) { /* 实现 */ }
}
// 具体子类
public class Circle extends Shape {
private double radius;
@Override
public double getArea() {
return Math.PI * radius * radius;
}
@Override
public double getPerimeter() {
return 2 * Math.PI * radius;
}
}
public class Rectangle extends Shape {
private double width, height;
@Override
public double getArea() {
return width * height;
}
@Override
public double getPerimeter() {
return 2 * (width + height);
}
}
这种设计实现了代码复用，新增图形类型时只需继承Shape并实现抽象方法即可。
技术掌握情况：对继承的基本概念和语法掌握较好，能够设计合理的类层次结构。但在实际应用中，有时过度使用继承导致类层次过深，影响代码可维护性。需要学习"组合优于继承"的设计原则，在适当的场景选择继承或组合。
多态技术的运用
理论认知：多态允许同一接口表现出不同的行为，是面向对象编程的核心特征。Java通过方法重写和动态绑定实现运行时多态。
实践应用：在航空货运管理系统中，我运用多态技术处理不同类型的货物：
public abstract class Cargo {
protected String id;
protected double weight;
public abstract double calculateShippingCost();
public abstract boolean requiresSpecialHandling();
}
public class FragileCargo extends Cargo {
@Override
public double calculateShippingCost() {
return weight * 15.0 + 50.0; // 易碎品附加费
}
@Override
public boolean requiresSpecialHandling() {
return true;
}
}
public class HazardousCargo extends Cargo {
@Override
public double calculateShippingCost() {
return weight * 20.0 + 100.0; // 危险品附加费
}
@Override
public boolean requiresSpecialHandling() {
return true;
}
}
// 多态使用
public class ShippingCalculator {
public double calculateTotalCost(List<Cargo> cargoList) {
double total = 0;
for (Cargo cargo : cargoList) {
total += cargo.calculateShippingCost(); // 多态调用
}
return total;
}
}
通过多态，同一个方法调用在运行时会根据对象的实际类型执行相应的实现，大大提高了代码的灵活性和可扩展性。
技术掌握情况：对多态的概念理解透彻，能够在设计中合理运用多态提高系统的扩展性。但在性能敏感的场景下，需要权衡多态带来的运行时开销。
抽象类与接口的应用
理论认知：抽象类提供部分实现的模板，接口定义纯粹的契约规范。Java 8之后接口支持默认方法，使得接口和抽象类的界限更加模糊。
实践应用：在图形卡片游戏中，我同时使用了抽象类和接口：
// 抽象类定义卡片模板
public abstract class Card {
protected String suit;
protected String rank;
// 具体方法
public String getSuit() { return suit; }
public String getRank() { return rank; }
// 抽象方法
public abstract int getValue();
public abstract String getDisplayName();
}
// 接口定义可比较行为
public interface Comparable<T> {
int compareTo(T other);
}
// 接口定义可排序行为
public interface Sortable {
void sort();
void shuffle();
}
// 具体实现
public class PlayingCard extends Card implements Comparable<PlayingCard> {
@Override
public int getValue() {
// 根据rank计算数值
}
@Override
public int compareTo(PlayingCard other) {
return Integer.compare(this.getValue(), other.getValue());
}
}
技术掌握情况：能够根据需求选择抽象类或接口，理解它们的不同使用场景。抽象类适合提供部分通用实现，接口适合定义行为契约。但在设计复杂系统时，如何平衡接口的粒度和数量仍需进一步实践。
集合框架的掌握
理论认知：Java集合框架提供了丰富的数据结构和算法实现，包括List、Set、Map等接口及其实现类。
实践应用：在各个项目中广泛使用了集合框架：
// 在电梯调度中使用队列
private Queue<Integer> upRequests = new LinkedList<>();
private Queue<Integer> downRequests = new LinkedList<>();
// 在货运系统中使用Map存储订单
private Map<String, Order> orderMap = new HashMap<>();
// 在卡片游戏中使用List管理卡片
private List<Card> deck = new ArrayList<>();
// 使用Set避免重复
private Set<String> processedIds = new HashSet<>();
// 使用TreeMap实现自动排序
private Map<String, Integer> keywordCount = new TreeMap<>();
特别是在Java关键词统计程序中，综合运用了多种集合类型：使用HashSet快速查找关键词，使用HashMap统计频次，使用TreeMap实现按键排序。
技术掌握情况：对常用集合类的特性和性能较为了解，能够根据需求选择合适的集合类型。但对于并发集合类和高级用法（如Stream API）的掌握还不够深入。
异常处理机制
理论认知：异常处理是Java程序健壮性的重要保障，通过try-catch-finally语句和异常类层次实现错误处理。
实践应用：在各个项目中都实现了完善的异常处理：
// 输入验证异常处理
public class InputValidator {
public static void validateFloor(int floor, int minFloor, int maxFloor)
throws InvalidFloorException {
if (floor < minFloor || floor > maxFloor) {
throw new InvalidFloorException("Floor " + floor + " is out of range");
}
}
}
// 文件操作异常处理
public void loadConfiguration() {
try (BufferedReader reader = new BufferedReader(new FileReader("config.txt"))) {
String line;
while ((line = reader.readLine()) != null) {
parseConfigLine(line);
}
} catch (IOException e) {
logger.error("Failed to load configuration", e);
useDefaultConfiguration();
} catch (ParseException e) {
logger.warn("Invalid configuration format", e);
useDefaultConfiguration();
}
}
技术掌握情况：掌握了基本的异常处理语法和机制，能够设计自定义异常类。但在异常处理的最佳实践方面还需学习，如何避免异常处理影响性能，如何设计良好的异常处理策略。
JavaFX图形界面开发
理论认知：JavaFX是Java的现代图形界面框架，支持FXML布局、CSS样式、事件处理和数据绑定等特性。
实践应用：在航空货运管理系统中开发了完整的JavaFX应用：
public class CargoManagementApp extends Application {
@Override
public void start(Stage primaryStage) {
// 创建主界面
TabPane tabPane = new TabPane();
// 订单创建页面
Tab orderCreationTab = new Tab("创建订单");
orderCreationTab.setContent(createOrderCreationPane());
// 订单管理页面
Tab orderManagementTab = new Tab("订单管理");
orderManagementTab.setContent(createOrderManagementPane());
// 支付管理页面
Tab paymentTab = new Tab("支付管理");
paymentTab.setContent(createPaymentPane());
// 物流跟踪页面
Tab trackingTab = new Tab("物流跟踪");
trackingTab.setContent(createTrackingPane());
tabPane.getTabs().addAll(orderCreationTab, orderManagementTab,
paymentTab, trackingTab);
Scene scene = new Scene(tabPane, 1000, 700);
scene.getStylesheets().add(getClass().getResource("styles.css").toExternalForm());
primaryStage.setTitle("航空货运管理系统");
primaryStage.setScene(scene);
primaryStage.show();
}
private VBox createOrderCreationPane() {
VBox pane = new VBox(10);
pane.setPadding(new Insets(20));
// 表单控件
GridPane grid = new GridPane();
grid.setHgap(10);
grid.setVgap(10);
TextField senderField = new TextField();
TextField receiverField = new TextField();
TextField weightField = new TextField();
ComboBox<String> cargoTypeBox = new ComboBox<>();
// 事件处理
Button createButton = new Button("创建订单");
createButton.setOnAction(e -> handleOrderCreation(
senderField.getText(),
receiverField.getText(),
weightField.getText(),
cargoTypeBox.getValue()
));
grid.add(new Label("发件人:"), 0, 0);
grid.add(senderField, 1, 0);
grid.add(new Label("收件人:"), 0, 1);
grid.add(receiverField, 1, 1);
grid.add(new Label("重量(kg):"), 0, 2);
grid.add(weightField, 1, 2);
grid.add(new Label("货物类型:"), 0, 3);
grid.add(cargoTypeBox, 1, 3);
grid.add(createButton, 1, 4);
pane.getChildren().add(grid);
return pane;
}
}
该应用实现了完整的用户界面，包括数据输入、表格显示、事件处理等功能，具有良好的用户体验。
技术掌握情况：掌握了JavaFX的基本组件和布局管理，能够开发简单的桌面应用。但对于复杂的UI设计、自定义控件开发和性能优化还需要更多实践。
踩坑心得
在学习过程中，我遇到了许多技术难题和设计陷阱，这些"踩坑"经历成为了宝贵的学习财富。
算法设计的复杂性陷阱
问题描述：在实现电梯调度的LOOK算法时，我最初采用了过于复杂的全扫描策略，试图同时考虑所有请求队列中的所有请求来决定电梯的运行方向。
具体表现：
// 错误的复杂实现
private Direction determineDirection() {
int upCount = 0, downCount = 0;
double upDistance = 0, downDistance = 0;
// 扫描所有上行请求
for (Integer floor : upRequests) {
upCount++;
upDistance += Math.abs(floor - currentFloor);
}
// 扫描所有下行请求
for (Integer floor : downRequests) {
downCount++;
downDistance += Math.abs(floor - currentFloor);
}
// 复杂的权重计算
double upPriority = upCount * 0.6 + (1.0 / (upDistance + 1)) * 0.4;
double downPriority = downCount * 0.6 + (1.0 / (downDistance + 1)) * 0.4;
return upPriority > downPriority ? Direction.UP : Direction.DOWN;
}
问题根源：对LOOK算法的理解不够深入，误认为需要考虑所有请求的全局优化，忽略了电梯调度的基本原则是按顺序处理请求。
解决方案：简化算法，只考虑队列头部的请求：
// 正确的简化实现
private Direction determineDirection() {
Integer upNext = upRequests.peek();
Integer downNext = downRequests.peek();
if (upNext == null && downNext == null) {
return Direction.IDLE;
} else if (upNext == null) {
return Direction.DOWN;
} else if (downNext == null) {
return Direction.UP;
} else {
// 选择距离较近的方向
int upDistance = Math.abs(upNext - currentFloor);
int downDistance = Math.abs(downNext - currentFloor);
return upDistance <= downDistance ? Direction.UP : Direction.DOWN;
}
}
经验教训：简单往往比复杂更有效。在算法设计时，应该先理解问题的本质，避免过度工程化。
面向对象设计的职责划分问题
问题描述：在早期的电梯调度实现中，我将所有功能都放在一个电梯类中，导致类的职责不明确，代码难以维护。
具体表现：
// 问题代码：职责过多的电梯类
public class Elevator {
// 电梯状态
private int currentFloor;
private Direction direction;
// 请求队列（应该独立管理）
private Queue<Integer> upRequests;
private Queue<Integer> downRequests;
// 输入解析（不应该在电梯类中）
public void parseInput(String input) { /* ... */ }
// 调度逻辑（应该由控制器负责）
public void scheduleRequests() { /* ... */ }
// 电梯运行（职责合理）
public void run() { /* ... */ }
// 输出格式化（不应该在电梯类中）
public void printStatus() { /* ... */ }
}
问题根源：对单一职责原则理解不深，没有进行合理的类设计和职责划分。
解决方案：重构为多类协作设计：
// 电梯类：只负责电梯本身的状态和行为
public class Elevator {
private int currentFloor;
private Direction direction;
private ElevatorState state;
public void moveUp() { /* ... */ }
public void moveDown() { /* ... */ }
public void stop() { /* ... */ }
}
// 请求队列类：专门管理请求
public class RequestQueue {
private Queue<Integer> upRequests;
private Queue<Integer> downRequests;
public void addUpRequest(int floor) { /* ... */ }
public void addDownRequest(int floor) { /* ... */ }
public Integer getNextUpRequest() { /* ... */ }
public Integer getNextDownRequest() { /* ... */ }
}
// 控制器类：负责整体调度逻辑
public class ElevatorController {
private Elevator elevator;
private RequestQueue requestQueue;
public void processRequests() { /* ... */ }
public void schedule() { /* ... */ }
}
经验教训：良好的类设计是面向对象编程的基础。每个类应该有明确且单一的职责，这样才能提高代码的可维护性和可扩展性。
JavaFX事件处理的内存泄漏问题
问题描述：在开发JavaFX应用时，不当的事件监听器使用导致内存泄漏。
具体表现：
// 问题代码：可能导致内存泄漏
public class OrderController {
private ObservableList<Order> orders = FXCollections.observableArrayList();
public void initializeTable(TableView<Order> table) {
table.setItems(orders);
// 添加监听器但没有正确移除
orders.addListener((ListChangeListener<Order>) change -> {
while (change.next()) {
if (change.wasAdded()) {
// 处理新增订单
for (Order order : change.getAddedSubList()) {
// 创建了大量的监听器，但没有清理
order.statusProperty().addListener((obs, oldVal, newVal) -> {
updateUI(order);
});
}
}
}
});
}
}
问题根源：对JavaFX的事件处理机制和内存管理理解不足，没有正确管理监听器的生命周期。
解决方案：使用弱引用监听器或正确移除监听器：
// 改进的代码
public class OrderController {
private ObservableList<Order> orders = FXCollections.observableArrayList();
private Map<Order, ChangeListener<OrderStatus>> statusListeners = new WeakHashMap<>();
public void initializeTable(TableView<Order> table) {
table.setItems(orders);
orders.addListener((ListChangeListener<Order>) change -> {
while (change.next()) {
if (change.wasAdded()) {
for (Order order : change.getAddedSubList()) {
// 使用弱引用或确保监听器可以被正确移除
WeakReference<Order> orderRef = new WeakReference<>(order);
ChangeListener<OrderStatus> listener = (obs, oldVal, newVal) -> {
Order o = orderRef.get();
if (o != null) {
updateUI(o);
}
};
order.statusProperty().addListener(listener);
statusListeners.put(order, listener);
}
}
if (change.wasRemoved()) {
for (Order order : change.getRemoved()) {
// 移除监听器
ChangeListener<OrderStatus> listener = statusListeners.remove(order);
if (listener != null) {
order.statusProperty().removeListener(listener);
}
}
}
}
});
}
}
经验教训：在GUI开发中，必须注意内存管理和资源清理。监听器、绑定等对象容易造成内存泄漏，需要建立良好的资源管理习惯。
集合框架使用的性能陷阱
问题描述：在处理大量数据时，不当的集合选择导致性能问题。
具体表现：
// 问题代码：在大数据场景下性能低下
public class KeywordCounter {
public Map<String, Integer> countKeywords(String text) {
Map<String, Integer> result = new HashMap<>();
String[] words = text.split("\\s+");
for (String word : words) {
// 对每个单词都进行Set查找，效率低
if (isKeyword(word)) {
result.put(word, result.getOrDefault(word, 0) + 1);
}
}
return result;
}
private boolean isKeyword(String word) {
// 每次都遍历数组，时间复杂度O(n)
for (String keyword : KEYWORDS) {
if (keyword.equals(word)) {
return true;
}
}
return false;
}
}
问题根源：没有选择合适的数据结构，导致算法时间复杂度过高。
解决方案：使用HashSet优化查找性能：
// 改进的代码
public class KeywordCounter {
private static final Set<String> KEYWORD_SET = new HashSet<>(Arrays.asList(KEYWORDS));
public Map<String, Integer> countKeywords(String text) {
Map<String, Integer> result = new HashMap<>();
String[] words = text.split("\\s+");
for (String word : words) {
// HashSet查找时间复杂度O(1)
if (KEYWORD_SET.contains(word)) {
result.put(word, result.getOrDefault(word, 0) + 1);
}
}
return result;
}
}
经验教训：选择合适的数据结构对性能至关重要。需要根据操作类型（查找、插入、删除）和数据特征选择最优的集合类型。
改进建议及总结
课程内容的综合评价
这门面向对象程序设计课程在内容设计上体现了很强的系统性和实践性。从基础的类设计到复杂的系统架构，从算法实现到用户界面开发，课程内容覆盖了Java编程的各个重要方面。特别是电梯调度问题的三次迭代设计，很好地展现了软件工程中需求演进和设计改进的过程，这种教学设计值得称赞。
对课程组织的改进建议
1. 增加设计模式内容
建议在课程中专门安排设计模式的教学内容。虽然在实际编程中我们无意中使用了一些设计模式的思想（如策略模式、观察者模式），但缺乏系统的理论学习。建议增加常用设计模式的专题讲座，并在PTA作业中设计相应的应用场景。
2. 强化代码评审环节
建议引入同学间的代码评审环节，让学生互相评审代码质量、设计思路和实现方案。这不仅能帮助发现代码问题，更重要的是能学习他人的优秀实践，培养代码审查能力。
3. 增加团队协作项目
建议设置一个学期项目，要求3-4人小组合作完成一个较大规模的系统开发。这样可以培养学生的团队协作能力、项目管理能力和代码协作能力，更贴近实际工作场景。
4. 完善测试教学内容
当前课程缺少系统的测试方法教学。建议增加单元测试、集成测试的相关内容，教授JUnit等测试框架的使用，培养测试驱动开发的思维。
5. 增加性能优化专题
建议增加Java性能优化的专题内容，包括JVM调优、算法优化、内存管理等，帮助学生编写高质量的代码。
对教学方法的建议
1. 案例驱动教学
建议更多采用案例驱动的教学方法，通过分析实际项目案例来讲解理论知识，提高学生的学习兴趣和实践能力。
2. 翻转课堂模式
可以尝试翻转课堂模式，让学生课前自学理论知识，课堂时间用于讨论、答疑和实践指导。
3. 在线编程平台
建议使用更多的在线编程平台和工具，如GitHub、在线IDE等，让学生熟悉现代软件开发环境。
对实验安排的建议
1. 渐进式实验设计
建议将大型实验分解为多个渐进式的小实验，每个实验专注于一个技术点，降低学习难度，提高完成质量。
2. 开放性实验题目
可以设计一些开放性的实验题目，允许学生选择不同的技术路线和实现方案，培养创新思维。
3. 实际项目导向
建议实验题目更多地来源于实际项目需求，让学生体验真实的软件开发过程。
个人学习的总结与反思
通过这门课程的学习，我不仅掌握了Java面向对象编程的技术知识，更重要的是培养了系统设计思维和问题解决能力。从最初的简单类设计到后来的复杂系统架构，从单纯的功能实现到对代码质量、性能优化的关注，这种思维的转变是最大的收获。
技术能力提升：
- 熟练掌握了Java语言的核心特性
- 理解了面向对象编程的核心概念和实践方法
- 具备了GUI应用开发的基础能力
- 培养了算法设计和优化的能力
思维方式转变：
- 从过程化思维转向面向对象思维
- 从功能实现转向系统设计
- 从个人开发转向团队协作意识
- 从完成任务转向追求代码质量
需要继续学习的方向：
- 深入学习设计模式和架构设计
- 掌握更多的框架和技术栈
- 提高系统性能调优能力
- 培养软件工程的项目管理能力
结语
面向对象程序设计是一门理论与实践并重的课程，通过一个学期的学习，我深刻体会到了编程不仅仅是写代码，更是一种思维方式和解决问题的方法论。从电梯调度算法的迭代优化到航空货运系统的架构设计，从JavaFX界面开发到集合框架的深入应用，每一个项目都是一次思维的锻炼和能力的提升。
这门课程最大的价值在于培养了我们的工程思维和系统化解决问题的能力。当面对复杂的业务需求时，我们学会了如何进行需求分析、系统设计、模块分解和接口定义；当遇到技术难题时，我们学会了如何查阅文档、分析问题、设计方案和验证结果。这些能力不仅适用于Java编程，更是软件开发和工程实践的通用能力。
展望未来，我将继续深入学习软件工程的相关知识，包括设计模式、系统架构、测试方法、项目管理等方面，努力成为一名优秀的软件开发工程师。同时，我也会将在这门课程中学到的思维方法和解决问题的策略应用到其他领域的学习和工作中，不断提升自己的综合能力。
感谢老师的悉心指导和同学们的相互帮助，这门课程的学习经历将成为我程序设计道路上的重要基石。
浙公网安备 33010602011771号