概括阐论软件开发过程中的方法，并用 python，Java和C++ 语言举实例说明之

原创 于 2025-12-08 20:49:57 发布 · 427 阅读 · 8 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#python #java #c++

现在将软件开发中的核心方法论分为几类，并结合 Python、Java 和 C++ 的实例进行说明。这些方法论是解决复杂问题的通用思维模式。

一、 核心方法论概述

  1. 抽象与具体

    • 抽象：隐藏复杂的实现细节，只暴露必要的接口或属性。这是管理复杂性的基石。
    • 具体：抽象概念的具体实现。关注“如何做”的细节。
    • 关系：通过抽象定义契约，通过具体实现功能。

  2. 一般与特殊（继承与多态）

    • 一般：定义通用的类、接口或模板。代表共性。
    • 特殊：从一般化定义中派生出特定化的版本，可以继承、覆盖或特化。代表特性。
    • 关系：实现代码复用和行为扩展。

  3. 分而治之

    • 将一个大问题分解为若干个相同或相似的小问题，递归求解，再合并结果。常见于算法设计（如排序、搜索）。

  4. 组合优于继承

    • 通过将对象作为其他对象的字段（组合）或通过接口协作来构建复杂功能，而非单纯依靠类继承树。这提高了灵活性和可维护性。

  5. 关注点分离

    • 将系统分解为不同的部分，每一部分只负责一个特定的功能领域（如数据访问、业务逻辑、用户界面）。MVC、分层架构就是其体现。

  6. 契约式设计

    • 明确规定函数或方法的前置条件、后置条件和不变式。确保组件在满足约定时正确工作。

二、 实例说明

我们将用三个例子来贯穿上述方法，并用三种语言实现。

例子场景：图形计算系统
  1. 定义一个抽象的 Shape。
  2. 实现具体的 Circle 和 Rectangle。
  3. 使用组合设计一个复杂的 Drawing（画布）。
  4. 演示分而治之（计算面积之和）。
  5. 演示契约设计（输入验证）。

1. 抽象与具体 & 一般与特殊

Python

from abc import ABC, abstractmethod
import math

# 抽象 & 一般
class Shape(ABC):
    @abstractmethod
    def area(self):
        pass  # 抽象方法，无具体实现

    def describe(self): # 具体方法，可被继承
        return f"I am a shape."

# 具体 & 特殊
class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius

    def area(self): # 实现抽象方法
        return math.pi * self.radius ** 2

    def describe(self): # 覆盖父类方法
        return f"I am a Circle with radius {self.radius}."

class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def area(self):
        return self.width * self.height

# 使用
shapes = [Circle(5), Rectangle(3, 4)]
for s in shapes:
    print(s.describe(), f"Area: {s.area()}")
# 输出体现了多态：同一个接口，不同行为

Java

// 抽象 & 一般
abstract class Shape {
    public abstract double area(); // 抽象方法
    public String describe() { // 具体方法
        return "I am a shape.";
    }
}

// 具体 & 特殊
class Circle extends Shape {
    private double radius;
    public Circle(double radius) { this.radius = radius; }
    @Override
    public double area() {
        return Math.PI * radius * radius;
    }
    @Override
    public String describe() {
        return "I am a Circle with radius " + radius;
    }
}

class Rectangle extends Shape {
    private double width, height;
    public Rectangle(double w, double h) { width = w; height = h; }
    @Override
    public double area() { return width * height; }
}

public class Main {
    public static void main(String[] args) {
        Shape[] shapes = {new Circle(5), new Rectangle(3, 4)};
        for (Shape s : shapes) {
            System.out.println(s.describe() + " Area: " + s.area());
        }
    }
}

C++

#include <iostream>
#include <vector>
#include <string>
#include <cmath>
using namespace std;

// 抽象 & 一般
class Shape {
public:
    virtual double area() const = 0; // 纯虚函数，使类成为抽象类
    virtual string describe() const { return "I am a shape."; }
    virtual ~Shape() {} // 虚析构函数，确保正确释放资源
};

// 具体 & 特殊
class Circle : public Shape {
    double radius;
public:
    Circle(double r) : radius(r) {}
    double area() const override {
        return M_PI * radius * radius;
    }
    string describe() const override {
        return "I am a Circle with radius " + to_string(radius);
    }
};

