S-JIS[2010-10-23/2017-01-21] 変更履歴

Scalaクラス

Scalaのクラスのメモ。

class

（Javaと同様の）複数インスタンス作るクラスは、classで定義する。
（staticメソッドに当たるものが欲しい場合はobjectで定義する）

class クラス名 {
}

→アクセス修飾子（protected・private）
→ジェネリクス（class クラス名[A]）

他のクラスから派生する（他のクラスを継承する）場合、extendsを使う。

class クラス名 extends 他クラス {
}

親クラスの引数つきコンストラクターを呼び出したい場合は、親クラス名の後ろに引数を書く。[2010-12-21]

class クラス名 extends 親クラス(値, …) {
}

トレイト（Javaのインターフェースのようなもの）を継承する場合、withを使う。ただしextendsが無い場合、最初のトレイトだけはextendsで指定する。
複数のトレイトを継承する場合は「with トレイト」を追加していく。

class クラス名 extends 親クラス with トレイト
class クラス名 extends 親クラス with トレイト1 with トレイト2
class クラス名 extends トレイト
class クラス名 extends トレイト1 with トレイト2

→トレイトの継承方法・初期化順序

抽象クラス（メンバーの具体的な定義をせず、子クラスで定義する）の場合は、abstractを付ける。
（Javaのabstractクラスと同様）

abstract class クラス名 extends 〜 {
}

→抽象メンバー

自クラスからそれ以上派生できない（自クラスを継承できない）ようにする場合は、finalを付ける。
（Javaのfinalクラスと同様）

final class クラス名 extends 〜 {
}

→メンバーに付けるfinal

finalでなくsealedを使うと、同一ソースファイル内のクラスは継承できるが、別ファイルのクラスからは継承できなくなる。[2010-12-21]

sealed class クラス名 extends 〜 {
}

class 同一ファイル内のクラス extends クラス名 {	//OK
}

class 別ファイルのクラス extends クラス名 {	//コンパイルエラー
}

クラス本体に書くものが何も無い場合は、波括弧（のブロック）を省略できる。[2012-05-19]

class クラス名
class クラス名(引数定義)
class クラス名 extends 別クラス
class クラス名 extends 別クラス(引数)

メンバー（フィールド・メソッド）

classやobjectのブロックの中にフィールド（変数・定数）やメソッドの定義を書く。[2010-12-19]

class クラス名 {
  type 型名 = 型

  val 定数名 = 値

  var 変数名 = 初期値
  var 変数名:型 = _	//初期値をその型のデフォルト値とする

  def メソッド名(引数) = 本体
}

フィールド名とメソッド名には同じものを付けることは出来ない。
（Javaではメソッド呼び出しなら「()」を付けるし、それが無ければフィールドアクセスとして区別できる。
 Scalaではメソッド名のみを指定できる場面があるので、その場合にフィールドと区別できない）

→アクセス修飾子（protected・private）

変数・定数・メソッド等の宣言（val・var・def・type）において「= 〜」を書かなかった場合、抽象フィールド・抽象メソッドを定義したことになる。
つまり、そのクラスを継承した子クラス（具象クラス）で実際に値（本体）を定義する必要がある。
（Javaでは、フィールドは抽象化することは出来ない。また、抽象メソッドを定義する際はメソッドの前にabstractを付ける必要があるが、Scalaでは付けない）

abstract class 抽象クラス名 {
  type 型名

  val 定数名:型

  var 変数名:型

  def メソッド名(引数):戻り型
  def メソッド名(引数)		//戻り値の型を指定しないと、Unitになるようだ
}

class 具象クラス extends 抽象クラス名 {
  type 型名 = 型

  val 定数名 = 値

  var 変数名 = 値

  def メソッド名(引数) = 本体
}

抽象メソッドでないメソッド（処理本体が書かれているメソッド）をオーバーライドする際は、メソッド定義の前にoverrideを付ける必要がある。
（Java（JDK1.5以降）では@Overrideアノテーションを付けるが、Scalaでは文法に含まれている）

class クラス名 extends 親クラス {
  override def メソッド名(引数) = 本体
}

