目標

• Javaにおけるスレッドの習得
• 教科書: 結城浩, “Java言語プログラミングレッスン(下)”, ソフトバンククリエイティブ, 2007.「第16章」

目次

1. スレッドとは何か
2. スレッドの待機と終了待ち
3. フィールドへの代入

スレッド(thread)

• Javaプログラムを実行する主体、実行跡の糸
• シングルスレッド = 同時点で実行作業はただ1つ
• マルチスレッド = 同時点で作業が複数
  • 並行(concurrent): 論理的な実行主体が複数。通常のPC環境。
  • 並列(parallel): 物理的に複数。例えばマルチプロセッサー/コア。

演習: スレッド(thread)

public class CountTen {
   public static void main(String[] args) {
      CountTen ct = new CountTen();
      ct.count();
      for (int i = 0; i < 1000; i++) {
         System.out.println("main:i = " + i);
      }
   }
   public void count() {
      for (int i = 0; i < 1000; i++) {
         System.out.println("count:i = " + i);
      }
   } }

count:i = 0
count:i = 1
・・・
count:i = 999
main:i = 0
main:i = 1
・・・
main:i = 999

マルチスレッドの意義

• 利用局面
  • GUI、Webサーバ、状態監視など
  • 必ずn倍になるわけではないが個々に処理するより速い
  • 時間のかかる処理の完了を待たなくて良い
• 難しさ
  • 同じ文を、複数のスレッドが同時に実行するかもしれない
  • 複数スレッドが干渉するとき排他制御(mutual exclusion control): スレッドに並んでもらう
  • 複数スレッドを協調作業させたいとき同期(synchronization): 待ち合わせ、通信

Javaにおけるスレッド作成方法

• (A) java.lang.Thread クラスの拡張
• (B) java.lang.Runnable インタフェースの実装
• 注意: スレッドの切り替えタイミングは(特に指定しない限り)Java処理系依存

演習: (A) Threadクラスの拡張

1. 処理内容を run() メソッドに定義
   • スレッドの実行開始点。mainのようなもの。
2. 当該クラス(スレッド)のインスタンスを new で作成
3. インスタンスの start() メソッドを呼ぶ
   • start() の中で実行主体が具体的に作られて run() が自動的に実行

public class CountTenA extends Thread {
    public static void main(String[] args) {
       CountTenA ct = new CountTenA();
       ct.start(); // 新しいスレッド開始
       for (int i = 0; i < 1000; i++) {
         System.out.println("main:i = " + i);
       }
   }
   public void run() {
      for (int i = 0; i < 1000; i++) {
         System.out.println("run:i = " + i);
      }
   }
}

main:i = 0
main:i = 1
・・・
main:i = 99
run:i = 0
run:i = 1
・・・
run:i = 88
main:i = 100
・・・
main:i = 999
・・・
run:i = 999

演習: (B) Runnableインタフェースの実装

1. Runnableのrun() を実装し、処理内容を定義
2. 当該クラスのインスタンスを引数にしてスレッドインスタンス作成
3. スレッドインスタンスの start() メソッドを呼ぶ

public class CountTenB implements Runnable {
   public static void main(String[] args) {
      CountTenB ct = new CountTenB();
      Thread th = new Thread(ct);
      th.start();
      for (int i = 0; i < 10; i++) {
         System.out.println("main:i = " + i);
      }
   }
   public void run() {
      for (int i = 0; i < 10; i++) {
         System.out.println("run:i = " + i);
      }
   }
}

main:i = 0
main:i = 1
・・・
main:i = 99
run:i = 0
run:i = 1
・・・
run:i = 88
main:i = 100
・・・
main:i = 999
・・・
run:i = 999

2つの方法の比較

スレッドの停止、待機

• 停止
  • Thread#run()メソッド中に終了条件を組み込むべき。
  • Thread#stop()メソッド: 強制停止。非推奨。
• 待機: Thread.sleep(x)
  • その文を実行しているスレッドをxミリ秒停止。
  • ロックは解放「しない」
  • チェック例外 java.lang.InterruptedException スロー

class Foo extends Thread {
   boolean running = true;
   public void stopRunning() {
      running = false;
   }
   public void run() {
      while (running) {
         ...
      }
   } }