class Rectangle : public Shape {
    double width, height;
public:
    Rectangle(double w, double h) : width(w), height(h) {}
    double area() const override { return width * height; }
};

int main() {
    vector<Shape*> shapes = {new Circle(5), new Rectangle(3, 4)};
    for (auto s : shapes) {
        cout << s->describe() << " Area: " << s->area() << endl;
        delete s; // 清理内存
    }
    return 0;
}

2. 组合优于继承 & 关注点分离

我们创建一个 Drawing 类，它组合了多个 Shape 对象。Drawing 只负责管理形状集合，不关心单个形状的具体计算（关注点分离）。

Python

class Drawing:
    def __init__(self):
        self.shapes = [] # 组合：持有其他对象的引用

    def add_shape(self, shape: Shape): # 依赖于抽象Shape，而非具体类
        self.shapes.append(shape)

    def total_area(self):
        # 分而治之：将“求总面积”分解为“求每个形状面积并求和”
        total = 0
        for shape in self.shapes:
            total += shape.area() # 委托给各个具体对象
        return total

    def describe_all(self):
        return [s.describe() for s in self.shapes]

# 使用
drawing = Drawing()
drawing.add_shape(Circle(5))
drawing.add_shape(Rectangle(3, 4))
print(f"Total Area: {drawing.total_area()}")
print(f"Descriptions: {drawing.describe_all()}")

Java

import java.util.ArrayList;
import java.util.List;

class Drawing {
    private List<Shape> shapes = new ArrayList<>(); // 组合

    public void addShape(Shape shape) {
        shapes.add(shape);
    }

    public double totalArea() {
        double total = 0;
        for (Shape s : shapes) {
            total += s.area(); // 委托
        }
        return total;
    }

    public List<String> describeAll() {
        List<String> desc = new ArrayList<>();
        for (Shape s : shapes) {
            desc.add(s.describe());
        }
        return desc;
    }
}

public class Main {
    public static void main(String[] args) {
        Drawing drawing = new Drawing();
        drawing.addShape(new Circle(5));
        drawing.addShape(new Rectangle(3, 4));
        System.out.println("Total Area: " + drawing.totalArea());
        System.out.println("Descriptions: " + drawing.describeAll());
    }
}

C++

class Drawing {
    vector<Shape*> shapes; // 组合：使用指针集合
public:
    void addShape(Shape* s) {
        shapes.push_back(s);
    }

    double totalArea() const {
        double total = 0;
        for (const auto& s : shapes) {
            total += s->area(); // 委托
        }
        return total;
    }

    vector<string> describeAll() const {
        vector<string> desc;
        for (const auto& s : shapes) {
            desc.push_back(s->describe());
        }
        return desc;
    }

    ~Drawing() {
        for (auto s : shapes) {
            delete s; // 清理资源
        }
    }
};

int main() {
    Drawing drawing;
    drawing.addShape(new Circle(5));
    drawing.addShape(new Rectangle(3, 4));
    cout << "Total Area: " << drawing.totalArea() << endl;
    auto desc = drawing.describeAll();
    for (const auto& d : desc) {
        cout << d << endl;
    }
    // drawing析构时会自动delete所有shape
    return 0;
}

3. 契约式设计

我们通过前置条件验证来演示契约思想。

Python (使用类型提示和 assert 或 if 检查)

class ValidatedRectangle(Rectangle):
    def __init__(self, width, height):
        # 前置条件契约：宽度和高度必须为正数
        if not (isinstance(width, (int, float)) and width > 0):
            raise ValueError("Width must be a positive number.")
        if not (isinstance(height, (int, float)) and height > 0):
            raise ValueError("Height must be a positive number.")
        # 不变式契约：创建后，width和height应保持不变（除非提供修改方法并同样验证）
        super().__init__(width, height)

    # 后置条件契约示例：area() 的返回值应 >= 0
    # 在这个简单例子中，由于构造时已验证，后置条件自然满足。

Java (使用 IllegalArgumentException)

class ValidatedRectangle extends Rectangle {
    public ValidatedRectangle(double width, double height) {
        super(width, height); // 先调用父类构造
        // 前置条件验证（更严格的做法应在赋值前验证）
        if (width <= 0 || height <= 0) {
            throw new IllegalArgumentException("Width and height must be positive.");
        }
        // 不变式：this.width > 0 && this.height > 0
    }
}

