Kotlinの公式リファレンスを日本語化してみた[前編]

皆さんこんにちは。ドワンゴ新卒1年目のdogwood008と申します。業務でAndroidアプリの作成に携わることがあり、その際にKotlinに初めて触れ、その可能性に惹かれてKotlinを好きになりました。

そこで、公式リファレンスを日本語化してみました。Kotlinがどんなものなのか、参考になれば幸いです（ちょっと長いので分けて投稿します（[Kotlinの公式リファレンスを日本語化してみた[後編]](http://qiita.com/dogwood008/items/f4ceabd0b0d801fb3a9f)）。また翻訳に着手中のページもあるので、まだ英語のページもあります）。

**[日本語版Kotlinリファレンス](http://dogwood008.github.io/kotlin-web-site-ja/docs/reference/)**

基本的には上記ページの内容と、本ページの内容は同じです。個別のページで見たい人用と、一覧で見たい人用です。

他にも、以下のページ等でKotlinが紹介されています。参考にして下さい。

- [今からKotlin](http://qiita.com/koki_cheese/items/bc68a4c765cd1f00c0d9)
- [Android開発を受注したからKotlinをガッツリ使ってみたら最高だった](http://qiita.com/omochimetaru/items/98e015b0b694dd97f323)
- [
プログラミング言語Kotlin 解説](https://sites.google.com/site/tarokotlin/home)

※2016/12/14追記
文体をですます調に変更し、全ての翻訳を見直しました。

---

# 基本的な構文

<!--original
# Basic Syntax
-->

## パッケージの定義

<!--original
## Defining packages
-->

パッケージの記述は、ソースファイルの先頭に置かなければなりません。

<!--original
Package specification should be at the top of the source file:
-->

``` kotlin
package my.demo

import java.util.*

// ...
```

<!--original
``` kotlin
package my.demo

import java.util.*

// ...
```
-->

ディレクトリとパッケージと一致する必要はありません。ソースファイルは、ファイルシステム内の任意の場所に配置することができます。

<!--original
It is not required to match directories and packages: source files can be placed arbitrarily in the file system.
-->

[パッケージ](packages.html)を参照してください。

<!--original
See [Packages](packages.html).
-->

## 関数の定義

<!--original
## Defining functions
-->

2つの`Int`型の引数を持ち、`Int`型を戻り値とする関数：

<!--original
Function having two `Int` parameters with `Int` return type:
-->

``` kotlin
fun sum(a: Int, b: Int): Int {
  return a + b
}
```

<!--original
``` kotlin
fun sum(a: Int, b: Int): Int {
  return a + b
}
```
-->

式本体と推論された戻り値の型を持つ関数：

<!--original
Function with an expression body and inferred return type:
-->

``` kotlin
fun sum(a: Int, b: Int) = a + b
```

<!--original
``` kotlin
fun sum(a: Int, b: Int) = a + b
```
-->

意味のある値を返さない関数：

<!--original
Function returning no meaningful value:
-->

``` kotlin
fun printSum(a: Int, b: Int): Unit {
  print(a + b)
}
```

<!--original
``` kotlin
fun printSum(a: Int, b: Int): Unit {
  print(a + b)
}
```
-->

`Unit`型の戻り値は省略できます：

<!--original
`Unit` return type can be omitted:
-->

``` kotlin
fun printSum(a: Int, b: Int) {
  print(a + b)
}
```

<!--original
``` kotlin
fun printSum(a: Int, b: Int) {
  print(a + b)
}
```
-->

[関数](functions.html)を参照してください。

<!--original
See [Functions](functions.html).
-->

## ローカル変数の定義

<!--original
## Defining local variables
-->

1度だけ代入できる（読み取り専用）ローカル変数：

<!--original
Assign-once (read-only) local variable:
-->

``` kotlin
val a: Int = 1
val b = 1   // `Int`型が推論される
val c: Int  // 初期値が与えられない場合、型指定が必要
c = 1       // 明確な代入
```

<!--original
``` kotlin
val a: Int = 1
val b = 1   // `Int` type is inferred
val c: Int  // Type required when no initializer is provided
c = 1       // definite assignment
```
-->

変更可能 (Mutable) な変数：

<!--original
Mutable variable:
-->

``` kotlin
var x = 5 // `Int`型が推論される
x += 1
```

<!--original
``` kotlin
var x = 5 // `Int` type is inferred
x += 1
```
-->

[プロパティとフィールド](properties.html)も参照してください。

<!--original
See also [Properties And Fields](properties.html).
-->


## コメント

<!--original
## Comments
-->

JavaとJavaScriptのように、Kotlinは行末コメントとブロックコメントをサポートしています。

<!--original
Just like Java and JavaScript, Kotlin supports end-of-line and block comments.
-->

``` kotlin
// これは行末コメントです

/* これは複数行にわたる
   ブロックコメントです。 */
```

<!--original
``` kotlin
// This is an end-of-line comment

/* This is a block comment
   on multiple lines. */
```
-->

Javaとは異なり、Kotlinのブロックコメントは入れ子にすることができます。

<!--original
Unlike Java, block comments in Kotlin can be nested.
-->

ドキュメンテーションコメントの構文の詳細については、[Kotlinコードの文章化](kotlin-doc.html)を参照してください。

<!--original
See [Documenting Kotlin Code](kotlin-doc.html) for information on the documentation comment syntax.
-->

## 文字列テンプレートの使用

<!--original
## Using string templates
-->

``` kotlin
fun main(args: Array<String>) {
  if (args.size == 0) return

  print("First argument: ${args[0]}")
}
```

<!--original
``` kotlin
fun main(args: Array<String>) {
  if (args.size == 0) return

  print("First argument: ${args[0]}")
}
```
-->

[文字列テンプレート](basic-types.html#string-templates)を参照してください。

<!--original
See [String templates](basic-types.html#string-templates).
-->

## 条件式の使用

<!--original
## Using conditional expressions
-->

``` kotlin
fun max(a: Int, b: Int): Int {
  if (a > b)
    return a
  else
    return b
}
```

<!--original
``` kotlin
fun max(a: Int, b: Int): Int {
  if (a > b)
    return a
  else
    return b
}
```
-->

*if*{: .keyword }を式として使用：

<!--original
Using *if*{: .keyword } as an expression:
-->

``` kotlin
fun max(a: Int, b: Int) = if (a > b) a else b
```

<!--original
``` kotlin
fun max(a: Int, b: Int) = if (a > b) a else b
```
-->

[*if*{: .keyword }式](control-flow.html#if-expression)を参照してください。

<!--original
See [*if*{: .keyword }-expressions](control-flow.html#if-expression).
-->

## NULL可能値を使用した、*null*{: .keyword }のチェック

<!--original
## Using nullable values and checking for *null*{: .keyword }
-->

*null*{: .keyword }値を取り得る場合、参照は明示的にnullとしてマークする必要があります。

<!--original
A reference must be explicitly marked as nullable when *null*{: .keyword } value is possible.
-->

`str`は整数を保持していない場合は*null*{: .keyword }を返します：

<!--original
Return *null*{: .keyword } if `str` does not hold an integer:
-->

``` kotlin
fun parseInt(str: String): Int? {
  // ...
}
```

<!--original
``` kotlin
fun parseInt(str: String): Int? {
  // ...
}
```
-->

null可能値を返す関数を使用：

<!--original
Use a function returning nullable value:
-->

``` kotlin
fun main(args: Array<String>) {
  if (args.size < 2) {
    print("Two integers expected")
    return
  }

  val x = parseInt(args[0])
  val y = parseInt(args[1])

  // `x`, `y`はnullが入っていることがあるので、`x * y`はエラーを引き起こす
  if (x != null && y != null) {
    // xとyは、nullチェックの後自動的に非null許容型へキャストされる
    print(x * y)
  }
}
```

<!--original
``` kotlin
fun main(args: Array<String>) {
  if (args.size < 2) {
    print("Two integers expected")
    return
  }

  val x = parseInt(args[0])
  val y = parseInt(args[1])

  // Using `x * y` yields error because they may hold nulls.
  if (x != null && y != null) {
    // x and y are automatically cast to non-nullable after null check
    print(x * y)
  }
}
```
-->

または

<!--original
or
-->

``` kotlin
  // ...
  if (x == null) {
    print("Wrong number format in '${args[0]}'")
    return
  }
  if (y == null) {
    print("Wrong number format in '${args[1]}'")
    return
  }

  // x and y are automatically cast to non-nullable after null check
  print(x * y)
```

<!--original
``` kotlin
  // ...
  if (x == null) {
    print("Wrong number format in '${args[0]}'")
    return
  }
  if (y == null) {
    print("Wrong number format in '${args[1]}'")
    return
  }

  // x and y are automatically cast to non-nullable after null check
  print(x * y)
```
-->

[null安全](null-safety.html)を参照してください。

<!--original
See [Null-safety](null-safety.html).
-->

## 型チェックと自動キャストの使用

<!--original
## Using type checks and automatic casts
-->

*is*{: .keyword }演算子はある式がある型のインスタンスであるかのチェックを行います。
不変のローカル変数やプロパティが特定の型であるかチェックされている場合は、明示的にキャストする必要はありません：

<!--original
The *is*{: .keyword } operator checks if an expression is an instance of a type.
If an immutable local variable or property is checked for a specific type, there's no need to cast it explicitly:
-->

``` kotlin
fun getStringLength(obj: Any): Int? {
  if (obj is String) {
    // `obj` はこのブランチ内では自動的に`String`へキャストされる
    return obj.length
  }

  // `obj` は型チェックが行われたブランチ外では、まだ`Any`型である
  return null
}
```

<!--original
``` kotlin
fun getStringLength(obj: Any): Int? {
  if (obj is String) {
    // `obj` is automatically cast to `String` in this branch
    return obj.length
  }

  // `obj` is still of type `Any` outside of the type-checked branch
  return null
}
```
-->

または

<!--original
or
-->

``` kotlin
fun getStringLength(obj: Any): Int? {
  if (obj !is String)
    return null

  // `obj` はこのブランチ内では自動的に`String`へキャストされる
  return obj.length
}
```

<!--original
``` kotlin
fun getStringLength(obj: Any): Int? {
  if (obj !is String)
    return null

  // `obj` is automatically cast to `String` in this branch
  return obj.length
}
```
-->

あるいは

<!--original
or even
-->

``` kotlin
fun getStringLength(obj: Any): Int? {
  // `obj` は`&&`の右側では自動的に`String`へキャストされる
  if (obj is String && obj.length > 0)
    return obj.length

  return null
}
```

<!--original
``` kotlin
fun getStringLength(obj: Any): Int? {
  // `obj` is automatically cast to `String` on the right-hand side of `&&`
  if (obj is String && obj.length > 0)
    return obj.length

  return null
}
```
-->

[クラス](classes.html)と[型のキャスト](typecasts.html)を参照してください。

<!--original
See [Classes](classes.html) and [Type casts](typecasts.html).
-->

## `for`ループの使用

<!--original
## Using a `for` loop
-->

``` kotlin
fun main(args: Array<String>) {
  for (arg in args)
    print(arg)
}
```

<!--original
``` kotlin
fun main(args: Array<String>) {
  for (arg in args)
    print(arg)
}
```
-->

または

<!--original
or
-->

``` kotlin
for (i in args.indices)
  print(args[i])
```

<!--original
``` kotlin
for (i in args.indices)
  print(args[i])
```
-->

[forループ](control-flow.html#for-loops)を参照してください。

<!--original
See [for loop](control-flow.html#for-loops).
-->

## `while`ループの使用

<!--original
## Using a `while` loop
-->

``` kotlin
fun main(args: Array<String>) {
  var i = 0
  while (i < args.size)
    print(args[i++])
}
```

<!--original
``` kotlin
fun main(args: Array<String>) {
  var i = 0
  while (i < args.size)
    print(args[i++])
}
```
-->

[whileループ](control-flow.html#while-loops)を参照してください。

<!--original
See [while loop](control-flow.html#while-loops).
-->

## `when`式の使用

<!--original
## Using `when` expression
-->

``` kotlin
fun cases(obj: Any) {
  when (obj) {
    1          -> print("One")
    "Hello"    -> print("Greeting")
    is Long    -> print("Long")
    !is String -> print("Not a string")
    else       -> print("Unknown")
  }
}
```

<!--original
``` kotlin
fun cases(obj: Any) {
  when (obj) {
    1          -> print("One")
    "Hello"    -> print("Greeting")
    is Long    -> print("Long")
    !is String -> print("Not a string")
    else       -> print("Unknown")
  }
}
```
-->

[when式](control-flow.html#when-expression)を参照してください。

<!--original
See [when expression](control-flow.html#when-expression).
-->

## 範囲の使用

<!--original
## Using ranges
-->

*in*{: .keyword }演算子を使用すると、数が範囲内にあるかどうかを確認できます：

<!--original
Check if a number is within a range using *in*{: .keyword } operator:
-->

``` kotlin
if (x in 1..y-1)
  print("OK")
```

<!--original
``` kotlin
if (x in 1..y-1)
  print("OK")
```
-->

数が範囲外であるかどうかを確認します：

<!--original
Check if a number is out of range:
-->

``` kotlin
if (x !in 0..array.lastIndex)
  print("Out")
```

<!--original
``` kotlin
if (x !in 0..array.lastIndex)
  print("Out")
```
-->

範囲内で反復処理：

<!--original
Iterating over a range:
-->

``` kotlin
for (x in 1..5)
  print(x)
```

<!--original
``` kotlin
for (x in 1..5)
  print(x)
```
-->

[範囲](ranges.html)を参照してください。

<!--original
See [Ranges](ranges.html).
-->

## コレクションの使用

<!--original
## Using collections
-->

コレクション内で反復処理：

<!--original
Iterating over a collection:
-->

``` kotlin
for (name in names)
  println(name)
```

<!--original
``` kotlin
for (name in names)
  println(name)
```
-->

コレクションがあるオブジェクトを含むかを*in*{: .keyword }演算子で調べる：

<!--original
Checking if a collection contains an object using *in*{: .keyword } operator:
-->

``` kotlin
if (text in names) // names.contains(text) が呼ばれる
  print("Yes")
```

<!--original
``` kotlin
if (text in names) // names.contains(text) is called
  print("Yes")
```
-->

フィルタやマップコレクションにラムダ式を使用します：

<!--original
Using lambda expressions to filter and map collections:
-->

``` kotlin
names
    .filter { it.startsWith("A") }
    .sortedBy { it }
    .map { it.toUpperCase() }
    .forEach { print(it) }
```

<!--original
``` kotlin
names
    .filter { it.startsWith("A") }
    .sortedBy { it }
    .map { it.toUpperCase() }
    .forEach { print(it) }
```
-->

[高階関数とラムダ](lambdas.html)を参照してください。

<!--original
See [Higher-order functions and Lambdas](lambdas.html).
-->

# イディオム

<!--original
# Idioms
-->

Kotlinでよく使用されるイディオムを集めました。もし好みのイディオムがあれば、プルリクエストを投げて貢献してください。

<!--original
A collection of random and frequently used idioms in Kotlin. If you have a favorite idiom, contribute it. Do a pull request.
-->

DTOの作成（POJO/ POCO）

<!--original
### Creating DTO's (POJO's/POCO's)
-->

``` kotlin
data class Customer(val name: String, val email: String)
```

<!--original
``` kotlin
data class Customer(val name: String, val email: String)
```
-->

`Customer`クラスは次の機能を提供します：

<!--original
provides a `Customer` class with the following functionality:
-->

* 全てのプロパティのゲッター（と*var*{: .keyword }キーワードが使用されたときはセッターも）
* `equals()`
* `hashCode()`
* `toString()`
* `copy()`
* すべてのプロパティに対して、`component1()`, `component2()`, …, （[Data classes](data-classes.html)を参照してください）
関数の引数に対するデフォルト値

<!--original
* getters (and setters in case of *var*{: .keyword }'s) for all properties
* `equals()`
* `hashCode()`
* `toString()`
* `copy()`
* `component1()`, `component2()`, ..., for all properties (see [Data classes](data-classes.html))
-->

### 関数の引数に対するデフォルト値

<!--original
### Default values for function parameters
-->

``` kotlin
fun foo(a: Int = 0, b: String = "") { ... }
```

<!--original
``` kotlin
fun foo(a: Int = 0, b: String = "") { ... }
```
-->

### リストのフィルタリング

<!--original
### Filtering a list
-->

``` kotlin
val positives = list.filter { x -> x > 0 }
```

<!--original
``` kotlin
val positives = list.filter { x -> x > 0 }
```
-->

または、こう短くも書けます：

<!--original
Or alternatively, even shorter:
-->

``` kotlin
val positives = list.filter { it > 0 }
```

<!--original
``` kotlin
val positives = list.filter { it > 0 }
```
-->

### 文字列補完

<!--original
### String Interpolation
-->

``` kotlin
println("Name $name")
```

<!--original
``` kotlin
println("Name $name")
```
-->

### インスタンスのチェック

<!--original
### Instance Checks
-->

``` kotlin
when (x) {
    is Foo -> ...
    is Bar -> ...
    else   -> ...
}
```

<!--original
``` kotlin
when (x) {
    is Foo -> ...
    is Bar -> ...
    else   -> ...
}
```
-->

### mapやlistのペアを書き下す

<!--original
### Traversing a map/list of pairs
-->

``` kotlin
for ((k, v) in map) {
    println("$k -> $v")
}
```

<!--original
``` kotlin
for ((k, v) in map) {
    println("$k -> $v")
}
```
-->

`k`, `v`は何からでも呼び出すことができます。

<!--original
`k`, `v` can be called anything.
-->

### 範囲の使用

<!--original
### Using ranges
-->

``` kotlin
for (i in 1..100) { ... }
for (x in 2..10) { ... }
```

<!--original
``` kotlin
for (i in 1..100) { ... }
for (x in 2..10) { ... }
```
-->

### 読み取り専用list

<!--original
### Read-only list
-->

``` kotlin
val list = listOf("a", "b", "c")
```

<!--original
``` kotlin
val list = listOf("a", "b", "c")
```
-->

### 読み取り専用map

<!--original
### Read-only map
-->

``` kotlin
val map = mapOf("a" to 1, "b" to 2, "c" to 3)
```

<!--original
``` kotlin
val map = mapOf("a" to 1, "b" to 2, "c" to 3)
```
-->

### mapへのアクセス

<!--original
### Accessing a map
-->

``` kotlin
println(map["key"])
map["key"] = value
```

<!--original
``` kotlin
println(map["key"])
map["key"] = value
```
-->

### 遅延評価プロパティ

<!--original
### Lazy property
-->

``` kotlin
val p: String by lazy {
    // 文字列を評価
}
```

<!--original
``` kotlin
val p: String by lazy {
    // compute the string
}
```
-->

### 拡張関数

<!--original
### Extension Functions
-->

``` kotlin
fun String.spaceToCamelCase() { ... }

"Convert this to camelcase".spaceToCamelCase()
```

<!--original
``` kotlin
fun String.spaceToCamelCase() { ... }

"Convert this to camelcase".spaceToCamelCase()
```
-->

### シングルトンの作成

<!--original
### Creating a singleton
-->

``` kotlin
object Resource {
    val name = "Name"
}
```

<!--original
``` kotlin
object Resource {
    val name = "Name"
}
```
-->

### if not nullの省略記法

<!--original
### If not null shorthand
-->

``` kotlin
val files = File("Test").listFiles()

println(files?.size)
```

<!--original
``` kotlin
val files = File("Test").listFiles()

println(files?.size)
```
-->

### if not null and elseの省略記法

<!--original
### If not null and else shorthand
-->

``` kotlin
val files = File("Test").listFiles()

println(files?.size ?: "empty")
```

<!--original
``` kotlin
val files = File("Test").listFiles()

println(files?.size ?: "empty")
```
-->

### if null文の実行

<!--original
### Executing a statement if null
-->

``` kotlin
val data = ...
val email = data["email"] ?: throw IllegalStateException("Email is missing!")
```

<!--original
``` kotlin
val data = ...
val email = data["email"] ?: throw IllegalStateException("Email is missing!")
```
-->

### if not null文の実行

<!--original
### Execute if not null
-->

``` kotlin
val data = ...

data?.let {
    ... // nullでなければこのブロックを実行する
}
```

<!--original
``` kotlin
val data = ...

data?.let {
    ... // execute this block if not null
}
```
-->

### when文でreturnする

<!--original
### Return on when statement
-->

``` kotlin
fun transform(color: String): Int {
    return when (color) {
        "Red" -> 0
        "Green" -> 1
        "Blue" -> 2
        else -> throw IllegalArgumentException("Invalid color param value")
    }
}
```

<!--original
``` kotlin
fun transform(color: String): Int {
    return when (color) {
        "Red" -> 0
        "Green" -> 1
        "Blue" -> 2
        else -> throw IllegalArgumentException("Invalid color param value")
    }
}
```
-->

### 'try / catch'式

<!--original
### 'try/catch' expression
-->

``` kotlin
fun test() {
    val result = try {
        count()
    } catch (e: ArithmeticException) {
        throw IllegalStateException(e)
    }

    // resultを使って何かする
}
```

<!--original
``` kotlin
fun test() {
    val result = try {
        count()
    } catch (e: ArithmeticException) {
        throw IllegalStateException(e)
    }

    // Working with result
}
```
-->

### 'if'式

<!--original
### 'if' expression
-->

``` kotlin
fun foo(param: Int) {
    val result = if (param == 1) {
        "one"
    } else if (param == 2) {
        "two"
    } else {
        "three"
    }
}
```

<!--original
``` kotlin
fun foo(param: Int) {
    val result = if (param == 1) {
        "one"
    } else if (param == 2) {
        "two"
    } else {
        "three"
    }
}
```
-->

### Unitを返すメソッドのビルダースタイルの使用

<!--original
### Builder-style usage of methods that return `Unit`
-->

``` kotlin
fun arrayOfMinusOnes(size: Int): IntArray {
    return IntArray(size).apply { fill(-1) }
}
```

<!--original
``` kotlin
fun arrayOfMinusOnes(size: Int): IntArray {
    return IntArray(size).apply { fill(-1) }
}
```
-->


### 単一式関数

<!--original
### Single-expression functions
-->

``` kotlin
fun theAnswer() = 42
```

<!--original
``` kotlin
fun theAnswer() = 42
```
-->

これは次と等価です：

<!--original
This is equivalent to
-->

``` kotlin
fun theAnswer(): Int {
    return 42
}
```

<!--original
``` kotlin
fun theAnswer(): Int {
    return 42
}
```
-->


これは他のイディオムと組み合わせることができ、コードを短くすることにつながります。例） *when*{: .keyword }-式：

<!--original
This can be effectively combined with other idioms, leading to shorter code. E.g. with the *when*{: .keyword }-expression:
-->

``` kotlin
fun transform(color: String): Int = when (color) {
    "Red" -> 0
    "Green" -> 1
    "Blue" -> 2
    else -> throw IllegalArgumentException("Invalid color param value")
}
```

<!--original
``` kotlin
fun transform(color: String): Int = when (color) {
    "Red" -> 0
    "Green" -> 1
    "Blue" -> 2
    else -> throw IllegalArgumentException("Invalid color param value")
}
```
-->

### 'with' を使って、あるオブジェクトのインスタンスで複数の関数を呼ぶ

<!--original
### Calling multiple methods on an object instance ('with')
-->

``` kotlin
class Turtle {
    fun penDown()
    fun penUp()
    fun turn(degrees: Double)
    fun forward(pixels: Double)
}

val myTurtle = Turtle()
with(myTurtle) { // 100pxの四角形を描く
    penDown()
    for(i in 1..4) {
        forward(100.0)
        turn(90.0)
    }
    penUp()
}
```

<!--original
``` kotlin
class Turtle {
    fun penDown()
    fun penUp()
    fun turn(degrees: Double)
    fun forward(pixels: Double)
}

val myTurtle = Turtle()
with(myTurtle) { //draw a 100 pix square
    penDown()
    for(i in 1..4) {
        forward(100.0)
        turn(90.0)
    }
    penUp()
}
```
-->

### Java 7のtry-with-resources

<!--original
### Java 7's try with resources
-->

``` kotlin
val stream = Files.newInputStream(Paths.get("/some/file.txt"))
stream.buffered().reader().use { reader ->
    println(reader.readText())
}
```

<!--original
``` kotlin
val stream = Files.newInputStream(Paths.get("/some/file.txt"))
stream.buffered().reader().use { reader ->
    println(reader.readText())
}
```
-->

# コーディング規約

<!--original
# Coding Conventions
-->

このページでは、Kotlin言語の現在のコーディングスタイルを紹介します。

<!--original
This page contains the current coding style for the Kotlin language.
-->

## 命名スタイル

よく分からない場合はJava のコード規約に従ってください：


<!--original
## Naming Style
If in doubt default to the Java Coding Conventions such as:
-->

* キャメルケースの使用（そして命名でのアンダースコアの使用を避ける）
* 型は大文字で始まる
* メソッドとプロパティは小文字で始まる
* 4スペースインデントの使用
* public関数はKotlin Docに登場するようなドキュメンテーションがないといけない

<!--original
* use of camelCase for names (and avoid underscore in names)
* types start with upper case
* methods and properties start with lower case
* use 4 space indentation
* public functions should have documentation such that it appears in Kotlin Doc
-->

## コロン

<!--original
## Colon
-->

コロンが型と継承元のセパレータとして使用される際は、一つ前にスペースが必要です。 一方、インスタンスと型のセパレータとして使用するときには、スペースは不要です。

<!--original
There is a space before colon where colon separates type and supertype and there's no space where colon separates instance and type:
-->

``` kotlin
interface Foo<out T : Any> : Bar {
    fun foo(a: Int): T
}
```

<!--original
``` kotlin
interface Foo<out T : Any> : Bar {
    fun foo(a: Int): T
}
```
-->

## ラムダ

<!--original
## Lambdas
-->

ラムダ式では、スペースが波括弧の周りに必要です。また、パラメータを本体と分かつアロー（->）も同様です。 可能な限り、ラムダを括弧の外に渡す必要があります。

<!--original
In lambda expressions, spaces should be used around the curly braces, as well as around the arrow which separates the parameters
from the body. Whenever possible, a lambda should be passed outside of parentheses.
-->

``` kotlin
list.filter { it > 10 }.map { element -> element * 2 }
```

<!--original
``` kotlin
list.filter { it > 10 }.map { element -> element * 2 }
```
-->

短くてネストされていない（入れ子でない）ラムダ内では、 パラメータを明示的に宣言する代わりに `it` 規約を使用することを推奨します。パラメータを持つネストされたラムダでは、パラメータを常に明示的に宣言する必要があります。

<!--original
In lambdas which are short and not nested, it's recommended to use the `it` convention instead of declaring the parameter
explicitly. In nested lambdas with parameters, parameters should be always declared explicitly.
-->

## ユニット (Unit)

<!--original
## Unit
-->

関数がUnitを返す場合、戻り値の型は省略されるべきです：

<!--original
If a function returns Unit, the return type should be omitted:
-->

``` kotlin
fun foo() { // ": Unit" が省略されている

}
```

<!--original
``` kotlin
fun foo() { // ": Unit" is omitted here

}
```
-->

# 基本の型

<!--original
# Basic Types
-->

Kotlinでは、メンバ関数やプロパティをどんな変数からでも呼び出せるという意味で、全てのものがオブジェクトです。 いくつかの型は実装が最適化されているためビルトインであるが、ユーザから見ると普通のクラスのように見えます。このセクションでは、次の型の大部分を説明します：数値、文字、真偽値（boolean）、配列。

<!--original
In Kotlin, everything is an object in the sense that we can call member functions and properties on any variable. Some types are built-in, because their implementation is optimized, but to the user they look like ordinary classes. In this section we describe most of these types: numbers, characters, booleans and arrays.
-->

## 数値

<!--original
## Numbers
-->

Kotlinは、Javaに近い方法で数字を扱うが、全く同じではありません。例えば、数値の暗黙の拡大変換が存在せず、リテラルはいくつかの事例では少し異なる。

<!--original
Kotlin handles numbers in a way close to Java, but not exactly the same. For example, there are no implicit widening conversions for numbers, and literals are slightly different in some cases.
-->

Kotlinは数値の表現用に次のビルトインの型を提供します（これはJavaに近い）：

<!--original
Kotlin provides the following built-in types representing numbers (this is close to Java):
-->

| 型	 | ビット幅 |
|--------|----------|
| Double | 64       |
| Float	 | 32       |
| Long	 | 64       |
| Int	 | 32       |
| Short	 | 16       |
| Byte	 | 8        |

<!--original
| Type	 | Bit width|
|--------|----------|
| Double | 64       |
| Float	 | 32       |
| Long	 | 64       |
| Int	 | 32       |
| Short	 | 16       |
| Byte	 | 8        |
-->

Kotlinでは文字は数値でないことに注意してください。

<!--original
Note that characters are not numbers in Kotlin.
-->

### リテラル定数

<!--original
### Literal Constants
-->


整数値のためのリテラル定数は、次の種類があります。

<!--original
There are the following kinds of literal constants for integral values:
-->

* 数値: `123`
  * Long型の数を表すには大文字の`L`でタグ付けする: `123L`
* 16進数: `0x0F`
* 2進数: `0b00001011`

<!--original
* Decimals: `123`
  * Longs are tagged by a capital `L`: `123L`
* Hexadecimals: `0x0F`
* Binaries: `0b00001011`
-->

注：8進数のリテラルはサポートされていません。

<!--original
NOTE: Octal literals are not supported.
-->

Kotlinは浮動小数点数の従来の表記法もサポートしています。

<!--original
Kotlin also supports a conventional notation for floating-point numbers:
-->
 
* デフォルトではdouble型: `123.5`, `123.5e10`
* float型を表すには `f` or `F` でタグ付けする: `123.5f` 

<!--original
* Doubles by default: `123.5`, `123.5e10`
* Floats are tagged by `f` or `F`: `123.5f` 
-->

### 表現

<!--original
### Representation
-->

Javaプラットフォームでは、null許容型な数値の参照（例：`Int?`）やジェネリクスが関与している場合を除いて、JVMプリミティブ型として数値が物理的に格納されています。後者の例では番号がボクシングされています。

<!--original
On the Java platform, numbers are physically stored as JVM primitive types, unless we need a nullable number reference (e.g. `Int?`) or generics are involved. 
In the latter cases numbers are boxed.
-->

数値のボクシングは一様性を保持しないことに注意してください：

<!--original
Note that boxing of numbers does not preserve identity:
-->

``` kotlin
val a: Int = 10000
print(a === a) // 'true'を出力する
val boxedA: Int? = a
val anotherBoxedA: Int? = a
print(boxedA === anotherBoxedA) // !!! 'false'を出力する !!!
```

<!--original
``` kotlin
val a: Int = 10000
print(a === a) // Prints 'true'
val boxedA: Int? = a
val anotherBoxedA: Int? = a
print(boxedA === anotherBoxedA) // !!!Prints 'false'!!!
```
-->

一方、これは同一性を保持しています：

<!--original
On the other hand, it preserves equality:
-->

``` kotlin
val a: Int = 10000
print(a == a) // 'true'を出力する
val boxedA: Int? = a
val anotherBoxedA: Int? = a
print(boxedA == anotherBoxedA) // 'true'を出力する
```

<!--original
``` kotlin
val a: Int = 10000
print(a == a) // Prints 'true'
val boxedA: Int? = a
val anotherBoxedA: Int? = a
print(boxedA == anotherBoxedA) // Prints 'true'
```
-->

### 明示的な変換

<!--original
### Explicit Conversions
-->

異なる表現であるが故に、小さな型は大きな型のサブタイプではありません。 もし仮にそうであったならば、次の種類の悩みを抱えたでしょう：

<!--original
Due to different representations, smaller types are not subtypes of bigger ones.
If they were, we would have troubles of the following sort:
-->

``` kotlin
// 仮説のコードであり、実際はコンパイルできません：
val a: Int? = 1 // ボクシングされたInt型 (java.lang.Integer)
val b: Long? = a // 暗黙の変換がLong型 (java.lang.Long)へのボクシングを引き起こします
print(a == b) // 仰天！これはLong型のequals()チェックで他の部分がLong型になるのと同等に "false" を出力します
```

<!--original
``` kotlin
// Hypothetical code, does not actually compile:
val a: Int? = 1 // A boxed Int (java.lang.Integer)
val b: Long? = a // implicit conversion yields a boxed Long (java.lang.Long)
print(a == b) // Surprise! This prints "false" as Long's equals() check for other part to be Long as well
```
-->

つまり、同一性だけでなく一様性でさえも全ての場所において静かに失われたのです。

<!--original
So not only identity, but even equality would have been lost silently all over the place.
-->

その結果、小さな型は、暗黙的に大きな型に変換されるのではありません。これは明示的変換無しで`Byte`型の値を`Int`型へ代入することができないことを意味します。


<!--original
As a consequence, smaller types are NOT implicitly converted to bigger types.
This means that we cannot assign a value of type `Byte` to an `Int` variable without an explicit conversion
-->

``` kotlin
val b: Byte = 1 // OK, リテラルは静的にチェックされています
val i: Int = b // ERROR
```

<!--original
``` kotlin
val b: Byte = 1 // OK, literals are checked statically
val i: Int = b // ERROR
```
-->

明示的変換は数字を拡張する際に使用することができます。

<!--original
We can use explicit conversions to widen numbers
-->

``` kotlin
val i: Int = b.toInt() // OK: 明示的に拡張されました
```

<!--original
``` kotlin
val i: Int = b.toInt() // OK: explicitly widened
```
-->

全ての数値型は次の変換をサポートしています：

<!--original
Every number type supports the following conversions:
-->

* `toByte(): Byte`
* `toShort(): Short`
* `toInt(): Int`
* `toLong(): Long`
* `toFloat(): Float`
* `toDouble(): Double`
* `toChar(): Char`

<!--original
* `toByte(): Byte`
* `toShort(): Short`
* `toInt(): Int`
* `toLong(): Long`
* `toFloat(): Float`
* `toDouble(): Double`
* `toChar(): Char`
-->

明示的変換がないことは滅多に目立ちません。なぜならその型は文脈から推測され、算術演算がオーバロードされ適切に変換されるからです。例えば：

<!--original
Absence of implicit conversions is rarely noticeable because the type is inferred from the context, and arithmetical operations are overloaded for appropriate conversions, for example
-->

``` kotlin
val l = 1L + 3 // Long + Int => Long
```

<!--original
``` kotlin
val l = 1L + 3 // Long + Int => Long
```
-->

### 演算

<!--original
### Operations
-->

Kotlinは算術計算の標準セットをサポートしています。それらは適切なクラス（ただしコンパイラは対応する命令の呼び出しを最適化する）のメンバとして宣言されています。[演算子のオーバーロード](operator-overloading.html)を参照してください。

<!--original
Kotlin supports the standard set of arithmetical operations over numbers, which are declared as members of appropriate classes (but the compiler optimizes the calls down to the corresponding instructions).
See [Operator overloading](operator-overloading.html).
-->

ビット演算にはそのような特殊な文字列がありませんが、中置形で呼び出せる名前付き関数があります。例えば：

<!--original
As of bitwise operations, there're no special characters for them, but just named functions that can be called in infix form, for example:
-->

``` kotlin
val x = (1 shl 2) and 0x000FF000
```

<!--original
``` kotlin
val x = (1 shl 2) and 0x000FF000
```
-->

これらはビット単位の操作を行う全リストです（`Int`と`Long`のみ利用可能）：

<!--original
Here is the complete list of bitwise operations (available for `Int` and `Long` only):
-->

* `shl(bits)` – 符号付き左シフト (Javaの `<<`)
* `shr(bits)` – 符号付き右シフト (Javaの `>>`)
* `ushr(bits)` – 符号無し右シフト (Javaの `>>>`)
* `and(bits)` – ビット演算のand
* `or(bits)` – ビット演算のor
* `xor(bits)` – ビット演算のxor
* `inv()` – ビット演算の反転

<!--original
* `shl(bits)` – signed shift left (Java's `<<`)
* `shr(bits)` – signed shift right (Java's `>>`)
* `ushr(bits)` – unsigned shift right (Java's `>>>`)
* `and(bits)` – bitwise and
* `or(bits)` – bitwise or
* `xor(bits)` – bitwise xor
* `inv()` – bitwise inversion
-->

## 文字

<!--original
## Characters
-->

文字は、`Char`型で表されます。数字として直接扱うことはできません。

<!--original
Characters are represented by the type `Char`. They can not be treated directly as numbers
-->

``` kotlin
fun check(c: Char) {
  if (c == 1) { // ERROR: 非互換の型
    // ...
  }
}
```

<!--original
``` kotlin
fun check(c: Char) {
  if (c == 1) { // ERROR: incompatible types
    // ...
  }
}
```
-->

[translation here]
文字リテラルを表現するには、シングルクォートで囲みます： `'1'`
特殊文字はバックスラッシュを使ってエスケープすることができます。
次のエスケープシーケンスがサポートされています：`\t`, `\b`, `\n`, `\r`, `\'`, `\"`, `\\`, `\$`
他の文字をエンコードするには、Unicodeエスケープシーケンスの構文を使用します：`'\uFF00'`


<!--original
Character literals go in single quotes: `'1'`.
Special characters can be escaped using a backslash.
The following escape sequences are supported: `\t`, `\b`, `\n`, `\r`, `\'`, `\"`, `\\` and `\$`.
To encode any other character, use the Unicode escape sequence syntax: `'\uFF00'`.
-->

明示的に文字を`Int`型の数に変換することもできます。

<!--original
We can explicitly convert a character to an `Int` number:
-->

``` kotlin
fun decimalDigitValue(c: Char): Int {
  if (c !in '0'..'9')
    throw IllegalArgumentException("Out of range")
  return c.toInt() - '0'.toInt() // 暗黙的な数値への変換
}
```

<!--original
``` kotlin
fun decimalDigitValue(c: Char): Int {
  if (c !in '0'..'9')
    throw IllegalArgumentException("Out of range")
  return c.toInt() - '0'.toInt() // Explicit conversions to numbers
}
```
-->

数値のように、文字はnull許容参照が必要なときにボクシングされます。同一性ははボクシング操作されると保持されません 。

<!--original
Like numbers, characters are boxed when a nullable reference is needed. Identity is not preserved by the boxing operation.
-->

## 真偽値 (Boolean)

<!--original
## Booleans
-->

[translation here]
`Boolean`型は真偽値を表し、*true*{: .keyword }と*false*{: .keyword }の2つの値があります。

<!--original
The type `Boolean` represents booleans, and has two values: *true*{: .keyword } and *false*{: .keyword }.
-->

Booleanはnull許容参照が必要なときにボクシングされます。

<!--original
Booleans are boxed if a nullable reference is needed.
-->

Booleanのビルトイン演算は次を含みます：

<!--original
Built-in operations on booleans include
-->

* `||` – 遅延評価論理和
* `&&` – 遅延評価論理積
* `!` - 否定

<!--original
* `||` – lazy disjunction
* `&&` – lazy conjunction
* `!` - negation
-->

## 配列

<!--original
## Arrays
-->

Kotlinでの配列は Array クラスで表され、`get`と`set1関数を持ちます（`[]`の演算子をオーバロードすることによって実現している）。また、`size`プロパティがいくつかの有用なメンバ関数と共に有効になっています：

<!--original
Arrays in Kotlin are represented by the `Array` class, that has `get` and `set` functions (that turn into `[]` by operator overloading conventions), and `size` property, along with a few other useful member functions:
-->

``` kotlin
class Array<T> private constructor() {
  val size: Int
  fun get(index: Int): T
  fun set(index: Int, value: T): Unit

  fun iterator(): Iterator<T>
  // ...
}
```

<!--original
``` kotlin
class Array<T> private constructor() {
  val size: Int
  fun get(index: Int): T
  fun set(index: Int, value: T): Unit

  fun iterator(): Iterator<T>
  // ...
}
```
-->

配列を作るには、ライブラリ関数の`arrayOf()`にアイテムの値を渡してください。つまり、`arrayOf(1, 2, 3)`は[1, 2, 3]の配列を作成します。
あるいはライブラリ関数の`arrayOfNulls()`で、null要素で埋められた指定サイズの配列を作ることができます。

<!--original
To create an array, we can use a library function `arrayOf()` and pass the item values to it, so that `arrayOf(1, 2, 3)` creates an array [1, 2, 3].
Alternatively, the `arrayOfNulls()` library function can be used to create an array of a given size filled with null elements.
-->

他のやり方として、配列のサイズと配列のインデックス値を与えると各要素の初期値用に値を返す関数を引数にとるファクトリ関数の使用があります。

<!--original
Another option is to use a factory function that takes the array size and the function that can return the initial value
of each array element given its index:
-->

``` kotlin
// Array<String>を["0", "1", "4", "9", "16"]の値で作成します
val asc = Array(5, { i -> (i * i).toString() })
```

<!--original
``` kotlin
// Creates an Array<String> with values ["0", "1", "4", "9", "16"]
val asc = Array(5, { i -> (i * i).toString() })
```
-->

前述したとおり、`[]`演算はメンバ関数の`get()`と`set()`の呼び出しを表します。

<!--original
As we said above, the `[]` operation stands for calls to member functions `get()` and `set()`.
-->

注：Javaとは異なり、Kotlinの配列は不変です。つまりKotlinでは`Array<Any>`へ`Array<String>`を代入することができないということを表します。これは実行時エラーを回避するためです（しかし、`Array<out Any>`を使えば代入できます。型プロジェクションを参照してください）。

<!--original
Note: unlike Java, arrays in Kotlin are invariant. This means that Kotlin does not let us assign an `Array<String>`
to an `Array<Any>`, which prevents a possible runtime failure (but you can use `Array<out Any>`, 
see [Type Projections](generics.html#type-projections)).
-->

Kotlinはプリミティブ型（`ByteArray`、`ShortArray`、`IntArray`等）の配列について、オーバーヘッド無しでボクシングができる特別なクラスを持ちます。 これらのクラスは`Array`クラスと継承関係を持ちませんが、同じメソッドとプロパティを持ちます。 それぞれのクラスにおいて、対応するファクトリ関数を持ちます：

<!--original
Kotlin also has specialized classes to represent arrays of primitive types without boxing overhead: `ByteArray`,
`ShortArray`, `IntArray` and so on. These classes have no inheritance relation to the `Array` class, but they
have the same set of methods and properties. Each of them also has a corresponding factory function:
-->

``` kotlin
val x: IntArray = intArrayOf(1, 2, 3)
x[0] = x[1] + x[2]
```

<!--original
``` kotlin
val x: IntArray = intArrayOf(1, 2, 3)
x[0] = x[1] + x[2]
```
-->

## 文字列

<!--original
## Strings
-->

文字列は、`String`型で表されます。文字列は不変（イミュータブル）です。
文字列の要素は、インデックスの演算でアクセスできます：`s[i]`
文字列は *for*{: .keyword }ループでイテレート（繰り返し操作）できます：

<!--original
Strings are represented by the type `String`. Strings are immutable.
Elements of a string are characters that can be accessed by the indexing operation: `s[i]`.
A string can be iterated over with a *for*{: .keyword }-loop:
-->

``` kotlin
for (c in str) {
  println(c)
}
```

<!--original
``` kotlin
for (c in str) {
  println(c)
}
```
-->

### 文字列リテラル

<!--original
### String Literals
-->

Kotlinは2つの種類の文字列リテラルを持ちます：1つはエスケープされた文字列を持ちうるエスケープ済み文字列で、もう1つは改行と任意の文字を含む生文字列です。 エスケープ済み文字列はJavaの文字列に非常によく似ています：

<!--original
Kotlin has two types of string literals: escaped strings that may have escaped characters in them and raw strings that can contain newlines and arbitrary text. An escaped string is very much like a Java string:
-->

``` kotlin
val s = "Hello, world!\n"
```

<!--original
``` kotlin
val s = "Hello, world!\n"
```
-->

エスケープは、バックスラッシュを用いて従来の方法で行われます。サポートされているエスケープシーケンスのリストについては、[文字列](#characters)を参照してください。

<!--original
Escaping is done in the conventional way, with a backslash. See [Characters](#characters) above for the list of supported escape sequences.
-->

生文字列は三連クオート (`"""`) で区切られます。エスケープは含まれておらず、改行や他の文字を含めることができます：

<!--original
A raw string is delimited by a triple quote (`"""`), contains no escaping and can contain newlines and any other characters:
-->

``` kotlin
val text = """
  for (c in "foo")
    print(c)
"""
```

<!--original
``` kotlin
val text = """
  for (c in "foo")
    print(c)
"""
```
-->

先頭の空白を[`trimMargin()`](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.text/trim-margin.html)関数で削除することができます。

<!--original
You can remove leading whitespace with [`trimMargin()`](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.text/trim-margin.html) function:
-->

``` kotlin
val text = """
    |Tell me and I forget. 
    |Teach me and I remember. 
    |Involve me and I learn.
    |(Benjamin Franklin)
    """.trimMargin()
```

<!--original
``` kotlin
val text = """
    |Tell me and I forget. 
    |Teach me and I remember. 
    |Involve me and I learn.
    |(Benjamin Franklin)
    """.trimMargin()
```
-->

デフォルトでは`|`はマージンの接頭辞として使用されますが、`trimMargin(">")`のように、パラメータとして別の文字を渡すとそれを接頭辞として使用することができます。

<!--original
By default `|` is used as margin prefix, but you can choose another character and pass it as a parameter, like `trimMargin(">")`.
-->

### 文字列テンプレート

<!--original
### String Templates
-->

文字列はテンプレート式、すなわち、評価され、その結果が文字列と結合されるコードの断片を含むことができる。テンプレート式は、ドル記号（$）で始まり、簡単な名前で構成されます：

<!--original
Strings may contain template expressions, i.e. pieces of code that are evaluated and whose results are concatenated into the string.
A template expression starts with a dollar sign ($) and consists of either a simple name:
-->

``` kotlin
val i = 10
val s = "i = $i" // "i = 10"と評価される
```

<!--original
``` kotlin
val i = 10
val s = "i = $i" // evaluates to "i = 10"
```
-->

または、波括弧を使った従来の記法もあります：

<!--original
or an arbitrary expression in curly braces:
-->

``` kotlin
val s = "abc"
val str = "$s.length is ${s.length}" // "abc.length is 3"と評価される
```

<!--original
``` kotlin
val s = "abc"
val str = "$s.length is ${s.length}" // evaluates to "abc.length is 3"
```
-->

テンプレートは生文字列、エスケープ済み文字列のどちらに含まれていても動作します。
もし`$`の文字リテラルを生文字列内（バックスラッシュでのエスケープをサポートしない）で表現する必要がある場合は、次の文法を使用できる：

<!--original
Templates are supported both inside raw strings and inside escaped strings.
If you need to represent a literal `$` character in a raw string (which doesn't support backslash escaping), you can use the following syntax:
-->

``` kotlin
val price = """
${'$'}9.99
"""
```

<!--original
``` kotlin
val price = """
${'$'}9.99
"""
```
-->

# パッケージ

<!--original
# Packages
-->

パッケージ宣言をするときは、ソースファイルの先頭に書いてください。

<!--original
A source file may start with a package declaration:
-->

``` kotlin
package foo.bar

fun baz() {}

class Goo {}

// ...
```

<!--original
``` kotlin
package foo.bar

fun baz() {}

class Goo {}

// ...
```
-->

ソースファイルの（このようなクラスや関数など）全ての内容は宣言パッケージに含まれています。従って、次の例で示すとおり、`baz()`の完全名は`foo.bar.baz`であり、`Goo`の完全名は`foo.bar.Goo`です。

<!--original
All the contents (such as classes and functions) of the source file are contained by the package declared.
So, in the example above, the full name of `baz()` is `foo.bar.baz`, and the full name of `Goo` is `foo.bar.Goo`. 
-->
 

もしパッケージが指定されない場合は、ファイルの内容は名前を持たない”default”パッケージに属することになる。

<!--original
If the package is not specified, the contents of such a file belong to "default" package that has no name.
-->

## インポート

<!--original
## Imports
-->

標準のインポートとは違い、それぞれのファイルは独自のインポートディレクティブを含んでもかまいません。
インポートの文法は、[文法](grammar.html#import)に記載されています。

<!--original
Apart from the default imports, each file may contain its own import directives.
Syntax for imports is described in the [grammar](grammar.html#import).
-->

単一の名前を指定してインポートできます。例：

<!--original
We can import either a single name, e.g.
-->

``` kotlin
import foo.Bar // Barは許可無しでアクセス可能になります
```

<!--original
``` kotlin
import foo.Bar // Bar is now accessible without qualification
```
-->

または、あるスコープ（パッケージ、クラス、オブジェクト等）内の全てのアクセス可能なコンテンツの場合：

<!--original
or all the accessible contents of a scope (package, class, object etc):
-->

``` kotlin
import foo.* // 'foo'内の全てがアクセス可能になります
```

<!--original
``` kotlin
import foo.* // everything in 'foo' becomes accessible
```
-->

名前の衝突がある場合、*as*{: .keyword }キーワードを使用して衝突するエンティティを局所的にリネームすることで明確にできます：

<!--original
If there is a name clash, we can disambiguate by using *as*{: .keyword } keyword to locally rename the clashing entity:
-->

``` kotlin
import foo.Bar // Barはアクセス可能
import bar.Bar as bBar // bBarは'bar.Bar'を意味する
```

<!--original
``` kotlin
import foo.Bar // Bar is accessible
import bar.Bar as bBar // bBar stands for 'bar.Bar'
```
-->

import キーワードはクラスをインポートするために限定されるわけではありません。他の宣言をインポートするために使用することができます：

<!--original
The `import` keyword is not restricted to importing classes; you can also use it to import other declarations:
-->

* トップレベルの関数とプロパティ
* [オブジェクトの宣言](object-declarations.html#object-declarations)で宣言された関数とプロパティ
* [enum定数](enum-classes.html)

<!--original
  * top-level functions and properties;
  * functions and properties declared in [object declarations](object-declarations.html#object-declarations);
  * [enum constants](enum-classes.html)
-->

Javaとは違って、Kotlinは別の"import static"構文を持っていません。全ての宣言は普通の`import`キーワードによってインポートされます。

<!--original
Unlike Java, Kotlin does not have a separate "import static" syntax; all of these declarations are imported using the regular `import` keyword.
-->

## トップレベル宣言の可視性

<!--original
## Visibility of Top-level Declarations
-->

もしトップレベルの宣言に*private*{: .keyword }マークがついていれば、それが宣言されたファイル内に対しプライベートです。 （[可視性修飾子](visibility-modifiers.html) を参照してください。）

<!--original
If a top-level declaration is marked *private*{: .keyword }, it is private to the file it's declared in (see [Visibility Modifiers](visibility-modifiers.html)).
-->

# 制御フロー

<!--original
# Control Flow
-->

## if式

<!--original
## If Expression
-->

Kotlinでは、*if*{: .keyword }は式であり、すなわち値を返します。従って、三項演算子は存在しません（条件 ? 真の時 : 偽の時）。なぜなら普通の *if*{: .keyword } がその役割を果たすためです。

<!--original
In Kotlin, *if*{: .keyword } is an expression, i.e. it returns a value.
Therefore there is no ternary operator (condition ? then : else), because ordinary *if*{: .keyword } works fine in this role.
-->

``` kotlin
// 伝統的な使い方
var max = a 
if (a < b) 
  max = b 
 
// else付き
var max: Int
if (a > b) 
  max = a 
else 
  max = b 
 
// 表現として
val max = if (a > b) a else b
```

<!--original
``` kotlin
// Traditional usage 
var max = a 
if (a < b) 
  max = b 
 
// With else 
var max: Int
if (a > b) 
  max = a 
else 
  max = b 
 
// As expression 
val max = if (a > b) a else b
```
-->

*if*{: .keyword } の分岐はブロックにすることができ、最後の式がそのブロックの値となります：

<!--original
*if*{: .keyword } branches can be blocks, and the last expression is the value of a block:
-->

``` kotlin
val max = if (a > b) { 
    print("Choose a") 
    a 
  } 
  else { 
    print("Choose b") 
    b 
  }
```

<!--original
``` kotlin
val max = if (a > b) { 
    print("Choose a") 
    a 
  } 
  else { 
    print("Choose b") 
    b 
  }
```
-->

もし*if*{: .keyword }を文ではなく式として使用する（例えば値を返したり変数に代入したりする）ならば、その式には`else`分岐が必要です。 

<!--original
If you're using *if*{: .keyword } as an expression rather than a statement (for example, returning its value or
assigning it to a variable), the expression is required to have an `else` branch.
-->

[*if*{: .keyword }の文法](grammar.html#if)を参照してください。

<!--original
See the [grammar for *if*{: .keyword }](grammar.html#if).
-->

## when式

<!--original
## When Expression
-->

*when*{: .keyword } はC言語のような言語におけるswitch演算子の置き換えです。最も簡単な形式では、次のようになります：

<!--original
*when*{: .keyword } replaces the switch operator of C-like languages. In the simplest form it looks like this
-->

``` kotlin
when (x) {
  1 -> print("x == 1")
  2 -> print("x == 2")
  else -> { // このブロックに注目してください
    print("x is neither 1 nor 2")
  }
}
```

<!--original
``` kotlin
when (x) {
  1 -> print("x == 1")
  2 -> print("x == 2")
  else -> { // Note the block
    print("x is neither 1 nor 2")
  }
}
```
-->

*when*{: .keyword } はその引数と条件が満たされる分岐が現れるまで、順番に全ての分岐に対して比較されます。*when*{: .keyword } は式としても文としても使うことができます。 もし式として使用されれば、その値は条件が満たされた分岐が全ての式の値となります。もし文として使用されれば、個別の条件は無視されます。（*if*{: .keyword }と全く同じく、それぞれの条件はブロックになれるため、その値はブロック内の最後の式のものとなる。）

<!--original
*when*{: .keyword } matches its argument against all branches sequentially until some branch condition is satisfied.
*when*{: .keyword } can be used either as an expression or as a statement. If it is used as an expression, the value
of the satisfied branch becomes the value of the overall expression. If it is used as a statement, the values of
individual branches are ignored. (Just like with *if*{: .keyword }, each branch can be a block, and its value
is the value of the last expression in the block.)
-->

*else*{: .keyword }条件は他の条件が全て満たされなかった際に評価されます。 もしが式として使用されれば、全てのあり得る場合を分岐条件で網羅できていることをコンパイラが証明できない限りは、*else*{: .keyword }条件は必須です。

<!--original
The *else*{: .keyword } branch is evaluated if none of the other branch conditions are satisfied.
If *when*{: .keyword } is used as an expression, the *else*{: .keyword } branch is mandatory,
unless the compiler can prove that all possible cases are covered with branch conditions.
-->

もしたくさんの条件を同じ方法で処理する必要がある場合には、分岐条件をコンマでまとめることができます：

<!--original
If many cases should be handled in the same way, the branch conditions may be combined with a comma:
-->

``` kotlin
when (x) {
  0, 1 -> print("x == 0 or x == 1")
  else -> print("それ以外")
}
```

<!--original
``` kotlin
when (x) {
  0, 1 -> print("x == 0 or x == 1")
  else -> print("otherwise")
}
```
-->

分岐条件として任意の式（定数に限らない）を使用することができます：

<!--original
We can use arbitrary expressions (not only constants) as branch conditions
-->

``` kotlin
when (x) {
  parseInt(s) -> print("sはxをエンコードする")
  else -> print("sはxをエンコードしない")
}
```

<!--original
``` kotlin
when (x) {
  parseInt(s) -> print("s encodes x")
  else -> print("s does not encode x")
}
```
-->

*in*{: .keyword }または*!in*{: .keyword }を使用すると、コレクションの [範囲 (range)](ranges.html) をチェックすることもできます： 

<!--original
We can also check a value for being *in*{: .keyword } or *!in*{: .keyword } a [range](ranges.html) or a collection:
-->

``` kotlin
when (x) {
  in 1..10 -> print("xは範囲内")
  in validNumbers -> print("xは有効")
  !in 10..20 -> print("xは範囲外")
  else -> print("どれにも該当せず")
}
```

<!--original
``` kotlin
when (x) {
  in 1..10 -> print("x is in the range")
  in validNumbers -> print("x is valid")
  !in 10..20 -> print("x is outside the range")
  else -> print("none of the above")
}
```
-->

値をチェックする他の方法として、特定の型の*is*{: .keyword }または*!is*{: .keyword }があります。[スマートキャスト](typecasts.html#smart-casts)のおかげで、その型のメソッドやプロパティに追加のチェック無しでアクセスできることに注意してください。

<!--original
Another possibility is to check that a value *is*{: .keyword } or *!is*{: .keyword } of a particular type. Note that,
due to [smart casts](typecasts.html#smart-casts), you can access the methods and properties of the type without
any extra checks.
-->

```kotlin
val hasPrefix = when(x) {
  is String -> x.startsWith("prefix")
  else -> false
}
```

<!--original
```kotlin
val hasPrefix = when(x) {
  is String -> x.startsWith("prefix")
  else -> false
}
```
-->

*when*{: .keyword }は *if*{: .keyword}-*else*{: .keyword} *if*{: .keyword}連鎖を代替することもできます。 引数が与えられない場合は、分岐条件は単純なbooleanの式となり、分岐はその条件がtrueの場合に実行されます：

<!--original
*when*{: .keyword } can also be used as a replacement for an *if*{: .keyword }-*else*{: .keyword } *if*{: .keyword } chain.
If no argument is supplied, the branch conditions are simply boolean expressions, and a branch is executed when its condition is true:
-->

``` kotlin
when {
  x.isOdd() -> print("x is odd")
  x.isEven() -> print("x is even")
  else -> print("x is funny")
}
```

<!--original
``` kotlin
when {
  x.isOdd() -> print("x is odd")
  x.isEven() -> print("x is even")
  else -> print("x is funny")
}
```
-->

[*when*{: .keyword } の文法](grammar.html#when)を参照してください。

<!--original
See the [grammar for *when*{: .keyword }](grammar.html#when).

-->

## Forループ

<!--original
## For Loops
-->

*for*{: .keyword }ループはイテレータによって提供されるものを何でも繰り返し実行します。構文は次のとおりです：

<!--original
*for*{: .keyword } loop iterates through anything that provides an iterator. The syntax is as follows:
-->

``` kotlin
for (item in collection)
  print(item)
```

<!--original
``` kotlin
for (item in collection)
  print(item)
```
-->

本文をブロックにすることもできます。

<!--original
The body can be a block.
-->

``` kotlin
for (item: Int in ints) {
  // ...
}
```

<!--original
``` kotlin
for (item: Int in ints) {
  // ...
}
```
-->

前述したように、 *for*{: .keyword} はイテレータとして提供されるものを何でも繰り返し実行します。すなわち：

<!--original
As mentioned before, *for*{: .keyword } iterates through anything that provides an iterator, i.e.
-->

* メンバ関数や拡張関数の `iterator()` は型を返し、
  * メンバ関数や拡張関数の `next()` と
  * メンバ関数や拡張関数の `hasNext()` は `Boolean` を返します。

<!--original
* has a member- or extension-function `iterator()`, whose return type
  * has a member- or extension-function `next()`, and
  * has a member- or extension-function `hasNext()` that returns `Boolean`.
-->

これら3つの関数は全て `演算子 (operator)` としてマークされる必要があります。

<!--original
All of these three functions need to be marked as `operator`.
-->

配列の`for`ループはイテレータオブジェクトを作成しないインデックスベースのループにコンパイルされます。

<!--original
A `for` loop over an array is compiled to an index-based loop that does not create an iterator object.
-->

もし配列やリストをインデックス付きで繰り返し処理したいならば、この方法を使用できる： 

<!--original
If you want to iterate through an array or a list with an index, you can do it this way:
-->

``` kotlin
for (i in array.indices)
  print(array[i])
```

<!--original
``` kotlin
for (i in array.indices)
  print(array[i])
```
-->

“範囲の繰り返し実行”は余分なオブジェクトを生成しない最適な実装へコンパイルされることに注意すること。

<!--original
Note that this "iteration through a range" is compiled down to optimal implementation with no extra objects created.
-->

別方法として、ライブラリ関数の withIndex を使用することもできます：

<!--original
Alternatively, you can use the `withIndex` library function:
-->

``` kotlin
for ((index, value) in array.withIndex()) {
    println("$indexの要素は$value")
}
```

<!--original
``` kotlin
for ((index, value) in array.withIndex()) {
    println("the element at $index is $value")
}
```
-->

[*for*{: .keyword }の文法](grammar.html#for)を参照してください。

<!--original
See the [grammar for *for*{: .keyword }](grammar.html#for).
-->

## whileループ

<!--original
## While Loops
-->

*while*{: .keyword } と *do*{: .keyword }..*while*{: .keyword } はいつものように動きます：

<!--original
*while*{: .keyword } and *do*{: .keyword }..*while*{: .keyword } work as usual
-->

``` kotlin
while (x > 0) {
  x--
}

do {
  val y = retrieveData()
} while (y != null) // y はここで可視(visible)
```

<!--original
``` kotlin
while (x > 0) {
  x--
}

do {
  val y = retrieveData()
} while (y != null) // y is visible here!
```
-->

[*while*{: .keyword }の文法](grammar.html#while)を参照してください。

<!--original
See the [grammar for *while*{: .keyword }](grammar.html#while).
-->

## ループ内でのbreakとcontinue

<!--original
## Break and continue in loops
-->

Kotlinはループ中の従来の *break*{: .keyword }と*continue*{: .keyword } 演算子をサポートしています。[Returnとジャンプ](returns.html)を参照してください。

<!--original
Kotlin supports traditional *break*{: .keyword } and *continue*{: .keyword } operators in loops. See [Returns and jumps](returns.html).
-->

# returnとジャンプ

<!--original
# Returns and Jumps
-->

Kotlinには3つの構造的ジャンプ演算子があります。

<!--original
Kotlin has three structural jump operators
-->

* *return*{: .keyword }. デフォルトでは最近のクロージャ（関数閉包）や[匿名関数](lambdas.html#anonymous-functions)から抜け出します。
* *break*{: .keyword } 最も近い外側のループを終わらせます。
* *continue*{: .keyword }. 最も近い外側のループである次のステップに進みます。

<!--original
* *return*{: .keyword }. By default returns from the nearest enclosing function or [anonymous function](lambdas.html#anonymous-functions).
* *break*{: .keyword }. Terminates the nearest enclosing loop.
* *continue*{: .keyword }. Proceeds to the next step of the nearest enclosing loop.
-->


## breakとcontinueのラベル

<!--original
## Break and Continue Labels
-->

Kotlinにおける任意の式を *label*{: .keyword }でマークすることができます。ラベルは、たとえば、 `@` 記号に続く識別子の形式を持っています： `abc@` 、`fooBar@`が有効なラベル（[文法](grammar.html#label)を参照してください）です。式にラベルを付けるには、式の前にラベルを置きましょう：

<!--original
Any expression in Kotlin may be marked with a *label*{: .keyword }.
Labels have the form of an identifier followed by the `@` sign, for example: `abc@`, `fooBar@` are valid labels (see the [grammar](grammar.html#label)).
To label an expression, we just put a label in front of it
-->

``` kotlin
loop@ for (i in 1..100) {
  // ...
}
```

<!--original
``` kotlin
loop@ for (i in 1..100) {
  // ...
}
```
-->

さあ、これで私たちは *break*{: .keyword } や *continue*{: .keyword } をラベル付けできるようになりました：

<!--original
Now, we can qualify a *break*{: .keyword } or a *continue*{: .keyword } with a label:
-->

``` kotlin
loop@ for (i in 1..100) {
  for (j in 1..100) {
    if (...)
      break@loop
  }
}
```

<!--original
``` kotlin
loop@ for (i in 1..100) {
  for (j in 1..100) {
    if (...)
      break@loop
  }
}
```
-->

ラベル付き *break*{: .keyword }  はそのラベルが付いたループの右後の実行ポイントへジャンプします。
*continue*{: .keyword } はそのループの次の繰り返し実行（イテレーション）まで進みます。

<!--original
A *break*{: .keyword } qualified with a label jumps to the execution point right after the loop marked with that label.
A *continue*{: .keyword } proceeds to the next iteration of that loop.

-->

## ラベルに復帰する

<!--original
## Return at Labels
-->

Kotlinでは、関数リテラル、ローカル変数、オブジェクト式を使用すると、関数を入れ子にすることができます。
ある条件付きの *return*{: .keyword }を使うと、外側の関数から復帰することができます。
最も重要なユースケースは、ラムダ式からのreturnです。これを書くとき、思い出してください：

<!--original
With function literals, local functions and object expression, functions can be nested in Kotlin. 
Qualified *return*{: .keyword }s allow us to return from an outer function. 
The most important use case is returning from a lambda expression. Recall that when we write this:
-->

``` kotlin
fun foo() {
  ints.forEach {
    if (it == 0) return
    print(it)
  }
}
```

<!--original
``` kotlin
fun foo() {
  ints.forEach {
    if (it == 0) return
    print(it)
  }
}
```
-->

*return*{: .keyword } 式は最も内側の関数、すなわち `foo` から復帰します。
（このような非局所的復帰が[インライン関数](inline-functions.html)に渡されたラムダ式でのみサポートされていることに注意してください。）
もしラムダ式から復帰する必要がある場合は、それにラベルを付け、 *return*{: .keyword } を修飾する必要があります：

<!--original
The *return*{: .keyword }-expression returns from the nearest enclosing function, i.e. `foo`.
(Note that such non-local returns are supported only for lambda expressions passed to [inline functions](inline-functions.html).)
If we need to return from a lambda expression, we have to label it and qualify the *return*{: .keyword }:
-->

``` kotlin
fun foo() {
  ints.forEach lit@ {
    if (it == 0) return@lit
    print(it)
  }
}
```

<!--original
``` kotlin
fun foo() {
  ints.forEach lit@ {
    if (it == 0) return@lit
    print(it)
  }
}
```
-->

これはラムダ式からのみ復帰します。多くの場合、暗黙のラベルを使用する方が便利です。
そのようなラベルは、ラムダが渡された関数と同じ名前を持っています。

<!--original
Now, it returns only from the lambda expression. Oftentimes it is more convenient to use implicits labels:
such a label has the same name as the function to which the lambda is passed.
-->

``` kotlin
fun foo() {
  ints.forEach {
    if (it == 0) return@forEach
    print(it)
  }
}
```

<!--original
``` kotlin
fun foo() {
  ints.forEach {
    if (it == 0) return@forEach
    print(it)
  }
}
```
-->

代わりの手法として、[無名関数](lambdas.html#anonymous-functions)とラムダ式を置き換えることができます。
無名関数内の *return*{: .keyword } 文は、その無名関数自体から復帰します。

<!--original
Alternatively, we can replace the lambda expression with an [anonymous function](lambdas.html#anonymous-functions).
A *return*{: .keyword } statement in an anomymous function will return from the anonymous function itself.
-->

``` kotlin
fun foo() {
  ints.forEach(fun(value: Int) {
    if (value == 0) return
    print(value)
  })
}
```

<!--original
``` kotlin
fun foo() {
  ints.forEach(fun(value: Int) {
    if (value == 0) return
    print(value)
  })
}
```
-->

値を返すとき、パーサは資格を持つreturnを優先します。すなわち、

<!--original
When returning a value, the parser gives preference to the qualified return, i.e.
-->

``` kotlin
return@a 1
```

<!--original
``` kotlin
return@a 1
```
-->

上記は「 `@a` ラベルにおけるreturn `1` 」を意味し、「 `(@a 1)` ラベルが付いた式からのreturn」ではありません。

<!--original
means "return `1` at label `@a`" and not "return a labeled expression `(@a 1)`".
-->

# クラスと継承

<!--original
# Classes and Inheritance
-->

## クラス

<!--original
## Classes
-->

Kotlinでのクラスは、*class*{: .keyword }キーワードを使用して宣言されます。

<!--original
Classes in Kotlin are declared using the keyword *class*{: .keyword }:
-->

``` kotlin
class Invoice {
}
```

<!--original
``` kotlin
class Invoice {
}
```
-->

クラス宣言はクラス名、クラスヘッダ（その型パラメータ、主コンストラクタ等）、そして波括弧で括られたクラス本体で構成されます。ヘッダと本体は両方とも必須ではありません。クラスに本体がない場合は、波括弧を省略することができます。

<!--original
The class declaration consists of the class name, the class header (specifying its type parameters, the primary
constructor etc.) and the class body, surrounded by curly braces. Both the header and the body are optional;
if the class has no body, curly braces can be omitted.
-->

``` kotlin
class Empty
```


<!--original
``` kotlin
class Empty
```

-->

### コンストラクタ

<!--original
### Constructors
-->

Kotlin内のクラスは、 **プライマリコンストラクタ** と1つまたは複数の **セカンダリコンストラクタ** を持つことができます。プライマリコンストラクタは、クラスのヘッダーの一部です。クラス名（型パラメータをつけることもできます）の後に続きます。

<!--original
A class in Kotlin can have a **primary constructor** and one or more **secondary constructors**. The primary
constructor is part of the class header: it goes after the class name (and optional type parameters).
-->

``` kotlin
class Person constructor(firstName: String) {
}
```

<!--original
``` kotlin
class Person constructor(firstName: String) {
}
```
-->

プライマリコンストラクタがアノテーションや可視性修飾子を持っていない場合は、 *constructor*{: .keyword }のキーワードを省略することができます。

<!--original
If the primary constructor does not have any annotations or visibility modifiers, the *constructor*{: .keyword }
keyword can be omitted:
-->

``` kotlin
class Person(firstName: String) {
}
```

<!--original
``` kotlin
class Person(firstName: String) {
}
```
-->

プライマリコンストラクタは、どんなコードも含めることはできません。初期化コードは、*init*{: .keyword }キーワードが付いている **初期化ブロック内** に書くことができます。

<!--original
The primary constructor cannot contain any code. Initialization code can be placed
in **initializer blocks**, which are prefixed with the *init*{: .keyword } keyword:
-->

``` kotlin
class Customer(name: String) {
    init {
        logger.info("Customer initialized with value ${name}")
    }
}
```

<!--original
``` kotlin
class Customer(name: String) {
    init {
        logger.info("Customer initialized with value ${name}")
    }
}
```
-->

プライマリコンストラクタの引数を初期化ブロックに使用できることに注意してください。クラス本体内で宣言されたプロパティの初期化処理で使用することもできます。

<!--original
Note that parameters of the primary constructor can be used in the initializer blocks. They can also be used in
property initializers declared in the class body:
-->

``` kotlin
class Customer(name: String) {
    val customerKey = name.toUpperCase()
}
```

<!--original
``` kotlin
class Customer(name: String) {
    val customerKey = name.toUpperCase()
}
```
-->

実際には、プロパティの宣言と初期化を主コンストラクタから行うために、Kotlinは簡潔な構文があります：

<!--original
In fact, for declaring properties and initializing them from the primary constructor, Kotlin has a concise syntax:

-->

``` kotlin
class Person(val firstName: String, val lastName: String, var age: Int) {
  // ...
}
```

<!--original
``` kotlin
class Person(val firstName: String, val lastName: String, var age: Int) {
  // ...
}
```
-->

通常のプロパティとほとんど同じ方法のように、プロパティは主コンストラクタの中で可変値（ミュータブル） ( *var*{: .keyword } ) または固定値（イミュータブル） ( *val*{: .keyword} ) で宣言することができます。

<!--original
Much the same way as regular properties, the properties declared in the primary constructor can be
mutable (*var*{: .keyword }) or read-only (*val*{: .keyword }).
-->

もしコンストラクタがアノテーションや可視性修飾子を持つ場合は、 *constructor*{: .keyword } キーワードが必要で修飾子はその前に置かれる：

<!--original
If the constructor has annotations or visibility modifiers, the *constructor*{: .keyword } keyword is required, and
the modifiers go before it:
-->

``` kotlin
class Customer public @Inject constructor(name: String) { ... }
```

<!--original
``` kotlin
class Customer public @Inject constructor(name: String) { ... }
```
-->

詳細については、[可視性修飾子](visibility-modifiers.html#constructors)を参照してください。

<!--original
For more details, see [Visibility Modifiers](visibility-modifiers.html#constructors).

-->

#### セカンダリコンストラクタ

<!--original
#### Secondary Constructors
-->

クラスは、 *constructor*{: .keyword } プレフィクスと共に **セカンダリコンストラクタ** を宣言することができます：

<!--original
The class can also declare **secondary constructors**, which are prefixed with *constructor*{: .keyword }:
-->

``` kotlin
class Person {
    constructor(parent: Person) {
        parent.children.add(this)
    }
}
```

<!--original
``` kotlin
class Person {
    constructor(parent: Person) {
        parent.children.add(this)
    }
}
```
-->

もしクラスがプライマリコンストラクタを持つなら、それぞれのセカンダリコンストラクタは直接的または間接的に、他のセカンダリコンストラクタを介してプライマリコンストラクタへ委譲する必要があります。 同クラスの他コンストラクタへの委譲は *this*{: .keyword } キーワードを用いて行います：

<!--original
If the class has a primary constructor, each secondary constructor needs to delegate to the primary constructor, either
directly or indirectly through another secondary constructor(s). Delegation to another constructor of the same class
is done using the *this*{: .keyword } keyword:
-->

``` kotlin
class Person(val name: String) {
    constructor(name: String, parent: Person) : this(name) {
        parent.children.add(this)
    }
}
```

<!--original
``` kotlin
class Person(val name: String) {
    constructor(name: String, parent: Person) : this(name) {
        parent.children.add(this)
    }
}
```
-->

もし非抽象クラスが何もコンストラクタ（プライマリ、セカンダリ共に）を宣言しなければ、プライマリコンストラクタが引数無しで生成されます。その際のコンストラクタの可視性はpublicになります。もしpublicなコンストラクタを望まないならば、空の主コンストラクタをデフォルトでない可視性で宣言する必要があります。

<!--original
If a non-abstract class does not declare any constructors (primary or secondary), it will have a generated primary
constructor with no arguments. The visibility of the constructor will be public. If you do not want your class
to have a public constructor, you need to declare an empty primary constructor with non-default visibility:
-->

``` kotlin
class DontCreateMe private constructor () {
}
```

<!--original
``` kotlin
class DontCreateMe private constructor () {
}
```
-->

> **注意**: JVMでは、プライマリコンストラクタの全ての引数がデフォルト値を持つなら、
> コンパイラは引数無しコンストラクタを追加で生成し、そのコンストラクタはデフォルト値を使用します。
> これにより、JacksonやJPAのように引数が無いコンストラクタを通してクラスインスタンスを作るようなライブラリを、
> Kotlinで使いやすくなります。
>
> ``` kotlin
> class Customer(val customerName: String = "")
> ```
{:.info}
 
<!--original
> **NOTE**: On the JVM, if all of the parameters of the primary constructor have default values, the compiler will
> generate an additional parameterless constructor which will use the default values. This makes it easier to use
> Kotlin with libraries such as Jackson or JPA that create class instances through parameterless constructors.
>
> ``` kotlin
> class Customer(val customerName: String = "")
> ```
{:.info}
-->

### クラスのインスタンス生成

<!--original
### Creating instances of classes
-->

クラスのインスタンスを生成するには、コンストラクタを普通の関数のように呼び出せば良いです：

<!--original
To create an instance of a class, we call the constructor as if it were a regular function:
-->

``` kotlin
val invoice = Invoice()

val customer = Customer("Joe Smith")
```

<!--original
``` kotlin
val invoice = Invoice()

val customer = Customer("Joe Smith")
```
-->

Kotlinは *new*{: .keyword } キーワードを持たないことに注意してください。

<!--original
Note that Kotlin does not have a *new*{: .keyword } keyword.
-->

ネストされたクラス、インナークラス、そして匿名のインナークラスの生成は[ネストされたクラス](nested-classes.html)の中に記述されています。

<!--original
Creating instances of nested, inner and anonymous inner classes is described in [Nested classes](nested-classes.html).
-->

### クラスメンバ

<!--original
### Class Members
-->

クラスは以下を含めることができます：

<!--original
Classes can contain
-->

* コンストラクタと初期化ブロック
* [関数](functions.html)
* [プロパティ](properties.html)
* [ネストされたインナークラス](nested-classes.html)
* [オブジェクトの宣言](object-declarations.html)


<!--original
* Constructors and initializer blocks
* [Functions](functions.html)
* [Properties](properties.html)
* [Nested and Inner Classes](nested-classes.html)
* [Object Declarations](object-declarations.html)

-->

## 継承
<!--original
## Inheritance
-->

Kotlinの全てのクラスは共通の `Any` スーパークラスをもちます。これはスーパータイプの宣言がないクラスのデフォルトのスーパークラスです。

<!--original
All classes in Kotlin have a common superclass `Any`, that is a default super for a class with no supertypes declared:
-->

``` kotlin
class Example // Anyから暗黙の継承
```

<!--original
``` kotlin
class Example // Implicitly inherits from Any
```
-->

`Any` は `java.lang.Object` ではありません。特に注意すべきは、 `equals()` 、 `hashCode()` 、 `toString()` 以外のメンバを持ちません。 詳細については [Javaとの相互運用性](java-interop.html#object-methods) を参照してください。

<!--original
`Any` is not `java.lang.Object`; in particular, it does not have any members other than `equals()`, `hashCode()` and `toString()`.
Please consult the [Java interoperability](java-interop.html#object-methods) section for more details.
-->

クラスヘッダ内のコロンの後に型を書くと、明示的にスーパータイプを宣言できます：

<!--original
To declare an explicit supertype, we place the type after a colon in the class header:
-->

``` kotlin
open class Base(p: Int)

class Derived(p: Int) : Base(p)
```

<!--original
``` kotlin
open class Base(p: Int)

class Derived(p: Int) : Base(p)
```
-->

もしこのような（明示的にスーパータイプを宣言する）クラスがプライマリコンストラクタをもつなら、基底の型をプライマリコンストラクタの引数を使用して、そこで初期化できる（し、しなければいけません）。

<!--original
If the class has a primary constructor, the base type can (and must) be initialized right there,
using the parameters of the primary constructor.
-->

もしこのようなクラスがプライマリコンストラクタを持たないならば、セカンダリコンストラクタはそれぞれ基底の型を *super*{: .keyword } キーワードを使って初期化するか、他の初期化してくれるコンストラクタに委譲しなければいけません。この事例では異なるセカンダリコンストラクタが異なる基底の型を持つコンストラクタを呼び出していることに注意すること：

<!--original
If the class has no primary constructor, then each secondary constructor has to initialize the base type
using the *super*{: .keyword } keyword, or to delegate to another constructor which does that.
Note that in this case different secondary constructors can call different constructors of the base type:
-->

``` kotlin
class MyView : View {
    constructor(ctx: Context) : super(ctx) {
    }

    constructor(ctx: Context, attrs: AttributeSet) : super(ctx, attrs) {
    }
}
```

<!--original
``` kotlin
class MyView : View {
    constructor(ctx: Context) : super(ctx) {
    }

    constructor(ctx: Context, attrs: AttributeSet) : super(ctx, attrs) {
    }
}
```
-->

クラスの *open*{: .keyword } アノテーションは、Javaの *final*{: .keyword } と反対です：他のクラスがこのクラスから継承することができます。デフォルトでは、Kotlinのすべてのクラスは [Effective Java](http://www.oracle.com/technetwork/java/effectivejava-136174.html) のアイテム17（ *継承またはそれの禁止のためのデザインとドキュメント* ）に合致する final です。

<!--original
The *open*{: .keyword } annotation on a class is the opposite of Java's *final*{: .keyword }: it allows others
to inherit from this class. By default, all classes in Kotlin are final, which
corresponds to [Effective Java](http://www.oracle.com/technetwork/java/effectivejava-136174.html),
Item 17: *Design and document for inheritance or else prohibit it*.
-->

### メンバのオーバーライド

<!--original
### Overriding Members
-->

前述の通り、私たちはKotlinに明示的にすることにこだわります。そして、Javaとは異なり、Kotlinはメンバをオーバーライドできるメンバ（私たちは *open* と呼んでいます）とオーバライド自体に明示的アノテーションを必要とします。

<!--original
As we mentioned before, we stick to making things explicit in Kotlin. And unlike Java, Kotlin requires explicit
annotations for overridable members (we call them *open*) and for overrides:
-->

``` kotlin
open class Base {
  open fun v() {}
  fun nv() {}
}
class Derived() : Base() {
  override fun v() {}
}
```

<!--original
``` kotlin
open class Base {
  open fun v() {}
  fun nv() {}
}
class Derived() : Base() {
  override fun v() {}
}
```
-->

*override*{: .keyword } アノテーションは `Derived.v()` のために必要です。もしなければ、コンパイラは文句を言うでしょう。もし `Base.nv()` のように *open*{: .keyword } アノテーションが関数になければ、メソッドをサブクラス内で同じ識別子で宣言することは *override*{: .keyword } の有無にかかわらず文法違反です。ファイナルクラス（例えば、 *open*{: .keyword } アノテーションを持たないクラス）の中では、openメンバは禁止されています。

<!--original
The *override*{: .keyword } annotation is required for `Derived.v()`. If it were missing, the compiler would complain.
If there is no *open*{: .keyword } annotation on a function, like `Base.nv()`, declaring a method with the same signature in a subclass is illegal,
either with *override*{: .keyword } or without it. In a final class (e.g. a class with no *open*{: .keyword } annotation), open members are prohibited.
-->

*override*{: .keyword } としてマークされているメンバは、それ自身がopenです。すなわち、サブクラス内でオーバライドされる可能性があります。もし再オーバライドを禁止したければ、 *final*{: .keyword } キーワードを使ってください：

<!--original
A member marked *override*{: .keyword } is itself open, i.e. it may be overridden in subclasses. If you want to prohibit re-overriding, use *final*{: .keyword }:
-->

``` kotlin
open class AnotherDerived() : Base() {
  final override fun v() {}
}
```

<!--original
``` kotlin
open class AnotherDerived() : Base() {
  final override fun v() {}
}
```
-->

プロパティのオーバライドもメソッドのオーバライドと同じように動きます。プライマリコンストラクターでプロパティ宣言の一部として、overrideキーワードを使用できることに注意してください。

<!--original
Overriding properties works in a similar way to overriding methods.
Note that you can use the `override` keyword as part of the property declaration in a primary constructor:
-->

``` kotlin
open class Foo {
    open val x: Int get { ... }
}

class Bar1(override val x: Int) : Foo() {

}
```

<!--original
``` kotlin
open class Foo {
    open val x: Int get { ... }
}

class Bar1(override val x: Int) : Foo() {

}
```
-->

`val` プロパティを `var` プロパティでオーバライドすることもでき、その逆もまた然りです（逆もまた同じです）。これは、`val` のプロパティは、本質的にgetterメソッドを宣言しているためであり、それを `var` としてオーバライドすることは、さらにsetterメソッドを派生クラスに宣言しているためです。

<!--original
You can also override a `val` property with a `var` property, but not vice versa.
This is allowed because a `val` property essentially declares a getter method, and overriding it as a `var` additionally declares a setter method in the derived class.

-->

#### 待って！じゃあどうやって自分のライブラリをハックすれば良いの？！

<!--original
#### Wait! How will I hack my libraries now?!
-->

オーバライドのKotlinでの方法（クラスやメンバはデフォルトでfinal）には1つ問題があります。あなたが使用しているライブラリ内の何かをサブクラス化し、 いくつかのメソッドをオーバライドして（ライブラリの設計者はそれを意図していない） そこにいくつかの厄介なハックを導入するのが難しくなる、という問題です。

<!--original
One issue with our approach to overriding (classes and members final by default) is that it would be difficult to subclass something inside the libraries you use to override some method that was not intended for overriding by the library designer, and introduce some nasty hack there.
-->

私たちは、次のような理由から、これは欠点ではないと考えています：

<!--original
We think that this is not a disadvantage, for the following reasons:
-->

* ベストプラクティスは「とにかくこれらのハックを許可すべきではない」ということである
* 同様のアプローチを取っている他の言語 (C++, C#) はうまくいっている
* もし本当にこのハックが必要ならば、それでも方法は残っている：いつでもハックをJavaで書き、Kotlinから呼ぶことができる（ *[Java Interop](java-interop.html)を参照* してください ）し、Aspectフレームワークはいつもこれらの目的にかないます

<!--original
* Best practices say that you should not allow these hacks anyway
* People successfully use other languages (C++, C#) that have similar approach
* If people really want to hack, there still are ways: you can always write your hack in Java and call it from Kotlin (*see [Java Interop](java-interop.html)*), and Aspect frameworks always work for these purposes
-->

### ルールのオーバーライド


<!--original
### Overriding Rules
-->

Kotlinでは、継承の実装は次のルールで定められています：もしクラスが直接のスーパークラスから同じメンバの多くの実装を継承する場合、クラスはこのメンバを継承し、その独自の実装（おそらく、継承されたものの一つを使用して）を提供しなければいけません。スーパータイプの名前を角括弧で記述し、 super キーワードを使用すると、継承された実装のスーパータイプであることを示すことができます。 例： `super<Base>`

<!--original
In Kotlin, implementation inheritance is regulated by the following rule: if a class inherits many implementations of the same member from its immediate superclasses,
it must override this member and provide its own implementation (perhaps, using one of the inherited ones).
To denote the supertype from which the inherited implementation is taken, we use *super*{: .keyword } qualified by the supertype name in angle brackets, e.g. `super<Base>`:
-->

``` kotlin
open class A {
  open fun f() { print("A") }
  fun a() { print("a") }
}

interface B {
  fun f() { print("B") } // インタフェースのメンバはデフォルトで'open'
  fun b() { print("b") }
}

class C() : A(), B {
  // オーバライドするためにコンパイラは f() を要求する
  override fun f() {
    super<A>.f() // A.f()の呼び出し
    super<B>.f() // B.f()の呼び出し
  }
}
```

<!--original
``` kotlin
open class A {
  open fun f() { print("A") }
  fun a() { print("a") }
}

interface B {
  fun f() { print("B") } // interface members are 'open' by default
  fun b() { print("b") }
}

class C() : A(), B {
  // The compiler requires f() to be overridden:
  override fun f() {
    super<A>.f() // call to A.f()
    super<B>.f() // call to B.f()
  }
}
```
-->

`A` と `B` の両方から継承するのは問題なく、 `C` はそれらの関数の唯一の実装であるため `a()` と `b()` も同様です。しかし `f()` については、2つの実装が `C` に継承されているため、 `C` にある `f()` をオーバライドし、曖昧さを排除するため独自の実装を提供する必要があります。

<!--original
It's fine to inherit from both `A` and `B`, and we have no problems with `a()` and `b()` since `C` inherits only one implementation of each of these functions.
But for `f()` we have two implementations inherited by `C`, and thus we have to override `f()` in `C`
and provide our own implementation that eliminates the ambiguity.
-->

## 抽象クラス

<!--original
## Abstract Classes
-->

クラスとそのメンバは *abstract*{: .keyword } を使用して抽象クラス・抽象メンバとして宣言することができます。抽象メンバはそのクラス内に実装を持ちません。抽象クラスや抽象関数にopenアノテーションを付ける必要はないことに注意してください。もっとも、それは言うまでもないことですが。

<!--original
A class and some of its members may be declared *abstract*{: .keyword }.
An abstract member does not have an implementation in its class.
Note that we do not need to annotate an abstract class or function with open – it goes without saying.
-->

非抽象オープンメンバを抽象メンバでオーバライドすることもできます。

<!--original
We can override a non-abstract open member with an abstract one
-->

``` kotlin
open class Base {
  open fun f() {}
}

abstract class Derived : Base() {
  override abstract fun f()
}
```

<!--original
``` kotlin
open class Base {
  open fun f() {}
}

abstract class Derived : Base() {
  override abstract fun f()
}
```
-->

## コンパニオンオブジェクト (Companion Objects)

<!--original
## Companion Objects
-->

Kotlinでは、JavaやC＃とは異なり、クラスはstaticメソッドを持ちません。ほとんどの場合、代替として、パッケージレベルの関数を使用することが推奨されています。

<!--original
In Kotlin, unlike Java or C#, classes do not have static methods. In most cases, it's recommended to simply use
package-level functions instead.
-->

もしクラスインスタンスを持たずに呼べるがクラス内部（例えばファクトリメソッド）へのアクセスが要る関数を書く必要があれば、そのクラスの中で [オブジェクト宣言](object-declaration.html) のメンバとして書くことができます。

<!--original
If you need to write a function that can be called without having a class instance but needs access to the internals
of a class (for example, a factory method), you can write it as a member of an [object declaration](object-declarations.html)
inside that class.
-->

特に、もし [コンパニオンオブジェクト](object-declarations.html#companion-objects) をクラス内で宣言した場合であっても、クラス名を識別子として、static関数をJava/C# で呼ぶのと同じ構文でそのメンバを呼ぶことができます。

<!--original
Even more specifically, if you declare a [companion object](object-declarations.html#companion-objects) inside your class,
you'll be able to call its members with the same syntax as calling static methods in Java/C#, using only the class name
as a qualifier.

-->

シールクラス (Sealed Classes)

<!--original
## Sealed Classes
-->

値が制限されたセットの1つの型を持つが、他の型を持てない場合、シールクラスが制限されたクラス階層を表現する際に用いられます。それらはある意味、enum（列挙型）クラスの拡張です。enum型の値のセットも同じく制限されているが、それぞれのenum定数はシングルインスタンスとしてのみ存在し、シールクラスのサブクラスは状態を保持できる複数のインスタンスをもつことができます。

<!--original
Sealed classes are used for representing restricted class hierarchies, when a value can have one of the types from a
limited set, but cannot have any other type. They are, in a sense, an extension of enum classes: the set of values
for an enum type is also restricted, but each enum constant exists only as a single instance, whereas a subclass
of a sealed class can have multiple instances which can contain state.
-->

`sealed` 修飾子をクラス名の前に置くと、シールクラスを宣言できます。ルクラスはサブクラスを持つことができますが、それらは全てシールクラス自身の宣言の中にネストされていなければいけません。

<!--original
To declare a sealed class, you put the `sealed` modifier before the name of the class. A sealed class can have
subclasses, but all of them must be nested inside the declaration of the sealed class itself.
-->

``` kotlin
sealed class Expr {
    class Const(val number: Double) : Expr()
    class Sum(val e1: Expr, val e2: Expr) : Expr()
    object NotANumber : Expr()
}
```

<!--original
``` kotlin
sealed class Expr {
    class Const(val number: Double) : Expr()
    class Sum(val e1: Expr, val e2: Expr) : Expr()
    object NotANumber : Expr()
}
```
-->

シールクラスのサブクラス（間接的な継承）を拡張するクラスはどこにでも置くことができ、シールクラスの中に書く必要はないことに注意してください。

<!--original
Note that classes which extend subclasses of a sealed class (indirect inheritors) can be placed anywhere, not necessarily inside
the declaration of the sealed class.
-->

シールクラスの主な利点は [`when`式](control-flow.html#when-expression) の中で使用されたときに発揮されます。もし文が全ての事象をカバーすることを確認・証明できれば、 `else` 句を追加する必要はありません。

<!--original
The key benefit of using sealed classes comes into play when you use them in a [`when` expression](control-flow.html#when-expression). If it's possible
to verify that the statement covers all cases, you don't need to add an `else` clause to the statement.
-->

``` kotlin
fun eval(expr: Expr): Double = when(expr) {
    is Expr.Const -> expr.number
    is Expr.Sum -> eval(expr.e1) + eval(expr.e2)
    Expr.NotANumber -> Double.NaN
    // 全ての事例を嘗めたため、`else` 句は不要
}
```

<!--original
``` kotlin
fun eval(expr: Expr): Double = when(expr) {
    is Expr.Const -> expr.number
    is Expr.Sum -> eval(expr.e1) + eval(expr.e2)
    Expr.NotANumber -> Double.NaN
    // the `else` clause is not required because we've covered all the cases
}
```
-->

# プロパティとフィールド

<!--original
# Properties and Fields
-->

## プロパティの宣言

<!--original
## Declaring Properties
-->

Kotlinのクラスは、プロパティを持つことができます。
これらは、 *var*{: .keyword } キーワードを使用して、ミュータブル（可変）として宣言することもでき、 *val*{: .keyword } キーワードを使用するとイミュータブル（読み取り専用）にすることもできます。

<!--original
Classes in Kotlin can have properties.
These can be declared as mutable, using the *var*{: .keyword } keyword or read-only using the *val*{: .keyword } keyword.
-->

``` kotlin
public class Address { 
  public var name: String = ...
  public var street: String = ...
  public var city: String = ...
  public var state: String? = ...
  public var zip: String = ...
}
```

<!--original
``` kotlin
public class Address { 
  public var name: String = ...
  public var street: String = ...
  public var city: String = ...
  public var state: String? = ...
  public var zip: String = ...
}
```
-->

プロパティを使うにはJavaでのフィールドでやるように、ただ単純に名前で参照するだけで良いです：

<!--original
To use a property, we simply refer to it by name, as if it were a field in Java:
-->

``` kotlin
fun copyAddress(address: Address): Address {
  val result = Address() // 'new' キーワードは Kotlin にありません
  result.name = address.name // アクセサが呼ばれる
  result.street = address.street
  // ...
  return result
}
```

<!--original
``` kotlin
fun copyAddress(address: Address): Address {
  val result = Address() // there's no 'new' keyword in Kotlin
  result.name = address.name // accessors are called
  result.street = address.street
  // ...
  return result
}
```
-->

## ゲッターとセッター

<!--original
## Getters and Setters
-->

プロパティを宣言するための完全な構文は次のとおりです

<!--original
The full syntax for declaring a property is
-->

``` kotlin
var <propertyName>: <PropertyType> [= <property_initializer>]
  [<getter>]
  [<setter>]
```

<!--original
``` kotlin
var <propertyName>: <PropertyType> [= <property_initializer>]
  [<getter>]
  [<setter>]
```
-->

イニシャライザ、ゲッターとセッターは必須ではありません。イニシャライザか基本クラスのメンバーからオーバライドされることが推測される場合は、プロパティの型も必須ではありません。 

<!--original
The initializer, getter and setter are optional. Property type is optional if it can be inferred from the initializer or from the base class member being overridden.
-->

例：

<!--original
Examples:
-->

``` kotlin
var allByDefault: Int? // エラー：明示的なイニシャライザが必要、デフォルトのゲッターとセッターは暗黙
var initialized = 1 // これは Int 型を持ち、ゲッターとセッターも持つ
```

<!--original
``` kotlin
var allByDefault: Int? // error: explicit initializer required, default getter and setter implied
var initialized = 1 // has type Int, default getter and setter
```
-->

読み取り専用のプロパティ宣言の完全な構文は、ミュータブルのものと比べて2点異なります。`var` の代わりに `val` で始まるのと、セッターを認めないことでです：

<!--original
The full syntax of a read-only property declaration differs from a mutable one in two ways: it starts with `val` instead of `var` and does not allow a setter:
-->

``` kotlin
val simple: Int? // Int 型を持ち、デフォルトゲッターを持つ。コンストラクタ内で初期化が必要
val inferredType = 1 // Int 型を持ち、デフォルトゲッターを持つ
```

<!--original
``` kotlin
val simple: Int? // has type Int, default getter, must be initialized in constructor
val inferredType = 1 // has type Int and a default getter
```
-->

カスタムアクセサは普通の関数ととても似ていて、プロパティの中に宣言することができます。ここでは、カスタムゲッターの例を示します：

<!--original
We can write custom accessors, very much like ordinary functions, right inside a property declaration. Here's an example of a custom getter:
-->

``` kotlin
val isEmpty: Boolean
  get() = this.size == 0
```

<!--original
``` kotlin
val isEmpty: Boolean
  get() = this.size == 0
```
-->

カスタムセッターは次のようになります：

<!--original
A custom setter looks like this:
-->

``` kotlin
var stringRepresentation: String
  get() = this.toString()
  set(value) {
    setDataFromString(value) // 文字列をパースして他のプロパティへ値を代入する
  }
```

<!--original
``` kotlin
var stringRepresentation: String
  get() = this.toString()
  set(value) {
    setDataFromString(value) // parses the string and assigns values to other properties
  }
```
-->

慣例により、セッターの引数名は `value` ですが、別の名前が良いならそちらを選択することもできます。

<!--original
By convention, the name of the setter parameter is `value`, but you can choose a different name if you prefer.
-->

アクセサの可視性を変更したり、アノテーションを付ける必要がありますが、デフォルトの実装を変更する必要がない場合は、その本体を定義せずにアクセサを定義することができます：

<!--original
If you need to change the visibility of an accessor or to annotate it, but don't need to change the default implementation,
you can define the accessor without defining its body:
-->

``` kotlin
var setterVisibility: String = "abc"
  private set // セッターはプライベートでデフォルトの実装を持つ

var setterWithAnnotation: Any? = null
  @Inject set // セッターに Inject でアノテーションを付ける
```

<!--original
``` kotlin
var setterVisibility: String = "abc"
  private set // the setter is private and has the default implementation

var setterWithAnnotation: Any? = null
  @Inject set // annotate the setter with Inject
```
-->

### バッキングフィールド (Backing Fields)

<!--original
### Backing Fields
-->

Kotlinのクラスは、フィールドを持つことができません。しかし、カスタムアクセサを使用するときにバッキングフィールドが必要になることがあります。この目的のために、Kotlinは自動バッキングフィールドを提供します。これにより、 `field` 識別子を使用してアクセスすることができます。

<!--original
Classes in Kotlin cannot have fields. However, sometimes it is necessary to have a backing field when using custom accessors. For these purposes, Kotlin provides
an automatic backing field which can be accessed using the `field` identifier:
-->

``` kotlin
var counter = 0 // イニシャライザの value はバッキングフィールドへ直に書き込まれる
  set(value) {
    if (value >= 0)
      field = value
  }
```

<!--original
``` kotlin
var counter = 0 // the initializer value is written directly to the backing field
  set(value) {
    if (value >= 0)
      field = value
  }
```
-->

`field` 識別子は、プロパティのアクセサにのみ使用することができます。

<!--original
The `field` identifier can only be used in the accessors of the property.
-->

プロパティがアクセサのデフォルトの実装のうち少なくとも1つを使用するか、カスタムアクセサが `field` 識別子を通して参照された場合に、バッキングフィールドは生成されます。

<!--original
A backing field will be generated for a property if it uses the default implementation of at least one of the accessors, or if a custom accessor references it through the `field` identifier.
-->

たとえば、以下のような場合にはバッキングフィールドは存在しません：

<!--original
For example, in the following case there will be no backing field:
-->

``` kotlin
val isEmpty: Boolean
  get() = this.size == 0
```

<!--original
``` kotlin
val isEmpty: Boolean
  get() = this.size == 0
```
-->

### バッキングプロパティ

<!--original
### Backing Properties
-->

「暗黙のバッキングフィールド」にそぐわないことをやりたい場合には、 *バッキングプロパティ (backing property)* を持つように必ずフォールバックさせることもできます：

<!--original
If you want to do something that does not fit into this "implicit backing field" scheme, you can always fall back to having a *backing property*:
-->

``` kotlin
private var _table: Map<String, Int>? = null
public val table: Map<String, Int>
  get() {
    if (_table == null)
      _table = HashMap() // 型パラメータが推論される
    return _table ?: throw AssertionError("他スレッドによってnullをセットされた")
  }
```

<!--original
``` kotlin
private var _table: Map<String, Int>? = null
public val table: Map<String, Int>
  get() {
    if (_table == null)
      _table = HashMap() // Type parameters are inferred
    return _table ?: throw AssertionError("Set to null by another thread")
  }
```
-->

全ての点において、これはちょうどJavaと同じです。なぜなら、privateプロパティへデフォルトゲッターとセッターでのアクセスが、関数呼び出しのオーバヘッドが無いように最適化されているためです。

<!--original
In all respects, this is just the same as in Java since access to private properties with default getters and setters is optimized so that no function call overhead is introduced.

-->

## コンパイル時定数

<!--original
## Compile-Time Constants
-->

値がコンパイル時にわかるプロパティは、 `const` 修飾子を使用して、 _コンパイル時定数 (compile time constants)_ としてマークすることができます。
このようなプロパティは、次の要件を満たす必要があります：

<!--original
Properties the value of which is known at compile time can be marked as _compile time constants_ using the `const` modifier.
Such properties need to fulfil the following requirements:
-->

  * トップレベルまたは object のメンバ
  * String 型の値またはプリミティブ型で初期化される
  * カスタムゲッターが無い

<!--original
  * Top-level or member of an `object`
  * Initialized with a value of type `String` or a primitive type
  * No custom getter
-->

このようなプロパティには、アノテーションを付けることができます：

<!--original
Such properties can be used in annotations:
-->

``` kotlin
const val SUBSYSTEM_DEPRECATED: String = "This subsystem is deprecated"

@Deprecated(SUBSYSTEM_DEPRECATED) fun foo() { ... }
```


<!--original
``` kotlin
const val SUBSYSTEM_DEPRECATED: String = "This subsystem is deprecated"

@Deprecated(SUBSYSTEM_DEPRECATED) fun foo() { ... }
```

-->

## 遅延初期化プロパティ

<!--original
## Late-Initialized Properties
-->

通常、非null型として宣言されたプロパティは、コンストラクタ内で初期化される必要があります。
しかし、かなり多くの場合において、これは便利ではありません。
たとえば、プロパティは、依存オブジェクト (DI; dependency injection; 依存性注入, 訳注：[参考](http://blog.a-way-out.net/blog/2015/08/31/your-dependency-injection-is-wrong-as-I-expected/))を介して、またはユニットテストのセットアップメソッドで初期化することができます。
この事例では、非nullのイニシャライザをコンストラクタ内で提供することができませんが、それでもなおクラス内の本体にあるプロパティを参照する際にnullチェックを避けたいでしょう。

<!--original
Normally, properties declared as having a non-null type must be initialized in the constructor.
However, fairly often this is not convenient. For example, properties can be initialized through dependency injection,
or in the setup method of a unit test. In this case, you cannot supply a non-null initializer in the constructor,
but you still want to avoid null checks when referencing the property inside the body of a class.
-->

このような事例を扱うには、`lateinit` 修飾子でプロパティをマークすると良いでしょう：

<!--original
To handle this case, you can mark the property with the `lateinit` modifier:
-->

``` kotlin
public class MyTest {
    lateinit var subject: TestSubject

    @SetUp fun setup() {
        subject = TestSubject()
    }

    @Test fun test() {
        subject.method()  // 参照先を直に見に行く(dereference directly)
    }
}
```

<!--original
``` kotlin
public class MyTest {
    lateinit var subject: TestSubject

    @SetUp fun setup() {
        subject = TestSubject()
    }

    @Test fun test() {
        subject.method()  // dereference directly
    }
}
```
-->

この識別子はクラス本体（プライマリコンストラクタでない）の中で宣言され、カスタムゲッターやカスタムセッターを持たない `var` プロパティでのみ使用することができます。
プロパティの型が非nullかつ、プリミティブ型であってはなりません。

<!--original
The modifier can only be used on `var` properties declared inside the body of a class (not in the primary constructor), and only
when the property does not have a custom getter or setter. The type of the property must be non-null, and it must not be
a primitive type.
-->

`lateinit` プロパティが初期化される前にアクセスした場合、アクセスされたプロパティと、それが初期化されていないことを特定するための特別な例外が投げられます。

<!--original
Accessing a `lateinit` property before it has been initialized throws a special exception that clearly identifies the property
being accessed and the fact that it hasn't been initialized.
-->

## プロパティのオーバライド

<!--original
## Overriding Properties
-->

[メンバのオーバライド](classes.html#overriding-members) を参照してください。

<!--original
See [Overriding Members](classes.html#overriding-members)
-->

## 委任プロパティ (Delegated Properties)

<!--original
## Delegated Properties
-->
  

プロパティのうち最も一般的なのは、単純にバッキングフィールドからの読み込み（または書き込みかもしれない）です。
一方、カスタムゲッターとセッターを使えばプロパティの振る舞いを如何様にも実装できます。
いろんなところに、プロパティの動作について、確立された共通パターンがあります。
いくつかの例を挙げます：遅延評価値、与えられたキーでのmapの読み込み、データベースへのアクセス、アクセスをトリガとするリスナへの通知等。

<!--original
The most common kind of properties simply reads from (and maybe writes to) a backing field. 
On the other hand, with custom getters and setters one can implement any behaviour of a property.
Somewhere in between, there are certain common patterns of how a property may work. A few examples: lazy values,
reading from a map by a given key, accessing a database, notifying listener on access, etc.
-->

このような一般的な振る舞いは、[_委譲プロパティ (delegated properties)_](delegated-properties.html) を使ってライブラリに実装することができます。

<!--original
Such common behaviours can be implemented as libraries using [_delegated properties_](delegated-properties.html).

-->

# インターフェース

<!--original
# Interfaces
-->

Kotlinでのインタフェースは、Java 8と非常によく似ています。インタフェースは抽象メソッドの宣言と同様に、メソッドの実装を含めることができます。抽象クラスと違って、インタフェースは状態を持てません。インタフェースはプロパティを持つことができますが、これらは abstract であること、またはアクセサの実装を提供することが必要です。

<!--original
Interfaces in Kotlin are very similar to Java 8. They can contain declarations of abstract methods, as well as method
implementations. What makes them different from abstract classes is that interfaces cannot store state. They can have
properties but these need to be abstract or to provide accessor implementations.
-->

インタフェースは、 *interface*{: .keyword } キーワードを使用して定義されます。

<!--original
An interface is defined using the keyword *interface*{: .keyword }
-->

``` kotlin
interface MyInterface {
    fun bar()
    fun foo() {
      // 本体は任意
    }
}
```

<!--original
``` kotlin
interface MyInterface {
    fun bar()
    fun foo() {
      // optional body
    }
}
```
-->

## インタフェースの実装

<!--original
## Implementing Interfaces
-->

クラスやオブジェクトは、1つまたは複数のインターフェイスを実装することができます：

<!--original
A class or object can implement one or more interfaces
-->

``` kotlin
class Child : MyInterface {
   override fun bar() {
      // 本体
   }
}
```

<!--original
``` kotlin
class Child : MyInterface {
   override fun bar() {
      // body
   }
}
```
-->

## インターフェイス内のプロパティ

<!--original
## Properties in Interfaces
-->

インターフェイス内にプロパティを宣言することができます。インタフェースで宣言されたプロパティは、 abstract にすることも、アクセサの実装を提供することもできます。インタフェース内で宣言されたプロパティはバッキングフィールドを持つことはできず、それ故にインタフェース内で宣言されたアクセサはそれらを参照できません。

<!--original
You can declare properties in interfaces. A property declared in an interface can either be abstract, or it can provide
implementations for accessors. Properties declared in interfaces can't have backing fields, and therefore accessors
declared in interfaces can't reference them.
-->

``` kotlin
interface MyInterface {
    val property: Int // abstract

    val propertyWithImplementation: String
        get() = "foo"

    fun foo() {
        print(property)
    }
}

class Child : MyInterface {
    override val property: Int = 29
}
```

<!--original
``` kotlin
interface MyInterface {
    val property: Int // abstract

    val propertyWithImplementation: String
        get() = "foo"

    fun foo() {
        print(property)
    }
}

class Child : MyInterface {
    override val property: Int = 29
}
```
-->

## オーバーライドの競合解決

<!--original
## Resolving overriding conflicts
-->

スーパータイプのリストでたくさんの型を宣言すると、同メソッドの複数の実装を継承するように見えることがあります。例えば：

<!--original
When we declare many types in our supertype list, it may appear that we inherit more than one implementation of the same method. For example
-->

``` kotlin
interface A {
  fun foo() { print("A") }
  fun bar()
}

interface B {
  fun foo() { print("B") }
  fun bar() { print("bar") }
}

class C : A {
  override fun bar() { print("bar") }
}

class D : A, B {
  override fun foo() {
    super<A>.foo()
    super<B>.foo()
  }
}
```

<!--original
``` kotlin
interface A {
  fun foo() { print("A") }
  fun bar()
}

interface B {
  fun foo() { print("B") }
  fun bar() { print("bar") }
}

class C : A {
  override fun bar() { print("bar") }
}

class D : A, B {
  override fun foo() {
    super<A>.foo()
    super<B>.foo()
  }
}
```
-->

インタフェース *A* と *B* は、両方とも関数 *foo()* と *bar()* を宣言しています。両方とも *foo()* を実装していますが、 *B* のみが *bar()* を実装しています。（ *bar()* は *A* では abstract としてマークされていません。これは関数が本体を持たないときのインタフェースのデフォルトだからです。） 
さて、もし具体クラス *C* を *A* から得れば、 *bar()* をオーバライドし、実装を提供しなければならないことは明らかです。そしてもし *D* を *A* と *B* から得れば、 *bar()* をオーバライドする必要はありません。なぜなら1つの実装を継承したからです。
しかし *foo()* の実装を2つ継承してしまったため、コンパイラはどっちを選んだら良いかわかりません。したがって *foo()* のオーバライドが強制され、何が欲しいのかを明示する必要があります。

<!--original
Interfaces *A* and *B* both declare functions *foo()* and *bar()*. Both of them implement *foo()*, but only *B* implements *bar()* (*bar()* is not marked abstract in *A*,
because this is the default for interfaces, if the function has no body). Now, if we derive a concrete class *C* from *A*, we, obviously, have to override *bar()* and provide
an implementation. And if we derive *D* from *A* and *B*, we don’t have to override *bar()*, because we have inherited only one implementation of it.
But we have inherited two implementations of *foo()*, so the compiler does not know which one to choose, and forces us to override *foo()* and say what we want explicitly.
-->


# 可視性修飾子

<!--original
# Visibility Modifiers
-->

クラス、オブジェクト、インタフェース、コンストラクタ、関数、プロパティとそのセッターは、_可視性修飾子 (visibility modifiers)_ を持つことができます。（ゲッターは常にプロパティと同じ可視性を持ちます。）Kotlinには4つの可視性修飾子があります： `private` , `protected` , `internal` , `public` 。明示的な修飾子がない場合に使用されるデフォルトの可視性は、`public` です。

<!--original
Classes, objects, interfaces, constructors, functions, properties and their setters can have _visibility modifiers_.
(Getters always have the same visibility as the property.) 
There are four visibility modifiers in Kotlin: `private`, `protected`, `internal` and `public`.
The default visibility, used if there is no explicit modifier, is `public`.
-->

宣言スコープの違いは、後述の例をご覧ください。

<!--original
Below please find explanations of these for different type of declaring scopes.
-->
  
## パッケージ

<!--original
## Packages
-->
  

関数、プロパティやクラス、オブジェクトやインターフェースは、「トップレベル」、つまり、パッケージ内部で直接宣言することができます。

<!--original
Functions, properties and classes, objects and interfaces can be declared on the "top-level", i.e. directly inside a package:
-->
  
``` kotlin
// ファイル名: example.kt
package foo

fun baz() {}
class Bar {}
```

<!--original
``` kotlin
// file name: example.kt
package foo

fun baz() {}
class Bar {}
```
-->

* 可視性修飾子を何も指定しない場合は、宣言がどこでも見える `public` がデフォルトして使用されます。
* `private` として宣言すると、その宣言を含むファイルの中でのみ見えます
* `internal` として宣言すると、同じモジュール内のどこからでも見えます
* `protected` はトップレベルの宣言では使用できません

<!--original
* If you do not specify any visibility modifier, `public` is used by default, which means that your declarations will be
visible everywhere;
* If you mark a declaration `private`, it will only be visible inside the file containing the declaration;
* If you mark it `internal`, it is visible everywhere in the same module;
* `protected` is not available for top-level declarations.
-->

例：

<!--original
Examples:
-->

``` kotlin
// ファイル名: example.kt
package foo

private fun foo() {} // example.kt の中で見える

public var bar: Int = 5 // プロパティはどこでも見える
    private set         // セッターは example.kt の中でのみ見える
    
internal val baz = 6    // 同じモジュール内でのみ見える
```

<!--original
``` kotlin
// file name: example.kt
package foo

private fun foo() {} // visible inside example.kt

public var bar: Int = 5 // property is visible everywhere
    private set         // setter is visible only in example.kt
    
internal val baz = 6    // visible inside the same module
```
-->

## クラスとインタフェース

<!--original
## Classes and Interfaces
-->

クラス内で宣言した場合：

<!--original
When declared inside a class:
-->

* `private` はそのクラス内（そのすべてのメンバーを含む）でのみ見える
* `protected` -- `private` と同じ + サブクラス内でも見えます
* `internal` -- `internal` 宣言するクラスを見る *そのモジュール内の* 任意のクライアントはその `internal` メンバが見えます
* `public` -- `public` 宣言するクラスを見ている任意のクライアントは、`public` のメンバが見えます

<!--original
* `private` means visible inside this class only (including all its members);
* `protected` --- same as `private` + visible in subclasses too;
* `internal` --- any client *inside this module* who sees the declaring class sees its `internal` members;
* `public` --- any client who sees the declaring class sees its `public` members.
-->

*注意* Javaのユーザーへ：Kotlinでは、外部クラスはその内部クラスのprivate メンバが見えません。

<!--original
*NOTE* for Java users: outer class does not see private members of its inner classes in Kotlin.
-->

`protected` のメンバをオーバーライドして、明示的に可視性を指定しない場合、オーバーライドするメンバも、`protected` の可視性になります。

<!--original
If you override a `protected` member and do not specify the visibility explicitly, the overriding member will also have `protected` visibility.
-->

例：

<!--original
Examples:
-->

``` kotlin
open class Outer {
    private val a = 1
    protected open val b = 2
    internal val c = 3
    val d = 4  // デフォルトで public
    
    protected class Nested {
        public val e: Int = 5
    }
}

class Subclass : Outer() {
    // a は見えない
    // b, c, d は見える
    // Nested と e は見える

    override val b = 5   // 'b' は protected
}

class Unrelated(o: Outer) {
    // o.a, o.b は見えない
    // o.c and o.d は見える（同じモジュール）
    // Outer.Nested, Nested::e は見えない
}
```

<!--original
``` kotlin
open class Outer {
    private val a = 1
    protected open val b = 2
    internal val c = 3
    val d = 4  // public by default
    
    protected class Nested {
        public val e: Int = 5
    }
}

class Subclass : Outer() {
    // a is not visible
    // b, c and d are visible
    // Nested and e are visible

    override val b = 5   // 'b' is protected
}

class Unrelated(o: Outer) {
    // o.a, o.b are not visible
    // o.c and o.d are visible (same module)
    // Outer.Nested is not visible, and Nested::e is not visible either 
}
```
-->

### コンストラクタ

<!--original
### Constructors
-->

クラスのプライマリコンストラクタの可視性を指定したい場合は、次の構文を使ってください（明示的に *constructor*{: .keyword }* キーワードを付加しなければならないことに注意）：

<!--original
To specify a visibility of the primary constructor of a class, use the following syntax (note that you need to add an
explicit *constructor*{: .keyword } keyword):
-->

``` kotlin
class C private constructor(a: Int) { ... }
```

<!--original
``` kotlin
class C private constructor(a: Int) { ... }
```
-->

ここでは、コンストラクタは `private` です。デフォルトでは、すべてのコンストラクタが `public` です。これにより、そのクラスが見える場所であればどこからでもそのクラスを見ることができます。（すなわち、 `internal` クラスのコンストラクタは、同じモジュール内でのみ見えます）

<!--original
Here the constructor is private. By default, all constructors are `public`, which effectively
amounts to them being visible everywhere where the class is visible (i.e. a constructor of an `internal` class is only 
visible within the same module).
-->
     
### ローカル宣言

<!--original
### Local declarations
-->
     
ローカル変数、関数やクラスは、可視性修飾子を持つことはできません。

<!--original
Local variables, functions and classes can not have visibility modifiers.
-->

## モジュール

<!--original
## Modules
-->

`internal` 可視性修飾子には、メンバが同じモジュールで見えることを意味します。具体的には、モジュールはKotlinのファイルセットであり、一緒にコンパイルされます。

<!--original
The `internal` visibility modifier means that the member is visible with the same module. More specifically,
a module is a set of Kotlin files compiled together:
-->

  * IntelliJ IDEAモジュール
  * MavenやGradleのプロジェクト
  * &lt;kotlinc&gt;Antタスクの1回の呼び出しでコンパイルされたファイルのセット

<!--original
  * an IntelliJ IDEA module;
  * a Maven or Gradle project;
  * a set of files compiled with one invocation of the <kotlinc> Ant task.
-->

# 拡張 (extension)

<!--original
# Extensions
-->

Kotlinは、C#やGosuと似ていて、クラスを継承したりDecoratorのようなデザインパターンを使用せずとも、クラスを新しい機能で拡張する能力を提供します。
これは、 _拡張_ と呼ばれる特別な宣言を介して行われます。Kotlinは、 _拡張関数_ と _拡張プロパティ_ をサポートしています。

<!--original
Kotlin, similar to C# and Gosu, provides the ability to extend a class with new functionality without having to inherit from the class or use any type of design pattern such as Decorator.
This is done via special declarations called _extensions_. Kotlin supports _extension functions_ and _extension properties_.
-->

## 拡張関数

<!--original
## Extension Functions
-->

拡張関数を宣言するには _レシーバタイプ (receiver type)_ を関数名の前に付ける必要があります。
次の例では、 `swap` 関数を `MutableList<Int>` に追加しています：

<!--original
To declare an extension function, we need to prefix its name with a _receiver type_, i.e. the type being extended.
The following adds a `swap` function to `MutableList<Int>`:
-->

``` kotlin
fun MutableList<Int>.swap(index1: Int, index2: Int) {
  val tmp = this[index1] // 'this' がリストに対応する
  this[index1] = this[index2]
  this[index2] = tmp
}
```

<!--original
``` kotlin
fun MutableList<Int>.swap(index1: Int, index2: Int) {
  val tmp = this[index1] // 'this' corresponds to the list
  this[index1] = this[index2]
  this[index2] = tmp
}
```
-->

拡張関数内での *this*{: .keyword } キーワードは、レシーバオブジェクト（ドットの前に渡されたもの）に対応しています。これで、この関数を任意の `MutableList<Int>` からでも呼べるようになりました：

<!--original
The *this*{: .keyword } keyword inside an extension function corresponds to the receiver object (the one that is passed before the dot). 
Now, we can call such a function on any `MutableList<Int>`:
-->

``` kotlin
val l = mutableListOf(1, 2, 3)
l.swap(0, 2) // 'swap()' 中の 'this' は値 '1' を保持する
```

<!--original
``` kotlin
val l = mutableListOf(1, 2, 3)
l.swap(0, 2) // 'this' inside 'swap()' will hold the value of 'l'
```
-->

もちろん、任意の `MutableList<T>` についてこの関数は理にかなっており、ジェネリックにもできます：

<!--original
Of course, this function makes sense for any `MutableList<T>`, and we can make it generic:
-->

``` kotlin
fun <T> MutableList<T>.swap(index1: Int, index2: Int) {
  val tmp = this[index1] // 'this' はリストに対応する
  this[index1] = this[index2]
  this[index2] = tmp
}
```

<!--original
``` kotlin
fun <T> MutableList<T>.swap(index1: Int, index2: Int) {
  val tmp = this[index1] // 'this' corresponds to the list
  this[index1] = this[index2]
  this[index2] = tmp
}
```
-->

関数名の前でジェネリック型のパラメータを宣言すると、レシーバ型の式で使用できるようになります。[ジェネリック関数](generics.html)を参照してください。

<!--original
We declare the generic type parameter before the function name for it to be available in the receiver type expression. 
See [Generic functions](generics.html).
-->

## 拡張は **静的** に解決される

<!--original
## Extensions are resolved **statically**
-->

拡張機能は拡張したクラスを実際に変更するわけではありません。拡張を定義すると、クラスに新たなメンバを挿入するのではなく、そのクラスのインスタンスにおいて、ただ単にその新しい関数をただドット付きで呼べるようになるだけです。

<!--original
Extensions do not actually modify classes they extend. By defining an extension, you do not insert new members into a class,
but merely make new functions callable with the dot-notation on instances of this class.
-->

拡張関数は **静的に** 処理される、つまり、それらはレシーバの型による仮の存在ではないということを強調しておきたいです。これは、関数が呼び出されたときの式の型によって、呼び出される拡張関数が決定されるのであって、実行時の式の評価によるのではないことを意味します。例えば：

<!--original
We would like to emphasize that extension functions are dispatched **statically**, i.e. they are not virtual by receiver type.
This means that the extension function being called is determined by the type of the expression on which the function is invoked,
not by the type of the result of evaluating that expression at runtime. For example:
-->

``` kotlin
open class C

class D: C()

fun C.foo() = "c"

fun D.foo() = "d"

fun printFoo(c: C) {
    println(c.foo())
}

printFoo(D())
```

<!--original
``` kotlin
open class C

class D: C()

fun C.foo() = "c"

fun D.foo() = "d"

fun printFoo(c: C) {
    println(c.foo())
}

printFoo(D())
```
-->

この例では、 "c"を出力します。呼び出されている拡張関数は `C` クラスのパラメータ `c` の宣言型にのみ依存するためです。

<!--original
This example will print "c", because the extension function being called depends only on the declared type of the
parameter `c`, which is the `C` class.
-->

もし、あるクラスがメンバ関数を持つうえ、さらに、同じレシーバ型、同じ名前を有し、与えられた引数を受容可能な拡張関数が宣言されると、 **常にメンバが優先されます** 。例えば：

<!--original
If a class has a member function, and an extension function is defined which has the same receiver type, the same name
and is applicable to given arguments, the **member always wins**.
For example:
-->

``` kotlin
class C {
    fun foo() { println("member") }
}

fun C.foo() { println("extension") }
```

<!--original
``` kotlin
class C {
    fun foo() { println("member") }
}

fun C.foo() { println("extension") }
```
-->

`C` 型の任意の `c` から `c.foo()` を呼べば、"extension" ではなく、 "member" と表示します。

<!--original
If we call `c.foo()` of any `c` of type `C`, it will print "member", not "extension".
-->

しかしながら、異なる署名を持つが同名のメンバ関数を拡張関数がオーバライドすることは全く問題ありません：

<!--original
However, it's perfectly OK for extension functions to overload member functions which have the same name but a different signature:
-->

``` kotlin
class C {
    fun foo() { println("member") }
}

fun C.foo(i: Int) { println("extension") }
```

<!--original
``` kotlin
class C {
    fun foo() { println("member") }
}

fun C.foo(i: Int) { println("extension") }
```
-->

`C().foo(1)` の呼び出しで "extension" を表示します。

<!--original
The call to `C().foo(1)` will print "extension".

-->

## Null許容レシーバー

<!--original
## Nullable Receiver
-->

拡張は、null許容なレシーバの型で定義できることに注意してください。このような拡張は、その値がnullの場合でも、オブジェクト変数で呼び出すことができ、かつその本体内で `this == null` をチェックすることができます。これにより、null をチェックせずに Kotlin で toString() を呼び出すことができます。チェックは拡張関数内で行われます。

<!--original
Note that extensions can be defined with a nullable receiver type. Such extensions can be called on an object variable
even if its value is null, and can check for `this == null` inside the body. This is what allows you
to call toString() in Kotlin without checking for null: the check happens inside the extension function.
-->

``` kotlin
fun Any?.toString(): String {
    if (this == null) return "null"
    // nullチェックの後だと、 'this' は非null型に自動キャストされるので、
    // 下記の toString() は Any クラスのメンバであると解決される
    return toString()
}
```

<!--original
``` kotlin
fun Any?.toString(): String {
    if (this == null) return "null"
    // after the null check, 'this' is autocast to a non-null type, so the toString() below
    // resolves to the member function of the Any class
    return toString()
}
```
-->

## 拡張プロパティ

<!--original
## Extension Properties
-->

関数と同様、Kotlinは拡張プロパティをサポートしています。

<!--original
Similarly to functions, Kotlin supports extension properties:
-->

``` kotlin
val <T> List<T>.lastIndex: Int
  get() = size - 1
```

<!--original
``` kotlin
val <T> List<T>.lastIndex: Int
  get() = size - 1
```
-->

注意してほしいのは、拡張機能は、実際にはクラスにメンバを挿入しないので、拡張プロパティが[バッキングフィールド](properties.html#backing-fields)を持つ効率的な方法がない、ということです。これが **初期化子が、拡張プロパティでは許可されていない** 理由です。この挙動は、明示的にゲッター/セッターを作ることによって定義することのみができます。

<!--original
Note that, since extensions do not actually insert members into classes, there's no efficient way for an extension 
property to have a [backing field](properties.html#backing-fields). This is why **initializers are not allowed for 
extension properties**. Their behavior can only be defined by explicitly providing getters/setters.
-->

例：

<!--original
Example:
-->

``` kotlin
val Foo.bar = 1 // エラー：初期化子は拡張プロパティでは許可されていない
```


<!--original
``` kotlin
val Foo.bar = 1 // error: initializers are not allowed for extension properties
```

-->

## コンパニオンオブジェクトの拡張機能

<!--original
## Companion Object Extensions
-->

クラスに[コンパニオンオブジェクト](object-declarations.html#companion-objects)が定義されている場合は、コンパニオンオブジェクトの拡張関数とプロパティを定義することもできます。

<!--original
If a class has a [companion object](object-declarations.html#companion-objects) defined, you can also define extension
functions and properties for the companion object:
-->

``` kotlin
class MyClass {
  companion object { }  // "Companion" と呼ばれる
}

fun MyClass.Companion.foo() {
  // ...
}
```

<!--original
``` kotlin
class MyClass {
  companion object { }  // will be called "Companion"
}

fun MyClass.Companion.foo() {
  // ...
}
```
-->

ちょうどコンパニオンオブジェクトの普通のメンバと同じように、それらは修飾子としてクラス名のみを使用して呼び出すことができます。

<!--original
Just like regular members of the companion object, they can be called using only the class name as the qualifier:
-->

``` kotlin
MyClass.foo()
```


<!--original
``` kotlin
MyClass.foo()
```

-->

## 拡張関数のスコープ

<!--original
## Scope of Extensions
-->

ほとんどの場合、トップレベル、すなわちパッケージ直下に拡張を定義します：

<!--original
Most of the time we define extensions on the top level, i.e. directly under packages:
-->
 

-->

``` kotlin
package foo.bar
 
fun Baz.goo() { ... } 
``` 

<!--original
``` kotlin
package foo.bar
 
fun Baz.goo() { ... } 
``` 
-->

そのような拡張を宣言しているパッケージの外で使用するには、それを呼び出し箇所でインポートする必要があります：

<!--original
To use such an extension outside its declaring package, we need to import it at the call site:
-->

``` kotlin
package com.example.usage

import foo.bar.goo // "goo" という名前で全ての拡張をインポートする
                   // または
import foo.bar.*   // "foo.bar" から全てインポートする

fun usage(baz: Baz) {
  baz.goo()
)

```

<!--original
``` kotlin
package com.example.usage

import foo.bar.goo // importing all extensions by name "goo"
                   // or
import foo.bar.*   // importing everything from "foo.bar"

fun usage(baz: Baz) {
  baz.goo()
)

```
-->

詳細については、[インポート](packages.html#imports)を参照してください。

<!--original
See [Imports](packages.html#imports) for more information.
-->

## メンバとして拡張関数を宣言

<!--original
## Declaring Extensions as Members
-->

クラス内では、別のクラスの拡張を宣言することができます。そのような拡張の中には、複数の _暗黙的なレシーバ_があります。修飾子なしでアクセスできるオブジェクトのメンバです。拡張が宣言されているクラスのインスタンスは _ディスパッチレシーバ (dispatch receiver)_ と呼ばれ、拡張関数のレシーバ型のインスタンスは _拡張レシーバ_ と呼ばれます。

<!--original
Inside a class, you can declare extensions for another class. Inside such an extension, there are multiple _implicit receivers_ -
objects members of which can be accessed without a qualifier. The instance of the class in which the extension is declared is called
_dispatch receiver_, and the instance of the receiver type of the extension method is called _extension receiver_.
-->

``` kotlin
class D {
    fun bar() { ... }
}

class C {
    fun baz() { ... }

    fun D.foo() {
        bar()   // D.bar を呼ぶ
        baz()   // C.baz を呼ぶ
    }

    fun caller(d: D) {
        d.foo()   // 拡張関数を呼ぶ
    }
}
```

<!--original
``` kotlin
class D {
    fun bar() { ... }
}

class C {
    fun baz() { ... }

    fun D.foo() {
        bar()   // calls D.bar
        baz()   // calls C.baz
    }

    fun caller(d: D) {
        d.foo()   // call the extension function
    }
}
```
-->

ディスパッチレシーバのメンバーと拡張レシーバの名前が衝突する場合には、拡張レシーバが優先されます。ディスパッチレシーバのメンバを参照するには、[修飾子付き `this` の構文](this-expressions.html#qualified)を使用することができます。

<!--original
In case of a name conflict between the members of the dispatch receiver and the extension receiver, the extension receiver takes
precedence. To refer to the member of the dispatch receiver you can use the [qualified `this` syntax](this-expressions.html#qualified).
-->

``` kotlin
class C {
    fun D.foo() {
        toString()         // D.toString() を呼ぶ
        this@C.toString()  // C.toString() を呼ぶ
    }
```

<!--original
``` kotlin
class C {
    fun D.foo() {
        toString()         // calls D.toString()
        this@C.toString()  // calls C.toString()
    }
```
-->

メンバとして宣言された拡張関数は、 `open` として宣言され、サブクラスでオーバーライドすることができます。これは、そのような関数のディスパッチは、ディスパッチレシーバ型に関しては仮想的であるが、拡張レシーバ型に関しては静的であることを意味する。

<!--original
Extensions declared as members can be declared as `open` and overridden in subclasses. This means that the dispatch of such
functions is virtual with regard to the dispatch receiver type, but static with regard to the extension receiver type.
-->

``` kotlin
open class D {
}

class D1 : D() {
}

open class C {
    open fun D.foo() {
        println("D.foo in C")
    }

    open fun D1.foo() {
        println("D1.foo in C")
    }

    fun caller(d: D) {
        d.foo()   // 拡張関数を呼ぶ
    }
}

class C1 : C() {
    override fun D.foo() {
        println("D.foo in C1")
    }

    override fun D1.foo() {
        println("D1.foo in C1")
    }
}

C().caller(D())   // 出力： "D.foo in C"
C1().caller(D())  // 出力： "D.foo in C1" - ディスパッチレシーバは仮想的に解決される
C().caller(D1())  // 出力： "D.foo in C" - 拡張レシーバは静的に解決される
``` 


<!--original
``` kotlin
open class D {
}

class D1 : D() {
}

open class C {
    open fun D.foo() {
        println("D.foo in C")
    }

    open fun D1.foo() {
        println("D1.foo in C")
    }

    fun caller(d: D) {
        d.foo()   // call the extension function
    }
}

class C1 : C() {
    override fun D.foo() {
        println("D.foo in C1")
    }

    override fun D1.foo() {
        println("D1.foo in C1")
    }
}

C().caller(D())   // prints "D.foo in C"
C1().caller(D())  // prints "D.foo in C1" - dispatch receiver is resolved virtually
C().caller(D1())  // prints "D.foo in C" - extension receiver is resolved statically
``` 

-->

## 動機

<!--original
## Motivation
-->

Javaでは、 "*Utils" という名前のクラス（ `FileUtils` 、 `StringUtils` など）をよく使っていました。有名な `java.util.Collections` は、同じ品種に属します。そして、これらのUtils-クラスについての不快な部分は、それらを使用するコードが次のようになることです：

<!--original
In Java, we are used to classes named "\*Utils": `FileUtils`, `StringUtils` and so on. The famous `java.util.Collections` belongs to the same breed.
And the unpleasant part about these Utils-classes is that the code that uses them looks like this:
-->

``` java
// Java
Collections.swap(list, Collections.binarySearch(list, Collections.max(otherList)), Collections.max(list))
```

<!--original
``` java
// Java
Collections.swap(list, Collections.binarySearch(list, Collections.max(otherList)), Collections.max(list))
```
-->

これらのクラス名は常に邪魔になってきます。static インポートを使用すると、これをこうすることができます：

<!--original
Those class names are always getting in the way. We can use static imports and get this:
-->

``` java
// Java
swap(list, binarySearch(list, max(otherList)), max(list))
```

<!--original
``` java
// Java
swap(list, binarySearch(list, max(otherList)), max(list))
```
-->

これは少しだけマシですが、IDEの強力なコード補完の助けを全くまたはほんの少ししか得られません。次のようにできるならば、それはとても良いでしょう：

<!--original
This is a little better, but we have no or little help from the powerful code completion of the IDE. It would be so much better if we could say
-->

``` java
// Java
list.swap(list.binarySearch(otherList.max()), list.max())
```

<!--original
``` java
// Java
list.swap(list.binarySearch(otherList.max()), list.max())
```
-->

でも、 `List` クラスの中に考えられるすべてのメソッドを実装したいというわけではありませんよね？このようなときに拡張が私たちを助けてくれます。

<!--original
But we don't want to implement all the possible methods inside the class `List`, right? This is where extensions help us.
-->

---

# ※権利関係について
リファレンスのオリジナルを作ったJetBrain社は[Contributing to Kotlin](http://dogwood008.github.io/kotlin-web-site-ja/https://kotlinlang.org/contribute.html#translations)で、「あなたの言語に翻訳し、Webサイト上で閲覧可能にすることを歓迎する。」 ( _You are welcome to translate the Kotlin documentation into your own language and to publish your translation on your Web site._ ) と宣言しています。

また、オリジナルは[github上のプロジェクト](https://github.com/JetBrains/kotlin-web-site)で管理されており、ライセンス表示が[Apache License ver. 2.0](https://github.com/JetBrains/kotlin-web-site/blob/master/LICENSE)で宣言されています。従って本ドキュメントもそれにならって、ライセンスを[Apache License ver. 2.0](https://github.com/dogwood008/kotlin-web-site-ja/blob/master/LICENSE)とします。