1‐1
次のように出力するクラスExer01_01を作成・コンパイル・実行しなさい。
Hello!!
World!!
1‐2
(1) 次の3つのクラスを1つのソースファイルExer01_02.javaに作成しなさい。
・Hello01!!と出力するクラスSample01
・Hello02!!と出力するクラスSample02
・Hello03!!と出力するクラスSample03
(2) 上記Exer01_02.javaをコンパイルしなさい。
(3) 上記の3つのクラスをそれぞれ実行しなさい。
1‐3
(1) 次のクラスをソースファイルExer01_03.javaに作成しなさい。
・OK!!と出力するpublicのついたクラスSayOK01
(2) 上記Exer01_03.javaをコンパイルし、エラーになることを確認しなさい。
(3) 上記Exer01_03.javaを正しく修正し、コンパイルして実行しなさい。
2‐1
次のような処理を行うクラスExer02_01を作成・コンパイル・実行しなさい。
・boolean型の変数b1を宣言し、trueを代入する。
・char型の変数c1を宣言し、'A'を代入する。
・int型の変数i1を宣言し、30を代入する。
・次の文字列を出力する。ただし、赤字の部分は変数に代入されている値である。
b1 = true, c1 = A, i1 = 30
2‐2
(1) 次のクラスを作成・コンパイルし、エラーとなることを確認しなさい。
------------------------------------------------------------------------
class Exer02_02 {
public static void main(String[] args){
int var1 = 10000000000L;
System.out.println("var1 = " + var1);
}
}
------------------------------------------------------------------------
(2) 上記コードの変数var1の型をある型に変更すれば、コンパイルが成功します。修正してコンパイル・実行しなさい。
2‐3
次のクラスをコンパイル・実行するとどのように出力されますか?
------------------------------------------------------------------------
class Exer02_03 {
public static void main(String[] args){
System.out.println(42);
System.out.println(052);
System.out.println(0x2a);
}
}
------------------------------------------------------------------------
2‐4
次のクラスをコンパイル・実行するとどのように出力されますか?
ただし、aという文字に対応する文字コードは97です。
------------------------------------------------------------------------
class Exer02_04 {
public static void main(String[] args){
char c1 = 97;
System.out.println("c1 = " + c1);
}
}
------------------------------------------------------------------------
3‐1
次のクラスをコンパイル・実行するとどのように出力されますか?
------------------------------------------------------------------------
class Exer03_01 {
public static void main(String[] args){
int a = 14;
int b = 5;
a %= b;
System.out.println("a = " + a);
}
}
------------------------------------------------------------------------
3‐2
次のクラスをコンパイル・実行するとどのように出力されますか?
------------------------------------------------------------------------
class Exer03_02 {
public static void main(String[] args){
int m = 8;
System.out.println("!(m != 8) : " + !(m != 8));
System.out.println("1 <= m && m <= 6 : " + (1 <= m && m <= 6));
System.out.println("1 <= m || m <= 6 : " + (1 <= m || m <= 6));
}
}
------------------------------------------------------------------------
3‐3
次のクラスをコンパイル・実行するとどのように出力されますか?
------------------------------------------------------------------------
class Exer03_03 {
public static void main(String[] args){
int a = 10;
int b;
b = a++;
System.out.println("b = " + b);
b = ++a;
System.out.println("b = " + b);
}
}
------------------------------------------------------------------------
3‐4
次のクラスをコンパイル・実行するとどのように出力されますか?
------------------------------------------------------------------------
class Exer03_04 {
public static void main(String[] args){
System.out.println(5 + 15 / (3 + 2) * 4);
}
}
------------------------------------------------------------------------
4‐1
次の2進数を10進数になおしなさい。
(1) 101101
(2) 11010
4‐2
次の10進数を2進数になおしなさい。
(1) 21
(2) 30
4‐3
次の16進数を10進数になおしなさい。
(1) e5
(2) 3f
4‐4
次の10進数を16進数になおしなさい。
(1) 186
(2) 30
4‐5
次の2進数を16進数になおしなさい。
(1) 10110110
(2) 11111111
4‐6
次の16進数を2進数になおしなさい。
(1) e5
(2) ffff
4‐7
整数型(byte, short, int, long)の各型についてビット数と範囲を答えなさい。(intとlongは2のべき乗で答えなさい。)
4‐8
整数型(byte, short, int, long)の最左ビット(一番左のビット)にはどんな意味がありますか?
4‐9
反転とはどんな演算ですか?またその演算子を答えなさい。
4‐10
次の式の下線部を埋めなさい。
~x =
4‐11
次の数を反転した結果を答えなさい。
(1) 17
(2) 152
(3) -40
(4) -128
4‐12
byte型の変数に次の値が格納されています。ビット(0または1)の並びを答えなさい。
(1) 39
(2) 23
(3) -24
(4) -19
4‐13
byte型の変数に次のビット(0または1)の並びが格納されています。値を答えなさい。
(1) 00010100
(2) 00001001
(3) 10010110
(4) 11110100
4‐14
整数型(byte, short, int, long)の各型のー1という値のビットの並びにはある特徴があります。どんな特徴ですか?
5‐1
次のクラスをコンパイル・実行するとどのように出力されますか?
------------------------------------------------------------------------
class Exer05_01 {
public static void main(String[] args){
short s = 100;
int i = s;
System.out.println("i = " + i);
}
}
------------------------------------------------------------------------
5‐2
(1) 次のクラスを作成・コンパイルし、エラーとなることを確認しなさい。
------------------------------------------------------------------------
class Exer05_02 {
public static void main(String[] args){
int i = 100;
short s = i;
System.out.println("s = " + s);
}
}
------------------------------------------------------------------------
(2) 上記コードはキャストを使用すれば、コンパイルが成功します。修正してコンパイル・実行しなさい。
5‐3
次のクラスをコンパイル・実行するとどのように出力されますか?
------------------------------------------------------------------------
class Exer05_03 {
public static void main(String[] args){
System.out.println(~200);
System.out.println((byte)200);
System.out.println((short)0xffffff);
}
}
------------------------------------------------------------------------
5‐4
(1) 次のクラスを作成・コンパイルし、エラーとなることを確認しなさい。
------------------------------------------------------------------------
class Exer05_04 {
public static void main(String[] args){
byte b1 = 10, b2 = 20, b3;
b3 = b1 + b2;
System.out.println(b3);
}
}
------------------------------------------------------------------------
(2) 上記コードはキャストを使用すれば、コンパイルが成功します。修正してコンパイル・実行しなさい。
6‐1
3つのコマンドライン引数(整数)の合計を出力するようなクラスを作成しなさい。
7‐1
if, else構文を使って次のようなクラスを作成・コンパイル・実行しなさい。
・コマンドライン引数(整数)を1つ指定する。
・それが100よりも大きいか0よりも小さい場合は、"エラー"と出力する。
・100以下で80以上の場合は、"ランクA"と出力する。
・80未満で50以上の場合は、"ランクB"と出力する。
・50未満で20以上の場合は、"ランクC"と出力する。
・20未満で0以上の場合は、"ランクD"と出力する。
7‐2
switch構文を使って次のようなクラスを作成・コンパイル・実行しなさい。
・コマンドライン引数(整数)を1つ指定する。
・それが1の場合は、"1. 終了"と出力する。
・それが2の場合は、"2. 表示"と出力する。
・それが3の場合は、"3. 追加"と出力する。
・それが4の場合は、"4. 削除"と出力する。
・それ以外の場合は、"エラー"と出力する。
7‐3
三項演算子を使って次のようなクラスを作成・コンパイル・実行しなさい。
・コマンドライン引数(整数)を1つ指定する。
・それが0の場合は、"指定された数は0です"と出力する。
・それが0でない場合は、"指定された数は0ではありません"と出力する。
8‐1
繰り返し構文を使って次のようなクラスを作成します。
・コマンドライン引数(整数)を1つ指定する。
・1からその数までの3の倍数ではない数を表示する。
例)コマンドライン引数で10を指定した場合
1
2
4
5
7
8
10
(1) continueを使用しないで作成しなさい。
(2) continueを使用して作成しなさい。
8‐2
繰り返し構文を使って次のようなクラスを作成します。
・コマンドライン引数(整数)を2つ指定する。
・1番目の引数はカウンタi、2番目はjとして、1から指定された引数までiとjの組合せを処理する。
・iとjの積が7以上の組合せを表示する
例)コマンドライン引数で3と8を指定した場合
i = 1, j = 7
i = 1, j = 8
i = 2, j = 4
i = 2, j = 5
i = 2, j = 6
i = 2, j = 7
i = 2, j = 8
i = 3, j = 3
i = 3, j = 4
i = 3, j = 5
i = 3, j = 6
i = 3, j = 7
i = 3, j = 8
8‐3
繰り返し構文を使って次のようなクラスを作成します。
・コマンドライン引数(整数)を2つ指定する。
・1番目の引数はカウンタi、2番目はjとして、1から指定された引数までiとjの組合せを処理する。
・iとjの積が6以下の組合せを表示する
例)コマンドライン引数で3と8を指定した場合
i = 1, j = 1
i = 1, j = 2
i = 1, j = 3
i = 1, j = 4
i = 1, j = 5
i = 1, j = 6
i = 2, j = 1
i = 2, j = 2
i = 2, j = 3
i = 3, j = 1
i = 3, j = 2
(1) breakとcontinueを使用しないで作成しなさい。
(2) breakを使用して作成しなさい。
(3) ラベルとcontinueを使用して作成しなさい。
8‐4
繰り返し構文を使って次のようなクラスを作成します。
・コマンドライン引数(整数)を2つ指定する。
・1番目の引数はカウンタi、2番目はjとして、1から指定された引数までiとjの組合せを処理する。
・iとjの積が7以上の組合せがでてくれば表示を中止する。
例)コマンドライン引数で3と4を指定した場合
i = 1, j = 1
i = 1, j = 2
i = 1, j = 3
i = 1, j = 4
i = 2, j = 1
i = 2, j = 2
i = 2, j = 3
8‐5
繰り返し構文を使って次のようなクラスを作成・コンパイル・実行しなさい。
・コマンドライン引数(整数)を1つ指定する。
・*を指定された数から1まで、逆ピラミッド状に出力する。
例)コマンドライン引数で5を指定した場合
*****
****
***
**
*
最初は1通りでいいです。余裕があれば3パターンくらいやってみて下さい。
9‐1
次のような手順で配列を扱うクラスを作成しなさい。
・intの配列型の変数を宣言する。
・5個の要素をもつintの配列を生成し、上記の変数に代入する。
・上記の配列の[0]番の要素に13を代入する。
・上記の配列の[1]番の要素に10を代入する。
・上記の配列の[2]番の要素に7を代入する。
・上記の配列の[3]番の要素に4を代入する。
・上記の配列の[4]番の要素に1を代入する。
・forループを使用して、上記配列の全ての要素を空白で区切って出力する。
9‐2
9‐1と同じことを配列初期化子を使って行いなさい。ただし、宣言と生成は別々に行うこと。
9‐3
9‐1と同じことを配列初期化子を使って行いなさい。ただし、宣言と生成は同時に行うこと。その際、なるべく簡素にしなさい。
9‐4
9‐1の配列は、規則性があります。それを利用して、代入をforループで行うように変更しなさい。ただし、宣言と生成は同時に行うこと。
9‐5
次のような手順で2次元配列を扱うクラスを作成しなさい。
・intの2次元配列型の変数を宣言する。
・3×2個の要素をもつintの2次元配列(下位となる1次元配列を含めて)を生成し、上記の変数に代入する。
・上記の2次元配列の[0][0]番の要素に22を代入する。
・上記の2次元配列の[0][1]番の要素に24を代入する。
・上記の2次元配列の[1][0]番の要素に42を代入する。
・上記の2次元配列の[1][1]番の要素に44を代入する。
・上記の2次元配列の[2][0]番の要素に62を代入する。
・上記の2次元配列の[2][1]番の要素に64を代入する。
・2重forループを使用して、上記2次元配列の全ての要素を次のように出力する。
22 24
42 44
62 64
9‐6
次のような手順で2次元配列を扱うクラスを作成しなさい。
・intの2次元配列型の変数を宣言する。
・3個の要素をもつintの2次元配列(ただし、下位となる1次元配列は含まない)を生成し、上記の変数に代入する。
・22, 24という要素をもつintの配列を配列初期化子によって生成し、上記の2次元配列の[0]番の要素に代入する。
・42という要素をもつintの配列を配列初期化子によって生成し、上記の2次元配列の[1]番の要素に代入する。
・62, 64, 66という要素をもつintの配列を配列初期化子によって生成し、上記の2次元配列の[2]番の要素に代入する。
・2重forループを使用して、上記2次元配列の全ての要素を次のように出力する。
22 24
42
62 64 66
9‐7
9‐6と同じ配列を、2次元配列としての配列初期化子を使って一度に生成するように変更しなさい。ただし、宣言と生成は別々に行うこと。
9‐8
9‐6と同じ配列を、2次元配列としての配列初期化子を使って一度に生成するように変更しなさい。ただし、宣言と生成は同時に行うこと。その際、なるべく簡素にしなさい。
9‐9
次のような手順で2次元配列を扱うクラスを作成しなさい。なお、配列内容は出力結果を参考に作成しなさい。
・intの2次元配列型の変数を宣言し、同時にintの2次元配列(ただし、下位となる1次元配列は含まない)を生成して代入する。
・forループを使用して1次元配列を生成する。
・2重forループを使用して1次元配列の各要素に代入する。
・2重forループを使用して、上記2次元配列の全ての要素を次のように出力する。
1 2 3 4 5
2 3 4 5
3 4 5
9‐10
次のクラスをコンパイル・実行するとどのように出力されますか?
------------------------------------------------------------------------
class Exer09_10 {
public static void main(String[] args){
int[][] ia = {{22, 24}, {42}, {62, 64, 66}};
System.out.println(ia.length);
System.out.println(ia[1].length);
System.out.println(ia[2][1]);
}
}
------------------------------------------------------------------------
9‐11
次のクラスはコンパイルエラーとなります。その理由を答えなさい。
------------------------------------------------------------------------
class Exer09_11 {
public static void main(String[] args){
int[] ia;
ia = {13, 10, 7, 4, 1};
for(int i = 0; i < ia.length; i++){
System.out.print(ia[i] + " ");
}
System.out.println();
}
}
------------------------------------------------------------------------
9‐12
次のクラスをコンパイル・実行するとどのように出力されますか?
------------------------------------------------------------------------
class Exer09_12 {
public static void main(String[] args){
int[] ia1 = {1, 2, 3, 4, 5};
int[] ia2 = ia1;
ia1[3] = 10;
System.out.println(ia2[3]);
}
}
------------------------------------------------------------------------
9‐13
次のクラスをコンパイル・実行するとどのように出力されますか?
------------------------------------------------------------------------
class Exer09_13 {
public static void main(String[] args){
int[][] ia = new int[3][];
ia[0] = ia[1] = ia[2] = new int[]{1, 2, 3};
ia[0][1] = 20;
for(int i = 0; i < ia.length; i++){
for(int j = 0; j < ia[i].length; j++){
System.out.print(ia[i][j] + " ");
}
System.out.println();
}
}
}
------------------------------------------------------------------------
10‐1
次のように出力するクラスを考えます。
Taro
Good morning!
Good afternoon!
Good evening!
Jiro
Good morning!
Good afternoon!
Good evening!
このために、次のようなmain以外のメソッドを定義します。なお、メソッド名は自分で決めなさい。
・staticである。
・戻り値はvoid型。
・引数はなし。
・Good morning!からGood evening!までを出力する。
上記メソッドを利用して作成し、コンパイル・実行しなさい。
10‐2
次のように出力するクラスを考えます。
Good morning! Taro
Good afternoon! Taro
Good evening! Taro
Good morning! Jiro
Good afternoon! Jiro
Good evening! Jiro
このために、次のようなmain以外のメソッドを定義します。なお、メソッド名は自分で決めなさい。
・staticである。
・戻り値はvoid型。
・String(文字列)型の引数を1個もつ。名前は自分で決めなさい。
・引数を後ろに連結してGood morning!からGood evening!までを出力する。
上記メソッドを利用して作成し、コンパイル・実行しなさい。
10‐3
積を計算する、次のようなmain以外のメソッドを定義します。なお、メソッド名は自分で決めなさい。
・staticである。
・戻り値はint型。
・int型の引数を2個もつ。名前は自分で決めなさい。
・2個の引数の積を返す。
次のような手順でクラスを作成し、コンパイル・実行しなさい。
・10×10の値を上記メソッドによって計算し、その結果を変数に代入する。変数名は自分で決めなさい。
・上記変数の値を"10 * 10 = "という文字列の後に連結して出力する。
・20×20の値を上記メソッドによって計算し、結果を変数に代入せずに、"20 * 20 = "という文字列の後に連結して直接出力する。
10‐4
商を計算する、次のようなmain以外のメソッドを定義します。なお、メソッド名は自分で決めなさい。
・staticである。
・戻り値はint型。
・int型の引数を2個もつ。名前は自分で決めなさい。
・1番目の引数を2番目の引数で割った値(商)を返す。ただし、2番目の引数が0の場合は計算できないので、便宜上0を返す。
次のような手順でクラスを作成し、コンパイル・実行しなさい。
・20÷5の値を上記メソッドによって計算し、結果を変数に代入せずに、"20 / 5 = "という文字列の後に連結して直接出力する。
・30÷8の値を上記メソッドによって計算し、結果を変数に代入せずに、"30 / 8 = "という文字列の後に連結して直接出力する。
・3÷0の値を上記メソッドによって計算し、結果を変数に代入せずに、"3 / 0 = "という文字列の後に連結して直接出力する。
・0÷2の値を上記メソッドによって計算し、結果を変数に代入せずに、"0 / 2 = "という文字列の後に連結して直接出力する。
10‐5
ローカルとフィールド変数の違いについて人に説明しなさい。
10‐6
ローカル変数は、外のメソッドでは使うことができません。そのことを確認するクラスの例を作成しなさい。(コンパイルエラーとなるクラスを作成する。)
10‐7
フィールドは、どのメソッドでも使うことができます。そのことを確認するクラスを作成しなさい。
11‐1
本をモデルとする、次のようなBook01というクラスを作成・コンパイルしなさい。
・題名を表すString型のtitleというフィールドをもつ。
・題名を出力するvoid型のprintTitle()というメソッドをもつ。
11‐2
次のような処理を行うExer11_02というクラスを作成・コンパイル・実行しなさい。
・Book01のインスタンスを生成し、Book01型の変数に代入する。
・変数を使用して、インスタンスのtitleフィールドに"Java"を代入する。
・変数を使用して、インスタンスのprintTitle()メソッドを呼び出す。
11‐3
次のような処理を行うExer11_03というクラスを作成・コンパイル・実行しなさい。
・Book01のインスタンスを3個生成し、Book01型の3個の変数にそれぞれを代入する。
・各変数を使用して、各インスタンスのtitleフィールドに"Java","Linux","Tomcat"をそれぞれ代入する。
・各変数を使用して、各インスタンスのprintTitle()メソッドを呼び出す。
11‐4
次のクラスをコンパイル・実行するとどのように出力されますか?
------------------------------------------------------------------------
class Exer11_04 {
public static void main(String[] args){
Book01 b1 = new Book01();
Book01 b2 = new Book01();
Book01 b3 = new Book01();
b1.title = "Java";
b2.title = "Linux";
b3.title = "Tomcat";
b1.printTitle();
b2.printTitle();
b3.printTitle();
}
}
------------------------------------------------------------------------
11‐5
次のクラスをコンパイル・実行するとどのように出力されますか?
------------------------------------------------------------------------
class Exer11_05 {
public static void main(String[] args){
Book01 b1 = new Book01();
Book01 b2 = b1;
b1.title = "Linux";
b2.title = "Java";
b1.printTitle();
}
}
------------------------------------------------------------------------
12‐1
次のようなExer12_01というクラスを作成・コンパイルしなさい。
・int型のsnumというstaticフィールドをもつ。初期値は10とする。
・snumを出力するprintSnum()というstaticメソッドをもつ。
12‐2
次のような処理を行うExer12_02というクラスを作成・コンパイル・実行しなさい。
・上記Exer12_01のprintSnum()を呼び出す。
・上記Exer12_01のsnumに20を代入する。
・上記Exer12_01のprintSnum()を呼び出す。
12‐3
次のようなExer12_03というクラスを作成・コンパイルしなさい。
・int型のsnumというstaticフィールドをもつ。初期値は0とする。
・int型のinumという非staticフィールドをもつ。初期値は0とする。
・snumとinumをそれぞれ1だけ増加するimcrement()という非staticメソッドをもつ。
12‐4
次のような処理を行うExer12_04というクラスを作成・コンパイル・実行しなさい。また、なぜそのような出力の結果になったのか図を描いて説明しなさい。
・Exer12_03のインスタンスを3個生成し、3個の変数にそれぞれを代入する。
・各変数を使用して、各インスタンスのimcrement()メソッドを呼び出す。
・各変数を使用して、各インスタンスのinumフィールドを出力する。
・クラスExer12_03のsnumフィールドを出力する。
12‐5
次のクラスをコンパイル・実行するとどのように出力されますか?
------------------------------------------------------------------------
class Class01 {
static int snum = 0;
int inum = 0;
void increment(){
snum++;
inum++;
}
void print(){
System.out.println("snum = " + snum + ", inum = " + inum);
}
}
class Exer12_05 {
public static void main(String[] args){
Class01 c1 = new Class01();
Class01 c2 = new Class01();
Class01 c3 = new Class01();
c1.increment();
c2.increment();
c3.increment();
c1.print();
c2.print();
c3.print();
}
}
------------------------------------------------------------------------
12‐6
staticメソッドからは、自クラスの非staticフィールドを直接使ったり、非staticメソッドを直接呼び出すことはできません。その理由を答えなさい。また、それを確認するクラスの例を自分で作成しなさい。(コンパイルエラーとなるクラスを作成する。)
12‐7
次のクラスをコンパイルするとどうなりますか?
------------------------------------------------------------------------
class Exer12_07 {
String name = "Tanaka";
void print(){
System.out.println("OK!");
}
public static void main(String[] args){
System.out.println(name);
print();
}
}
------------------------------------------------------------------------
12‐8
12‐7のクラスのnameフィールドや、print()メソッドはインスタンスの中に確保されます。よって、staticメソッドからでも、インスタンスを生成すれば使用することができます。
12‐7のクラスを変更し、main()メソッドから自分のクラスのインスタンスを生成し、そのインスタンスのnameフィールドを出力し、print()メソッドを呼び出すように変更したExer12-08というクラスを作成しなさい。
13‐1
シグニチャを説明しなさい
13‐2
2つのメソッドのシグニチャが同じかどうか答えなさい。
(1)
void abc(){...}
void def(){...}
(2)
void abc(int v){...}
void abc(int v1, int v2){...}
(3)
void abc(int v1){...}
void abc(long v1){...}
(4)
void abc(int v1){...}
void abc(int v2){...}
(5)
void abc(int v1, long v2){...}
void abc(long v1, int v2){...}
(6)
void abc(int v1, long v2){...}
int abc(int v1, long v2){...}
13‐3
オーバーロードを説明しなさい
13‐4
次のようなExer13_04というクラスを作成・コンパイル・実行しなさい。
・int型のmet()というstaticメソッドを2個オーバーロードする。
・1個目のmet()はint型の引数1個で、引数の値をそのまま返す。
・2個目のmet()はint型の引数2個で、引数の値を足した値を返す。
・mainメソッドから2個のmet()を適当な引数を指定して呼び出し、その結果を出力する。
13‐5
上記のExer13_04を次のように変更し、Exer13_05というクラスを作成しなさい。
・2個のmet()メソッドを非staticに変更する。
・mainメソッドから2個のmet()を適当な引数を指定して呼び出し、その結果を出力する。非staticなので注意すること。
13‐6
次のようなExer13_06というクラスを作成・コンパイルしなさい。
・非staticなint型のnumというフィールドをもつ。
・次のようなmet()というメソッドを2個オーバーロードする。
static int met(int v1){...}
int met(){...}
・static int met(int v1){...}は、引数の2乗を返す。
・int met(){...}はnumフィールドの2乗を返す。
13‐7
次のような処理を行うExer13_07というクラスを作成・コンパイル・実行しなさい。
・上記Exer13-06の引数をもつmet()を適当な引数を指定して呼び出して出力する。
・上記Exer13-06のインスタンスを生成する。
・そのインスタンスのnumフィールドにを適当な値を代入する。
・そのインスタンスの引数のないmet()を呼び出して出力する。
14‐1
次のクラスを実行するとどのように出力されますか?
------------------------------------------------------------------------
class Exer14_01 {
int num = 10;
void print(){
int num = 20;
System.out.println(num);
System.out.println(this.num);
}
void print(int num){
System.out.println(num);
System.out.println(this.num);
}
public static void main(String[] args){
Exer14_01 e = new Exer14_01();
e.print();
e.print(30);
}
}
------------------------------------------------------------------------
14‐2
本をモデルとする、次のようなBook02というクラスを作成・コンパイルしなさい。
・題名を表すString型のtitleというフィールドをもつ。
・コンストラクタの引数で題名を指定させる。ただし、コンストラクタの引数の名前はフィールド名と同じにする。
・題名を出力するvoid型のprintTitle()というメソッドをもつ。
14‐3
次のような処理を行うExer14_03というクラスを作成・コンパイル・実行しなさい。
・題名に"Java","Linux","Tomcat"を指定してBook02のインスタンスを3個生成し、Book02型の3個の変数にそれぞれを代入する。
・各変数を使用して、各インスタンスのprintTitle()メソッドを呼び出す。
14‐4
次のようなクラスExer14_04を作成・コンパイルしなさい。
・int型のフィールドを2個もつ。
・引数無し、int型の引数1個、int型の引数2個、の3個のコンストラクタをもつ。
・引数無しのコンストラクタは、適当な値を指定して自クラスの引数1個のコンストラクタを呼び出す。
・引数1個のコンストラクタは、引数として受け取った値と適当な値を指定して、自クラスの引数2個のコンストラクタを呼び出す。
・引数2個のコンストラクタは、2個の引数を2個のフィールドにそれぞれ代入する。
・2個のフィールドを出力するメソッドをもつ。
14‐5
次のような処理を行うクラスExer14_05を作成・コンパイル・実行して結果を確認しなさい。
・上記Exer14_04の引数無し、引数1個、引数2個のコンストラクタを呼び出して、インスタンスを3個生成する。
・それぞれのインスタンスに対し、フィールドを出力するメソッドを呼び出す。
14‐6
次のクラスを実行するとどのように出力されますか?
------------------------------------------------------------------------
class Exer14_06 {
int i1;
int i2;
Exer14_06(){
this(10);
}
Exer14_06(int i1){
this(i1, 20);
}
Exer14_06(int i1, int i2){
this.i1 = i1;
this.i2 = i2;
}
void print(){
System.out.println("i1 = " + i1 + ", i2 = " + i2);
}
public static void main(String[] args){
Exer14_06 e;
e = new Exer14_06();
e.print();
e = new Exer14_06(100);
e.print();
e = new Exer14_06(100, 200);
e.print();
}
}
------------------------------------------------------------------------
15‐1
次のような手順で配列を扱うクラスを作成しなさい。
・14‐2で作成したクラスBook02の配列型の変数を宣言する。
・5個の要素をもつBook02の配列を生成し、上記の変数に代入する。
・上記の配列の[0]番の要素に題名が"Java"であるBook02のインスタンスを代入する。
・上記の配列の[1]番の要素に題名が"Linux"であるBook02のインスタンスを代入する。
・上記の配列の[2]番の要素に題名が"Tomcat"であるBook02のインスタンスを代入する。
・上記の配列の[3]番の要素に題名が"PostgreSQL"であるBook02のインスタンスを代入する。
・上記の配列の[4]番の要素に題名が"XML"であるBook02のインスタンスを代入する。
・forループを使用して、上記配列の全ての要素に対してprintTitle()を呼び出して題名を出力する。
15‐2
15‐1と同じことを配列初期化子を使って行いなさい。ただし、宣言と生成は別々に行うこと。
15‐3
15‐1と同じことを配列初期化子を使って行いなさい。ただし、宣言と生成は同時に行うこと。その際、なるべく簡素にしなさい。
15‐4
次のような手順で2次元配列を扱うクラスを作成しなさい。
・Book02の2次元配列型の変数を宣言する。
・3×2個の要素をもつBook02の2次元配列(下位となる1次元配列を含めて)を生成し、上記の変数に代入する。
・上記の2次元配列の[0][0]番の要素に題名が"Java"であるBook02のインスタンスを代入する。
・上記の2次元配列の[0][1]番の要素に題名が"Linux"であるBook02のインスタンスを代入する。
・上記の2次元配列の[1][0]番の要素に題名が"Tomcat"であるBook02のインスタンスを代入する。
・上記の2次元配列の[1][1]番の要素に題名が"PostgreSQL"であるBook02のインスタンスを代入する。
・上記の2次元配列の[2][0]番の要素に題名が"XML"であるBook02のインスタンスを代入する。
・上記の2次元配列の[2][1]番の要素に題名が"Apache"であるBook02のインスタンスを代入する。
・2重forループを使用して、上記2次元配列の全ての要素に対してprintTitle()を呼び出し、次のように題名を出力する。
--------
Java
Linux
--------
Tomcat
PostgreSQL
--------
XML
Apache
15‐5
次のような手順で2次元配列を扱うクラスを作成しなさい。
・Book02の2次元配列型の変数を宣言する。
・3個の要素をもつBook02の2次元配列(ただし、下位となる1次元配列は含まない)を生成し、上記の変数に代入する。
・題名が"Java","Linux"であるBook02のインスタンス2個を要素とする配列を配列初期化子によって生成し、上記の2次元配列の[0]番の要素に代入する。
・題名が"Tomcat"であるBook02のインスタンス1個を要素とする配列を配列初期化子によって生成し、上記の2次元配列の[1]番の要素に代入する。
・題名が"PostgreSQL","XML","Apache"であるBook02のインスタンス3個を要素とする配列を配列初期化子によって生成し、上記の2次元配列の[2]番の要素に代入する。
・2重forループを使用して、上記2次元配列の全ての要素に対してprintTitle()を呼び出し、次のように題名を出力する。
--------
Java
Linux
--------
Tomcat
--------
PostgreSQL
XML
Apache
15‐6
15‐5と同じ配列を、2次元配列としての配列初期化子を使って一度に生成するように変更しなさい。ただし、宣言と生成は別々に行うこと。
15‐7
15‐5と同じ配列を、2次元配列としての配列初期化子を使って一度に生成するように変更しなさい。ただし、宣言と生成は同時に行うこと。その際、なるべく簡素にしなさい。
16‐1
車をモデルとする、次のようなCar01というクラスを作成しなさい。
・機種を表すString型のmodelというフィールドをもつ。
・メーカーを表すString型のmakerというフィールドをもつ。
・コンストラクタの引数で機種とメーカーを指定させる。ただし、コンストラクタの引数の名前はフィールド名と同じにする。
・機種を出力するvoid型のprintModel()というメソッドをもつ。
・メーカーを出力するvoid型のprintMaker()というメソッドをもつ。
・printModel()とprintMaker()を順に呼び出して、機種とメーカーを出力するvoid型のprintData()というメソッドをもつ。
16‐2
上記Car01を継承し、トラックをモデルとする、次のようなTrack01というクラスを作成しなさい。
・積載量を表すint型のloadというフィールドをもつ。
・コンストラクタの引数で機種とメーカーと積載量を指定させる。ただし、コンストラクタの引数の名前はフィールド名と同じにする。
・コンストラクタからスーパークラスのコンストラクタを呼び出す。
・積載量を出力するvoid型のprintLoad()というメソッドをもつ。
16‐3
次のような処理を行うExer16_03というクラスを作成・コンパイル・実行し、結果を確認しなさい。
・機種にELF、メーカーにISUZU、積載量に2を指定して、Track01のインスタンスを生成し、Track01型の変数に代入する。
・機種にCanter、メーカーにMITSUBISHI、積載量に4を指定して、Track01のインスタンスを生成し、Track01型の変数に代入する。
・機種にHiAce、メーカーにTOYOTA、積載量に1を指定して、Track01のインスタンスを生成し、Track01型の変数に代入する。
・変数を利用して各インスタンスのprintData()を呼び出す。
16‐4
16‐3の結果、各インスタンスの機種とメーカーしか出力されません。
そこで、Track01を次のように変更して、Track02というクラスを作成しなさい。
・printData()メソッドをオーバーライドし、機種とメーカーと積載量を出力するようにする。その際、スーパークラスのprintData()を呼び出した後、printLoad()を呼び出すようにしなさい。
16‐5
Exer16_03をTrack02を使用するように変更したExer16_05というクラスを作成・コンパイル・実行し、結果を確認しなさい。
16‐6
左辺がスーパークラス型、右辺がサブクラス型という代入文は有効であることを確認します。
上記Car01とTrack02を使用し、次のような処理を行うExer16_06というクラスを作成・コンパイル・実行しなさい。
・スーパークラス型の変数を宣言する。
・サブクラス型の変数を宣言し、サブクラス型のインスタンスを生成して代入する。
・上記のスーパークラス型の変数にサブクラス型の変数を代入する。
・OKと出力する。
16‐7
Exer16_06を、スーパークラス型の変数に直接サブクラス型のインスタンスを生成して代入するように変更したExer16_07というクラスを作成・コンパイル・実行しなさい。
16‐8
左辺がサブクラス型、右辺がスーパークラス型という代入文は無効であることを確認します。
上記Car01とTrack02を使用し、次のような処理を行うExer16_08というクラスを作成し、コンパイルエラーとなることを確認しなさい。
・サブクラス型の変数を宣言する。
・スーパークラス型の変数を宣言し、スーパークラス型のインスタンスを生成して代入する。
・上記のサブクラス型の変数にスーパークラス型の変数を代入する。
・OKと出力する。
16‐9
Exer16_08を、サブクラス型の変数に直接スーパークラス型のインスタンスを生成して代入するように変更したExer16_09というクラスを作成し、コンパイルエラーとなることを確認しなさい。
16‐10
上記Car01とTrack02を使用し、次のような処理を行うExer16_10というクラスを作成し、コンパイルエラーとなることを確認しなさい。
・サブクラス型の変数を宣言する。
・スーパークラス型の変数を宣言し、サブクラス型のインスタンスを生成して代入する。
・上記のサブクラス型の変数にスーパークラス型の変数を代入する。
・OKと出力する。
16‐11
Exer16_10は、結果的にサブクラス型の変数の参照先がサブクラス型のインスタンスになるので、コンパイルが成功すれば、正常に実行される可能性が残っています。
コンパイルが通るように修正したExer16_11というクラスを作成・コンパイル・実行しなさい。
(ヒント:キャストを使用しなさい。)
16‐12
Exer16_08をキャストを使用してコンパイルが通るように修正したExer16_12というクラスを作成・コンパイル・実行し、結果を確認しなさい。
16‐13
次のことを確認できるクラスを作成しなさい。
・スーパークラス型の変数がサブクラス型のインスタンスを参照している場合、インスタンスには存在しているにもかかかわらず、サブクラスにしかないフィールドやメソッドは、そのスーパークラス型の変数から使用することができない。(コンパイルエラーとなるクラスを作成しなさい。)
16‐14
次のことを確認できるクラスを作成しなさい。
・スーパークラス型の変数がサブクラス型のインスタンスを参照している場合、その変数からオーバーライドされたメソッドを呼び出せば、変数の型(スーパークラス型)ではなく、インスタンスの型(サブクラス型)のほうが有効である。
17‐1
次のクラスをコンパイル・実行するとどのようになりますか?
------------------------------------------------------------------------
class Class01 {
int num1 = 10;
}
class Class02 extends Class01 {
int num2 = 20;
}
class Exer17_01 {
public static void main(String[] args){
Class01 c1 = new Class02();
System.out.println(c1.num1);
}
}
------------------------------------------------------------------------
17‐2
次のクラスをコンパイル・実行するとどのようになりますか?
------------------------------------------------------------------------
class Class01 {
int num1 = 10;
}
class Class02 extends Class01 {
int num2 = 20;
}
class Exer17_02 {
public static void main(String[] args){
Class01 c1 = new Class02();
System.out.println(c1.num2);
}
}
------------------------------------------------------------------------
17‐3
次のクラスをコンパイル・実行するとどのようになりますか?
------------------------------------------------------------------------
class Class01 {
void print(){
System.out.println("Class01!");
}
}
class Class02 extends Class01 {
void print(){
System.out.println("Class02!");
}
}
class Exer17_03 {
public static void main(String[] args){
Class01 c1 = new Class02();
c1.print();
}
}
------------------------------------------------------------------------
17‐4
(1) 次のクラスをコンパイル・実行するとどのようになりますか?
------------------------------------------------------------------------
class Class01 {
int num1 = 10;
}
class Class02 extends Class01 {
int num2 = 20;
}
class Exer17_04 {
public static void main(String[] args){
Class01 c1 = new Class02();
Class02 c2 = c1;
System.out.println(c2.num2);
}
}
------------------------------------------------------------------------
(2) 上記クラスはコンパイルが失敗します。キャストを使用して、コンパイルが成功するようにしなさい。
(3) 実行した結果を予想しなさい。
17‐5
次のクラスをコンパイル・実行するとどのようになりますか?
------------------------------------------------------------------------
class Class01 {
int num1 = 10;
}
class Class02 extends Class01 {
int num2 = 20;
}
class Exer17_05 {
public static void main(String[] args){
Class01 c1 = new Class01();
Class02 c2 = (Class02)c1;
System.out.println(c2.num2);
}
}
------------------------------------------------------------------------
17‐6
次のクラスをコンパイル・実行するとどのようになりますか?
------------------------------------------------------------------------
class Class01 {
int num1;
int num2;
Class01(int num1, int num2){
this.num1 = num1;
this.num2 = num2;
}
void print(){
System.out.println("num1 = " + num1);
System.out.println("num2 = " + num2);
}
}
class Class02 extends Class01 {
int num3;
Class02(int num1, int num2, int num3){
super(num1, num2);
this.num3 = num3;
}
void print(){
super.print();
System.out.println("num3 = " + num3);
}
}
class Exer17_06 {
public static void main(String[] args){
Class01 c1 = new Class02(10, 20, 30);
c1.print();
}
}
------------------------------------------------------------------------
17‐7
次のクラスをコンパイル・実行するとどのようになりますか?
------------------------------------------------------------------------
class Class01 {
int num1;
Class01(int num1){
this.num1 = num1;
}
}
class Class02 extends Class01 {
Class02(){
super();
}
}
class Exer17_07 {
public static void main(String[] args){
Class01 c1 = new Class02();
}
}
------------------------------------------------------------------------
18‐1
アクセス修飾子の3個のキーワードを答えなさい。
18‐2
アクセス修飾子は上記3個と何も指定しないという場合を含めて4種類あります。
それぞれ、どこからのアクセスが許されるかを答えなさい。
18‐3
final修飾子はクラスとメソッドと変数(フィールド・ローカル変数)を修飾する場合があります。
それぞれの場合について説明しなさい。
18‐4
次のクラスをコンパイルするとどうなりますか?
------------------------------------------------------------------------
class Class01 {
private int num;
Class01(int num){
this.num = num;
}
}
class Exer18_04 {
public static void main(String[] args){
Class01 c = new Class01(20);
System.out.println(c.num);
}
}
------------------------------------------------------------------------
18‐5
次のクラスをコンパイルするとどうなりますか?
------------------------------------------------------------------------
final class Class01 {
}
class Class02 extends Class01 {
}
------------------------------------------------------------------------
18‐6
次のクラスをコンパイルするとどうなりますか?
------------------------------------------------------------------------
class Class01 {
final void print(){
}
}
class Class02 extends Class01 {
void print(){
}
}
------------------------------------------------------------------------
18‐7
次のクラスをコンパイルするとどうなりますか?
------------------------------------------------------------------------
class Exer18_07 {
public static void main(String[] args){
final int i;
i = 10;
i = 20;
System.out.println(i);
}
}
------------------------------------------------------------------------
19‐1
図形をモデルとする、次のようなShape01という抽象クラスを作成しなさい。
・横幅を表すint型のwidthというフィールドをもつ。
・高さを表すint型のheightというフィールドをもつ。
・コンストラクタの引数で横幅と高さを指定させる。ただし、コンストラクタの引数の名前はフィールド名と同じにする。
・描画するためのvoid型のdraw()という抽象メソッドをもつ。
19‐2
Shape01を継承し、長方形をモデルとする、次のようなRectangle01というクラスを作成しなさい。
・コンストラクタの引数で横幅と高さを指定させる。ただし、コンストラクタの引数の名前はフィールド名と同じにする。
・コンストラクタからスーパークラスのコンストラクタを呼び出す。
・draw()は■を出力した後、横幅と高さを出力するようにオーバーライドする。
19‐3
Shape01を継承し、楕円形をモデルとする、次のようなEllipse01というクラスを作成しなさい。
・コンストラクタの引数で横幅と高さを指定させる。ただし、コンストラクタの引数の名前はフィールド名と同じにする。
・コンストラクタからスーパークラスのコンストラクタを呼び出す。
・draw()は●を出力した後、横幅と高さを出力するようにオーバーライドする。
19‐4
Shape01を継承し、三角形をモデルとする、次のようなTriangle01というクラスを作成しなさい。
・コンストラクタの引数で横幅と高さを指定させる。ただし、コンストラクタの引数の名前はフィールド名と同じにする。
・コンストラクタからスーパークラスのコンストラクタを呼び出す。
・draw()は▲を出力した後、横幅と高さを出力するようにオーバーライドする。
19‐5
次のような処理を行うExer19_05というクラスを作成・コンパイル・実行し、結果を確認しなさい。
・配列初期化子を使用して、Shape01の配列にRectangle01、Ellipse01、Triangle01のインスタンスを適当に様々な大きさで生成し、代入する。
・配列の全ての要素に対して順番にdraw()メソッドを呼び出す。
20‐1
(1) インターフェースで宣言したフィールドは自動的にある修飾子が付加されたとみなされます。その修飾子を3つ答えなさい。
(2) インターフェースで定義したメソッドは自動的にある修飾子が付加されたとみなされます。その修飾子を2つ答えなさい。
20‐2
電話の抽象的な側面をモデルとする、次のようなPhone01というインターフェースを作成しなさい。
・電話を掛けるためのvoid型で引数無しのcall()というメソッドをもつ。
・電話を受けるためのvoid型で引数無しのtake()というメソッドをもつ。
20‐3
Phone01を実装し、電話の具体的な側面をモデルとする、次のようなPhone01TypeAというクラスを作成しなさい。
・電話番号を表すString型のnumberというフィールドをもつ。
・コンストラクタの引数で電話番号を指定させる。ただし、コンストラクタの引数の名前はフィールド名と同じにする。
・call()はTypeAと電話番号と電話を掛けているという旨の内容を出力するようにしなさい。
・take()はTypeAと電話番号と電話を受けているという旨の内容を出力するようにしなさい。
20‐4
Phone01を実装し、電話の具体的な側面をモデルとする、次のようなPhone01TypeBというクラスを作成しなさい。
・電話番号を表すString型のnumberというフィールドをもつ。
・コンストラクタの引数で電話番号を指定させる。ただし、コンストラクタの引数の名前はフィールド名と同じにする。
・call()はTypeBと電話番号と電話を掛けているという旨の内容を出力するようにしなさい。
・take()はTypeBと電話番号と電話を受けているという旨の内容を出力するようにしなさい。
20‐5
カメラの抽象的な側面をモデルとする、次のようなCamera01というインターフェースを作成しなさい。
・写真を撮るためのsnap()というメソッドをもつ。snap()はvoid型で、画素数を表すint型の引数を1つもつ。
20‐6
Camera01を実装し、カメラの具体的な側面をモデルとする、次のようなCamera01TypeCというクラスを作成しなさい。
・snap()はTypeCと画素数と写真を撮っているという旨の内容を出力するようにしなさい。
20‐7
Camera01を実装し、カメラの具体的な側面をモデルとする、次のようなCamera01TypeDというクラスを作成しなさい。
・snap()はTypeDと画素数と写真を撮っているという旨の内容を出力するようにしなさい。
20‐8
Phone01とCamera01を実装し、カメラ付き携帯電話の具体的な側面をモデルとする、次のようなMobile01TypeEというクラスを作成しなさい。
・電話番号を表すString型のnumberというフィールドをもつ。
・コンストラクタの引数で電話番号を指定させる。ただし、コンストラクタの引数の名前はフィールド名と同じにする。
・call()はTypeEと電話番号と電話を掛けているという旨の内容を出力するようにしなさい。
・take()はTypeEと電話番号と電話を受けているという旨の内容を出力するようにしなさい。
・snap()はTypeEと画素数と写真を撮っているという旨の内容を出力するようにしなさい。
20‐9
Phone01とCamera01を実装し、カメラ付き携帯電話の具体的な側面をモデルとする、次のようなMobile01TypeFというクラスを作成しなさい。
・電話番号を表すString型のnumberというフィールドをもつ。
・コンストラクタの引数で電話番号を指定させる。ただし、コンストラクタの引数の名前はフィールド名と同じにする。
・call()はTypeFと電話番号と電話を掛けているという旨の内容を出力するようにしなさい。
・take()はTypeFと電話番号と電話を受けているという旨の内容を出力するようにしなさい。
・snap()はTypeFと画素数と写真を撮っているという旨の内容を出力するようにしなさい。
20‐10
次のような処理を行うExer20_10というクラスを作成・コンパイル・実行し、結果を確認しなさい。
・電話の機能をもっている(Phone01を実装している)すべてのクラスのテストを次の手順で行います。
・配列初期化子を使用して、Phone01の配列にPhone01TypeA、Phone01TypeA、Mobile01TypeE、Mobile01TypeFのインスタンスを適当な電話番号を指定して生成し、代入する。
・配列の全ての要素に対して順番にcall()とtake()メソッドを呼び出す。
・カメラの機能をもっている(Camera01を実装している)すべてのクラスのテストを次の手順で行います。
・配列初期化子を使用して、Camera01の配列にCamera01TypeC、Camera01TypeD、Mobile01TypeE、Mobile01TypeFのインスタンスを生成し、代入する。(電話番号が必要な場合は適当に指定すること。)
・配列の全ての要素に対して順番にsnap()メソッドを呼び出す。画素数は500万画素から100万ずつ増やしていくこと。
20‐11
次のクラスをコンパイル・実行するとどのようになりますか?
------------------------------------------------------------------------
interface Inter01 {
void met01();
}
interface Inter02 {
void met02();
}
class Class01 implements Inter01, Inter02 {
public void met01(){
System.out.println("met01!!");
}
}
class Exer20_11 {
public static void main(String[] args){
Inter01 i1 = new Class01();
i1.met01();
}
}
------------------------------------------------------------------------
20‐12
次のクラスをコンパイル・実行するとどのようになりますか?
------------------------------------------------------------------------
interface Inter01 {
void met01();
}
interface Inter02 {
void met02();
}
class Class01 implements Inter01, Inter02 {
void met01(){
System.out.println("met01!!");
}
void met02(){
System.out.println("met02!!");
}
}
class Exer20_12 {
public static void main(String[] args){
Inter01 i1 = new Class01();
i1.met01();
}
}
------------------------------------------------------------------------
20‐13
次のクラスをコンパイル・実行するとどのようになりますか?
------------------------------------------------------------------------
interface Inter01 {
void met01();
}
interface Inter02 {
void met02();
}
class Class01 implements Inter01, Inter02 {
public void met01(){
System.out.println("met01!!");
}
public void met02(){
System.out.println("met02!!");
}
}
class Exer20_13 {
public static void main(String[] args){
Inter01 i1 = new Class01();
i1.met01();
}
}
------------------------------------------------------------------------
20‐14
次のクラスをコンパイル・実行するとどのようになりますか?
------------------------------------------------------------------------
interface Inter01 {
void met01();
}
interface Inter02 {
void met02();
}
class Class01 implements Inter01, Inter02 {
public void met01(){
System.out.println("met01!!");
}
public void met02(){
System.out.println("met02!!");
}
}
class Exer20_14 {
public static void main(String[] args){
Inter01 i1 = new Class01();
i1.met02();
}
}
------------------------------------------------------------------------
20‐15
次のクラスをコンパイル・実行するとどのようになりますか?
Basicでやってない内容も一部含まれます(キャストの部分)が、予想してみて下さい。
------------------------------------------------------------------------
interface Inter01 {
void met01();
}
interface Inter02 {
void met02();
}
class Class01 implements Inter01, Inter02 {
public void met01(){
System.out.println("met01!!");
}
public void met02(){
System.out.println("met02!!");
}
}
class Exer20_15 {
public static void main(String[] args){
Inter01 i1 = new Class01();
Inter02 i2 = (Inter02)i1;
i2.met02();
}
}
------------------------------------------------------------------------
20‐16
次のクラスをコンパイル・実行するとどのようになりますか?
Basicでやってない内容も一部含まれます(キャストの部分)が、予想してみて下さい。
------------------------------------------------------------------------
interface Inter01 {
void met01();
}
interface Inter02 {
void met02();
}
class Class01 implements Inter01 {
public void met01(){
System.out.println("met01!!");
}
public void met02(){
System.out.println("met02!!");
}
}
class Exer20_16 {
public static void main(String[] args){
Inter01 i1 = new Class01();
Inter02 i2 = (Inter02)i1;
i2.met02();
}
}
------------------------------------------------------------------------
21‐1
jp.co.pa01というパッケージに属する次のようなExer21_01というクラスを作成・コンパイルしなさい。
なお、必要なディレクトリなどは自分で作成しなさい。
・クラスはpublicを指定する。
・適当な文字列を出力するメソッドを定義する。これもpublicを指定する。
21‐2
jp.co.pa02というパッケージに属する次のようなExer21_02というクラスを作成・コンパイル・実行しなさい。
なお、必要なディレクトリなどは自分で作成しなさい。
・クラスはpublicを指定する。
・上記jp.co.pa01パッケージのExer21_01クラスのインスタンスを生成し、定義したメソッドを呼び出す。
・必要であれば、import文を記述する。
21‐3
上記jp.co.pa01パッケージのExer21_01クラスのクラスやメソッドのpublic指定をはずして、どうなるか確認しなさい。
22‐1
A
____|____
| |
B C
| __|___
(X) | |
(Y) D
|
(Z)
(1) 上記図は例外クラスの継承関係の図です。AからDに当てはまる例外クラスを答えなさい。
(2) 上記図で、例外に対する対処がないとコンパイルが通らない系列は(X)から(Z)のうちどれですか?
(3) (2)の系列の例外を何といいますか?
(4) (2)の系列以外の例外を何といいますか?
22‐2
次のクラスをコンパイルするとエラーになります。その理由を答えなさい。
ヒント:Thread.sleep()はInterruptedExceptionという例外を発生する可能性があり、これはExceptionの直接のサブクラス。
------------------------------------------------------------------------
class Exer22_02 {
void met(){
System.out.println("start");
Thread.sleep(3000);
System.out.println("end");
}
}
------------------------------------------------------------------------
22‐3
上記Exer22_02をtry ... catchを使ってコンパイルが通るように修正し、Exer22_03というクラスを作成しなさい。なお、tryで囲むのは最小限の処理にしなさい。
また、例外発生時の処理は例外情報を出力するだけでよい。
22‐4
上記Exer22_03のインスタンスを生成し、そのmet()メソッドを呼び出すという処理を行うExer22_04というクラスを作成・コンパイル・実行しなさい。
22‐5
上記Exer22_02をthrowsを使ってコンパイルが通るように修正し、Exer22_05というクラスを作成しなさい。
22‐6
上記Exer22_05のインスタンスを生成し、そのmet()メソッドを呼び出すという処理を行うExer22_06というクラスを作成・コンパイル・実行しなさい。
22‐7
下記のクラスは実行時のコマンドライン引数によって、次の3つの例外を発生する可能性があります。
・コマンドライン引数を指定しなかった場合 … ArrayIndexOutOfBoundsException(配列の存在しない添字番号を使用した)
・数字でないものを指定した場合 … NumberFormatException(数字に変更できなかった)
・0を指定した場合 … ArithmeticException(0で割り算をした)
・1桁の数字を指定した場合 … StringIndexOutOfBoundsException(文字列の存在しない添字番号を使用した)
これらはすべてExceptionのサブクラスです。
------------------------------------------------------------------------
class Exer22_07 {
public static void main(String[] args){
int num = Integer.parseInt(args[0]);
System.out.println("1000を割った結果 : " + 1000 / num);
System.out.println("2桁目の数字 : " + args[0].charAt(1));
}
}
------------------------------------------------------------------------
上記クラスは例外対処をしていませんが、次のように例外対処をしなさい。
また、args[0].charAt(1)の部分は気にしないでください。
・ArrayIndexOutOfBoundsExceptionが発生した場合は、"コマンドライン引数を指定して下さい"と出力する。
・NumberFormatExceptionが発生した場合は、"数字を指定して下さい"と出力する。
・それ以外の例外が発生した場合は"2桁以上の数字を指定して下さい"と出力する。
22‐8
次のクラスをコンパイルするとエラーになります。その理由を答えなさい。また、コンパイルが成功するように修正しなさい。
------------------------------------------------------------------------
class Exer22_08 {
public static void main(String[] args){
try{
int num = Integer.parseInt(args[0]);
System.out.println("1000を割った結果 : " + 1000 / num);
System.out.println("2桁目の数字 : " + args[0].charAt(1));
}catch(Exception ex){
ex.printStackTrace();
}catch(StringIndexOutOfBoundsException ex){
ex.printStackTrace();
}
}
}
------------------------------------------------------------------------
23‐1
(1) 何も継承することなく定義したクラスも自動的にあるクラスを継承します。そのクラスは何ですか?
すなわち、そのクラスは広い意味で全てのクラスのスーパークラスになります。
(2) (1)のクラスのメソッドで、あるインスタンスを文字列に変換するという役割をもつものは何ですか?
(3) (1)のクラスのメソッドで、自分のインスタンスと他のインスタンスが等しいかどうか判定するという役割をもつものは何ですか?
23‐2
選手をモデルとするPlayer01というクラスを次のように作成・コンパイルします。
------------------------------------------------------------------------
class Player01 {
private String name;
Player01(String name){
this.name = name;
}
}
------------------------------------------------------------------------
上記Player01を使用する次のようなクラスを作成・コンパイル・実行します。
------------------------------------------------------------------------
class Exer23_02 {
public static void main(String[] args){
Player01 p = new Player01("Matsui");
System.out.println(p);
}
}
------------------------------------------------------------------------
実行結果は、"Player01@7ced01"のような意味不明の出力になりました。
これを、Exer23_02を実行すると"Matsui"と出力されるように、Player01を変更しなさい。
23‐3
次のクラスをコンパイル・実行するとどのように出力されますか?
なお、Player02は23‐2で変更した後のものとします。(変更前であっても同じです。)
------------------------------------------------------------------------
class Exer23_03 {
public static void main(String[] args){
Player01 p1 = new Player01("Matsui");
Player01 p2 = p1;
Player01 p3 = new Player01("Matsui");
System.out.println(p1 == p2);
System.out.println(p1 == p3);
System.out.println(p1.equals(p2));
System.out.println(p1.equals(p3));
}
}
------------------------------------------------------------------------
23‐4
次のクラスをコンパイル・実行するとどのように出力されますか?
------------------------------------------------------------------------
class Exer23_04 {
public static void main(String[] args){
System.out.println("abcdefgh".length());
System.out.println("abcdefgh".charAt(4));
System.out.println("abcdefgh".indexOf("efg"));
System.out.println("abcdefgh".substring(4, 6));
}
}
------------------------------------------------------------------------
23‐5
次のクラスをコンパイル・実行するとどのように出力されますか?
------------------------------------------------------------------------
class Exer23_05 {
public static void main(String[] args){
String s1 = new String("Matsui");
String s2 = s1;
String s3 = new String("Matsui");
System.out.println(s1 == s2);
System.out.println(s1 == s3);
System.out.println(s1.equals(s2));
System.out.println(s1.equals(s3));
}
}
------------------------------------------------------------------------
23‐6
コマンドライン引数で指定した2つの文字列をチェックする次のようなクラスを作成しました。
------------------------------------------------------------------------
class Exer23_06 {
public static void main(String[] args){
if(args[0] == "tanaka" && args[1] == "zzz0123"){
System.out.println("ログインできました");
}else{
System.out.println("ログインできませんでした");
}
}
}
------------------------------------------------------------------------
上記クラスをコンパイルし、次のように実行しました。
java Exer23_06 tanaka zzz0123
その結果、"ログインできませんでした"と出力されました。
その理由を説明するとともに、"ログインできました"と出力されるように修正しなさい。
23‐7
次のクラスをコンパイル・実行するとどのように出力されますか?
------------------------------------------------------------------------
class Exer23_07 {
public static void main(String[] args){
StringBuffer sb = new StringBuffer();
sb.append("zyxwvu");
sb.insert(3, "abc");
sb.replace(3, 6, "0123");
System.out.println(sb);
}
}
------------------------------------------------------------------------
23‐8
3つのコマンドライン引数(整数)の積の桁数を出力するようなクラスを作成しなさい
23‐9
Integerクラスのインスタンスはint型のデータを内部に保持します。インスタンスの生成方法は次のものがあります。
・コンストラクタでint型の引数を指定してnewする。
・コンストラクタでString型の引数を指定してnewする。
・IntegerクラスのstaticメソッドvalueOf()をString型の引数を指定して呼び出す。
上記の3通りの方法を使用し、適当な値を指定してIntegerのインスタンスを生成し、それぞれのインスタンスから内部で保持しているint型のデータを取り出して積を求め、それを出力するようなクラスを作成しなさい。
24‐1
Collection
____|____
| |
A B
|
C
(1) 上記図はコレクションインターフェースの継承関係の図です。AからCに当てはまるコレクションインターフェースを答えなさい。
(2) 上記Aのインターフェースを実装する代表的なクラスを2つ答えなさい。
(3) 上記Bのインターフェースを実装する代表的なクラスを答えなさい。
(4) 上記Cのインターフェースを実装する代表的なクラスを答えなさい。
(5) 上記Aのインターフェースは追加した要素をどのような順番で管理しますか?
(6) 上記Bのインターフェースは追加した要素をどのような順番で管理しますか?
(7) 上記Cのインターフェースは追加した要素をどのような順番で管理しますか?
24‐2
次のような処理を行うExer24_02というクラスを作成・コンパイル・実行しなさい。
・LinkedList型の変数を宣言し、それにLinkedListのインスタンスを生成して代入する。
・14‐2で作成したBook02のインスタンスを3個生成し、上記のLinkedListに追加する。タイトルは適当でよい。
・LinkedListが管理している全てのBook02のインスタンスに対して、printTitle()を呼び出す。その際、追加された順番で処理されるように、LinkedListのget()メソッドを使用しなさい。
24‐3
Exer24_02をget()メソッドではなくIteratorを使用するように変更し、Exer24_03というクラスを作成・コンパイル・実行しなさい。
24‐4
Exer24_02を追加した順序とは逆順で処理するように変更し、Exer24_04というクラスを作成・コンパイル・実行しなさい。
get()を使用する方法のままでよい。
24‐5
Exer24_03を追加した順序とは逆順で処理するように変更し、Exer24_05というクラスを作成・コンパイル・実行しなさい。
ヒント:Iteratorではなく、ListIteratorを使用する。
24‐6
コマンドライン引数で指定した文字列を辞書順で並び替えて、改行して出力するようなExer24_06というクラスを作成・コンパイル・実行しなさい。
24‐7
1から順に増加する数を2乗した数で200以下の集合を考えます。
すなわち、1, 4, 9, 16, 25, ...で200以下の数の集合です。
それを逆順で出力するクラスを次のような手順で作成し、コンパイル・実行しなさい。
・LinkedList型の変数を宣言し、それにLinkedListのインスタンスを生成して代入する。
・forループを利用し、1の2乗から順に200以下の範囲で、その数をLinkedListに追加していく。ただし、int型のデータを直接LinkedListでは扱えないので、何か工夫しなさい。
・LinkedListに追加された数を逆順で出力する。get()を使用してよい。
25‐1
上記は入出力を行う際に使用するストリームの分類の表です。AからDのストリームの種類を答えなさい。
25‐2
入力の効率をよくするため、通常はデータをバッファリング(ためること)するストリームを使用します。
(1) 上記25‐1のCの上位にくるバッファリングするストリームは何ですか?
(2) (1)のストリームで使用することのできる、1行分読み込むためのメソッドは何ですか?
(3) 上記25‐1のDの上位にくるバッファリングするストリームは何ですか?
25‐3
2つのコマンドライン引数(整数)の合計を出力するようなクラスExer25_03を次の用件を満たすように作成しなさい。
・コマンドライン引数の個数が2つ以外の場合は、標準エラー出力に"2個の引数を指定してください"と出力する。
・個数は2つだが、整数に変換できないコマンドライン引数が指定されていた場合は、標準エラー出力に"整数を指定してください"と出力する。
・コマンドライン引数が正しい場合はその合計を標準出力に出力する。
上記クラスを作成後、結果が標準出力か標準エラー出力のどちらに出力されているか、Linuxのリダイレクションを利用して(すなわち > や 2> を利用して出力先をファイルに切り替えて)確認しなさい。
ヒント:数字に変換できない場合、Integer.parseInt()でNumberFormatExceptionという例外が発生します。
25‐4
入力した単語を入力した順番とは逆の順番で出力する次のようなクラスExer25_04を作成・コンパイル・実行しなさい。
(1) ユーザーに機能を選択させるため、次のように出力する。
機能番号を選択してください。 1.終了 2.単語入力=>
(2) (1)で2が選択された場合、続けて次のように出力し、ユーザーに単語を入力させる。その後(1)に戻る。
単語を入力してください=>
(3) (1)で1が選択された場合、これまでユーザーが入力してきた単語を入力した順番とは逆の順番で出力し、終了する。
ヒント:あるコレクションを使用する。
25‐5
Exer25_04を辞書順で出力するように変更したクラスExer25_05を作成・コンパイル・実行しなさい。
ヒント:使用するコレクションを変更する。
25‐6
次のようなクラスExer25_06を、Exer25_04を参考にして作成・コンパイルしなさい。
・入力ファイルと出力ファイルをコマンドライン引数で指定させる。
・入力ファイルはテキストデータ(文字列データ)とする。
・入力ファイルの行の順番を逆順にして出力ファイルに出力する。
入力用のテキストデータファイルを適当に作成しなさい。実行時はそのファイルと適当な出力ファイルを指定しなさい。
25‐7
Exer25_06を辞書順で出力するように変更したクラスExer25_07を作成・コンパイル・実行しなさい。
26‐1
(1) スレッドとして起動されて動作するクラスの定義方法として2つあります。あるクラスを継承する方法と、あるインターフェースを実装する方法です。そのクラスとインターフェースは何ですか。
(2) (1)の2つの方法のどちらの場合でも、あるメソッドをオーバーライドする必要があります。そのメソッドは何ですか?
26‐2
短距離走者をモデルとするSprinter01という次のようなクラスを作成しなさい。
・スレッドとして動作することを前提とするので、あるクラスを継承する。
・名前を表すprivateでString型のnameというフィールドをもつ。
・10メートルを走るのに必要なミリ秒数(ラップタイム)を表すprivateでint型のrapというフィールドをもつ。
・コンストラクタの引数で、名前とラップタイムを指定させる。ただし、コンストラクタの引数の名前はフィールド名と同じにする。
・スレッドとしての処理は、100メートルを走るということを想定する。まず、名前とスタートした旨を出力し、その後ラップタイムの時間分処理を停止して、名前と10メートル毎にスタート地点からの距離を出力する。
26‐3
次のような処理を行うExer26_03というクラスを作成・コンパイル・実行し、結果を確認しなさい。
・適当な名前・ラップタイムを指定して、上記のSprinter01のインスタンスを3個生成し、それらをスレッドとして起動する。
・main()メソッドでは上記の処理以外に何かする必要はない。
26‐4
上記Sprinter01をあるクラスを継承するのではなく、あるインターフェースを実装するように変更し、Sprinter02というクラスを作成しなさい。
26‐5
上記Exer26_03をSprinter02を使用するように変更し、Exer26_05というクラスを作成・コンパイル・実行し、結果を確認しなさい。
26‐6
上記Exer26_05を、全員が100メートルを走り終わった後、すなわち起動した全てのスレッド終了を待って、"レースが終了しました"と出力するように変更し、Exer26_06というクラスを作成・コンパイル・実行し、結果を確認しなさい。
26‐7
金庫をモデルとするCashbox01という次のようなクラスを作成しなさい。
(1) 簡単のため、この金庫は一万円札のみを保管し、なおかつ、最初は1枚しかないとする。
(2) この金庫がその時点で保管する一万円札の数を表すprivateなint型のnumberというフィールドをもつ。当然初期値は1とする。
(3) この金庫から一万円札を1枚借りて何かを行ってそれを返すという処理を、publicでvoid型のborrowというメソッドとして定義する。borrow()は借りる人の名前を表すString型の引数を1個もつ。具体的なborrow()の処理は次の通りとする。
・numberフィールドを1だけ減らす。
・引数で受け取った名前の人が借りた旨とその時点でのnumberの値を出力する。
・1秒間処理を止める。
・numberを1だけ増やして戻す。
・引数で受け取った名前の人が返した旨とその時点でのnumberの値を出力する。
26‐8
上記の金庫を使用する職員をモデルとするStaff01という次のようなクラスを作成しなさい。
(1) スレッドとして動作することを前提とするので、Runnableインターフェースを実装する。
(2) その職員の名前を表すprivateなString型のnameというフィールドをもつ。
(3) その職員が使用する金庫を表すprivateなCashbox01型のcashboxというフィールドをもつ。
(4) コンストラクタの引数で、名前と金庫を指定させる。ただし、コンストラクタの引数の名前はフィールド名と同じにする。
(5) スレッド、すなわちrun()メソッドの処理としては、金庫から一万円札を1枚借りる処理を行う。具体的には次の通り。
・cashboxフィールドが参照するCashbox01インスタンスのborrow()メソッドを呼び出す。引数は自分の名前を指定する。
26‐9
一つの金庫から3人の職人がほぼ同時に一万円を借りることを想定し、次のようなExer26_09というクラスを作成・コンパイル・実行し、結果を確認しなさい。
(1) 上記Cashbox01のインスタンスを生成する。
(2) 適当な名前と、(1)で生成したインスタンスを指定して、Staff01のインスタンスを3個生成し、スレッドとして起動する。
26‐10
上記Exer26_09をは、金庫が保管しているお札の数がマイナスになるという実際にはあり得ないことが起こる。Cashbox01を変更して、その現象を回避しなさい。
27‐1
次のクラスをコンパイル・実行するとどのようになりますか?
------------------------------------------------------------------------
class Class01 {
void print(){
System.out.println("OK");
}
}
class Exer27_01 {
private static void met(Class01 c){
c.print();
}
public static void main(String[] args){
Class01 c = new Class01();
met(c);
}
}
------------------------------------------------------------------------
27‐2
次のクラスをコンパイル・実行するとどのようになりますか?
------------------------------------------------------------------------
class Class01 {
void print(){
System.out.println("OK");
}
}
class Exer27_02 {
private static Class01 met(){
Class01 c = new Class01();
return c;
}
public static void main(String[] args){
Class01 c = met();
c.print();
}
}
------------------------------------------------------------------------
27‐3
次のクラスをコンパイル・実行するとどのようになりますか?
------------------------------------------------------------------------
class Class01 {
void print(){
System.out.println("OK");
}
}
class Exer27_03 {
private static void met(Class01 c){
c.print();
}
public static void main(String[] args){
met(new Class01());
}
}
------------------------------------------------------------------------
27‐4
次のクラスをコンパイル・実行するとどのようになりますか?
------------------------------------------------------------------------
class Class01 {
void print(){
System.out.println("OK");
}
}
class Exer27_04 {
private static Class01 met(){
return new Class01();
}
public static void main(String[] args){
met().print();
}
}
------------------------------------------------------------------------
27‐5
次のクラスをコンパイル・実行するとどのようになりますか?
------------------------------------------------------------------------
class Class01 {
void print(){
System.out.println("OK");
}
}
class Exer27_05 {
public static void main(String[] args){
new Class01().print();
}
}
------------------------------------------------------------------------
27‐6
次のクラスをコンパイル・実行するとどのようになりますか?
------------------------------------------------------------------------
class Class01 {
void print(){
System.out.println("OK");
}
}
class Class02 {
Class01 c1 = new Class01();
}
class Class03 {
Class02 c2 = new Class02();
}
class Exer27_06 {
public static void main(String[] args){
new Class03().c2.c1.print();
}
}
------------------------------------------------------------------------
27‐7
次のクラスをコンパイル・実行するとどのようになりますか?
------------------------------------------------------------------------
class Class01 {
private String name;
Class01(String name){
this.name = name;
}
void printName(){
System.out.println(name);
}
}
class Class02 {
Class01 c1;
Class02(Class01 c1){
this.c1 = c1;
}
void met(){
c1.printName();
}
}
class Exer27_07 {
public static void main(String[] args){
new Class02(new Class01("Tanaka")).met();
}
}
------------------------------------------------------------------------
27‐8
次のクラスをコンパイル・実行するとどのようになりますか?
------------------------------------------------------------------------
class Class01 {
private int num;
Class01(int num){
this.num = num;
}
int calc(Class01 c){
return c.num - num;
}
}
class Exer27_08 {
public static void main(String[] args){
Class01 c1 = new Class01(10);
Class01 c2 = new Class01(20);
System.out.println(c2.calc(c1));
}
}
------------------------------------------------------------------------
27‐9
次のクラスをコンパイル・実行するとどのようになりますか?(一部Basicでやってない部分も含みます。)
------------------------------------------------------------------------
interface Inter01 {
void print();
}
class Class01 implements Inter01 {
public void print(){
System.out.println("OK");
}
}
class Exer27_09 {
private static void met(Inter01 i){
i.print();
}
public static void main(String[] args){
met(new Class01());
}
}
------------------------------------------------------------------------
27‐10
次のクラスをコンパイル・実行するとどのようになりますか?(一部Basicでやってない部分も含みます。)
------------------------------------------------------------------------
interface Inter01 {
void print();
}
class Class01 implements Inter01 {
public void print(){
System.out.println("OK");
}
}
class Exer27_10 {
private static Inter01 met(){
return new Class01();
}
public static void main(String[] args){
Inter01 i = met();
met().print();
}
}
------------------------------------------------------------------------
27‐11
次のクラスの//で挟まれた2行を1行にまとめなさい。
------------------------------------------------------------------------
import java.io.*;
class Exer27_11 {
public static void main(String[] args){
try{
//
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader br = new BufferedReader(isr);
//
String s = br.readLine();
System.out.println(s);
}catch(Exception ex){
ex.printStackTrace();
}
}
}
------------------------------------------------------------------------
27‐12
次のクラスの//で挟まれた2行を1行にまとめなさい。
------------------------------------------------------------------------
class Class01 extends Thread {
public void run(){
System.out.println("Class01!!");
}
}
class Exer27_12 {
public static void main(String[] args){
//
Class01 c = new Class01();
c.start();
//
System.out.println("Exer27_12!!");
}
}
------------------------------------------------------------------------
27‐13
次のクラスの//で挟まれた3行を1行にまとめなさい。
------------------------------------------------------------------------
class Class01 implements Runnable {
public void run(){
System.out.println("Class01!!");
}
}
class Exer27_13 {
public static void main(String[] args){
//
Class01 c = new Class01();
Thread t = new Thread(c);
t.start();
//
System.out.println("Exer27_13!!");
}
}
------------------------------------------------------------------------