C++ (使用 exceptions 或 assert)

class ValidatedRectangle : public Rectangle {
public:
    ValidatedRectangle(double width, double height) : Rectangle(width, height) {
        // 前置条件验证
        if (width <= 0 || height <= 0) {
            throw std::invalid_argument("Width and height must be positive.");
        }
        // 或者使用 assert (仅在调试模式生效)
        // assert(width > 0 && height > 0);
    }
    // 后置条件：area() > 0 在构造函数验证后成立
};

4. 其他重要方法补充

  • 迭代与递归：解决问题的一种重复机制。

    • 实例：计算斐波那契数列。
    # Python 迭代
def fib_iterative(n):
    a, b = 0, 1
    for _ in range(n):
        a, b = b, a + b
    return a

# Python 递归 (分而治之的体现)
def fib_recursive(n):
    if n <= 1:
        return n # 基本情况
    return fib_recursive(n-1) + fib_recursive(n-2) # 分解问题

  • 配置与约定：通过外部配置（如文件、环境变量）改变行为，或遵循特定约定（如Java Bean的getter/setter）。

  • 依赖注入：将对象的依赖从内部创建改为外部传入，实现控制反转，提高可测试性。Spring框架是典范。

总结

方法核心思想示例体现
抽象与具体隐藏细节，暴露接口Shape 抽象类与 Circle 具体类
一般与特殊继承共性，扩展特性Shape 作为父类，Rectangle 继承并实现 area()
分而治之分解、解决、合并Drawing.total_area() 循环求和
组合优于继承通过包含而非继承构建功能Drawing 类包含 Shape 列表
关注点分离模块各司其职Shape 管计算，Drawing 管集合，Main 管流程
契约式设计明确前提、保证结果ValidatedRectangle 的构造参数验证

这些方法不是孤立的，而是交织在优秀的软件设计中。例如，Drawing 类使用组合（持有Shape列表），遵循关注点分离（只管理集合），其 total_area 方法体现了分而治之，并且它依赖于抽象的 Shape 类，通过多态（一般与特殊）调用具体实现，在添加形状时可能还会用到契约验证。掌握这些思维模式，能让你在使用任何语言进行开发时，都能写出结构清晰、易于维护的代码。

