编程语言的一些基础概念（三）：面向对象

在前面两篇中，主要讲了函数式编程语言的一些基础概念。这篇是 Coursera Programming Languages, Part C 的总结，通过 Ruby 介绍面向对象编程里的一些概念。了解这些概念能让你在上手任何一门新的面向对象语言时，都更加得心应手。

虽然用的是 Ruby，但是不会涉及很深的 Ruby，即使不懂 Ruby，读下来应该没问题。对于已经了解面向对象编程的朋友，可以考虑直接跳到子类和继承那部分，或许你会有一些新的启发。

面向对象编程 & Ruby

面向对象编程（Object Oriented Programming）简称 OOP，像 Java，C++ 等语言的主要编程模式都是面向对象的。OOP 主要是通过 对象(Object) 来抽象表示，比如说平面上的一个点，可以抽象表示成 Point(x, y)，x，y 表示这个点的横纵坐标。在对象中可以有一些方法(methods) 来具体表示这个对象能做些什么，比如对于一个点，可定义一个 method distFromOrigin ，去求这个点的到原点的距离。

Everything is object in Ruby

Ruby 是动态类型的面向对象语言。Ruby 中所有的表达式都是一个对象，比如数字 1, 2, 3, 4 等是对象，+ 加法是对象的一个方法。Ruby 最出名的是在网页应用的开发，但是因为 Everything is object in Ruby，被选做为这个课程的教学语言。

Class & Methods

在 OOP 中，最基本的就是怎么定义和使用对象以及对象中的方法。

定义 Class 和 Methods

Ruby 中，对象的定义通过 Class 实现。

class Foo
  def m1
    ...
  end
  def m2 (x,y)
    ...
  end
end

这里定义了一个对象 Foo，以及两个方法 m1 和 m2。

调用方法

foo = Foo.new
foo.m1
foo.m2(x, y)

上例是最简单的方法调用。

 e0.m(e1, ..., en)

这是调用方法的抽象表达，可以有另一种理解： 发送消息，e0 是消息的接受者，可以说将 e1 的结果作为参数放在消息 m 里，发送给 e0。

在 Ruby 中，所有表达式都是对象，e1 + e2 实际上是 e1.+ e2 的简写法，e1 调用了 方法 +，e2 是这个方法调用的参数。

定义 实例变量、类变量、类常量、类方法

class Foo
  Const = "constant"

  def initialize
    @foo = 1
    @@bar = 2

  def m1
    ...
  end

  def m2 (x,y)
    ...
  end

  def self.classMethod
    ...
  end
end

上例中，@f 为实例变量 (instance variable) ，@@f 为类变量 (class variable) ，Const 是类常量 (Class constant)，classMethod 是类方法。

怎么使用类常量和类方法？

Foo::Const
Foo.classMethod

别名 Aliasing

foo = Foo.new
bar = foo

在这个例子中，bar 是 foo 的别名，他们对应是同一个 object，如果 bar 更改了，foo 也会相对应的更改。在 OOP 中，不像函数式编程里数据不可更改，需要特别注意什么时候用别名，什么时候要新建一个 object。

可见性 Visibility

对象内的变量和方法根据不同的定义方式，对象外不一定可见，可以理解为知不知道它的存在。

class Foo
  def initialize
    @foo = 1

  public
  def m1
    ...
  end

  protected
  def m2
    ...
  end

  private
  def m3
    ...
  end
end

foo = Foo.new
foo.@foo # 报错
foo.m1   # 可见
foo.m2   # 报错
foo.m3   # 报错

实例变量 @foo 在 class Foo 外是不知道它的存在的，foo.@foo 会报错，实例变量只有对象内的方法 m1, m2, m3 可以使用。

这样的设计其实很符合面向对象的概念，Foo 是一个对象，要跟这个对象交流，只能通过发送消息，也就是调用方法的方式。

对象内的方法也可以定义可见性。

  • public，表示对外可见，Ruby 对象默认的模式，在类之外可以调用。
  • protected 和 private 只能在 类和子类都能调用。

Getter & Setter

对象的实例变量对外不可见，但是很多情况下可能会需要实例变量，这个时候可以通过定义 Getter 和 Setter 两个方法来实现实例变量的读写。

# getter
def foo @foo
end

# setter
def foo= x
  @foo = x
end