抽象メソッドの処理本体を定義する場合は、overrideを付けても付けなくてもよい。（個人的には付けた方が分かりやすいと思うが、Scalaの文化としては付けない方が優勢っぽい）

→共変戻り値型
→defによって定義されたメソッドをvalでオーバーライド

メンバー（フィールド・メソッド）を子クラスでオーバーライドできなくしようと思ったら、finalを付ける。
（Javaのfinalメソッドと同様）

class クラス名 {
  final val 定数名 = 値

  final var 変数名 = 初期値
  
  final def メソッド名(引数) = 本体
}

親クラスのメソッドにアクセスしたい場合はsuperを使う（Javaのsuperと同様）。[2010-12-25]
自クラスのフィールド・メソッドを明示したい場合はthisを使う（Javaのthisと同様）。

class A {
  val V = 123
  def f() = println("aaa")
}

class B extends A {
  override def f() = {
    super.f()

    val V = 456
    println(V)
    println(this.V)
  }
}

scala> new B().f()
aaa
456
123

→super[トレイト名]

コンストラクター

Scalaでは、classのブロックの中に直接処理を書くのがコンストラクターになる。[2010-12-19]

class クラス名 {


  //ここに初期処理を記述

}

public class クラス名 {
  /** コンストラクター */
  public クラス名() {
    //ここに初期処理を記述
  }
}

class Example {
  var v1 = 123
  printf("A %d %d%n", v1, v2)
  var v2 = 456
  printf("B %d %d%n", v1, v2)
}

public class Example {
  public int v1 = 123;
  { System.out.printf("A %d %d%n", v1, v2); }
  public int v2 = 456;
  { System.out.printf("B %d %d%n", v1, v2); }
}

public class Example {
  public int v1;
  public int v2;

  /** コンストラクター */
  public Example() {
    v1 = 123;
    System.out.printf("A %d %d%n", v1, v2);
    v2 = 456;
    System.out.printf("B %d %d%n", v1, v2);
  }
}

class クラス名(引数名:型, …) {


  //ここに初期処理を記述

}

class Example(a0:Int, a1:Int) {
  val n0 = a0
  var n1 = a1
}

public class クラス名 {
  /** コンストラクター */
  public クラス名(型 引数名, …) {
    //ここに初期処理を記述
  }
}

public class Example {
  public final int n0;
  public int n1;

  /** コンストラクター */
  public Example(int a0, int a1) {
    this.n0 = a0;
    this.n1 = a1;
  }
}

class Example(
  val n0: Int,
  var n1: Int
) {
}

public class Example {
  public final int n0;
  public int n1;

  /** コンストラクター */
  public Example(int a0, int a1) {
    this.n0 = a0;
    this.n1 = a1;
  }
}

class Example(a0:Int, a1:Int) {
  val n0 = a0

  def foo() = a1
}

public class Example {
  public  final int n0;
  private final int a1;
  public int foo() = { return a1; }

  /** コンストラクター */
  public Example(int a0, int a1) {
    this.n0 = a0;
    this.a1 = a1;
  }
}

class Example

class Example(val n0:Int)

class Example(a0:Int, a1:Int) {
  val n0 = a0
  var n1 = a1







  //コンストラクター
  def this(a:Int) = {
    this(a, 2)
    println("サブ")
  }
}

class Example(
  val n0: Int,
  var n1: Int
) {






  //コンストラクター
  def this(a: Int) = this(a, 2)
  def this()       = this(1)
}

public class Example {
  public final int n0;
  public int n1;

  /** コンストラクター */
  public Example(int a0, int a1) {
    this.n0 = a0;
    this.n1 = a1;
  }

  //コンストラクター
  public Example(int a) {
    this(a, 2);
    System.out.println("サブ");
  }
}

public class Example {
  public final int n0;
  public int n1;

  /** コンストラクター */
  public Example(int a0, int a1) {
    this.n0 = a0;
    this.n1 = a1;
  }

  //コンストラクター
  public Example(int a) { this(a, 2); }
  public Example()      { this(1);    }
}

class Example(
  val n0: Int = 1,
  var n1: Int = 2
)

