MATLAB面向对象编程：如何构造问题专属的右侧向量B？

针对你遇到的B向量生成框架统一但具体公式随问题变化的情况，不需要在类外定义完整的B生成流程，以下两种MATLAB OOP方案可以帮你避免重复代码，同时保留灵活性：

方案1：抽象基类+子类继承（推荐，符合OOP设计规范） #

核心思路是将通用的B生成框架（循环、nj的定义）放在抽象基类中，把问题特有的计算公式抽象为抽象方法，让每个具体问题对应一个子类，实现自身的计算逻辑。

抽象基类代码 #

classdef LinearSystemSolver < handle
    properties
        parameter1
        parameter2
        % 可添加其他通用物理参数
    end
    properties (Dependent)
        B
    end
    % 定义抽象方法，要求子类必须实现
    methods (Abstract)
        val = computeBZero(obj)      % 处理nj=0的情况
        val = computeBNonZero(obj, nj_m)  % 处理nj≠0的情况，传入当前nj值
    end
    methods
        % B的get方法实现通用生成逻辑
        function b = get.B(obj)
            nj = -10:10;
            b = zeros(size(nj));
            for m = 1:length(nj)
                if nj(m) == 0
                    b(m) = obj.computeBZero();
                else
                    b(m) = obj.computeBNonZero(nj(m));
                end
            end
        end
        % 通用求解方法（可选）
        function x = solve(obj)
            A = obj.A;  % 假设A的生成逻辑也可按类似方式封装
            x = A\obj.B;
        end
    end
end

具体问题子类代码 #

问题1的子类

classdef Problem1Solver < LinearSystemSolver
    methods
        function val = computeBZero(obj)
            val = obj.parameter1 * obj.parameter2;
        end
        function val = computeBNonZero(obj, nj_m)
            val = obj.parameter1 * nj_m;  % 示例公式，可替换为实际逻辑
        end
    end
end

问题2的子类

classdef Problem2Solver < LinearSystemSolver
    methods
        function val = computeBZero(obj)
            val = 3 * obj.parameter1 * obj.parameter2;
        end
        function val = computeBNonZero(obj, nj_m)
            val = 2 * obj.parameter2 * abs(nj_m);  % 示例公式，可替换为实际逻辑
        end
    end
end

使用示例 #

% 初始化问题1求解器
solver1 = Problem1Solver();
solver1.parameter1 = 2;
solver1.parameter2 = 3;
B1 = solver1.B;  % 自动按问题1的公式生成B

% 初始化问题2求解器
solver2 = Problem2Solver();
solver2.parameter1 = 1;
solver2.parameter2 = 5;
B2 = solver2.B;  % 自动按问题2的公式生成B

这个方案的优势是通用逻辑仅需编写一次，子类只需实现差异化部分，完全遵循OOP的开闭原则，便于后续扩展新问题。

方案2：函数句柄属性（灵活快速，无需创建子类） #

如果不想定义多个子类，可以在基类中添加两个函数句柄属性，分别对应nj=0和nj≠0的计算逻辑，创建对象时传入不同的函数句柄即可。

基类代码 #

classdef LinearSystemSolver < handle
    properties
        parameter1
        parameter2
        % 用于存储问题特有的计算逻辑
        computeBZeroFcn
        computeBNonZeroFcn
    end
    properties (Dependent)
        B
    end
    methods
        function b = get.B(obj)
            nj = -10:10;
            b = zeros(size(nj));
            for m = 1:length(nj)
                if nj(m) == 0
                    b(m) = obj.computeBZeroFcn(obj);
                else
                    b(m) = obj.computeBNonZeroFcn(obj, nj(m));
                end
            end
        end
        % 构造函数，可选传入默认逻辑
        function obj = LinearSystemSolver(bZeroFcn, bNonZeroFcn)
            if nargin >= 1
                obj.computeBZeroFcn = bZeroFcn;
            end
            if nargin >= 2
                obj.computeBNonZeroFcn = bNonZeroFcn;
            end
        end
    end
end

使用示例 #

% 定义问题1的计算逻辑
b1Zero = @(obj) obj.parameter1 * obj.parameter2;
b1NonZero = @(obj, nj_m) obj.parameter1 * nj_m;
solver1 = LinearSystemSolver(b1Zero, b1NonZero);
solver1.parameter1 = 2;
solver1.parameter2 = 3;
B1 = solver1.B;

% 定义问题2的计算逻辑
b2Zero = @(obj) 3 * obj.parameter1 * obj.parameter2;
b2NonZero = @(obj, nj_m) 2 * obj.parameter2 * abs(nj_m);
solver2 = LinearSystemSolver(b2Zero, b2NonZero);
solver2.parameter1 = 1;
solver2.parameter2 = 5;
B2 = solver2.B;

这个方案无需创建子类，适合快速测试不同的计算公式，灵活性更高，但封装性不如抽象基类方案。

内容的提问来源于stack exchange，提问作者Silver Pages