# simpler way to define getters
attr_reader :y, :z # defines getters

# simpler way to define getters and setters
attr_accessor :x # defines getters and setters

反射 Reflections

反射指的是在程序运行的过程中，能访问、检测和修改它本身的这个对象。比如说可以在运行的过程中去访问这个对象里都有哪些方法，然后动态的去调用这些方法。

鸭子类型 Duck Typing

当看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子，那么这只鸟就可以被称为鸭子。

def mirror_update point
  point.x = point.x * -1
end

这个方法本意是将一个点 (point) 的 x 值变为 -x，但是所有"像点一样有 x 这个方法"的对象都可以作为参数传入这个函数，这就是所谓的鸭子类型。通常只有动态类型的语言才会支持鸭子类型，但是 Golang 也是有办法实现，这里不展开了。

优缺点

鸭子类型的最大的优点在于代码的重用，同样一段代码，传进的参数只要有那些方法，就能够复用这段代码。但是也带来了缺点，重用使得代码表意不清，我们在用这个方法时，考虑的不是这个方法怎么调用，而是要清楚的了解这个方法的具体实现。举个例子：

def double x
  x + x
end

看到 double 这个函数名，可能最直观的理解就是把数字翻倍，具体的实现 x + x，也可以把两个字符串连在一起。但假如 Ruby 的字符串没有 * 这个方法，具体实现是 2*x 的话，这个函数就不适用于字符串。所以知道一个函数名不够，还得看具体的实现，也挺麻烦的。

Blocks and Using Blocks

这是 Ruby 特有的一个特性。

def silly a
  (yield a) + (yield 42)
end

x.silly(5) {|b| b*2} # 5 * 2 + 42 * 2 = 94

{|b| b*2} 类似于这种的结构，在 Ruby 中是一个 Block，Block 可以放在任何方法调用后，通过方法里的 yeild 来调用 Block 里的内容。上例中，yield a 变成了 a * 2，也就是 5*2。如果一个方法里有 yield，就一定要传入 Block，不然会报错。

子类化和继承

子类化 (SubClassing) 和 继承 (Inheritence) 是 基于类的 OOP 里最重要也是最基础的概念。如果一个类是另一个的子类，那么这个类的实例也是另一个的实例。

class Point
  attr_accessor :x, :y
  def initialize(x,y)
    @x = x
    @y = y end
  def distFromOrigin
    Math.sqrt(@x * @x  + @y * @y)
  end
end
class ColorPoint < Point
  attr_accessor :color
  def initialize(x,y,c="clear")
    super(x,y)
    @color = c
  end
end

在 Ruby 中，子类化用 < 来表示，ColorPoint 是 Point 的子类，它继承了 Point 里所有的方法和变量，所以 ColorPoint 也有 distFromOrigin 的方法，也有 x, y 坐标。可以看出，通过这种继承关系，ColorPoint 不用将 Point 里关于 x, y 及计算到顶点的距离的代码再复制一遍，实现了代码的重用。

覆写和动态调度

覆写 (Overriding) 指的是在子类里和父类一样名字的方法会覆写父类的方法。

动态调度 (Dynamic Patching) 也叫 late binding 或者 virtual methods，指的是从子类去调用父类方法，父类方法里可以动态的调度子类的方法。

class A
  def m1
    self.m2
  end
  def m2
    puts "m2 in A is called"
  end
  def m3
    puts "m3 in A is called"
  end
end

class B < A
  def dynamicDispatch
    self.m1
  end
  def m2
    puts "m2 in B is called"
  end
  def m3
    puts "m3 in B is called"
  end
end

b = B.new
b.m3 # m3 in B is called
b.dynamicDispatch # m2 in B is called

上例中，子类 B 中的方法 m3 覆写了 A 中的 m3，b.dynamicDispatch 调用了 A 中的 m1, m1 里 self.m2的应该调用 A 还是 B 的 方法 m2 呢？因为发起调用的是 b，所以虽然调用的是 A 中 m1 的 self.m2，但是会被动态的调用到 B 中的 m2。

动态调度 VS Closure

对比下吗 ML 和 Ruby 的两个例子：

fun even x = if x=0 then true  else odd  (x-1)
and odd  x = if x=0 then false else even (x-1)

fun even x = (x mod 2)=0
fun even x = false

在 ML 中，有 closure，所以后面定义的两个 even 函数，对第一个函数没有任何影响。

