anchor.diff:  a(id="parent-token")
   :marked
     ### The *Parent* class-interface
  -  ### *父级*类-接口
  +  
  +  ### *Parent*类-接口
  +  
     We [learned earlier](#class-interface) that a *class-interface* is an abstract class used as an interface rather than as a base class.
     
  -  我们[之前学到](#class-interface)：一个*类-接口*是一个抽象类，被当做一个接口来使用，而非被当做基本类使用。
  +  我们[之前学到](#class-interface)：*类-接口*是一个抽象类，被当做一个接口来使用，而非被当做基础类使用。
   
     Our example defines a `Parent` *class-interface* .
     
     我们的例子定义了一个`Parent`*类-接口*。
  +  
   +makeExample('cb-dependency-injection/ts/app/parent-finder.component.ts','parent','parent-finder.component.ts (Parent class-interface)')(format='.')
   :marked
     The `Parent` *class-interface* defines a `name` property with a type declaration but *no implementation*., 
     The `name` property is the only member of a parent component that a child component can call.
     Such a narrowing interface helps decouple the child component class from its parent components.
  -  
  -  该`Parent` *类-接口*定义了一个`Name`属性，它有一个类型声明，但是*没有实现*，该`name`是该父级组件的子级组件们唯一能调用的属性。
  + 
  +  该`Parent` *类-接口*定义了`Name`属性，它有类型声明，但是*没有实施*，该`name`是该父级的所有子级组件们唯一能调用的属性。
     这样一个窄的接口帮助分离子级类和它的父级组件。
     
     A component that could serve as a parent *should* implement the *class-interface* as the `AliceComponent` does:
     
     一个能当做父级的组件*应该*实现*类-接口*，和下面的`AliceComponent`的做法一样：
  +  
   +makeExample('cb-dependency-injection/ts/app/parent-finder.component.ts','alice-class-signature','parent-finder.component.ts (AliceComponent class signature)')(format='.')
   :marked
     Doing so adds clarity to the code.  But it's not technically necessary. 
     Although the `AlexComponent` has a `name` property (as required by its `Base` class) 
     its class signature doesn't mention `Parent`:
     
  -  这样做增加了代码的清晰度。但是技术并不一定需要它。虽然`AlexComponent`有一个`name`属性(被他的`基本`类要求)，它的类签名并不提及`Parent`。
  +  这样做增加了代码的清晰度。但是在技术上，我们并不一定需要它。虽然`AlexComponent`有一个`name`属性(被它的`基础`类要求)，它的类签名并不提及`Parent`。
  +  
   +makeExample('cb-dependency-injection/ts/app/parent-finder.component.ts','alex-class-signature','parent-finder.component.ts (AlexComponent class signature)')(format='.')
   .l-sub-section
     :marked
       The `AlexComponent` *should* implement `Parent` as a matter of proper style. 
       It doesn't in this example *only* to demonstrate that the code will compile and run without the interface 
       
  -    为了正确的代码风格，该`AlexComponent`*应该*实现`Parent`。在这个例子里面它不这样，仅仅是为了演示在没有该接口的情况下，该代码会被编译并执行。
  +    为了正确的代码风格，该`AlexComponent`*应该*实现`Parent`。在这个例子里面它不这样，仅仅是为了演示在没有该接口的情况下，该代码会被编译并运行。
       
   a(id="provideparent")
   :marked
     ### A *provideParent* helper function
  -  ### 一个*privdeParent*帮助函数
  +  
  +  ### *provideParent*助手函数
     
     Writing variations of the same parent *alias provider* gets old quickly, 
     especially this awful mouthful with a [*forwardRef*](#forwardref): 
     
  -  编写同一个父级的各种*别名供应商*很快就变得很啰嗦，在用[*forwardRef](#forwardRef)的时候尤其绕口：
  +  编写同一个父级的各种*别名供应商*很快就会变得很啰嗦，在用[*forwardRef](#forwardRef)的时候尤其绕口：
  +  
   +makeExample('cb-dependency-injection/ts/app/parent-finder.component.ts','alex-providers')(format='.')
   :marked
     We can extract that logic into a helper function like this:
     
  -  我们可以像这样把这个逻辑提取到一个帮助函数里面：
  +  我们可以像这样把这个逻辑提取到一个助手函数里面：
  +  
   +makeExample('cb-dependency-injection/ts/app/parent-finder.component.ts','provide-the-parent')(format='.')
   :marked
     Now we can add a simpler, more meaningful parent provider to our components:
     
     现在我们就可以为我们的组件添加一个简单点的，更加直观的父级供应商：
  +  
   +makeExample('cb-dependency-injection/ts/app/parent-finder.component.ts','alice-providers')(format='.')
   :marked
     We can do better. The current version of the helper function can only alias the `Parent` *class-interface*.
     Our application might have a variety of parent types, each with its own *class-interface* token.
     
  -  我们可以做的更好。当前版本的帮助函数只能为`父级`*类-接口*提供别名。我们的应用程序可能有很多类型的父级，每个父级有自己的*类-接口*令牌。
  +  我们可以做的更好。当前版本的助手函数只能为`Parent`*类-接口*提供别名。我们的应用程序可能有很多类型的父级，每个父级有自己的*类-接口*令牌。
     
     Here's a revised version that defaults to `parent` but also accepts an optional second parameter for a different parent *class-interface*.
     
  -  这里是一个修改版本，默认接受一个`父级`，但是同时接受一个可选的第二个参数，可以用来指定一个不同的父级*类-接口*。
  +  这里是一个修改版本，默认接受一个`Parent`，但是同时接受一个可选的第二个参数，可以用来指定一个不同的父级*类-接口*。
  +  
   +makeExample('cb-dependency-injection/ts/app/parent-finder.component.ts','provide-parent')(format='.')
   :marked
     And here's how we could use it with a different parent type:
     
     下面是我们如何使用它添加一个不同类型的父级：
  +  
   +makeExample('cb-dependency-injection/ts/app/parent-finder.component.ts','beth-providers')(format='.')
   :marked
   
  
positive.code:   The key benefit of a *class-interface* is that we can get the strong-typing of an interface
    and we can ***use it as a provider token*** in the same manner as a normal class.
    
    我们称这种用法的类叫做*类-接口*。它关键的好处是一个*类-接口*给我们提供了一个接口的强类型，同时，我们能想正常类一样***使用它作为一个供应商令牌***。
    
    A ***class-interface*** should define *only* the members that its consumers are allowed to call.
    Such a narrowing interface helps decouple the concrete class from its consumers.
    The `MinimalLogger` defines just two of the `LoggerClass` members.
    
    一个***类-接口***应该*只*定义它的消费者容许调用的成员。这样一个窄的接口帮助我们分离该类的具体类实例和他的消费者。
    该`MinimalLogger`只定义了两个`LoggerClass`的成员。
  
  .l-sub-section
    :marked
      #### Why *MinimalLogger* is a class and not an interface
      We can't use an interface as a provider token because 
      interfaces are not JavaScript objects. 
      They exist only in the TypeScript design space. 
      They disappear after the code is transpiled to JavaScript.
      
      ### 为什么*MinimalLogger*是一个类而不是一个接口？因为我们不能把一个接口当做一个供应商的令牌，因为接口不是JavaScript对象。
      它们只存在在TypeScript的设计空间里。它们会在被编译到JavaScript之后消失。
      
      A provider token must be a real JavaScript object of some kind: 
  
negative.code:   The `MinimalLogger` is an abstract class. 
    
    该`MinimalLogger`是一个抽象类。
    
  +makeExample('cb-dependency-injection/ts/app/date-logger.service.ts','minimal-logger')(format='.')   
  :marked
    We usually inherit from an abstract class.
  