一、解讀

// 組件的邊框，繼承于抽象類 BoxBorder
class Border extends BoxBorder {
  // 創建一個邊框，參數不能為空
  const Border({
    this.top = BorderSide.none, // BorderSide.none 是無邊框
    this.right = BorderSide.none,
    this.bottom = BorderSide.none,
    this.left = BorderSide.none,
  }) : assert(top != null), // 參數不能為空的斷言
       assert(right != null),
       assert(bottom != null),
       assert(left != null);

  // 創建和一個邊相同的邊
  const Border.fromBorderSide(BorderSide side)
      : assert(side != null),
        top = side,
        right = side,
        bottom = side,
        left = side;

  /// 創建水平 （頂部和底部）和垂直（左邊和右邊）的邊 
  const Border.symmetric({
    BorderSide vertical = BorderSide.none, // 垂直
    BorderSide horizontal = BorderSide.none, // 水平
  }) : assert(vertical != null),
       assert(horizontal != null),
       left = vertical,
       top = horizontal,
       right = vertical,
       bottom = horizontal;

  /// 所有顏色和寬度都相同的邊框
  /// 調用 fromBorderSide 來實現
  factory Border.all({
    Color color = const Color(0xFF000000),
    double width = 1.0,
    BorderStyle style = BorderStyle.solid,// 邊框的樣式，實線
  }) {
    final BorderSide side = BorderSide(color: color, width: width, style: style);
    return Border.fromBorderSide(side);
  }

  ///  創建一個邊框，有兩個邊框相加
  static Border merge(Border a, Border b) {
    assert(a != null);
    assert(b != null);
    assert(BorderSide.canMerge(a.top, b.top)); // canMerge 檢查是否可以合并，判斷的條件是邊框的樣式和顏色是否相同
    assert(BorderSide.canMerge(a.right, b.right));
    assert(BorderSide.canMerge(a.bottom, b.bottom));
    assert(BorderSide.canMerge(a.left, b.left));
    return Border(
      top: BorderSide.merge(a.top, b.top),
      right: BorderSide.merge(a.right, b.right),
      bottom: BorderSide.merge(a.bottom, b.bottom),
      left: BorderSide.merge(a.left, b.left),
    );
  }

  // 頂部邊框
  @override
  final BorderSide top;

  // 右邊邊框
  final BorderSide right;
  
  // 底部邊框
  @override
  final BorderSide bottom;

  // 左邊邊框
  final BorderSide left;
  
  // 獲取尺度
  @override
  EdgeInsetsGeometry get dimensions {
    return EdgeInsets.fromLTRB(left.width, top.width, right.width, bottom.width);
  }
  
  // 判斷邊框的顏色、粗細、樣式是否一致
  @override
  bool get isUniform => _colorIsUniform && _widthIsUniform && _styleIsUniform;
  
  // 判斷所有邊框顏色是否統一
  bool get _colorIsUniform {
    final Color topColor = top.color;
    return right.color == topColor && bottom.color == topColor && left.color == topColor;
  }
  
  // 判斷邊框粗細是否一致
  bool get _widthIsUniform {
    final double topWidth = top.width;
    return right.width == topWidth && bottom.width == topWidth && left.width == topWidth;
  }
  
  // 判斷邊框樣式是否一致
  bool get _styleIsUniform {
    final BorderStyle topStyle = top.style;
    return right.style == topStyle && bottom.style == topStyle && left.style == topStyle;
  }
  
  //  重寫 BoxBorder 的 add 方法，增加邊框的數值
  @override
  Border? add(ShapeBorder other, { bool reversed = false }) {
    if (other is Border && // is 是類型判斷
        BorderSide.canMerge(top, other.top) &&
        BorderSide.canMerge(right, other.right) &&
        BorderSide.canMerge(bottom, other.bottom) &&
        BorderSide.canMerge(left, other.left)) {
      return Border.merge(this, other);
    }
    return null;
  }
  
  // 重寫 BoxBorder 的父類 ShapeBorder 的 scale 方法，比例增加邊框的粗細
  @override 
  Border scale(double t) {
    return Border(
      top: top.scale(t),
      right: right.scale(t),
      bottom: bottom.scale(t),
      left: left.scale(t),
    );
  }
  
  // 
  @override
  ShapeBorder? lerpFrom(ShapeBorder? a, double t) { 
    if (a is Border)
      return Border.lerp(a, this, t);
    return super.lerpFrom(a, t);
  }

  @override
  ShapeBorder? lerpTo(ShapeBorder? b, double t) {
    if (b is Border)
      return Border.lerp(this, b, t);
    return super.lerpTo(b, t);
  }