class A
  def even x
    if x==0 then true  else odd  (x-1) end
  end
  def odd x
    if x==0 then false else even (x-1) end
end end
class B < A  # improves odd in B objects
  def even x ; x % 2 == 0 end
end
class C < A  # breaks odd in C objects
  def even x ; false end
end

B.new.odd
C.new.odd

因为动态调度 A 中的 even 不会被调用，而是调用子类 B 和子类 C 的 even。对于程序员来说，可以像 B 一样，写出更好的 even 的代码，也可能像 C 一样写 bug。

可以说动态调度这个特性使得代码更加灵活，重用率可能更高，给了程序员更大的自由度，但是需要程序员去注意不会一不小心写了 bug。

方法查询 Method Lookup

在覆写和动态调度中，涉及到了 OOP 编程语言中怎么去查询方法的设计。在 Ruby 中，对于一个 class C 的实例调用方法 m，方法查询经过下面这些过程：

  1. 在 class C 中找方法 m
  2. 在 class C 中的 mixin (后面介绍) 中找方法 m
  3. 在 class C 的父类中找方法 m
  4. 在 class C 的父类的 mixin 中找方法 m
  5. 以此类推向上查找，直到找到方法 m 的定义，或者找不到返回 method missing error。

多方法 和 静态重载

多方法 (Multimethods) ** 指的是在一个类里，有多个方法有一样的名字，一样数量的参数，但是参数的类型不一样，在调用这个名字的方法时，会在动态**的找到最合适类型的那个方法，进行调用。Ruby 不支持 Multimethods，下面这个例子，借用 Ruby 的语法：

class A
  def addValue Int
    ...
  end
  def addValue String
    ...
  end
  def addValue Rational
    ...
  end
end

在调用时，A.new.addValue ?会根据参数类型，动态的找到最合适的方法。

Clojure 支持 Multimethods。

静态重载 (Static Overload) 和多方法一样，定义的多个方法名字是一样的，但是可以是不同数量的参数和类型。和多方法最大的不同在于，重载不是动态调用时完成的，而是静态的，感觉有点像类型检查，在程序编译时就完成了（不是很确定）。看一个 Java 的例子：

public class Sum {
    // Overloaded sum(). This sum takes two int parameters
    public int sum(int x, int y) {
        return (x + y);
    }

    // Overloaded sum(). This sum takes three int parameters
    public int sum(int x, int y, int z) {
        return (x + y + z);
    }

    // Overloaded sum(). This sum takes two double parameters
    public double sum(double x, double y) {
        return (x + y);
    }
}

多重继承 Multiple Inheritence

多重继承指的是继承多个父类。看一个 C++ 的例子：

struct Base1 {
  void print (void) {
    std::cout << "Base 1" << std::endl;}
};

struct Base2 {
  void print (void) {
    std::cout << "Base 2" << std::endl;}
};

struct Derived1 : public Base1, public Base2 {
  void print (void) { // 重写基类方法
    Base1::print(); // 指定使用何种
    Base2::print();
  }
}

// 原文：https://blog.csdn.net/caroline_wendy/article/details/18077235

多重继承比只能有一个父类的继承要复杂的多，比如多个父类的优先顺序问题，多个父类中，都有同一个方法时，method lookup 要怎么行？类型检查，class 的结构也要相对的复杂的多。所以不是所有的 OOP 都支持多重继承，C++ 是支持的，但 Java 和 Ruby 就没有。

Mixin

因为多继承的复杂性，还有单继承代码复用的局限性，有了一个新的概念可以解决这个问题，mixin。Mixin 是一些方法的合集，可以被包含在 class 里，在这个 class 里可以直接用 mixin 里的方法。

module Doubler
  def double
    self + self # assume included in classes w/ +
  end
end
class String
  include Doubler
end
class Point
  attr_accessor :x, :y
  include Doubler
  def + other
    ans = Point.new
    ans.x = self.x + other.x
    ans.y = self.y + other.y
    ans
end

上例中，Doubler 是一个 Mixin 被用在了 String 和 Point 两个类里，使得两个类都有了 double 这个方法，然后在 class 里可以像 Point 里一样去实现 double 里的 + 方法，来相加两个 Point。再看一个例子：