JAVA面试八股文刷题记录兼笔记（时不时更新）
Tanboku的博客
09-04 412
Java核心概念摘要 Java是一种面向对象的编程语言，具有平台无关性、内存自动管理等特性。其核心内容包括： 基础数据类型：8种基本类型及其包装类，涉及类型转换和自动装箱拆箱机制 面向对象：封装、继承、多态三大特性，以及设计原则（开闭原则、里氏替换等） 集合框架： List：ArrayList（动态数组）、LinkedList（双向链表） Map：HashMap（哈希表+红黑树）、ConcurrentHashMap（线程安全） Set：HashSet、TreeSet等 异常处理：Checked/Unchec
【通识】C++基础知识
Achenganggyel的博客
06-20 501
C++ 的基础知识
c++后端相关(加深记忆，抄的github和小林coding)
weixin_44350672的博客
09-17 1428
宏定义相当于字符替换，而const是常量声明；宏定义是预处理器处理，而const是编译器处理；宏定义五类型安全检查，而const有类型安全检查；宏定义不分配内存，const要分配内存；宏定义存在代码段，const存在数据段；析构函数设为私有，类生成对象就只能定义在堆上，因为c++是静态绑定语言，为类对象分配栈空间时，会先检查类析构函数的访问性，若析构函数不能访问就不能在栈上创建对象；第一阶段，使用 new 在堆上寻找可用内存，分配给对象；第二阶段，调用构造函数生成对象。
Python机器学习：从入门到精通
YunWisdom
07-18 1214
当您翻开此书，您正踏入一场数据与智慧的修行。机器学习，并非冰冷的符码，而是机器模拟人类洞察世界的法门。本书将带您，以Python为舟，泛游于算法之海。我们不只传授“术”，更探求其后的“道”——从数据的生灭流转中观照规律，于模型的迭代演进里体悟得失。愿您合上书卷时，收获的不仅是驾驭数据的技能，更有一双洞悉复杂、化繁为简的“智慧之眼”。现在，让我们一同启程。
万字浓缩版，Python 潮流周刊第 1 季的 800 个链接！
Python猫
07-17 1565
△△请给“Python猫”加星标，以免错过文章推送你好，我是豌豆花下猫。前几天，我重新整理了 Python 潮流周刊的往期分享，推出了第 1 季的图文版电子书，受到了很多读者的一致好评。但是，合集和电子书的篇幅很长，阅读起来要花不少时间。所以，为了方便大家阅读，我打算将合集进一步整理，分门别类将原始内容的标题罗列出来。本文总计约 800 个链接，有 5 大分类，你可以快速浏览文章、项目、播客、视...
Java知识点概览
qq_48403611的博客
08-03 4235
java后端开发常见面试题总结
java高级进阶面试题
weixin_43139183的博客
10-28 3247
JVM 面试题目 1.请简单描述下 JVM 运行时数据区包括哪些部分？ JVM 在执行 Java 程序的过程中会把它管理的内存分为若干个不同的区域，这些组成部 分有些是线程私有的，有些则是线程共享的 线程私有的：程序计数器，虚拟机栈，本地方法栈 线程共享的：方法区，堆 2.JVM 中是怎么判断对象可回收的？ 可达性分析算法 这个算法的基本思想就是通过一系列的称为 “GC Roots” 的对象作为起点，从这些节 点开始向下搜索，节点所走过的路径称为引用链，当一个对象到 GC Roots 没有任何引用链 相连的
动手学python系列之Python面向对象编程(一)
尚拙的博客
10-11 385
上一篇文章我们简单地介绍了Python函数，包括函数的定义，参数传递等，接下来，我们将继续学习Python中的面向对象编程。 Python在设计之初就是一门面向对象的编程语言，正因为如此，在Python中，一切皆对象。Python的面向对象编程我们将从以下五个方面去介绍： 面向对象VS面向过程 面向对象简介 类和实例 面向对象三大特征 面向对象重写和重载 Part.1面向对象VS面向过程 我们通常说，C或C++是面...
Java开发：从入门到精通
weixin_45747731的博客
07-17 1195
亲爱的读者朋友们，欢迎开启这段Java的修行之旅。代码，是思想的显化，是逻辑的禅定。本书将带您从“万物皆对象”的初心出发，掌握Java核心，驰骋于Spring的广阔天地，构建微服务的坛城，乃至驾驭AI的智慧之光。莫将此书仅作技术图谱，它更是一张心法地图。愿您于此，不仅习得一身精湛“术”法，更能悟得软件工程背后严谨、创造、演进不息的“道”。愿智慧之光，常伴您行。
coala 0.4.1开发版源码包下载
标题“PyPI 官网下载 | coala-0.4.1.dev20160210111949.tar.gz”所指的是一种从Python官方第三方库仓库——PyPI（Python Package Index）获取名为coala的软件开发工具源码包的具体实例。该资源以`.tar.gz`格式打包，...
【恶意软件检测论文】通过提取 API 语义来实现的一个新颖的安卓恶意软件检测方法
czc的博客的csdn版本，欢迎访问我的还在建设的个人网站：czchx.cc
12-15 1480
由于Android框架和恶意软件的持续进化，使用过时应用程序训练的传统恶意软件检测方法在有效识别复杂的进化恶意软件方面已不足够。为了解决这个问题，本文提出了一种新颖的安卓恶意软件检测方法，名为API语义提取的安卓恶意软件检测方法（AMDASE），它可以有效识别进化的恶意软件实例。首先，AMDASE执行API聚类以获取代表API功能的聚类中心，然后在恶意软件检测之前设计API句子来总结API特征，并使用自然语言处理（NLP）工具获取API句子的嵌入，用于聚类。
【恶意软件检测】一种基于API语义提取的Android恶意软件检测方法（期刊等级：CCF-B、Q2）
czc的博客的csdn版本，欢迎访问我的还在建设的个人网站：czchx.cc
12-23 2502
由于Android框架和恶意软件的持续演变，使用过时应用程序训练的传统恶意软件检测方法在有效识别复杂演化的恶意软件方面已显不足。为了解决这个问题，本文提出了一种新颖的Android恶意软件检测方法，名为API语义提取的Android恶意软件检测方法（AMDASE），它可以有效识别演化的恶意软件实例。首先，AMDASE执行API聚类以获取代表API功能的聚类中心，然后在恶意软件检测之前设计API句子来总结API特征，并使用自然语言处理（NLP）工具获取API句子的嵌入用于聚类。
2021-05-28 2021年ICSE中与Android相关的论文分享
hanzhehao123的博客
05-28 1923
2021年ICSE中与Android相关的论文分享关于2021 ICSE文章1：Too Quiet in the Library: An Empirical Study of Security Updates in Android Apps’ Native Code文章2：RAICC: Revealing Atypical Inter-Component Communication in Android Apps文章3：ATVHUNTER: Reliable V ersion Detection of Th
50、【Ubuntu】【Gitlab】拉出内网 Web 服务：http.server 单/多线程分析（二）
HIT_Weston的博客
12-04 1335
本文分析了Python的http.server模块在单线程和多线程模式下的性能表现。通过测试发现，单线程模式下（Python<3.7）并发请求会被阻塞，后发请求需要等待前一个请求完成；而多线程模式下（Python≥3.7）可以同时处理多个请求。作者通过slow_server.py脚本模拟耗时操作，使用time curl命令测试响应时间，验证了线程模型的差异。文章还指出Python 3.7是一个重要分水岭，官方将默认命令行服务器升级为多线程以提升用户体验。技术细节参考了CPython源码，并提供了Git
推荐 | JoyAgent-JDGenie：开箱即用的端到端多智能体产品
lpfasd123的博客
12-05 330
如果你在寻找一款真正可落地的多智能体产品，用来“搜索-分析-生成报告”、“数据问答与诊断”、“代码解释与图表生成”，同时希望易部署、易扩展、易二次开发——JoyAgent-JDGenie 是非常值得试用与推荐的选择。只需填好少量配置，即可获得端到端的流式体验与交付能力。
大模型应用：大模型 MapReduce 全解析：核心概念、中文语料示例实现.12
minhuan的专栏
12-03 1309
本文介绍了MapReduce编程模型及其在大模型训练中的应用。MapReduce通过"分治-并行-聚合"思想处理大规模数据，传统Hadoop MapReduce侧重结构化数据计算，而大模型MapReduce则针对自然语言处理任务。文章详细对比了两者在架构、处理对象和核心算力等方面的差异，并提供了中文词频统计的Python实现示例，包括单机版和分布式版本。分布式实现利用多进程模拟集群计算，展示了数据分片、Map、Shuffle和Reduce的完整流程。
零基础学JAVA--Day41(IO文件流+IO流原理+InputStream+OutputStream)
最新发布
Dxxyyyy的博客
12-05 914
文件在程序中是以流的形式来操作的流：数据在数据源（文件）和程序（内存）之间经历的路径输入流：数据从数据源（文件）到程序（内存）的路径输出流：数据从程序（内存）到数据源（文件）的路径。
【Android逆向工程】第19章：协议分析与接口还原
w987333120的博客
12-03 422
本文介绍了网络协议分析的关键技术与工具。主要内容包括HTTP/HTTPS协议分析流程、常用抓包工具配置（Charles/Burp Suite）、协议格式解析方法以及签名算法还原技术。通过示例展示了完整的请求/响应分析过程，涵盖请求行、请求头、请求体的解析方法，特别关注签名相关字段的识别。文章还提供了Python代码示例演示如何自动分析HTTP请求结构，帮助逆向工程师理解业务逻辑、还原接口签名算法并实现自动化脚本。
使用 DeepSeek 提升工作效率
Deng872347348的博客
12-03 679
摘要：本文系统介绍了如何利用DeepSeek AI工具提升工作效率。文章首先分析职场痛点，指出DeepSeek在技术文档、代码开发、数据处理等专业场景的优势。随后详细解析核心功能模块，包括文本生成、代码支持、数据分析和知识管理，并明确其适用边界。重点提供了可直接复用的指令模板，涵盖技术文档撰写、脚本开发、数据可视化等典型场景，如自动生成API文档、Python数据分析脚本等。最后给出集成办公软件的最佳实践，并针对不同行业提供适配方案，强调AI工具"增强而非替代"的定位，帮助用户将重复性工
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

千江明月

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值