格式与对象：垂直格式、水平格式、数据抽象、数据、对象的反对称性

说实话，代码格式这个话题，很多程序员觉得是「小事」。不就是缩进几个空格、换行对不对齐嘛？

但我见过太多因为格式混乱导致的线上事故了。有一次我接手一个老项目，一个文件三千行，垂直方向上各种逻辑混在一起，水平方向上有的行超过两百个字符。我花了整整两天才理清楚一个if分支的逻辑。嗯，从那以后，我对格式这件事就特别较真。

今天咱们聊聊格式与对象。说白了，就是两件事：代码怎么摆，以及数据怎么藏。

垂直格式：让代码像报纸一样阅读

我个人习惯是，一个文件尽量控制在200行以内。超过这个数，我就会问自己：这个类是不是承担了太多职责？

垂直格式的核心原则其实很简单：相关的东西放一起，不相关的东西用空行隔开。

你想想看，读报纸的时候，标题、导语、正文是层层递进的。代码也应该这样。我见过最糟糕的写法是把所有成员变量堆在文件顶部，所有方法堆在底部，中间没有任何逻辑分组。这种代码读起来就像在翻一本没有目录的书。

// 不好的垂直格式
public class OrderService {
    private double taxRate;
    private String currency;
    private List<OrderItem> items;
    private Customer customer;
    private DiscountCalculator calculator;
    
    public double calculateTotal() {
        // ... 50行逻辑
    }
    
    private double applyTax(double subtotal) {
        // ... 20行逻辑
    }
    
    private double applyDiscount(double amount) {
        // ... 30行逻辑
    }
    
    public void printInvoice() {
        // ... 40行逻辑
    }
}

// 好的垂直格式
public class OrderService {
    // 配置相关
    private double taxRate;
    private String currency;
    
    // 订单数据
    private List<OrderItem> items;
    private Customer customer;
    
    // 计算器
    private DiscountCalculator calculator;
    
    public double calculateTotal() {
        double subtotal = calculateSubtotal();
        double afterTax = applyTax(subtotal);
        return applyDiscount(afterTax);
    }
    
    private double calculateSubtotal() {
        // 相关逻辑
    }
    
    private double applyTax(double subtotal) {
        // 相关逻辑
    }
    
    private double applyDiscount(double amount) {
        // 相关逻辑
    }
    
    public void printInvoice() {
        // 相关逻辑
    }
}

水平格式：别让代码跑出屏幕

我记得有一次在Code Review时，看到同事写了一行300多个字符的代码。我问他：「你写这行的时候，眼睛不累吗？」他说：「我用的宽屏显示器，能显示完。」

但问题是，不是所有人都用宽屏。而且，一行代码太长，本质上说明它做了太多事。

// 不好的水平格式
public double calculateDiscountedPrice(double basePrice,double discountRate,int quantity,boolean isVIP){
    return basePrice*quantity*(1-discountRate)*(isVIP?0.95:1.0);
}

// 好的水平格式
public double calculateDiscountedPrice(
        double basePrice, 
        double discountRate, 
        int quantity, 
        boolean isVIP) {
    double vipFactor = isVIP ? 0.95 : 1.0;
    double subtotal = basePrice * quantity;
    double discount = subtotal * discountRate;
    return subtotal * (1 - discount) * vipFactor;
}

数据抽象：藏得越深，改得越爽

数据抽象，说白了就是「不要让别人知道你的数据长什么样」。你暴露的是行为，不是数据结构。

我遇到过最典型的反例：一个类里全是public的getter和setter，外部代码直接操作内部字段。后来需求变了，需要把存储方式从List改成Map，结果改了二十多个文件。

// 不好的数据暴露
public class Point {
    public double x;
    public double y;
}

// 好的数据抽象
public class Point {
    private double x;
    private double y;
    
    public double distanceTo(Point other) {
        double dx = this.x - other.x;
        double dy = this.y - other.y;
        return Math.sqrt(dx * dx + dy * dy);
    }
    
    public Point translate(double dx, double dy) {
        return new Point(this.x + dx, this.y + dy);
    }
}

数据与对象的反对称性

这个标题有点绕，我换个说法：面向对象和面向过程，其实是互补的。

你想想看：

• 面向对象：把数据和操作绑在一起。新增一个操作很难，因为要改所有类。但新增一个数据类型很容易。
• 面向过程：把数据和操作分开。新增一个操作很容易，但新增一个数据类型很难，因为要改所有函数。

这就是所谓的「反对称性」。说白了，没有银弹。你得根据场景选。

举个例子。如果你在做一个图形编辑器，图形类型（圆形、方形、三角形）基本不变，但经常要加新操作（旋转、缩放、镜像），那用面向对象就很合适。每个图形自己实现这些操作。

反过来，如果你在做编译器，语法树节点类型经常变，但遍历操作基本固定（打印、类型检查、代码生成），那用访问者模式（面向过程思路）就更合适。

// 面向对象风格：新增操作难，新增类型易
interface Shape {
    double area();
    double perimeter();
}

class Circle implements Shape {
    private double radius;
    public double area() { return Math.PI * radius * radius; }
    public double perimeter() { return 2 * Math.PI * radius; }
}

class Square implements Shape {
    private double side;
    public double area() { return side * side; }
    public double perimeter() { return 4 * side; }
}

// 面向过程风格：新增类型难，新增操作易
class ShapeOperations {
    static double area(Object shape) {
        if (shape instanceof Circle) {
            Circle c = (Circle) shape;
            return Math.PI * c.radius * c.radius;
        } else if (shape instanceof Square) {
            Square s = (Square) shape;
            return s.side * s.side;
        }
        throw new IllegalArgumentException();
    }
}

知识体系总览

下面这张图总结了本章的核心逻辑。你可以把它当作一个快速参考。

好了，这一章的内容就到这里。格式和对象，看似是两个独立的话题，但本质上都指向同一个目标：让代码更容易被理解、更容易被修改。下次你写代码的时候，不妨多问自己一句：「这段代码，三个月后的我还看得懂吗？」

---