class A(a:Int) {

}

class B extends A(123) {



}

class C(n:Int) extends A(n) {



}

public class A {
  public A(int a) {}
}

public class B extends A {
  public B() {
    super(123);
  }
}

public class C extends A {
  public C(int n) {
    super(n);
  }
}

コンストラクターの定義順序

コンストラクターを複数定義する（補助コンストラクターを定義する）場合、定義順序に意味があるので気をつける必要がある。[2015-03-07]
Scalaでは、補助コンストラクターは自分より前に定義されたコンストラクターを必ず呼ぶ必要がある。（最終的には基本コンストラクターが必ず呼ばれることになる）

（Javaの場合は、コンストラクターを定義する順序は自由。また、「別のコンストラクターを呼ばなければならない」といったルールは無い。（親クラスのコンストラクターのいずれかは必ず呼ばれる、というルールはあるが））

自分型アノテーション

基本コンストラクターの先頭で、自分自身のインスタンスを指す識別子（変数のようなもの）を定義することが出来る。[2011-01-08]
（self type annoationsの構文のうち、型の指定が無い形式。self aliasesとでも言うべきもの[2012-04-29]）
識別子は何でもよいが、慣習としてselfを使うらしい。

class クラス名 {
  識別子 =>

  〜
}

ただ、自分自身を指すキーワードとしては「this」があるわけで、この識別子の値とthisの値は同じになる。（つまりthisの別名を定義することになる）

class C {
  self =>

  def print() = {
    println(self)
    println(this)
  }
}

scala> new C().print
line163$object$$iw$$iw$C@1c44fe9
line163$object$$iw$$iw$C@1c44fe9

class C {
  private final C self = this;

  public void print() {
    System.out.println(self);
    System.out.println(this);
  }
}

class C {
  ccc =>

  class D {
    ddd =>

    def print() = {
      println(ccc)
      println(C.this)
      println(ddd)
      println(this)
      println(D.this)
    }
  }

  def print() = { 
    new D().print
  }
}

scala> new C().print
line169$object$$iw$$iw$C@18dc649
line169$object$$iw$$iw$C@18dc649
line169$object$$iw$$iw$C$D@d5064b
line169$object$$iw$$iw$C$D@d5064b
line169$object$$iw$$iw$C$D@d5064b

class C {
  private final C ccc = this;

  class D {
    private final D ddd = this;

    void print() {
      System.out.println(ccc);
      System.out.println(C.this);
      System.out.println(ddd);
      System.out.println(this);
      System.out.println(D.this);
    }
  }

  public void print() {
    new D().print();
  }
}

“あるクラスのインスタンスを示している”ことをはっきりさせる為に、「クラス名.this」という構文を使うのでなく、「識別子 =>」で名前を付けてそれを使う方が良い、ということだろうか。
※無名クラスの場合は「クラス名.this」という書き方が出来ないので、=>で別名を付けられるのは便利。[2011-04-03]

この構文では型を指定することができ、それを自分型アノテーション（Self-Type Annotations）と呼ぶ。[2011-04-03/2012-04-29]
特に自分型アノテーションが威力を発揮するのは、識別子に（自分以外の）別の型を指定できること。[2011-08-25]

class クラス名 {
  識別子: 型 =>

  〜
}

trait A {
  def a() = println("A")
}

class C {
  self: A =>

  def c() = println("C")

  def print() = {
    a()
    c()
  }
}

scala> val c = new C with A
c: C with A = $anon$1@1c2ee8e

scala> c.print
A
C

scala> class A { def f() = "a" }
defined class A

scala> trait B extends A {
     |   def g() = super.f
     | }
defined trait B

scala> trait B {
     |   self: A =>
     |   def g() = super.f
     | }

→トレイトと自分型アノテーションを使ってソースファイル分割を行う例

アクセス修飾子

Scalaでは、アクセス修飾子を付けないとpublic（どこからでもアクセス可）になる。[2010-12-19]

アクセス修飾子 class クラス名 {
  アクセス修飾子 val 定数定義
  アクセス修飾子 var 変数定義
  アクセス修飾子 def メソッド定義
}

