Merge pull request scala#1247 from dwijnand/rename-abstract-type-members-page

julienrf · web-flow · commit b2d69f9dd10a · 2018-12-20T09:02:30.000+01:00
Rename abstract type members page
diff --git a/_ba/tour/abstract-type-members.md b/_ba/tour/abstract-type-members.md
diff --git a/_ba/tour/compound-types.md b/_ba/tour/compound-types.md
@@ -9,7 +9,7 @@ partof: scala-tour
 
 num: 24
 next-page: self-types
-previous-page: abstract-types
+previous-page: abstract-type-members
 
 ---
 
@@ -56,4 +56,4 @@ def cloneAndReset(obj: Cloneable with Resetable): Cloneable = {
 Složeni tipovi mogu se sastojati od više tipova i mogu imati jednu rafinaciju koja može biti korištena da suzi potpis postojećih članova objekta.
 General forma je: `A with B with C ... { refinement }`
 
-Primjer za upotrebu rafinacije dat je na stranici o [apstraktnim tipovima](abstract-types.html). 
+Primjer za upotrebu rafinacije dat je na stranici o [apstraktnim tipovima](abstract-type-members.html). 
diff --git a/_ba/tour/inner-classes.md b/_ba/tour/inner-classes.md
@@ -8,7 +8,7 @@ discourse: true
 partof: scala-tour
 
 num: 22
-next-page: abstract-types
+next-page: abstract-type-members
 previous-page: lower-type-bounds
 
 ---
diff --git a/_ba/tour/tour-of-scala.md b/_ba/tour/tour-of-scala.md
@@ -45,7 +45,7 @@ Konkretno, sistem tipova podržava sljedeće:
 * [generičke klase](generic-classes.html)
 * [anotacije varijanse](variances.html)
 * [gornje](upper-type-bounds.html) i [donje](lower-type-bounds.html) granice tipa,
-* [unutarnje klase](inner-classes.html) i [apstraktne tipove](abstract-types.html) kao članove objekta
+* [unutarnje klase](inner-classes.html) i [apstraktne tipove](abstract-type-members.html) kao članove objekta
 * [složene tipove](compound-types.html)
 * [eksplicitno tipizirane samo-reference](self-types.html)
 * implicitne [parametre](implicit-parameters.html) i [konverzije](implicit-conversions.html)
diff --git a/_ba/tour/upper-type-bounds.md b/_ba/tour/upper-type-bounds.md
@@ -13,7 +13,7 @@ previous-page: variances
 
 ---
 
-U Scali, [tipski parametri](generic-classes.html) i [apstraktni tipovi](abstract-types.html) mogu biti ograničeni granicom tipa.
+U Scali, [tipski parametri](generic-classes.html) i [apstraktni tipovi](abstract-type-members.html) mogu biti ograničeni granicom tipa.
 Takve granice tipa ograničavaju konkretne vrijednosti tipskih varijabli i ponekad otkrivaju još informacija o članovima takvih tipova.
   _Gornja granica tipa_ `T <: A` kaže da se tipska varijabla `T` odnosi na podtip tipa `A`.
 Slijedi primjer koji demonstrira gornju granicu tipa za tipski parametar klase `PetContainer`:
diff --git a/_es/tour/abstract-type-members.md b/_es/tour/abstract-type-members.md
diff --git a/_es/tour/annotations.md b/_es/tour/annotations.md
@@ -10,7 +10,7 @@ num: 3
 language: es
 
 next-page: classes
-previous-page: abstract-types
+previous-page: abstract-type-members
 ---
 
 Las anotaciones sirven para asociar meta-información con definiciones.
diff --git a/_es/tour/compound-types.md b/_es/tour/compound-types.md
@@ -44,4 +44,4 @@ Los tipos compuestos pueden crearse a partir de varios tipos de objeto y pueden
 
 La forma general es: `A with B with C ... { refinamiento }`
 
-Un ejemplo del uso de los refinamientos se muestra en la página sobre [tipos abstractos](abstract-types.html).
+Un ejemplo del uso de los refinamientos se muestra en la página sobre [tipos abstractos](abstract-type-members.html).
diff --git a/_es/tour/self-types.md b/_es/tour/self-types.md
@@ -28,7 +28,7 @@ Aquí hay una definición que sirve para describir un grafo:
       def agregarNodo: Nodo
     }
 