  /// 生成兩個邊框之間的線性邊框
  /// 注意: t ==0 ,a 生效；t == 1, b 生效
  /// 最后，邊框的寬度為  a * (1.0 - t) + b * t
  static Border? lerp(Border? a, Border? b, double t) {
    assert(t != null);
    if (a == null && b == null)
      return null;
    if (a == null)
      return b!.scale(t);
    if (b == null)
      return a.scale(1.0 - t);
    return Border(
      top: BorderSide.lerp(a.top, b.top, t),
      right: BorderSide.lerp(a.right, b.right, t),
      bottom: BorderSide.lerp(a.bottom, b.bottom, t),
      left: BorderSide.lerp(a.left, b.left, t),
    );
  }

  /// 在給定大小畫布上繪制邊框
  @override
  void paint(
    Canvas canvas,
    Rect rect, {
    TextDirection? textDirection, // 文字方向
    BoxShape shape = BoxShape.rectangle, // 形狀
    BorderRadius? borderRadius, // 圓角
  }) {
    // 判斷是否統一
    if (isUniform) {
      // 判斷邊框樣式
      switch (top.style) {
        // 無樣式，不繪制
        case BorderStyle.none:
          return;
        // 實線
        case BorderStyle.solid:
          // 組件的樣式
          switch (shape) {
            // 圓弧型
            case BoxShape.circle:
              assert(borderRadius == null, 'A borderRadius can only be given for rectangular boxes.');
              BoxBorder._paintUniformBorderWithCircle(canvas, rect, top);
              break;
            // 長方型
            case BoxShape
              BoxBorder._paintUniformBorderWithRectangle(canvas, rect, top);
              break;
          }
          return;
      }
    }

    assert(() {
      // 判斷圓角
      if (borderRadius != null) {
        throw FlutterError.fromParts(<DiagnosticsNode>[
          ErrorSummary('A borderRadius can only be given for a uniform Border.'),
          ErrorDescription('The following is not uniform:'),
          if (!_colorIsUniform) ErrorDescription('BorderSide.color'),
          if (!_widthIsUniform) ErrorDescription('BorderSide.width'),
          if (!_styleIsUniform) ErrorDescription('BorderSide.style'),
        ]);
      }
      return true;
    }());
    assert(() {
      // 判斷形狀
      if (shape != BoxShape.rectangle) {
        throw FlutterError.fromParts(<DiagnosticsNode>[
          ErrorSummary('A Border can only be drawn as a circle if it is uniform'),
          ErrorDescription('The following is not uniform:'),
          if (!_colorIsUniform) ErrorDescription('BorderSide.color'),
          if (!_widthIsUniform) ErrorDescription('BorderSide.width'),
 
 // 邊框的運算
  @override
  bool operator ==(Object other) {
    if (identical(this, other))
      return true;
    if (other.runtimeType != runtimeType)
      return false;
    return other is Border
        && other.top == top
        && other.right == right
        && other.bottom == bottom
        && other.left == left;
  }
  
  // 獲取組件的哈希嗎
  @override
  int get hashCode => hashValues(top, right, bottom, left);

//  獲取對該類的描述
@override
  String toString() {
    if (isUniform)
      return '${objectRuntimeType(this, 'Border')}.all($top)';
    final List<String> arguments = <String>[
      if (top != BorderSide.none) 'top: $top',
      if (right != BorderSide.none) 'right: $right',
      if (bottom != BorderSide.none) 'bottom: $bottom',
      if (left != BorderSide.none) 'left: $left',
    ];
    return '${objectRuntimeType(this, 'Border')}(${arguments.join(", ")})';
  }
}

二、總結

• 繼承于 Border ，而 Border 繼承于 BoxBorder .
• 邊框的快捷創建方法以及運算

三、實例

// 顏色、邊框樣式、粗細
Border.all(
  color: Colors.green,
  width: 3,
  style: BorderStyle.solid,
)

// 從一邊生成相同的多邊
Border.fromBorderSide(
  BorderSide(
    color: Colors.green,
    width: 3,
    style: BorderStyle.solid,
  ),
)

// 合并兩個邊框，生成新的邊框
// 注意：合并的兩個邊框的顏色和樣式要一樣
Border.merge(Border.all(width: 2), Border.all(width: 3))

// 設置水平邊框和垂直邊框
Border.symmetric(
  vertical: BorderSide(
    color: Colors.green,
    width: 5,
  ),
  horizontal: BorderSide(
    color: Colors.black,
    width: 5,
  ),
)

// 判斷兩個邊框是否相等
Border(top: BorderSide(color: Colors.green)) == Border(top: BorderSide(color: Colors.red))

// 生成兩個邊框的線性插值邊框
Border.lerp(
  Border(top: BorderSide(color: Colors.green, width: 10)),
  Border(top: BorderSide(color: Colors.purple, width: 2)),
  2,
)