→パッケージによるアクセス可能範囲
↓クラス指定によるアクセス可能範囲

class C1 {

  // 自クラス（C1の内側）
  class C2 {
                    val c2pub  = 1
    protected       val c2pro  = 1
    private         val c2pri  = 1
    protected[this] val c2prot = 1
    private[this]   val c2prit = 1
    protected[C1]   val c2proc = 1
    private[C1]     val c2pric = 1
  }

  def c1method() = {
    val c2 = new C2()
    c2.c2pub
//x c2.c2pro
//x c2.c2pri
//x c2.c2prot
//x c2.c2prit
    c2.c2proc
    c2.c2pric
  }
}

アクセス修飾子の記述箇所の例。[2010-12-21]

private class クラス {
}

class クラス {
  private val 定数 = 値
  private def メソッド() = 式
}

class クラス(
  private val 定数:型
) {
}

class クラス private(引数:型) {
}

class クラス private() {
}

class クラス private {
}

class クラス {
  private def this(引数:型) = {
    this()
  }
}

インスタンス生成（new）

インスタンスは「new クラス名()」で生成する。
Scalaでは、引数の無いコンストラクターの場合は丸括弧が省略できるので、「new クラス名」でも可。

引数のあるコンストラクターを呼び出す場合は「new クラス名(引数,…)」となる。[2010-12-21]
なお、メソッドの場合は引数が1個だけのときは丸括弧「()」の代わりに波括弧「{}」を使うことが出来るが、newでは出来ない。

よくサンプルで見かける「Array(1,2,3)」「Array("a","b","c")」「List(1,2,3)」といったnewを使わない初期化方法は、newが省略されているわけではなく、apply()メソッドの呼び出しである。

「new クラス名〜」の後に波括弧「{}」を付けることで、元のクラスを拡張したインスタンスを生成することが出来る。[2011-01-09]
（Javaの無名内部クラス（匿名クラス）と同様）
それどころか、newの直後に波括弧を付けることで、新しいインスタンスを作ることが出来る。
（この場合はAnyRefを継承したクラスになる）

new クラス名
new クラス名(引数…)
new クラスまたはトレイト名         { メンバー定義 }
new クラスまたはトレイト名(引数…) { メンバー定義 }
new クラスまたはトレイト名         with トレイト1 with …
new クラスまたはトレイト名(引数…) with トレイト1 with …
new クラスまたはトレイト名         with トレイト1 with … { メンバー定義 }
new クラスまたはトレイト名(引数…) with トレイト1 with … { メンバー定義 }
new { メンバー定義 }
new { 事前初期化   }               with トレイト1 with … { メンバー定義 }

内部クラス

クラス定義の中でクラス（内部クラス）を定義することが出来る。[2011-01-09]
ただ、この内部クラスの扱いがJavaとScalaでは少々異なる。

class A {
  class B {
  }
}

class A {
  class B {
  }
}

class A {
  class B {
  }

  def createB() = {
    new B()
  }
}

class A {
  class B {
  }

  public B createB() {
    return new B();
  }
}

val a = new A()
val b = new a.B()

× new (a).B()
× new (new A()).B()

A   a = new A();
A.B b = a.new B();

○ new (a).new B();
○ new A().new B();

scala> val a1 = new A()
a1: A = A@10ccdfa

scala> val a2 = new A()
a2: A = A@13f582a

scala> var b1 = new a1.B()
b1: a1.B = A$B@19ce161

scala> val b2 = new a2.B()
b2: a2.B = A$B@14089dc

scala> b1 = b2
<console>:21: error: type mismatch;
 found   : a2.B
 required: a1.B
       b1 = b2
            ^

scala> val a3 = a1
a3: A = A@10ccdfa

scala> b1 = new a3.B()
<console>:20: error: type mismatch;
 found   : a3.B
 required: a1.B
       b1 = new a3.B()
            ^

A a1 = new A();


A a2 = new A();


A.B b1 = a1.new B();


A.B b2 = a2.new B();


b1 = b2; //代入OK

scala> var b: A#B = b1
b: A#B = A$B@19ce161