-Los grafos consisten de una lista de nodos y vértices (o aristas en alguna bibliografía) donde tanto el tipo nodo, como el vértice fueron declarados abstractos. El uso de [tipos abstractos](abstract-types.html) permite las implementaciones del trait `Grafo` proveer sus propias clases concretas para nodos y vértices. Además, existe un método `agregarNodo` para agregar nuevos nodos al grafo. Los nodos se conectan entre sí utilizando el método `conectarCon`.
+Los grafos consisten de una lista de nodos y vértices (o aristas en alguna bibliografía) donde tanto el tipo nodo, como el vértice fueron declarados abstractos. El uso de [tipos abstractos](abstract-type-members.html) permite las implementaciones del trait `Grafo` proveer sus propias clases concretas para nodos y vértices. Además, existe un método `agregarNodo` para agregar nuevos nodos al grafo. Los nodos se conectan entre sí utilizando el método `conectarCon`.
 
 Una posible implementación de la clase `Grafo`es dada en el siguiente programa:
 
diff --git a/_es/tour/tour-of-scala.md b/_es/tour/tour-of-scala.md
@@ -9,7 +9,7 @@ partof: scala-tour
 num: 1
 language: es
 
-next-page: abstract-types
+next-page: abstract-type-members
 ---
 
 Scala es un lenguaje de programación moderno multi-paradigma diseñado para expresar patrones de programación comunes de una forma concisa, elegante, y de tipado seguro. Integra fácilmente características de lenguajes orientados a objetos y funcionales.
@@ -27,7 +27,7 @@ Scala cuenta con un expresivo sistema de tipado que fuerza estáticamente las ab
 * [Clases genéricas](generic-classes.html)
 * [anotaciones variables](variances.html),
 * límites de tipado [superiores](upper-type-bounds.html) e [inferiores](lower-type-bounds.html),
-* [clases internas](inner-classes.html) y [tipos abstractos](abstract-types.html) como miembros de objetos,
+* [clases internas](inner-classes.html) y [tipos abstractos](abstract-type-members.html) como miembros de objetos,
 * [tipos compuestos](compound-types.html)
 * [auto-referencias explicitamente tipadas](self-types.html)
 * [implicit conversions](implicit-conversions.html)
diff --git a/_es/tour/upper-type-bounds.md b/_es/tour/upper-type-bounds.md
@@ -13,7 +13,7 @@ next-page: lower-type-bounds
 previous-page: traits
 ---
 
-En Scala, los [parámetros de tipo](generic-classes.html) y los [tipos abstractos](abstract-types.html) pueden ser restringidos por un límite de tipado. Tales límites de tipado limitan los valores concretos de las variables de tipo y posiblemente revelan más información acerca de los miembros de tales tipos. Un _límite de tipado superior_ `T <: A` declara que la variable de tipo `T` es un subtipo del tipo `A`.
+En Scala, los [parámetros de tipo](generic-classes.html) y los [tipos abstractos](abstract-type-members.html) pueden ser restringidos por un límite de tipado. Tales límites de tipado limitan los valores concretos de las variables de tipo y posiblemente revelan más información acerca de los miembros de tales tipos. Un _límite de tipado superior_ `T <: A` declara que la variable de tipo `T` es un subtipo del tipo `A`.
 Aquí se muestra un ejemplo el cual se basa en un límite de tipado superior para la implementación del método polimórfico `findSimilar`:
 
     trait Similar {
diff --git a/_ko/tour/abstract-type-members.md b/_ko/tour/abstract-type-members.md
diff --git a/_ko/tour/compound-types.md b/_ko/tour/compound-types.md
@@ -10,7 +10,7 @@ num: 23
 language: ko
 
 next-page: self-types
-previous-page: abstract-types
+previous-page: abstract-type-members
 ---
 
 때론 객체의 타입을 여러 다른 타입의 서브타입으로 표현해야 할 때가 있다. 스칼라에선 *합성 타입(Compound Types)*으로 표현될 수 있는데, 이는 객체 타입들의 교차점을 의미한다.
@@ -44,6 +44,6 @@ previous-page: abstract-types
 
 합성 타입은 여러 객체 타입으로 구성될 수 있고, 단일 리파인먼트를 가짐으로써 객체 멤버의 시그니처의 범위를 좁힐 수도 있다. 일반적인 형태는 `A with B with C ... { 리파인먼트 }`이다.
 
-리파인먼트 사용 예제는 [추상 타입](abstract-types.html) 에 있다.  
+리파인먼트 사용 예제는 [추상 타입](abstract-type-members.html) 에 있다.  
 
 윤창석, 이한욱 옮김, 고광현 수정
diff --git a/_ko/tour/inner-classes.md b/_ko/tour/inner-classes.md
@@ -9,7 +9,7 @@ partof: scala-tour
 num: 21
 language: ko
 
-next-page: abstract-types
+next-page: abstract-type-members
 previous-page: lower-type-bounds
 ---
 
diff --git a/_ko/tour/self-types.md b/_ko/tour/self-types.md
@@ -28,7 +28,7 @@ previous-page: compound-types
       def addNode: Node
     }
 