# you define <=> and you get ==, >, <, >=, <= from the mixin
# (overrides Object's ==, adds the others)
class Name
  attr_accessor :first, :middle, :last
  include Comparable
  def initialize(first,last,middle="")
    @first = first
    @last = last
    @middle = middle
  end
  def <=> other
    l = @last <=> other.last # <=> defined on strings
    return l if l != 0
    f = @first <=> other.first
    return f if f != 0
    @middle <=> other.middle
  end
end

a = Name.new("Tom", "Li")
b = Name.new("Jame", "Chong")
a < b

include Comparable 把 ==, >, <, >=, <= 这些方法都包含进去了，在 Comparable 里用 <=> 这个方法返回的结果 -1, 0, 1 来决定 ``==, >, <, >=, <=` 这些返回 true 或者 false。

感觉是一个非常巧妙的做法，让代码的重用蹭蹭蹭往上涨。也很好的解决了在只有一个继承的情况下，怎么去扩展一个 class 的实现。

接口 Interface

接口 (Interface) 是另外一个 OOP 中非常重要的概念，在接口里可以定义一些方法，但是这些方法只有名称、参数类型还有返回类型，没有方法的实现。接口的实现由别的类来完成。

interface Example {
  void   m1(int x, int y);
  Object m2(Example x, String y);
}

class A implements Example {
  public void m1(int x, int y) {...}
  public Object m2(Example e, String s) {...}
}

class B implements Example {
  public void m1(int pizza, int beer) {...}
  public Object m2(Example e, String s) {...}
}

在这个例子中，class A 和 class B 分别实现了 接口 Example，可以看出接口的一个大的优势在于将实现和接口分离，可以很容易的更换实现，而不变接口，从客户端来说，只要知道接口是什么样的，不用管具体的实现。

像 Java 这类静态类型的语言，因为有类型检查，所以不像 Ruby 这种动态类型的语言那样灵活，Interface 的另一个优点是让这个语言有了更大的灵活性。这也是动态类型语言中没有 Interface 的原因之一，因为那些语言本身已经非常灵活了。

抽象方法 Abstract Methods

抽象方法 (Abstract Methods) 是由父类定义了一些没有实现的方法，具体实现由子类 (subclass) 去实现。

abstract class A {
  T1 m1(T2 x) { ... m2(e); ... }
  abstract T3 m2(T4 x);
}
class B extends A {
  T3 m2(T4 x) {
    ...
  }
}

上例中，父类 A 里定义了抽象方法 m2，只有参数类型和返回类型，所有继承了 A 的子类，都需要实现 m2，比如 class B。

抽象方法、接口还有多重继承，通常一门语言里不会都包括这三项。比如 C++ 中，只有抽象方法和多重继承，所以可以定义抽象类，让子类多重继承，抽象类的作用就有点像 interface。

子类型 SubTyping

先看两个类型定义：

1. (int, int, string)
2. (int, int)

在这例子中，1是2的子类型 (SubTyping)。如果一列类型通过省略掉其中零个或者几个类型和另一列类型一模一样，可以说这列类型是另一列类型的子类型。

子类型影响到的是静态类型中的类型检查，如果一个函数传入的参数是要求参数的子类型，类型检查该不该通过？

fun distToOrigin (p:{x:real,y:real}) = ...
fun makePurple (p:{color:string}) = ...
val c :{x:real,y:real,color:string} = {x=3.0, y=4.0, color="green"}
val _ = distToOrigin(c)
val _ = makePurple(c)

这是一个捏造的例子，distToOrigin(c)和makePurple(c)该不该报错呢？一门语言该不该接受子类型呢？要在什么样的程度接受子类型？

在 OOP 中，SubClass 的类型其实就是父类的子类型。在 Java 中，是支持子类型的传递，也支持一个 list 子类型的传递，但是会产生一些问题：

class Point { ... }
class ColorPoint extends Point { ... }
...
void m1(Point[] pt_arr) {
  pt_arr[0] = new Point(3,4);
}
String m2(int x) {
  ColorPoint[] cpt_arr = new ColorPoint[x];
  for(int i=0; i < x; i++)
     cpt_arr[i] = new ColorPoint(0,0,"green");
  m1(cpt_arr); // !
  return cpt_arr[0].color; // !
}

在这个例子中，m1(cpt_arr) 是能通过类型检查的，但是在 m1里 ColorPoint 被设置成了 Point，没了 color 这个 attribute，在 cpt_arr[0].color 中就会出错。Java 的处理方式是在虽然通过了类型检查，但是 run-time 自在pt_arr[0] = new Point(3,4) 报错 ArrayStoreException。

更加灵活的类型系统，需要更多更灵活的程序，但是同时能避免的错误也减少了。

另一个很有一些的是 null，在 Java 中本该不是对象，也没有任何的方法，但是却像是所有类型的"子类型"，任何对象类型都可以以 null 传入。

泛型 和 子类型

泛型 (Generics) 指的是能够接受任何类型。

class Pair<T1,T2> {
  T1 x;
  T2 y;
  Pair(T1 _x, T2 _y){ x = _x; y = _y; }
  Pair<T2,T1> swap() {
     return new Pair<T2,T1>(y,x);
  }
  ...
}

这里 T1 和 T2 可以是任何类型。在一些情况下，我们可能会要求一个类型是任何子类型的泛型。比如下面这个例子：

List<Point> inCircle(List<Point> pts, Point center, double r) { ... }

List<Point> result = new ArrayList<Point>();
for(Point pt: pts)
  if(pt.distance(center) <= r)
    result.add(pt);
return result;

inCircle 参数和返回的类型是 Point 的 List，如果我们有 Point 的子类 ColorPoint，就得把这个代码复制一遍。为了代码复用，也不能把 List 设置成泛型，因为如果 List 不是 Point 的子类会出问题。有没有办法能实现一个只允许子类型的泛型？这叫做 限定多态 (bounded polymorphism)

<T extends Pt> List<T> inCircle(List<T> pts, Pt center, double r) {
   List<T> result = new ArrayList<T>();
   for(T pt: pts)
     if(pt.distance(center) <= r)
       result.add(pt);
   return result;
}

这里，通过 <T extends Pt> 实现了限定多态。

总结

在这篇文章中，介绍了很多面向对象类语言的基础概念，比如方法/变量的可见性、子类、继承、接口、抽象方法等等。不是每一门语言都包括了所有的这些概念，这里应该也只介绍了多数，不能说所有的概念。但是如果你好好读了这篇文章，以后你在碰到任何一门面向对象的编程语言时，敢说一定有很多相似处，可以让你更快的上手那门语言。通过 子类，多重继承，Mixin，接口，抽象方法等的讨论，也能让你更好的理解那门语言的特性。

这篇文章是这个系列文章的最后一篇。三篇文章分别是对 Coursera Programming Languages 三个部分的总结，介绍了函数式编程和面向对象编程的一些基础概念。这个应该是目前学到的 Coursera 上最棒的课，帮助我深入了解了 函数式编程 和 面向对象编程，虽然平时一直是在面向对象编程，但是从编程语言这个角度去解读现在和以前用过的编程语言，还是学到了许多新内容，认识到了一门编程语言在设计的过程中，都有哪些取舍，能够进一步去思考为什么这么取舍，这么取舍导致了这门语言的什么特性？

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 206,126评论 6赞 481
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 88,254评论 2赞 382
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 152,445评论 0赞 341
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 55,185评论 1赞 278
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 64,178评论 5赞 371
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 48,970评论 1赞 284
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 38,276评论 3赞 399
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 36,927评论 0赞 259
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 43,400评论 1赞 300
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 35,883评论 2赞 323
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 37,997评论 1赞 333
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 33,646评论 4赞 322
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 39,213评论 3赞 307
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 30,204评论 0赞 19
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 31,423评论 1赞 260
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 45,423评论 2赞 352
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 42,722评论 2赞 345

推荐阅读更多精彩内容

  • 藏在尘埃里的日子
    找不到自己的世界，找不到自己存在的方式。像一条明明在水里的鱼，在寻找自己的池塘。 在与自己养成的不良顽疾做苦苦的挣...
    和和菁音阅读 304评论 0赞 0
  • 中国人的生活
    最后，我想就“生活的艺术”这一章谈谈自己的看法。纵观全书，我觉得这一部分是最接地气的一部分，它较为详细地描述了中...
    陨落的小白阅读 631评论 0赞 2
  • 锻炼身体好
    星期六的早上，阳光明媚，东东和兰兰在公园的大树下做早操，胸前的红领巾在太阳的照射下更加鲜艳了！
    65dac2cad152阅读 494评论 0赞 0