public class Periodic {
   public static void main(String[] args) {
      for (int i = 0; i < 10; i++) {
         int tm = i * 1000;
         System.out.println("Start sleep:tm = " + tm);
         try {
            Thread.sleep(tm);
         } catch (InterruptedException e) {
         }
      }
   } }

スレッドの独立性と待機

• 前掲のPeriodicとの違いは?

public class Periodic2 extends Thread {
   public void run() {
      for (int i = 0; i < 10; i++) {
         int tm = i * 1000;
         System.out.println("Start sleep:tm = " + tm);
         try {
            Thread.sleep(tm);
         } catch (InterruptedException e) {
         }
      }
   }
   public static void main(String[] args) {
      new Periodic2().start();
      // for (int i = 0; i < 100000; i++) {
      // System.out.println(i);
      // }
   }
}

他のスレッドの終了待ち

• Thread#join()
  • 呼び出し対象スレッドの終了を、呼び出し側スレッドが待つ
  • チェック例外 java.lang.InterruptedException スロー
  • join(long m): mミリ秒でタイムアウト
  • join(long m, int n): mミリ秒+nナノ秒でタイムアウト

public class JoinTest extends Thread {
   public static void main(String[] args){
      JoinTest th = new JoinTest();
      System.out.println("main:開始");
      th.start();
      try {
         System.out.println("main:待ち中");
         th.join();
      } catch (InterruptedException e) {
         System.out.println(e);
      }
      System.out.println("main:終了");
   }

   public void run() {
      System.out.println("run:開始");
      try {
         Thread.sleep(5000);
      } catch (InterruptedException e) {
         System.out.println(e);
      }
      System.out.println("run:終了");
   }
}

演習: 問題のある例

• addMoney(): フィールドvalueに引数の値を加算。矛盾の検知。
• Thread.currentThread(): 実行中のスレッドインスタンスの取得
• System.exit(-1): Java仮想マシンの終了。引数-1で異常終了の明示。

public class BadBank {
   private int value = 0;
   public void addMoney(int money) {
      int currentValue = value;
      System.out.println(Thread.currentThread() + "が addMoney に入った");
      value += money;
      if (currentValue + money != value) {
         System.out.println(Thread.currentThread() + "で矛盾");
         System.exit(-1);
      }
      System.out.println(Thread.currentThread() + "が addMoney から出た");
   }
}

演習: 問題のある例(つづき)

• スレッドがメソッド実行中にフィールドを参照した後に、スレッドが切り替わり、別スレッドがフィールドの値を書き換え

public class BadBankTest extends Thread {
   BadBank bank;
   public BadBankTest(BadBank bank) {
      this.bank = bank;
   }
   public void run() {
      while (true) {
         bank.addMoney(100);
         bank.addMoney(-100);
      }
   }
   public static void main(String[] args) {
      BadBank bank = new BadBank();
      new BadBankTest(bank).start();
      new BadBankTest(bank).start();
   } }

解答: 問題のある例

• スレッドがメソッド実行中フィールドを参照した後に、スレッドが切り替わり、別スレッドがフィールドの値を書き換え

public class BadBankTest extends Thread {
   BadBank bank;
   public BadBankTest(BadBank bank) {
      this.bank = bank;
   }
   public void run() {
      while (true) {
         bank.addMoney(100);
         bank.addMoney(-100);
      }
   }
   public static void main(String[] args) {
      BadBank bank = new BadBank();
      new BadBankTest(bank).start();
      new BadBankTest(bank).start();
   } }

Thread[Thread-0,5,main]が addMoney に入った
Thread[Thread-0,5,main]が addMoney から出た
・・・
Thread[Thread-0,5,main]が addMoney に入った
Thread[Thread-1,5,main]が addMoney に入った
Thread[Thread-1,5,main]が addMoney から出た
Thread[Thread-1,5,main]が addMoney に入った
Thread[Thread-1,5,main]が addMoney から出た
Thread[Thread-1,5,main]が addMoney に入った
Thread[Thread-1,5,main]が addMoney から出た
Thread[Thread-1,5,main]が addMoney に入った
Thread[Thread-1,5,main]で矛盾
Thread[Thread-0,5,main]で矛盾

synchronizedと同期

• 全インスタンス・クラスには固有のロック(鍵)あり
  • ロックがスレッドによって獲得(設定)されている間、他のスレッドは当該ロックを獲得できない