-그래프는 노드와 엣지의 리스트로 구성되며, 노드와 엣지의 타입은 모두 추상적으로 남겨뒀다. [추상 타입](abstract-types.html)을 사용해서 트레잇 Graph를 구현할 수 있도록 했고, 이를 통해 노드와 엣지에 해당하는 자신의 콘크리트 클래스를 만들 수 있다. 뿐만 아니라 `addNode`라는 메소드는 그래프에 새로운 노드를 추가해준다. 메소드 `connectWith`를 사용해 노드를 연결한다.
+그래프는 노드와 엣지의 리스트로 구성되며, 노드와 엣지의 타입은 모두 추상적으로 남겨뒀다. [추상 타입](abstract-type-members.html)을 사용해서 트레잇 Graph를 구현할 수 있도록 했고, 이를 통해 노드와 엣지에 해당하는 자신의 콘크리트 클래스를 만들 수 있다. 뿐만 아니라 `addNode`라는 메소드는 그래프에 새로운 노드를 추가해준다. 메소드 `connectWith`를 사용해 노드를 연결한다.
 
 다음 클래스는 클래스 `Graph`를 구현하는 한 예다.
 
diff --git a/_ko/tour/tour-of-scala.md b/_ko/tour/tour-of-scala.md
@@ -28,7 +28,7 @@ next-page: basics
 * [제네릭 클래스](generic-classes.html)
 * [가변성 어노테이션](variances.html)
 * [상위 타입 경계](upper-type-bounds.html)와 [하위 타입 경계](lower-type-bounds.html)
-* 객체 멤버로써의 [내부 클래스](inner-classes.html)와 [추상 타입](abstract-types.html)
+* 객체 멤버로써의 [내부 클래스](inner-classes.html)와 [추상 타입](abstract-type-members.html)
 * [합성 타입](compound-types.html)
 * [명시적으로 타입이 지정된 자기 참조](self-types.html)
 * 뷰
diff --git a/_ko/tour/upper-type-bounds.md b/_ko/tour/upper-type-bounds.md
@@ -13,7 +13,7 @@ next-page: lower-type-bounds
 previous-page: variances
 ---
 
