小课堂week13 Clean Code Part2

Clean Code Part2

对象与数据结构

首先让我们进行一个严肃的思考，对象与数据结构的区别在哪里？

如下两段代码分别用数据结构和对象的方法来描述了一个Point。

    public class Point {
        private double x;
        public double y;
    }

    public interface Point {
        double getX();
        double getY();
        void setCartesian(double x,double y);
        double getR();
        double getTheta();
        void setPolar(double r,double theta);
    }

可以看到，数据结构表达的是实现:Point这个事物由x和y来组成。

而对象只是表达了"怎么用"这个主题。无需了解数据的实现就能操作数据的本体，是对象最大的区别。

过程式与面向对象

那么，围绕数据结构和对象，我们代码实现会有什么不同么？

下面分别是使用数据结构和对象，实现了面积计算这个功能。

    public class Square {
        public Point topLeft;
        public double side;
    }
    public class Rectangle {
        public Point topLeft;
        public double height;
        public double width;
    }
    public class Circle {
        public Point center;
        public double radius;
    }
    public class Geometry {
        public final double PI = 3.141592653589793;
        public double area(Object shape) throws NoSuchShapeException {
            if ( shape instanceof Square) {
                Square s = (Square) shape;
                return s.side * s.side;
            }
            else if ( shape instanceof Rectangle ) {
                Rectangle r = (Rectangle) shape;
                return r.height * r.width;
            }
            else if ( shape instanceof Circle) {
                Circle c = (Circle) shape;
                return PI * c.radius * c.radius;
            }
            throw new NoSuchShapeException();
        }
    }

    public class Square implements Shape {
        private Point topLeft;
        private double side;
        public double area() {
            return side * side;
        }
    }
    public class Rectangle implements Shape {
        private Point topLeft;
        private double height;
        private double width;
        public double area() {
            return height * width;
        }
    }
    public class Circle implements Shape {
        private Point center;
        private double radius;
        public final double PI = 3.141592653589793;
        public double area() {
            return PI * radius * radius;
        }
    }

可以认为，面向过程是基于数据结构的开发，而面向对象是基于对象的开发。

它们其实是互有优劣：

过程式代码便于在不改动数据结构的前提下添加新函数。

面向对象便于在不改动既有函数的前提下添加新类。

在实际使用中，我们要根据使用场景来进行选择。一切都是对象，只是一个传说。

迪米特法则

下面讨论下面向对象的一个重要原则：迪米特法则。

法则的定义是：模块不应了解它所操作对象的内部情况。最小知识原则。

talk only to your immediate friends

具体来说，类C的方法f只应调用一下对象的方法：

1.C

2.由f创建的对象

public void a(){
   A a = new A();
   a.do();
}

3.作为参数传递给f的对象

4.由C的实体变量持有的对象

class C {
   private A a;
   public void f(){
     a.do();
   }
}

个人觉得，对于迪米特法则的运用，更重要的是要弄清楚，这个法则主要是希望禁止什么操作。

主要是：方法不应调用任何函数返回对象的方法。只和朋友谈话，不与陌生人谈话。

典型的是下面这种链式的调用，方法返回对象，然后继续调用返回对象的方法。这类代码常被称为"火车失事"。

  final String outputDir = ctxt.getOptions().getScratchDir().getAbsolutePath();

如何避免火车失事呢，我们可以采用facade(门面)模式，对代码进行封装。

   BufferedOutputStream bos = ctxt.createScratchFileStream(classFileName);

那如果方法存在排列组合的调用情况，facade模式无法表述呢，这个时候有一个折衷的方法，就是装饰模式。

 class Num {
     public Num add(int a){
         ...
         return this;
     }
 }

小结

对象和数据结构是对事物的两种表达方法，对象关注"怎么用"，数据结构关注"是什么"。

相对应的，过程式代码便于在不改动数据结构的前提下添加新函数。面向对象便于在不改动既有函数的前提下添加新类。

迪米特法则主要希望禁止"火车失事"的链式调用，我们可以用facade模式来重构代码，如无法避免链式调用，也应用装饰模式来实现。