次の Java プログラムの説明及びプログラムを読んで，設問に答えよ。

〔プログラムの説明〕

　固定バイト長のブロック（以下，ブロックという）を単位としてデータを保管している装置 （以下，ブロックデバイスという）に対し，ブロックのデータ（以下，ブロックデータという）への アクセスを管理するプログラムである。図１に，プログラム構成の概要を示す。 図中の四角はプログラムの構成要素を，矢印はブロックデータの流れを示す。 ここで，このプログラムでは，ブロックデバイスからの読込みだけを考える。

図１　プログラム構成の概要

　ブロックデバイス内の各ブロックは，インデックス値で指定する。 最初のブロックのインデックス値は，0である。

　ブロックアクセッサは，アプリケーションから要求されたブロックデータを ブロックデバイスから取得して，アプリケーションに渡す役割をする。 ブロックアクセッサはキャッシュを使用し，ブロックデバイスから 取得したブロックデータをキャッシュする。 アプリケーションから要求されたブロックデータがキャッシュされていれば， キャッシュから取得したブロックデータをアプリケーションに渡す。

　キャッシュは，FIFO（First In，First Out）と LRU（Least Recently Used）の２種類の 管理方針に基づく実装が用意されていて，アプリケーションはどの実装を使用するかを指定する。

(1) クラス BlockAccessor は，ブロックアクセッサを表す。

(3) 抽象クラス Cache は，ブロックアクセッサからキャッシュ機能を使用するためのクラスを表す。

〔プログラム１］

public class BlockAccessor {
   private final Cache cache;
   private final BlockDevice device;

   public BlockAccessor(Cache.Policy policy) {
      device = BlockDevice.open();
      cache = Cache.createCache(policy);
   }

   public byte[] readBlock(int index) {
      byte[] blookData = cache.getCachedBlockData(index);
      if (blockData == null) {
         blockData = new byte[device.getBlockSize()];
         device.readBlock(index, blockData);
         cache.cacheBlockData(index, blockData);
      }
      return blockData.clone();
   }
}

class BlockDevice {
   private final byte[][] blocks = new byte[1ØØ][512];

   static BlockDevice open() {
      return new BlockDevice();
   }

   int getBlockSize() {
      return  .length;
   }

   void readBlock(int index, byte[] buffer) {
      byte[] block = blocks[index];
      System.arraycopy(block, Ø, buffer, Ø, block.length);
   }
}

public abstract class Cache {
   public enum Policy {
      FIFO, LRU;
   }

   static  createCache(Policy policy) {
      switch (policy) {
      case FIFO:
         return new ListBasedCache.Fifo();
      case LRU:
         return new ListBasedCache.Lru();
      }
      throw new UnsupportedOperationException();
   }

   abstract byte[] getCachedBlockData(int index);
   abstract void cacheBlockData(int index, byte[] blockData);
}

import java.util.ArrayList;
import java.util.List;

abstract class ListBasedCache extends Cache {
   final List<Entry> entries = new ArrayList<Entry>();
   private static final int CACHE_SIZE = 2Ø;

   byte[] getCachedBlockData(int index) {
      for (Entry entry : entries) {
         if (entry.getIndex()  Index) {
            hit(entry);
            return entry.getBlockData();
         }
      }
      return null;
   }

   void cacheBlockData(int index, byte[] blockData) {
      if (  ) {
         entries.remove(  );
      }
     entries.add(Ø, new Entry(index, blockData));
   }

   abstract void hit(Entry entry);

   private static class Entry {
      private final int index;
      private final byte[] blockData;

      private Entry(int index, byte[] bLockData) {
         this.index = index;
         this.blockData = blockData;
      }

      int getIndex() { return index; }
      byte[] getBlockData() { return blockData; )
   }

   static class Fifo extends  {
      void hit(Entry entry) { }
   }

   static class Lru extends  {
      void hit(Entry entry) {
         entries.remove(  );
         entries.add(Ø, entry);
      }
   }
}

a に関する解答群

b に関する解答群

c に関する解答群

d に関する解答群

e に関する解答群

f に関する解答群

g に関する解答群