-스칼라에선 [타입 파라미터](generic-classes.html) 와 [추상 타입](abstract-types.html)의 타입 경계를 제한할 수 있다. 이런 타입 경계는 타입 변수의 콘크리트 값을 제한하고, 해당 타입의 멤버에 관한 정보를 추가할 수도 있다. _상위 타입 경계_ `T <: A`는 타입 변수 `T`를 선언하면서 서브타입 `A`를 참조하고 있다. 다음은 다형성 메소드 `findSimilar`의 구현을 위해 상위 타입 경계를 사용한 예제다.
+스칼라에선 [타입 파라미터](generic-classes.html) 와 [추상 타입](abstract-type-members.html)의 타입 경계를 제한할 수 있다. 이런 타입 경계는 타입 변수의 콘크리트 값을 제한하고, 해당 타입의 멤버에 관한 정보를 추가할 수도 있다. _상위 타입 경계_ `T <: A`는 타입 변수 `T`를 선언하면서 서브타입 `A`를 참조하고 있다. 다음은 다형성 메소드 `findSimilar`의 구현을 위해 상위 타입 경계를 사용한 예제다.
 
     trait Similar {
       def isSimilar(x: Any): Boolean
diff --git a/_pl/tour/abstract-type-members.md b/_pl/tour/abstract-type-members.md
diff --git a/_pl/tour/compound-types.md b/_pl/tour/compound-types.md
@@ -9,7 +9,7 @@ partof: scala-tour
 num: 23
 language: pl
 next-page: self-types
-previous-page: abstract-types
+previous-page: abstract-type-members
 ---
 
 Czasami konieczne jest wyrażenie, że dany typ jest podtypem kilku innych typów. W Scali wyraża się to za pomocą *typów złożonych*, które są częścią wspólną typów obiektów.
@@ -50,4 +50,4 @@ def cloneAndReset(obj: Cloneable with Resetable): Cloneable = {
 Typy złożone mogą składać się z kilku typów obiektów i mogą mieć tylko jedno wyrafinowanie, które może być użyte do zawężenia sygnatury istniejących elementów obiektu.
 Przyjmują one postać: `A with B with C ... { wyrafinowanie }`
 
-Przykład użycia wyrafinowania typów jest pokazany na stronie o [typach abstrakcyjnych](abstract-types.html).
+Przykład użycia wyrafinowania typów jest pokazany na stronie o [typach abstrakcyjnych](abstract-type-members.html).
diff --git a/_pl/tour/inner-classes.md b/_pl/tour/inner-classes.md
@@ -8,7 +8,7 @@ partof: scala-tour
 
 num: 21
 language: pl
-next-page: abstract-types
+next-page: abstract-type-members
 previous-page: lower-type-bounds
 ---
 
diff --git a/_pl/tour/self-types.md b/_pl/tour/self-types.md
@@ -29,7 +29,7 @@ abstract class Graph {
 }
 ```
 
-Grafy składają się z listy węzłów oraz krawędzi, gdzie zarówno typ węzła jak i krawędzi jest abstrakcyjny. Użycie [typów abstrakcyjnych](abstract-types.html) pozwala implementacjom cechy `Graph` na to, by określały swoje konkretne klasy dla węzłów i krawędzi. Ponadto graf zawiera metodę `addNode`, której celem jest dodanie nowych węzłów do grafu. Węzły są połączone z użyciem metody `connectWith`.
+Grafy składają się z listy węzłów oraz krawędzi, gdzie zarówno typ węzła jak i krawędzi jest abstrakcyjny. Użycie [typów abstrakcyjnych](abstract-type-members.html) pozwala implementacjom cechy `Graph` na to, by określały swoje konkretne klasy dla węzłów i krawędzi. Ponadto graf zawiera metodę `addNode`, której celem jest dodanie nowych węzłów do grafu. Węzły są połączone z użyciem metody `connectWith`.
 
 Przykład implementacji klasy `Graph`:
 
diff --git a/_pl/tour/tour-of-scala.md b/_pl/tour/tour-of-scala.md
@@ -42,7 +42,7 @@ W szczególności system typów wspiera:
 * [klasy generyczne](generic-classes.html),
 * [adnotacje wariancji](variances.html),
 * [górne](upper-type-bounds.html) oraz [dolne](lower-type-bounds.html) ograniczenia typów,
-* [klasy zagnieżdżone](inner-classes.html) i [typy abstrakcyjne](abstract-types.html) jako elementy obiektów,
+* [klasy zagnieżdżone](inner-classes.html) i [typy abstrakcyjne](abstract-type-members.html) jako elementy obiektów,
 * [typy złożone](compound-types.html),
 * [jawnie typowane samoreferencje](self-types.html),
 * [parametry domniemane](implicit-parameters.html) i [konwersje niejawne](implicit-conversions.html),
diff --git a/_pl/tour/upper-type-bounds.md b/_pl/tour/upper-type-bounds.md
@@ -12,7 +12,7 @@ next-page: lower-type-bounds
 previous-page: variances
 ---
 
-W Scali [parametry typów](generic-classes.html) oraz [typy abstrakcyjne](abstract-types.html) mogą być warunkowane przez ograniczenia typów. Tego rodzaju ograniczenia pomagają określić konkretne wartości zmiennych typu oraz odkryć więcej informacji na temat elementów tych typów. _Ograniczenie górne typu_ `T <: A` zakładają, że zmienna `T` jest podtypem typu `A`.
+W Scali [parametry typów](generic-classes.html) oraz [typy abstrakcyjne](abstract-type-members.html) mogą być warunkowane przez ograniczenia typów. Tego rodzaju ograniczenia pomagają określić konkretne wartości zmiennych typu oraz odkryć więcej informacji na temat elementów tych typów. _Ograniczenie górne typu_ `T <: A` zakładają, że zmienna `T` jest podtypem typu `A`.
 
 Poniższy przykład demonstruje zastosowanie ograniczeń górnych typu dla parametru typu klasy `Cage`:
 
diff --git a/_pt-br/tour/abstract-type-members.md b/_pt-br/tour/abstract-type-members.md
diff --git a/_pt-br/tour/compound-types.md b/_pt-br/tour/compound-types.md
@@ -8,7 +8,7 @@ partof: scala-tour
 
 num: 23
 next-page: self-types
-previous-page: abstract-types
+previous-page: abstract-type-members
 language: pt-br
 ---
 
@@ -51,4 +51,4 @@ Os tipos de compostos podem consistir em vários tipos de objeto e eles podem te
 
 A forma geral é: `A with B with C ... { refinamento }`
 
-Um exemplo para o uso de refinamentos é dado na página sobre [tipos abstratos](abstract-types.html). 
+Um exemplo para o uso de refinamentos é dado na página sobre [tipos abstratos](abstract-type-members.html). 
diff --git a/_pt-br/tour/inner-classes.md b/_pt-br/tour/inner-classes.md
@@ -7,7 +7,7 @@ discourse: false
 partof: scala-tour
 
 num: 21
-next-page: abstract-types
+next-page: abstract-type-members
 previous-page: lower-type-bounds
 language: pt-br
 ---
diff --git a/_pt-br/tour/self-types.md b/_pt-br/tour/self-types.md
@@ -29,7 +29,7 @@ abstract class Graph {
 }
 ```
 
-Um grafo consiste em uma lista de nós e arestas onde o nó e o tipo de aresta são declarados como abstratos. O uso de [tipos abstratos](abstract-types.html) permite que a implementação da trait `Graph` forneça suas próprias classes concretas para nós e arestas. Além disso, existe um método `addNode` para adicionar novos nós a um grafo. Os nós são conectados usando o método `connectWith`.
+Um grafo consiste em uma lista de nós e arestas onde o nó e o tipo de aresta são declarados como abstratos. O uso de [tipos abstratos](abstract-type-members.html) permite que a implementação da trait `Graph` forneça suas próprias classes concretas para nós e arestas. Além disso, existe um método `addNode` para adicionar novos nós a um grafo. Os nós são conectados usando o método `connectWith`.
 
 Uma possível implementação de `Graph` é ilustrada na classe a seguir:
 
diff --git a/_pt-br/tour/tour-of-scala.md b/_pt-br/tour/tour-of-scala.md
@@ -28,7 +28,7 @@ Scala é equipada com um expressivo sistema de tipos que reforça estaticamente
 * [Classes genéricas](generic-classes.html)
 * [Anotações variáveis](variances.html)
 * [Limites de tipos superiores](upper-type-bounds.html) e [limites de tipos inferiores](lower-type-bounds.html),
-* [Classes internas](inner-classes.html) e [tipos abstratos](abstract-types.html) como membros de um objeto
+* [Classes internas](inner-classes.html) e [tipos abstratos](abstract-type-members.html) como membros de um objeto
 * [Tipos compostos](compound-types.html)
 * [Auto referências explicitamente tipadas](self-types.html)
 * [parâmetros implícitos](implicit-parameters.html) e [conversões implícitas](implicit-conversions.html)
diff --git a/_pt-br/tour/upper-type-bounds.md b/_pt-br/tour/upper-type-bounds.md
@@ -12,7 +12,7 @@ previous-page: variances
 language: pt-br
 ---
 
-Em Scala, [parâmetros de tipos](generic-classes.html) e [tipos abstratos](abstract-types.html) podem ser restringidos por um limitante de tipo. Tal limitante de tipo limita os valores concretos de uma variável de tipo e possivelmente revela mais informações sobre os membros de determinados tipos. Um _limitante superiror de tipos_ `T <: A` declare que a variável tipo `T` refere-se a um subtipo do tipo `A`.
+Em Scala, [parâmetros de tipos](generic-classes.html) e [tipos abstratos](abstract-type-members.html) podem ser restringidos por um limitante de tipo. Tal limitante de tipo limita os valores concretos de uma variável de tipo e possivelmente revela mais informações sobre os membros de determinados tipos. Um _limitante superiror de tipos_ `T <: A` declare que a variável tipo `T` refere-se a um subtipo do tipo `A`.
 Aqui um exemplo que demonstra um limitante superior de tipo para um parâmetro de tipo da classe `Cage`:
 
 ```tut
diff --git a/_th/tour/abstract-type-members.md b/_th/tour/abstract-type-members.md
@@ -1,6 +1,6 @@
 ---
 layout: tour
-title: Abstract Types
+title: Abstract Type Members
 
 discourse: false
 
diff --git a/_th/tour/compound-types.md b/_th/tour/compound-types.md
@@ -11,5 +11,5 @@ num: 22
 language: th
 
 next-page: self-types
-previous-page: abstract-types
+previous-page: abstract-type-members
 ---
diff --git a/_th/tour/inner-classes.md b/_th/tour/inner-classes.md
@@ -10,6 +10,6 @@ num: 20
 
 language: th
 
-next-page: abstract-types
+next-page: abstract-type-members
 previous-page: lower-type-bounds
 ---
diff --git a/_th/tour/tour-of-scala.md b/_th/tour/tour-of-scala.md
@@ -35,7 +35,7 @@ Scala เป็นระบบที่มีลักษณะของชน
 * [คลาสทั่วไป](generic-classes.html)
 * [คำอธิบายประกอบผันแปร](variances.html)
 * ขอบเขตชนิดข้อมูล [ข้างบน](upper-type-bounds.html) และ [ข้างล่าง](lower-type-bounds.html)
-* [คลาสภายใน](inner-classes.html) และ [ชนิดข้อมูลนามธรรม](abstract-types.html) เป็นสมาชิกของวัตถุ
+* [คลาสภายใน](inner-classes.html) และ [ชนิดข้อมูลนามธรรม](abstract-type-members.html) เป็นสมาชิกของวัตถุ
 * [ชนิดข้อมูลผสม](compound-types.html)
 * [อ้างอิงตัวเองของชนิดข้อมูลอย่างชัดเจน](self-types.html)
 * [พารามิเตอร์ปริยาย](implicit-parameters.html) และ [การเปลี่ยนปริยาย](implicit-conversions.html)
diff --git a/_tour/abstract-type-members.md b/_tour/abstract-type-members.md
@@ -1,20 +1,23 @@
 ---
 layout: tour
-title: Abstract Types
+title: Abstract Type Members
 
 discourse: true
 
 partof: scala-tour
 num: 23
 next-page: compound-types
 previous-page: inner-classes
-topics: abstract types
+topics: abstract type members
 prerequisite-knowledge: variance, upper-type-bound
 
 redirect_from: "/tutorials/tour/abstract-types.html"
+redirect_from: "/tour/abstract-types.html"
 ---
 
-Traits and abstract classes can have an abstract type member. This means that the concrete implementations define the actual type. Here's an example:
+Abstract types, such as traits and abstract classes, can in turn have abstract type members.
+This means that the concrete implementations define the actual types.
+Here's an example:
 
 ```tut
 trait Buffer {
diff --git a/_tour/compound-types.md b/_tour/compound-types.md
@@ -8,7 +8,7 @@ partof: scala-tour
 
 num: 24
 next-page: self-types
-previous-page: abstract-types
+previous-page: abstract-type-members
 
 redirect_from: "/tutorials/tour/compound-types.html"
 ---
diff --git a/_tour/inner-classes.md b/_tour/inner-classes.md
@@ -7,7 +7,7 @@ discourse: true
 partof: scala-tour
 
 num: 22
-next-page: abstract-types
+next-page: abstract-type-members
 previous-page: lower-type-bounds
 
 redirect_from: "/tutorials/tour/inner-classes.html"
diff --git a/_tour/tour-of-scala.md b/_tour/tour-of-scala.md
@@ -38,7 +38,7 @@ Scala is equipped with an expressive type system that enforces statically that a
 * [generic classes](generic-classes.html)
 * [variance annotations](variances.html)
 * [upper](upper-type-bounds.html) and [lower](lower-type-bounds.html) type bounds,
-* [inner classes](inner-classes.html) and [abstract types](abstract-types.html) as object members
+* [inner classes](inner-classes.html) and [abstract type members](abstract-type-members.html) as object members
 * [compound types](compound-types.html)
 * [explicitly typed self references](self-types.html)
 * [implicit parameters](implicit-parameters.html) and [conversions](implicit-conversions.html)
diff --git a/_tour/upper-type-bounds.md b/_tour/upper-type-bounds.md
diff --git a/_zh-cn/tour/abstract-type-members.md b/_zh-cn/tour/abstract-type-members.md
diff --git a/_zh-cn/tour/compound-types.md b/_zh-cn/tour/compound-types.md
diff --git a/_zh-cn/tour/inner-classes.md b/_zh-cn/tour/inner-classes.md
diff --git a/_zh-cn/tour/tour-of-scala.md b/_zh-cn/tour/tour-of-scala.md
diff --git a/_zh-cn/tour/upper-type-bounds.md b/_zh-cn/tour/upper-type-bounds.md

Original file line number	Diff line number	Diff line change
`@@ -44,4 +44,4 @@ Los tipos compuestos pueden crearse a partir de varios tipos de objeto y pueden`
`44`	`44`
`45`	`45`	La forma general es: `A with B with C ... { refinamiento }`
`46`	`46`
`47`		`-Un ejemplo del uso de los refinamientos se muestra en la página sobre [tipos abstractos](abstract-types.html).`
	`47`	`+Un ejemplo del uso de los refinamientos se muestra en la página sobre [tipos abstractos](abstract-type-members.html).`
Original file line number	Diff line number	Diff line change
`@@ -28,7 +28,7 @@ Aquí hay una definición que sirve para describir un grafo:`
`28`	`28`	`def agregarNodo: Nodo`
`29`	`29`	`}`
`30`	`30`
`31`		-Los grafos consisten de una lista de nodos y vértices (o aristas en alguna bibliografía) donde tanto el tipo nodo, como el vértice fueron declarados abstractos. El uso de [tipos abstractos](abstract-types.html) permite las implementaciones del trait `Grafo` proveer sus propias clases concretas para nodos y vértices. Además, existe un método `agregarNodo` para agregar nuevos nodos al grafo. Los nodos se conectan entre sí utilizando el método `conectarCon`.
	`31`	+Los grafos consisten de una lista de nodos y vértices (o aristas en alguna bibliografía) donde tanto el tipo nodo, como el vértice fueron declarados abstractos. El uso de [tipos abstractos](abstract-type-members.html) permite las implementaciones del trait `Grafo` proveer sus propias clases concretas para nodos y vértices. Además, existe un método `agregarNodo` para agregar nuevos nodos al grafo. Los nodos se conectan entre sí utilizando el método `conectarCon`.
`32`	`32`
`33`	`33`	Una posible implementación de la clase `Grafo`es dada en el siguiente programa:
`34`	`34`