11/15付講義資料と今回の講義資料中のサンプルプログラムについて考察せよ。講義資料サンプルプログラム考察については、static変数以降とする
・異なるオブジェクト間の変数合計プログラム例
1: class Sum {
2: int total;
3: Sum() { // コンストラクタ(クラス名と同名)
4: total = 0; // 0 クリア
5: }
6: void add(int x) {
7: total += x;
8: }
9: }
10:
11: class SumSample {
12: public static void main(String args[]) {
13: Sum obj1 = new Sum(); // クラスSumのオブジェクトobj1生成
14: Sum obj2 = new Sum(); // クラスSumのオブジェクトobj2生成
15: obj1.add(10);
16: obj1.add(20);
17: obj2.add(30);
18: obj2.add(40);
19: System.out.println("obj1.total = " + obj1.total);
20: System.out.println("obj2.total = " + obj2.total);
21: }
22: }
[nw051:~/java/Rep6] j04051% java SumSample
obj1.total = 30
obj2.total = 70
考察
・プログラムについて
1: class Sum {
2: int total;
3: Sum() {
4: total = 0;
5: }
6: void add(int x) {
7: total += x;
8: }
9: }
・Sumクラスの{と}の中に書いているものが、クラス宣言の内容である。
・int型のtotalをフィールドとして宣言(フィールドとは「情報を保存する場所」)。totalという変数を持つSum。
・Sum()は、Sumクラスのコンストラクタである。コンストラクタとは、新しくオブジェクト(インスタンス)を作ると同時
に、オブジェクトの「初期化」をするものである。しかも、引数なしのコンストラクタなので、オブジェクトを作成する
と同時にtotalの値を０に自動的に初期化するという意味になる。
・addメソッドを宣言(メソッドは「情報を処理する方法」)。voidは、このメソッドが処理の結果を戻り値として返さない
ということを意味する。(int x)の部分がメソッドの仮引数列であり、メソッドの入力にあたるものである。ここでは
int型の引数xを宣言している。{}内がaddメソッドの処理内容となる。totalの値にxを足したものを、totalに代入する。
11: class SumSample {
12: public static void main(String args[]) {
13: Sum obj1 = new Sum();
14: Sum obj2 = new Sum();
・SumSampleクラスの{}内に書かれているものが、クラス宣言の内容である。
・mainは実行開始を意味する。
・Sum obj1 = new Sum();は、コンストラクタの呼び出してあり、Sumのオブジェクトが生成され、変数obj1に代入される。
Sum obj2 = new Sum();は、コンストラクタの呼び出しであり、Sumのオブジェクトが生成され、変数obj2に代入される。
Sumは異なる２つのオブジェクトを確保し、それぞれ異なるフィールドが確保されている。
15: obj1.add(10);
・addメソッドの呼び出し。
引数xを10とし、total += x の式に代入。totalは０なので０＋10となる。求められた値をobj1が指し示す。
16: obj1.add(20);
・addメソッドの呼び出し。
引数xを20とし、total += x の式に代入。obj1の示すtotalは10なので、10＋20になる。求められた値をobj1が指し示す。
17: obj2.add(30);
・addメソッドの呼び出し。
引数xを30とし、total += x の式に代入。totalは０なので０＋30となる。求められた値をobj2が指し示す。(totalは、
obj1とobj2で違うフィールドに確保されているため、値はそれぞれちがうものになる)
18: obj2.add(40);
・addメソッドの呼び出し。
引数xを40とし、total += x の式に代入。obj2の示すtotalは30なので、30＋40になる。(17行の実行により、totalは30)
求められた値をobj2が指し示す。
19: System.out.println("obj1.total = " + obj1.total);
・obj1が示すtotalを表示する。16行と17行でobj1の示すtotalの値が30になる。
20: System.out.println("obj2.total = " + obj2.total);
・obj2が示すtotalを表示する。18行と19行でobj2の示すtotalの値が70になる。
・staticを用いて値を共有するプログラム例
1: class Sum {
2: static int total; // 値を共有させる
3: Sum() { // コンストラクタ(クラス名と同名)
4: total = 0; // 0 クリア
5: }
6: void add(int x) {
7: total += x;
8: }
9: }
10:
11: class SumSample {
12: public static void main(String args[]) {
13: Sum obj1 = new Sum(); // クラスSumのオブジェクトobj1生成
14: Sum obj2 = new Sum(); // クラスSumのオブジェクトobj2生成
15: obj1.add(10);
16: obj1.add(20);
17: obj2.add(30);
18: obj2.add(30);
19: System.out.println("obj1.total = " + obj1.total);
20: System.out.println("obj2.total = " + obj2.total);
21: }
22: }
[nw051:~/java/Rep6] j04051% java SumSample
obj1.total = 100
obj2.total = 100
考察
・プログラムについて
1: class Sum {
2: static int total;
3: Sum() {
4: total = 0;
5: }
6: void add(int x) {
7: total += x;
8: }
9: }
・Sumクラスの{と}の中に書いているものが、クラス宣言の内容である。
・int型のtotalをクラスフィールドとして宣言(フィールドとは「情報を保存する場所」)。クラスフィールドは、全オブジェ
クト(インスタンス)に共通の情報を保持する場所のことを意味する(クラス変数とも呼ばれる)。totalというクラス変数を
持つSum。
・Sum()は、Sumクラスのコンストラクタである。コンストラクタとは、新しくオブジェクト(インスタンス)を作ると同時
に、オブジェクトの「初期化」をするものである。しかも、引数なしのコンストラクタなので、オブジェクトを作成する
と同時にtotalの値を０に自動的に初期化するという意味になる。
・addメソッドを宣言(メソッドは「情報を処理する方法」)。voidは、このメソッドが処理の結果を戻り値として返さない
ということを意味する。(int x)の部分がメソッドの仮引数列であり、メソッドの入力にあたるものである。ここでは
int型の引数xを宣言している。{}内がaddメソッドの処理内容となる。totalの値にxを足したものを、totalに代入する。
11: class SumSample {
12: public static void main(String args[]) {
13: Sum obj1 = new Sum();
14: Sum obj2 = new Sum();
・SumSampleクラスの{}内に書かれているものが、クラス宣言の内容である。
・mainは実行開始を意味する。
・Sum obj1 = new Sum();は、コンストラクタの呼び出してあり、Sumのオブジェクトが生成され、変数obj1に代入される。
Sum obj2 = new Sum();は、コンストラクタの呼び出しであり、Sumのオブジェクトが生成され、変数obj2に代入される。
Sumは異なる２つのオブジェクトを生成し、異なるフィールドが確保された。
15: obj1.add(10);
・addメソッドの呼び出し。
引数xを10とし、total += x の式に代入。totalは０なので０＋10となる。求められた値をobj1が指し示す。
16: obj1.add(20);
・addメソッドの呼び出し。
引数xを20とし、total += x の式に代入。obj1の示すtotalは10なので、10＋20になる。求められた値をobj1が指し示す。
17: obj2.add(30);
・addメソッドの呼び出し。
引数xを30とし、total += x の式に代入。totalは30なので30＋30となる。求められた値をobj2が指し示す。totalは、
staticで宣言されているため、クラス変数となりオブジェクトの共通の情報になる。そのため、obj2でもそのまま値が引き
継がれる。
18: obj2.add(40);
・addメソッドの呼び出し。
引数xを40とし、total += x の式に代入。obj2の示すtotalは60なので、60＋40になる。(17行の実行により、totalは60)
求められた値をobj2が指し示す。
19: System.out.println("obj1.total = " + obj1.total);
20: System.out.println("obj2.total = " + obj2.total);
・obj1とobj2が示すtotalは、クラス変数なので同じ値となる。
・コンストラクタを用いた合計プログラム例
1: class Sum {
2: int total;
3: Sum() { // コンストラクタ 引数無し
4: total = 0;
5: }
6: Sum(int x) { // コンストラクタ 引数 x
7: total = x;
8: }
9: void add(int x) {
10: total += x;
11: }
12: }
13:
14: class ConstrcSample {
15: public static void main(String args[]) {
16: Sum obj1 = new Sum(); // クラスSumのオブジェクトobj1生成
17: obj1.add(10);
18: obj1.add(20);
19: System.out.println("sum1 = " + obj1.total);
20: Sum obj2 = new Sum(100); // クラスSumのオブジェクトobj2生成
21: obj2.add(10);
22: obj2.add(20);
23: System.out.println("sum2 = " + obj2.total);
24: }
25: }
[nw051:~java/Rep6/] j04051% java ConstrcSample
sum1 = 30
sum2 = 130
考察
・プログラムについて
1: class Sum {
2: int total;
・Sumクラスの{と}の中に書いているものが、クラス宣言の内容である。
・int型のtotalをフィールドとして宣言(フィールドとは「情報を保存する場所」)。totalという変数を持つSum。
3: Sum() {
4: total = 0;
5: }
6: Sum(int x) {
7: total = x;
8: }
・Sum()は、Sumクラスのコンストラクタである。コンストラクタとは、新しくオブジェクト(インスタンス)を作ると同時
に、オブジェクトの「初期化」をするものである。しかも、引数なしのコンストラクタなので、オブジェクトを作成する
と同時にtotalの値を０に自動的に初期化するという意味になる。
・Sum(int x)は、Sumクラスのコンストラクタである。オブジェクトを作成すると同時にtotalの値に引数xを代入したもの
を初期値とする。
※ここでは、コンストラクタが２種類宣言されている。引数列が異なるため、異なるインストラクタとして扱われる
9: void add(int x) {
10: total += x;
11: }
・addメソッドを宣言(メソッドは「情報を処理する方法」)。voidは、このメソッドが処理の結果を戻り値として返さない
ということを意味する。(int x)の部分がメソッドの仮引数列であり、メソッドの入力にあたるものである。ここでは
int型の引数xを宣言している。{}内がaddメソッドの処理内容となる。totalの値にxを足したものを、totalに代入する。
14: class ConstrcSample {
15: public static void main(String args[]) {
16: Sum obj1 = new Sum();
・ConstrcSampleクラスの{}内に書かれているものが、クラス宣言の内容である。
・mainは実行開始を意味する。
・Sum obj1 = new Sum();は、コンストラクタの呼び出してあり、Sumのオブジェクトが生成され、変数obj1に代入される。
ここで呼び出されるコンストラクタは、引数をもたないSum()のコンストラクタである。
17: obj1.add(10);
・addメソッドの呼び出し。
引数xを10とし、total += x の式に代入。totalは０なので０＋10となる。求められた値をobj1が指し示す。
18: obj1.add(20);
・addメソッドの呼び出し。
引数xを20とし、total += x の式に代入。obj1の示すtotalは10なので、10＋20になる。求められた値をobj1が指し示す。
19: System.out.println("sum1 = " + obj1.total);
・obj1が示すtotalを表示する。17行と18行でobj1の示すtotalの値が30になる。
20: Sum obj2 = new Sum(100);
・Sum obj2 = new Sum(100);は、コンストラクタの呼び出しであり、Sumのオブジェクトが生成され、変数obj2に代入さ
れる。ここで呼び出されるコンストラクタは、引数xをもつSum(int x)のコンストラクタである。
21: obj2.add(10);
・addメソッドの呼び出し。
引数xを10とし、total += x の式に代入。Sum(int x)でtotalには引数xの値が代入されるので、totalは100になり100＋10
となる。求められた値をobj2が指し示す。
22: obj2.add(20);
・addメソッドの呼び出し。
引数xを20とし、total += x の式に代入。obj2の示すtotalは110なので、110＋20になる。(20行の実行により、totalは110)
求められた値をobj2が指し示す。
23: System.out.println("sum2 = " + obj2.total);
・obj2が示すtotalを表示する。21行と22行でobj2の示すtotalの値が130になる。
・staticイニシャライズを行ったプログラム例
1: class Disp {
2: static { // static イニシャライズ
3: System.out.println("initialize");
4: }
5: Disp() { // コンストラクタ
6: System.out.println("construct");
7: }
8: }
9:
10: class StaticSample {
11: public static void main(String args[]) {
12: Disp obj1 = new Disp(); // オブジェクト生成時にコンストラクタを処理
13: Disp obj2 = new Disp(); // オブジェクト生成時にコンストラクタを処理
14: }
15: }
[nw051:~/java/Rep6] j04051% java StaticSample
initialize
construct
construct
考察
・プログラムについて
1: class Disp {
2: static {
3: System.out.println("initialize");
4: }
・Dispクラスの{と}の中に書いているものが、クラス宣言の内容である。
・static{}は、静的初期化ブロックといい、プログラムの起動時に実行される。つまり、一番最初に実行されるものである。
プログラムの起動時に、initializeと表示する。
5: Disp() {
6: System.out.println("construct");
7: }
・Disp()は、Dispクラスのコンストラクタである。コンストラクタとは、新しくオブジェクト(インスタンス)を作ると同時
に、オブジェクトの「初期化」をするものである。
・新しくオブジェクトを作ると、constructと表示する。
10: class StaticSample {
11: public static void main(String args[]) {
12: Disp obj1 = new Disp();
13: Disp obj2 = new Disp();
14: }
15: }
・StaticSampleクラスの{と}の中に書いてあるものが、クラス宣言の内容である。
・mainは実行開始を意味する。
・Disp obj1 = new Disp();は、コンストラクタの呼び出してあり、Dispのオブジェクトが生成され、変数obj1に代入される。
・Disp obj2 = new Disp();は、コンストラクタの呼び出してあり、Dispのオブジェクトが生成され、変数obj2に代入される。
・メソッドのオーバーロードを行ったプログラム例
1: class Display {
2: void Disp() { // メソッド Disp 引数なし
3: System.out.println("Nothing");
4: }
5: void Disp(int x) { // メソッド Disp 引数 x
6: System.out.println(x);
7: }
8: void Disp(int x, int y) { // メソッド Disp 引数 x, y
9: System.out.println(x + y);
10: }
11: }
12:
13: class OvldSample {
14: public static void main(String args[]) {
15: Display obj = new Display(); // クラスDisplayのオブジェクトobj生成
16: obj.Disp(); // オブジェクトobjのDisp()を実行
17: obj.Disp(1); // オブジェクトobjのDisp(1)を実行
18: obj.Disp(1, 2); // オブジェクトobjのDisp(1,2)を実行
19: }
20: }
[nw051:~/java/Rep6] j04051% java OvldSample
Noting
1
3
考察
・プログラムについて
1: class Display {
・Displayクラスの{と}の中に書いているものが、クラス宣言の内容である。
2: void Disp() {
3: System.out.println("Nothing");
4: }
5: void Disp(int x) {
6: System.out.println(x);
7: }
8: void Disp(int x, int y) {
9: System.out.println(x + y);
10: }
・Dispメソッドの宣言。voidなので戻り値が無く、引数も持たない。呼び出されると、Nothingと表示する。
・Dispメソッドの宣言。voidなので戻り値が無い。int型の引数xを持つ。呼び出されると、引数xを表示する。
・Dispメソッドの宣言。voidなので戻り値が無い。int型の引数xとyの２つを持つ。呼び出されると、引数xと引数yを足した
ものを表示する。
※複数のメソッドが、同じ名前を使うことを多重定義(オーバーロード)という。引数の型と個数によって、メソッドを使い分ける
13: class OvldSample {
14: public static void main(String args[]) {
15: Display obj = new Display();
・OvldSampleクラスの{と}の中に書いてあるものが、クラス宣言の内容である。
・mainが実行開始を意味する。
・Displayクラスにobjオブジェクトを新しく作成する。
16: obj.Disp();
17: obj.Disp(1);
18: obj.Disp(1, 2);
・Dispメソッドの呼び出し。引数の無いメソッドを呼び出したので、Nothingと表示する。
・Dispメソッドの呼び出し。引数を持つメソッドを呼び出す。xに引数を代入したものを表示するため、１を表示する。
・Dispメソッドの呼び出し。引数を２つ持つメソッドの呼び出し。xとyに引数を代入し、xとyを足したものを表示するため、
３を表示する。
・privateを用いて変数の参照を不可にするプログラム例
1: class keisan {
2: static int tanka;
3: private float rate; // private変数rateの宣言
4: keisan() { // コンストラクタ
5: tanka = 1000;
6: rate = 0.05f;
7: }
8: int keisan(int kazu) {
9: int kingaku;
10: kingaku = (int)(tanka * kazu * (1.0 + rate));
11: return kingaku;
12: }
13: }
14:
15: class PrvSample {
16: public static void main(String args[]) {
17: keisan obj1 = new keisan();
18: int kazu = 3;
19: int kingaku = obj1.keisan(kazu);
20: System.out.println("tanka = " + obj1.tanka);
21: System.out.println("kazu = " + kazu);
22: System.out.println("kingaku = " + kingaku);
23: System.out.println("rate = " + obj1.rate); //private変数のため参照不可
24: }
25: }
[nw051:~/java/Rep6] j04051% java PrvSample
tanka = 1000
kazu = 3
kingaku = 3150
考察
・プログラムについて
1: class keisan {
2: static int tanka;
3: private float rate;
・keisanクラスの{}内に書いてあるものが、クラス宣言の内容である。
・int型のtankaをクラスフィールドとして宣言。tankaはkeisanクラス内で共通の情報となる。
・floa型のrateを宣言。private修飾子が付いているので、他のクラスで使用できない。
4: keisan() {
5: tanka = 1000;
6: rate = 0.05f;
7: }
・keisan()は、keisanクラスのコンストラクタである。コンストラクタとは、新しくオブジェクト(インスタンス)を作ると同時
に、オブジェクトの「初期化」をするものである。
・初期値としてtankaの値を1000とする。
・初期値としてrateの値を0.05fとする。
8: int keisan(int kazu) {
9: int kingaku;
10: kingaku = (int)(tanka * kazu * (1.0 + rate));
11: return kingaku;
12: }
・keisan(int kazu)は、keisanクラスのint型の引数kazuをもつコンストラクタである。
・int型のkingakuを宣言。
・tanka * kazu * (1.0 + rate)ででた値をint型にキャストし、kingakuに代入する。
・kingakuが戻り値となる
※引数列が異なっていれば、１つクラスにコンストラクタが複数あってもかまわない。
15: class PrvSample {
16: public static void main(String args[]) {
17: keisan obj1 = new keisan();
・PrvSampleクラスの{}内に書いてあるものが、クラス宣言の内容である。
・mainは実行開始の意味である。
・keisanクラスに、新しくobj1オブジェクトを作成する。
18: int kazu = 3;
19: int kingaku = obj1.keisan(kazu);
20: System.out.println("tanka = " + obj1.tanka);
21: System.out.println("kazu = " + kazu);
22: System.out.println("kingaku = " + kingaku);
23: System.out.println("rate = " + obj1.rate);
24: }
・int型のkazuを宣言し、３を代入する。
・keisanコンストラクタの呼び出し。keisanの引数にkazuを代入する。keisanメソッドの戻り値をkingakuに代入する。
・obj1の示すtankaを表示する。
・kazuを表示する。
・kingakuを表示する。
・rateはprivate修飾子が付いて宣言されていたので、このクラスでは使用することができないため、実行するとコンパ
イルエラーがででしまう。
・継承
1: class Display { // スーパークラス Display
2: void Disp() { // メソッド
3: System.out.println("Hello!");
4: }
5: }
6:
7: class Succeed extends Display { // スーパークラスDisplayを継承したサブクラスSucceed
8: public static void main(String args[]) { // メソッド
9: Succeed obj = new Succeed(); // オブジェクト生成
10: obj.Disp(); // スーパークラスから継承したメソッドを利用
11: }
12: }
[nw051:~/java/Rep6] j04051% java Succeed
Hello!
考察
・プログラムについて
1: class Display {
2: void Disp() {
3: System.out.println("Hello!");
4: }
5: }
・Displyクラスの{}内に書かれているものが、クラス宣言の内容である。
・Dispメソッドの宣言。voidなので戻り値が無く、引数も持たない。呼び出されると、Hello!と表示する。
7: class Succeed extends Display {
8: public static void main(String args[]) {
9: Succeed obj = new Succeed();
10: obj.Disp();
11: }
12: }
・Displayクラスを継承したSucceedクラスを宣言する。Succeedクラスは、Displayクラスのフィールドとメソッドを
受け継ぐ。
・mainは実行開始を意味する。
・Succeedに、新しくobjオブジェクトを作成する。
・Dispメソッドの呼び出し。呼び出された結果を、objが指し示す。
・オーバーライド
1: class Display { // スーパークラス Display
2: void Disp() { // メソッド
3: System.out.println("Hello!");
4: }
5: }
6:
7: class Override extends Display { // サブクラス Override
8: void Disp() { // メソッドのオーバーライド
9: System.out.println("Hello! Java!!");
10: }
11: public static void main(String args[]) { // メソッド
12: Override obj = new Override(); // オブジェクト生成
13: obj.Disp(); // メソッド Disp 実行
14: }
15: }
[nw051:~/java/Rep6] j04051% java Override
Hello! Java!!
考察
・プログラムについて
1: class Display {
2: void Disp() {
3: System.out.println("Hello!");
4: }
5: }
・Displayクラスの{}内に書かれているものが、クラス宣言の内容である。
・Dispメソッドの宣言。voidなので戻り値が無く、引数も無い。実行されると、Helloと表示する。
7: class Override extends Display {
8: void Disp() {
9: System.out.println("Hello! Java!!");
10: }
・Displayクラスを継承したOverrideクラスを宣言する。Overrideクラスは、Displayクラスのフィールドとメソッドを
受け継ぐ。
・Dispメソッドの宣言。voidなので戻り値が無く、引数も無い。実行されると、Hello! Java!!と表示する。
※新たなメソッドを追加するだけでなく、継承したフィールドやメソッドを変更することができる。このような変更
メソッドのオーバーライド(override)という。ここでは、DisplayクラスのDispメソッドを、Overrideクラスの
Dispメソッドがオーバーライドしている。
11: public static void main(String args[]) {
12: Override obj = new Override();
13: obj.Disp();
14: }
・mainは、実行開始を意味する。
・Overrideクラスに、新しくobjオブジェクトを作成する。
・Dispメソッドの呼び出し。呼び出された結果を、objが指し示す。ここで呼び出されるDispメソッドは、Overrideクラス
のDispメソッドである。
・super
1: class Display { // スーパークラス Display
2: void Disp() { // メソッド
3: System.out.println("Hello!");
4: }
5: }
6:
7: class SuperSample extends Display { // サブクラス SuperSample
8: void Disp() { // メソッドのオーバーライド
9: super.Disp(); // スーパークラスの Disp 実行
10: System.out.println("Hello! Java!!");
11: }
12: public static void main(String args[]) { // メソッド
13: SuperSample obj = new SuperSample(); // オブジェクト生成
14: obj.Disp(); // サブクラスの Disp 実行
15: }
16: }
[nw051:~/java/Rep6] j04051% java SuperSample
Hello!
Hello! Java!!
考察
・プログラムについて
1: class Display {
2: void Disp() {
3: System.out.println("Hello!");
4: }
5: }
・Displayクラスの{}内に書かれているものが、クラス宣言の内容となる。
・Dispメソッドの宣言。voidなので戻り値がなく、引数も無い。実行されると、Hello!と表示する。
7: class SuperSample extends Display {
8: void Disp() {
9: super.Disp();
10: System.out.println("Hello! Java!!");
11: }
・Displayクラスを継承したSuperSampleクラスを宣言する。SuperSampleクラスは、Displayクラスのフィールドと
メソッドを受け継ぐ。
・Dispメソッドの宣言。voidなので戻り値が無く、引数も無い。ここでは、SuperSampleクラスのDispメソッドがDisplay
クラスのDispメソッドをオーバーロードしている。
・スーパークラスのDispメソッドを呼び出している。
・Hello! Java!!と表示する。
※オーバーライドされたメソッドは、スーパークラスのメソッドを隠してしまうため、定義された元のメソッドを使うこと
ができない。そのため、superキーワードを使い、スーパークラスのメソッドを参照する。なので、９行目に呼び出され
たDispメソッドは、スーパークラスのメソッドであり、実行されるとHello!と表示される。
12: public static void main(String args[]) {
13: SuperSample obj = new SuperSample();
14: obj.Disp();
15: }
・mainは、実行開始の意味である。
・SuperSampleクラスに、新しくobjオブジェクトを作成する。
・Dispメソッドの呼び出し。ここで呼び出されるDispメソッドは、SuperSampleクラスのDispメソッドである。実行された
結果を、objが指し示す。
・this
1: class Keisan { // スーパークラス Keisan
2: int x = 100;
3: void add(int x, int y) { // メソッド
4: int w1 = x + y;
5: int w2 = this.x + y;
6: System.out.println("w1 = " + w1 + " w2 = " + w2);
7: }
8: }
9:
10: class ThisSample1 extends Display { // サブクラス ThisSample1
11: public static void main(String args[]) { // メソッド
12: ThisSample1 obj = new ThisSample1(); // オブジェクト生成
13: obj.add(10, 20); // add 実行
14: }
15: }
[nw051:~/java/Rep6] j04051% java ThisSample1
w1 = 30 w2 = 120
考察
・プログラムについて
1: class Keisan {
2: int x = 100;
・keisanクラスの{}内に書かれているものが、クラス宣言の内容である。
・int型の変数xを宣言。100を代入する。
3: void add(int x, int y) {
4: int w1 = x + y;
5: int w2 = this.x + y;
6: System.out.println("w1 = " + w1 + " w2 = " + w2);
7: }
・addメソッドの宣言。voidなので戻り値は無いが、int型の引数xとyの２つをもつ。
・int型のw1を宣言。引数xとyを足したものを、w1に代入する。
・int型のw2を宣言。xと引数yを足したものを、w2に代入する。
※５行目のthis.xのthisは、クラス内のことを意味する。なので、引数のxではなく、２行目に宣言されたxのことになる。
・実行されると、w1とw2を表示する。
10: class ThisSample1 extends Display {
11: public static void main(String args[]) {
12: ThisSample1 obj = new ThisSample1();
13: obj.add(10, 20);
14: }
・Displayクラスを継承したThisSampleクラスの宣言。ThisSampleクラスは、Displayクラスのフィールドとメソッドを受け継ぐ。
・mainは、実行開始を意味する。
・ThisSampleクラスに、新しくobjオブジェクトを作成する。
・addメソッドの呼び出し。引数として、xには10をyには20を代入する。実行した結果をobjが指し示す。
・this
1: class Keisan {
2: void Keisan(int x, int y) { // 引数が二つのコンストラクタ
3: System.out.println("Keisan = " + (x * y));
4: }
5: void Keisan(int x) { // 引数が一つのコンストラクタ
6: this(x, 1); // Keisan(x, 1)と同じ
7: }
8: }
9:
10: class ThisSample2 extends Display { // サブクラス ThisSample2
11: public static void main(String args[]) { // メソッド
12: Keisan obj1 = new Keisan(200, 5); // 引数が二つのコンストラクタ実行
13: Keisan obj2 = new Keisan(200); // 引数が一つのコンストラクタ実行
14: }
15: }
[nw051:~/java/Rep6] j04051% java ThisSample2
Keisan = 1000
Keisan = 200
考察
・プログラムについて
1: class Keisan {
・keisanクラスの{}内に書いてあるものが、クラス宣言の内容である。
2: void Keisan(int x, int y) {
3: System.out.println("Keisan = " + (x * y));
4: }
・keisan(int x,int y)は、keisanクラスのコンストラクタである。voidなので戻り値は無いが、引数としてint型のxとy
を持っている。呼び出されると、引数のxとyを代入し、xとyを乗算ものを表示する。
5: void Keisan(int x) {
6: this(x, 1);
7: }
・keisan(int x)は、keisanクラスのコンストラクタである。voidなので戻り値は無いが、引数としてint型のxを持って
いる。
※同じクラス内でも、引数列が違えば同じ名前で複数のコンストラクタを作ることができる。
・this(x,1)は、クラス内の違うコンストラクタの呼び出しになる。引数が２つなので、keisan(int x,int y)を呼び出す
ことになる。
10: class ThisSample2 extends Display {
11: public static void main(String args[]) {
12: Keisan obj1 = new Keisan(200, 5);
13: Keisan obj2 = new Keisan(200);
14: }
・Displayクラスを継承したThisSampleクラスを宣言する。ThisSampleクラスは、Displayクラスのフィールドとメソッド
を受け継ぐ。
・mainは、実行開始を意味する。
・Keisan obj1 = new Keisan(200,5)は、コンストラクタの呼び出しである。引数が２つなので、Keisan(int x,int y)の
コンストラクタが呼び出される。実行された結果を、obj1が指し示す。
・Keisan obj2 = new Keisan(200)は、コンストラクタの呼び出しである。引き数が１つなので、Keisan(int x)のコンス
トラクタが呼び出される。実行された結果を、obj2が指し示す。
※引数が１つのコンストラクタは、this(x,1)で別のコンストラクタを呼び出しているので、引数が２つのコンスト
ラクタを実行する。
・abstract
1: public abstract class PreDefine { // 抽象クラス PreDefine
2: public abstract int add(int x, int y); // 抽象メソッド add
3: public int sub(int x, int y) { // メソッド sub
4: return x - y;
5: }
6: }
7:
8: class AbstractSample extends PreDefine { // 抽象クラス PreDefine の継承
9: public int add(int x, int y) { // メソッドの内容を具体的に定義
10: return x + y;
11: }
12:
13: public static void main(String args[]) { // メソッド
14: AbstractSample obj = new AbstractSample();
15: System.out.println("add = " + obj.add(100, 80));
16: System.out.println("sub = " + obj.sub(100, 80));
17: }
18: }
[nw051:~/java/Rep6] j04051% java AbstractSample
add = 180
sub = 20
考察
・プログラムについて
1: public abstract class PreDefine {
2: public abstract int add(int x, int y);
3: public int sub(int x, int y) {
4: return x - y;
5: }
6: }
・抽象メソッドを含んでいる、抽象クラスPreDefineを宣言。
・抽象メソッドaddを宣言。
・int型の戻り値を持ち、int型の引数xとyを２つもつsubメソッドを宣言する。
・引数xとyを代入し計算した結果を、戻り値として返す。
8: class AbstractSample extends PreDefine {
9: public int add(int x, int y) {
10: return x + y;
11: }
・PreDefineクラスを継承したAbstractSampleクラスの宣言。
・addメソッドを宣言。int型の戻り値を持ち、int型の引数xとyの２つをもつ。
・引数のxとyを代入し、x＋yを計算した結果を戻り値として返す。
13: public static void main(String args[]) {
14: AbstractSample obj = new AbstractSample();
15: System.out.println("add = " + obj.add(100, 80));
16: System.out.println("sub = " + obj.sub(100, 80));
17: }
・mainは、実行開始を意味する。
・AbstractSampleクラスに、新しくobjオブジェクトを作る。
・addメソッドの呼び出し。xとyを代入し、結果を表示する。100＋80なので、180になる。
・subメソッドの呼び出し。xとyを代入し、結果を表示する。100-80なので、20になる。
・interface
1: public interface PreDefine { // インタフェース PreDefine
2: int add(int x, int y); // 抽象メソッド add
3: int sub(int x, int y); // 抽象メソッド sub
4: }
5:
6: class InterfaceSample implement PreDefine { // PreDefine のインプリメント
7: public int add(int x, int y) { // メソッドの内容を具体的に定義
8: return x + y;
9: }
10: public int sub(int x, int y) { // メソッドの内容を具体的に定義
11: return x + y;
12: }
13:
14: public static void main(String args[]) { // メソッド
15: InterfaceSample obj = new InterfaceSample();
16: System.out.println("add = " + obj.add(100, 80));
17: System.out.println("sub = " + obj.sub(100, 80));
18: }
19: }
[nw051:~/java/Rep6] j04051% java InterfaceSample
add = 180
sub = 20
考察
・プログラムについて
1: public interface PreDefine {
2: int add(int x, int y);
3: int sub(int x, int y);
4: }
・PreDefineインターフェースの宣言である。{}内がインタフェースの宣言の範囲である。
・抽象メソッドaddを宣言。
・抽象メソッドsubを宣言。
6: class InterfaceSample implement PreDefine {
7: public int add(int x, int y) {
8: return x + y;
9: }
・InterfaceSampleクラスの宣言。InterfaceSampleクラスは、PreDefineクラスと同じメソッドを持つ。
※implementsと書くことで、同じインターフェースを実装させることができ、「共通のメソッドを持っている」
ということになる。
・addメソッドの宣言。int型の戻り値を持ち、int型の引数xとyの２つを持つ。
・引数xとyを代入し、そのxとyを足したものを、戻り値とする。
10: public int sub(int x, int y) {
11: return x + y;
12: }
・subメソッドの宣言。int型の戻り値を持ち、int型の引数xとyの２つを持つ。
・引数xとyを代入し、そのxとyを足したものを、戻り値とする。
14: public static void main(String args[]) {
15: InterfaceSample obj = new InterfaceSample();
16: System.out.println("add = " + obj.add(100, 80));
17: System.out.println("sub = " + obj.sub(100, 80));
18: }
・mainは、実行開始を意味する。
・InterfaceSampleクラスに、新しくオブジェクトを作成する。
・addメソッドの呼び出し。addメソッドの引数のxに100を、yに80を代入する。その結果を表示する。
・subメソッドの呼び出し。subメソッドの引数のxに100を、yに80を代入する。その結果を表示する。
感想・反省
今回は、解説するプログラムが多く、内容も難しかった。考察の途中で、メソッドとコンストラクタの違いが分からなくなることがあった。まだまだ勉強不足である。しかも、提出期限を全然守っていない!?一番の反省点だ。
参考文献
独習Java 第２版 ジョセフ・オニール 著
Jave入門 河西朝雄 著
Java言語プログラミングレッスン上・下 結城浩 著