• synchronized メソッド(同期メソッド)
  • 実行前に対象インスタンスのロックの獲得
  • 実行後にロックの解除(unlock)⇒ 同時点でただ1つのスレッドが実行可能
  • 1度ロックを獲得すれば、続けて他の同期メソッドを呼べる
• 非synchronizedなメソッド
  • ロックと無関係。自由に実行可能。

演習: synchronized と同期

• [演習] 矛盾を生じないように、さきのBadBank を修正せよ

public class BadBank {
   private int value = 0;
   public void addMoney(int money) {
      int currentValue = value;
      System.out.println(Thread.currentThread() + "が addMoney に入った");
      value += money;
      if (currentValue + money != value) {
         System.out.println(Thread.currentThread() + "で矛盾");
         System.exit(-1);
      }
      System.out.println(Thread.currentThread() + "が addMoney から出た");
   }
}

synchronizedブロック、クラスメソッド

• synchronizedブロック
  • メソッドの一部のみのロック
  • ロックをかけるインスタンスの指定
• クラスメソッドのsynchronized
  • クラスそのもののロック

public class BadBank {
   private int value = 0;
   public void addMoney(int money) {
      synchronized(this) {
         int currentValue = value;
         ・・・
      }
   }
}

public class MyClass {
   public synchronized void instanceMethod() {
      ...
   }
   public synchronized static void classM() {
      ...
   }
}

synchronizedブロックの利用

• BadBankクラスそのものを修正せずに、BadBankTestを以下のように修正すると?

public class BadBankTest extends Thread {
   BadBank bank;
   public BadBankTest(BadBank bank) {
      this.bank = bank;
   }
   public void run() {
      while (true) {
         synchronized(bank) {
            bank.addMoney(100);
            bank.addMoney(-100);
         }
      }
   }
   ・・・

スレッド同士の待ち合わせ

他のスレッドの終了待ち

• Thread#join()
  • 呼び出し対象スレッドの終了を、呼び出し側スレッドが待つ
  • チェック例外java.lang.InterruptedExceptionスロー
  • join(long m): mミリ秒でタイムアウト
  • join(long m, int n): mミリ秒+nナノ秒でタイムアウト

public class JoinTest extends Thread {
   public static void main(String[] args){
      JoinTest th = new JoinTest();
      System.out.println("main:開始");
      th.start();
      try {
         System.out.println("main:待ち中");
         th.join();
      } catch (InterruptedException e) {
         System.out.println(e);
      }
      System.out.println("main:終了");
   }