scala> b = b2
b: A#B = A$B@14089dc

scala> var b = b1.asInstanceOf[A#B]
b: A#B = A$B@19ce161

ケースクラス

Scalaのクラスには「こういった使い方をよくする」という事柄がある。[2011-01-10]
クラス定義時に「case」を付けてケースクラス（case class）にすると、便利なメソッドやコンパニオンオブジェクトが自動的に生成される。
また、java.io.Serializableもミックスインされる。[2014-09-15]

case class クラス名(引数…) {
}

→ケースオブジェクト

ケースクラスの実体のイメージ。[2017-01-21]

case class Example(value1: String, value2: Int) {
  def hoge() = "zzz"
}

↓

/**
 * 生成されるクラスのイメージ
 */
class Example(val value1: String, val value2: Int) extends AnyRef with Product with Serializable {

  // 独自実装したフィールドやメソッド
  def hoge() = "zzz"

  // 値の一部を変更したインスタンスを返すメソッド（各引数の名前はフィールド名と同じで、デフォルト値に自インスタンスの値が指定されている）
  def copy(value1: String = value1, value2: Int = value2) = Example(value1, value2)

  // Productの各メソッド
  override def productPrefix: String = "Example"
  def productArity: Int = 2
  def productElement(n: Int): Any = n match {
    case 0 => value1
    case 1 => value2
  }
  override def productIterator: Iterator[Any] = ScalaRunTime.typedProductIterator(this)
  def canEqual(that: Any): Boolean = that.isInstanceOf[Example]

  // Objectの各メソッド
  override def toString(): String = ScalaRunTime._toString(this)
  override def hashCode(): Int = { scala.runtime.Staticsを使って算出 }
  override def equals(x: Any): Boolean = { 各フィールドを比較 }
}

/**
 * 生成されるコンパニオンオブジェクトのイメージ
 */
object Example extends ((String, Int) => Example) with Serializable {

  override def toString(): String = "Example"

  // AbstractFuntion2[String, Int, Example]（(String, Int) => Example）のメソッド
  def apply(value1: String, value2: Int): Example = new Example(value1, value2)

  def unapply(x: Example): Option[(String, Int)] = Some((x.value1, x.value2))
}

ケースクラスの使用例。[2012-12-15]

scala> case class A(n: Int)
defined class A

scala> val a1 = A(1)	//コンパニオンオブジェクトのapplyメソッドが実装されるので、それを使ってインスタンスを生成できる
a1: A = A(1)
scala> val a2 = new A(2)	//newを使ったインスタンス生成も出来る
a2: A = A(2)

scala> println(a1.n)	//フィールドの取得は普通に出来る
1

//unapplyメソッドが実装されるので、パターンマッチを行うことが出来る
scala> a1 match {
         case A(n) => println(n)
       }
1

//equalsメソッドが実装されるので、普通に比較できる
scala> println(a1 == a2)
false

//copyメソッドが実装されるので、複製が簡単
scala> case class B(i: Int, j: Int, k: Int)
defined class B

scala> val b1 = B(123, 456, 789)
b1: B = B(123,456,789)

scala> val b2 = b1.copy()
b2: B = B(123,456,789)

scala> val b3 = b1.copy(j = 9999)	//名前付き引数を使って、フィールドの一部だけを変えたインスタンスを作れる
b3: B = B(123,9999,789)

ケースクラスのコンストラクターの可視性をprivateにすると、インスタンスを生成する手段が無くなる＾＾； [2012-12-15]

package example

object PrivateCaseClass {

  case class A private (n: Int)
  case class B private[example] (n: Int)
  case class C private[PrivateCaseClass] (n: Int)

  def main(args: Array[String]) {
×  println(A(1))
    println(B(1))
    println(C(1))

×  println(new A(1))
    println(new B(1))
    println(new C(1))

×  println(A.apply(1))
    println(B.apply(1))
    println(C.apply(1))
  }
}

apply()メソッドの呼び出しでも、「constructor A in class A cannot be accessed in object PrivateCaseClass」（コンストラクターにアクセスできない）というコンパイルエラーになる。

参考： nisshieeorgさんのツイート