   public void run() {
      System.out.println("run:開始");
      try {
         Thread.sleep(5000);
      } catch (InterruptedException e) {
         System.out.println(e);
      }
      System.out.println("run:終了");
   }
}

待ち合わせ

• スレッドが他スレッドの処理を待ちたいことがある
  • しかし、join()ではスレッドの終了しか待てない
• Object#wait()
  • 呼び出したスレッドが当該Objectのインスタンスのロックを獲得している場合、一旦 ロックを解除して、当該インスタンスのウェイトセット(wait set: 待合室)で自ら待機
• Object#notify()・notifyAll()
  • 呼び出したスレッドが当該Objectのインスタンスのロックを獲得している場合、当該インスタンスのウェイトセットで待機中のある1つ・全スレッドを「起こす」
  • ただし、ロックは獲得したまま。ロックを解放して起こされたスレッドがロックを獲得すると処理再開。x1のウェイト

例: スレッドセーフなスタック

• Stack
  • 有限。先入れ後出し(First-In-Last-Out: FILO)構造。
  • マルチスレッド環境で適切に動作、スレッドセーフ。
• 生産者 Producer
  • スタックに空きがあればデータ追加。空きがなければ待機。
• 消費者 Consumer
  • スタックにデータがあれば消費。データが無ければ待機。

Stack

class Stack {
   int[] array = new int[3];
   int index = 0;
   public synchronized void put(int n) throws InterruptedException {
      while (index == array.length) {
         System.out.println(Thread.currentThread().getName()+" 空き待ち");
         wait();
      }
      array[index] = n;
      index++;
      notifyAll();
   }
   public synchronized int take() throws InterruptedException {
      while(index == 0) {
         System.out.println(Thread.currentThread().getName() + " データ待ち");
         wait();
      }
      int n = array[index - 1];
      index--;
      notifyAll();
      return n;
   }
}

Producer

class Producer extends Thread {
   Stack stack = null;
   Producer(Stack s) {
      stack = s;
   }
   public void run() {
      try {
         for (int i = 0; i < 30; i++) {
            stack.put(i);
            System.out.println(getName() + " " + i + " 追加");
            sleepRandomly();
         }
      } catch (InterruptedException e) {
      }
   }
   void sleepRandomly() {
      try {
         int n = (int)(Math.random() * 1000);
         Thread.sleep(n);
      } catch (InterruptedException e) {
      }
   }
}

Consumer

class Consumer extends Thread {
   Stack stack = null;
   Consumer(Stack s) {
      stack = s;
   }
   public void run() {
      try {
         while (true) {
            int x = stack.take();
            System.out.println(getName() + " " + x + " を消費");
            sleepRandomly();
         }
      } catch (InterruptedException e) {
      }
   }
   void sleepRandomly() {
      try {
         int n = (int)(Math.random() * 1000);
         Thread.sleep(n);
      } catch (InterruptedException e) {
      }
   }
}

演習: スタック関係の実行

• 以下によりスタックへのデータ生産者・消費者を実行し、結果を確認せよ

public class ProducerConsumer {
   public static void main(String[] args) {
      Stack stack = new Stack();
      Producer producer = new Producer(stack);
      Consumer consumer = new Consumer(stack);
      producer.start();
      consumer.start();
   }
}

解答: スタック関係の実行

• 以下によりスタックへのデータ生産者・消費者を実行し、結果を確認せよ

Thread-0 0 追加
Thread-1 0 を消費
Thread-0 1 追加
Thread-0 2 追加
Thread-0 3 追加
Thread-1 3 を消費
Thread-1 2 を消費
Thread-0 4 追加
Thread-1 4 を消費
Thread-1 1 を消費
Thread-0 5 追加
Thread-1 5 を消費

Thread-0 6 追加
Thread-0 7 追加
Thread-0 8 追加
Thread-1 8 を消費
Thread-0 9 追加
Thread-1 9 を消費
Thread-1 7 を消費
Thread-0 10 追加
Thread-0 11 追加
Thread-1 11 を消費
Thread-0 12 追加
Thread-1 12 を消費

Thread-0 13 追加
Thread-0 空き待ち
Thread-0 14 追加
Thread-1 13 を消費
Thread-1 14 を消費
Thread-1 10 を消費
Thread-1 6 を消費
Thread-0 15 追加
Thread-1 15 を消費
Thread-1 データ待ち
Thread-0 16 追加
Thread-1 16 を消費
...

待ち合わせのポイント

• synchronizedメソッドにおいて、while文で条件が満たされるまでwait()して、満たされたら処理を再開し最後にnotifyAll()
  • ifでは不適切。他のスレッドにnotifyAll()されたからといって、条件が満たされているとは限らない。
  • notifyAll()すれば直ちに他のスレッドが動き出すわけではない。synchronizedメソッドを抜けてロックを解除してから。
  • ロックを獲得していなければ wait(), notifyAll()できない。synchronizedメソッドの実行でロックを獲得できる。

public synchronized void doSomething() throws InterruptedException {
   while( !求めている条件 ) {
      wait();
   }
   // 処理
   notifyAll();
}

スレッドの補足事項

• Thread.currentThread()
  • この文を実行しているスレッドインスタンス取得
• スレッドの優先順位
  • Thread#getPriority(): 優先順位取得
  • Thread#setPriority(int newPriority): 設定
  • Thread.MIN_PRIORITY: 最低の優先順位
  • Thread.NORM_PRIORITY: 通常の優先順位
  • Thread.MAX_PRIORITY: 最高の優先順位

スレッドのまとめ

• スレッドはJavaプログラムの実行主体である。マルチスレッドとは、スレッドが複数あって同時に複数の処理が並行して行われることを指す
• スレッドの作り方には、Threadのサブクラス化と、Runnableインタフェースの実装の2種類がある
• スレッドの必要な処理はrun()に書き、start()で開始する。スレッドの一時停止sleep()、他スレッドの終了待ち合わせjoin()も可能。
• 各スレッドが独立している場合は問題ないが、フィールドや資源を共有する場合は同期・排他処理が必要。それらの処理は、インスタンス・クラスごとの「ロック」により実現する。
• synchronizedによるメソッドの同期化でロックを獲得できる。wait(), notifyAll(), notify()によりロックの解放・待機、待機中スレッドの「起こし」を行える

目標

• Javaにおけるパッケージおよびアクセス制御の習得
• 教科書: 結城浩, “Java言語プログラミングレッスン(下)”, ソフトバンククリエイティブ, 2007.「第17章」

目次

1. パッケージの宣言と利用
2. パッケージとアクセス制御
3. まとめ

パッケージ(Package)とは

• クラス名やインタフェース名の衝突を防ぐためのグループ分けの仕組み。名前空間。
  • 同名のクラスであっても、パッケージが異なれば異なるクラス
  • 関連するクラスやインタフェースを「まとめて」配布・再利用できる

package A;
public class XXX {
}
class YYY {
}

package B;
public class XXX {
}

パッケージの宣言とアクセス制御

• ソースファイル中の先頭で一度だけ
  • package パッケージ名;
• パッケージの外からは public なクラスのみにアクセスできる

package A;
public class XXX {
}
class YYY {
}

package B;
public class XXX {
}

パッケージの利用

• パッケージ内のpublicなクラスを外から利用する場合、完全限定名で指定する必要がある
  • 完全限定名: パッケージ名.クラス名
  • 例: java.util.Random r = new java.util.Random(); (java.utilパッケージ中のRandomクラス)
• ただし、ソースファイルの先頭でimportを書いておけば以降は省略できる
  • シングル・タイプ・インポート宣言(推奨): 各クラスをそれぞれ厳密にimport宣言
  • タイプ・インポート・オンデマンド宣言: 「*」でパッケージ内のクラス/インタフェースを自動的に取り込み

import java.util.Random;
import java.util.Calendar;
class Foo {
   Random r = new Random();
   Calendar c = new Calendar();
   ... }

import java.util.*;
class Foo {
   Random r = new Random();
   Calendar c = new Calendar();
   ... }

java.langパッケージ

• 基本的なクラス・インタフェースをまとめたパッケージ
  • 根源クラス: Object
  • 数値系: Integer, Double, Math, …
  • 文字列: String, …
  • システム: System, Thread, …
• 「特別に」自動的にimportされている
  • 本当はjava.lang.String s = "文字列";
  • しかしimport java.lang.*; が暗黙にされているので
  • String s = "文字列"; と書けてしまう

パッケージの階層

• パッケージは階層を持てる
  • 例: java.lang.String, java.util.Random
• 分かりやすくする分類であり、名前空間に特例無し
  • 上位のパッケージから下位パッケージ(サブパッケージ)内の非publicクラスに「アクセス不可」
  • サブパッケージ内であるからといって、上位パッケージ内のクラスやインタフェースは、普段どおりに指定の必要あり。逆もしかり。

package mytool;
import mytool.security.Trust;
public class TextParser {
   Trust t = ...;
}

package mytool.security;
import mytool.TextParser;
public class User {
   TextParser p = ...; }

package mytool.security;
class Trust {
}

パッケージの留意事項

パッケージ階層 = フォルダ/ディレクトリ階層

パッケージ名のつけかた

• 慣習: 全てアルファベット小文字にしよう
  • 大文字開始のクラス名と見分けしやすく。
• 唯一性を確保したい
  • パッケージ名が同一の場合、処理できない(衝突)
  • 世界中で唯一/ユニークなパッケージ名をつける必要がある
  • Sun はパッケージ名の登録・管理を行っていない。他機関も同様
• そこで、インターネットドメイン名の唯一性を用いて、Java
  • パッケージ名の唯一性を確保しようとする。
  • 「ドメイン名の逆順+パッケージ名」
  • むろん厳密には保証されない。誰かがつけてしまえばそれまで。

// 組織の場合：waseda.jp
package jp.waseda;
package jp.waseda.testpackage;

// 個人の場合：ess@waseda.jp
package jp.waseda.ess;
package jp.waseda.ess.mypackage;

演習1: パッケージ

1. パッケージの考察
   • 以下の HelloWorld クラスが、何と言うパッケージに所属しているのか?
   • HelloWorld クラスは、自身の所属以外に、他のどのようなパッケージを利用しているのか?
2. パッケージの作成と実行
   • 自分自身のユニークなパッケージ名を考案せよ
   • その新たなパッケージ名に合致するようにディレクトリを作成せよ
   • その作成したディレクトリにHelloWorld.javaを移動させて、ソースファイルを修正せよ
   • コンパイル・実行せよ

public class HelloWorld {
   public static void main(String[] args) {
      System.out.println("Hello World.");
   }
}

解説1: パッケージ

• Javaコマンドによる実行時に-verbose:classオプションを付けることで、仮想マシンがロードするクラスを順に確認できる
  • ただし JavaVM の起動そのものに必要なクラスも含まれる
  • java –verbose:class jp.waseda.ess.HelloWorld

[Loaded java.lang.Object from shared objects file]
...
[Loaded java.lang.String from shared objects file]
...
[Loaded java.lang.ClassLoader from shared objects file]
[Loaded java.lang.System from shared objects file]
...
[Loaded java.io.FileReader from shared objects file]
...
[Loaded jp.waseda.ess.HelloWorld from
file:/C:/WORK/jp/waseda/ess/]
Hello World.
...
[Loaded java.util.LinkedHashMap$KeyIterator from shared objects file]

スタティック・インポート宣言

• クラスメソッド、クラスフィールドをインポート宣言可能
  • いちいちクラスを指定する必要が無い
  • J2SE 5.0(Java SDK 5.0)から追加された新機能
• シングル・スタティック・インポート宣言
  • 単一のクラスメソッド/フィールドの取り込み
• スタティック・インポート・オンデマンド宣言
  • クラスメソッド/フィールドを「*」で必要に応じて取り込み

import static java.lang.System.out;
import static java.lang.Math.sin;
import static java.lang.Math.*;
public class Foo {
   public static void main(String[] args){
      out.println("text");
      out.println(sin(1.0));
      out.println(cos(1.0));
   }
}

// 左と同じ意味

public class Foo {
   public static void main(String[] args) {
      System.out.println("text");
      System.out.println(Math.sin(1.0));
      System.out.println(Math.cos(1.0));
   }
}

クラス/インタフェースのアクセス制御

• クラス/インタフェースのアクセス修飾子: 無指定、public

package A;
public class XXX {
}
class YYY { }

package B;
public class XXX {
}

メソッド/コンストラクタ/フィールドのアクセス制御 (1)

• メソッド、コンストラクタ、フィールドのアクセス修飾子: private、無指定、protected、public

メソッド/コンストラクタ/フィールドのアクセス制御 (2)

• メソッド、コンストラクタ、フィールドのアクセス修飾子: private、無指定、protected、public

例: privateフィールド、メソッド

• 当該クラス内のみから
• privateメソッドやprivateフィールドはサブクラスに「継承されない」

class Rectangle {
   private int width = 0;
   private void setSize(
   int w, int h){
      ...
   }
   public int getArea() {
      return width * height;
   }
}

// 外部からのアクセス
Rectangle r = new Rectangle();
r.width = 50; // NG!
r.setSize(100,99); // NG!
System.out.println(r.getArea()); // OK

カプセル化と情報隠蔽 (1)

• カプセル化(encapsulation)
  • 互いに関連するデータや手続きを1つのクラスにまとめあげる
• 情報隠蔽(information hiding) = カプセル化達成のための方法
  • インスタンス内のデータや手続きの一部を外部に対して隠す
• データ隠蔽 = 情報隠蔽の一種
  • フィールドをprivateにして外部に非公開
  • 同フィールドにアクセスするメソッドをpublicにして公開
  • 利用側が、フィールドの定義変更の影響を受けない
  • 利用側が、誤って不必要にフィールドの値を書き換えることを防ぐ

カプセル化と情報隠蔽 (2)

class NamedRectangle extends Rectangle {
   private String name = null;
   // nameのアクセスメソッド (getter)
   String getName() {
      return name;
   }
   // nameのアクセスメソッド (setter)
   void setName(String n) {
      name = n;
   } }

例: privateコンストラクタ

• 外部から呼び出せないコンストラクタ。目的は例えば:
  • A. 共通の初期化処理をまとめたうえで、その他の付加的なコンストラクタを「必ず」使わせたい(例えばフィールド値の指定必須)
  • B. クラスフィールド/クラスメソッドのみで機能するためインスタンスが不要、しかし機能させたいので抽象クラスは不可
  • C. インスタンスは必要だが勝手に作らせたくない。生成個数制限。

public class MyClass {
   private MyClass() {
      ... //共通の初期化処理
   }
   public MyClass(String s) {
      this();
      ... //付加的な初期化処理
   }
   public MyClass(int x, int y) {
      this();
      ... //付加的な初期化処理
   } }

package java.lang;
public class Math {
   public static double PI
      = 3.14159265358979323846;
   private Math() {}
   public static double sin(double a){
      ...
   }
}

演習2: アクセス制限

• 以下のRepositoryクラスを次を満たすように修正せよ
  • (X) フィールド size を外部から読み書きするアクセスメソッドを追加し、かつ、同フィールドを外部から隠蔽せよ。
  • (Y) Clientの mainメソッド内で インスタンスを複数生成できてしまう。唯1つに制限して使いまわしたい(台帳が複数あるのは不都合)。
  • (Yのヒント) 唯一のインスタンスを返すクラスメソッドgetInstance()を追加し、同メソッドを Client に呼ばせればよい。その唯一のインスタンスを最初にどのように作っておけばよいだろう?
• 以下のClientクラスのmainメソッドを修正して、上記の修正が正しく実施されたことを確認せよ

public class Repository {
   public int size = 0;
   public Repository() {
   }
}

public class Client {
   public static void main(String[] args) {
      Repository r1 = new Repository();
      Repository r2 = new Repository();
      r1.size = 100;
      r2.size = 500;
      System.out.println(r1.size);
      System.out.println(r2.size);
   } }

解説: Singletonパターン (1)

• 状況: クラスのコンストラクタを設計している。
• 問題: 設計の保守性を保ちつつ、オブジェクト(クラスインスタンス)生成数を1つに制限したい。
• 考慮する事柄:
  • プログラム中でただ1つの生成をしたとしても、それは実装上の詳細であり、プログラムの他の部分は変更される可能性がある。
  • プログラムの拡張性を保ったままで、クラスの保守性を維持したい。
• 解決:
  • 対象クラスのコンストラクタを非公開(private)にし、
  • 同クラス内に自身の唯一のオブジェクトを持たせて、
  • 同オブジェクトを外部へ公開するクラスメソッドを用意する

解説: Singletonパターン (2)

abstract修飾子

• 抽象メソッド(abstract method)
  • メソッドのシグニチャのみが宣言され、本体の無いメソッド
  • サブクラスで「実装」してから呼び出せる
• 抽象クラス(abstract class)
  • 1つ以上の抽象メソッドを持つクラス
  • インスタンスを作ることができない
  • 抽象クラスのサブクラスは、抽象メソッドを「実装」しなければならない ⇒ サブクラスに実装を期待・要請

abstract class Player {
   void loop(int n) {
      for(int i = 0; i < n; i++) {
         play();
      }
   }
   // 抽象メソッド
   abstract void play();
}

class TextPlayer extends Player {
   // 抽象メソッドの実装
   void play() {
      System.out.println("TEXT");
   }
   public static void main(String[] args) {
      Player p = new TextPlayer();
      p.loop(2);
   }
}

修飾子のまとめ

• クラスやクラス構成要素に対する制限を明確にして、それらを意図通りに正確に利用させるための仕組み
• static: インスタンス生成不要でクラス固有のフィールド/メソッド
• final: 継承できず上書きできない、値を(宣言時の初期化後に)代入できないクラス/フィールド/メソッド
• アクセス修飾子public, protected, private: アクセス制限
• abstract: 抽象クラス/メソッド。継承されて実装されて始めてインスタンス生成/アクセス可

パッケージのまとめ

• パッケージとは、関連するクラスやインタフェースの集合をまとめたもの
• パッケージ≠クラス階層
• パッケージ=ファイル階層
• インターネットドメイン名によりユニークなパッケージ名をこころがける
• import節によるインポート宣言で、クラスやインタフェース利用時のパッケージ名を省略できる
• インポート宣言における「*」の扱いに注意
• アクセス修飾子により、様々なアクセス制限が可能
• 特にprivateは、情報隠蔽のためよく用いられる