Javaの開発をしたことがないので、やったことをまとめていこうと思います。
基本的なことをやっていくので初心者でも出来るレベルだと思います。
newを使用したインスタンスの生成
[Rensyu402_01.java]
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
// パッケージの宣言 package chapter_4_2; /** * Rensyu402_01クラス */ public class Rensyu402_01 { // mainメソッド(最初に実行される特別なメソッド) public static void main(String[] args) { // フィールドの定義 Rensyu402_01 instA; // インスタンスの生成 instA = new Rensyu402_01(); // メソッドの呼び出し instA.helloDisp(); } // helloDispメソッド public void helloDisp() { // 画面表示 System.out.println("こんにちは！"); } } |
[表示結果]
|
1 |
こんにちは！ |
★ポイント
- 処理の開始はmainメソッドから行われる。したがって必ずひとつのmainメソッドを持つクラスを用意する。
複数のクラスを利用する
[DispMessage2.java]
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
// パッケージの宣言 package chapter_4_3; /** * DispMessage2クラス */ public class DispMessage2 { // helloDispメソッド public void helloDisp() { // 画面表示 System.out.println("こんにちは！"); } } |
[Rensyu403_01.java]
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
// パッケージの宣言 package chapter_4_3; /** * Rensyu403_01クラス */ public class Rensyu403_01 { // mainメソッド(最初に実行される特別なメソッド) public static void main(String[] args) { // フィールドの定義 DispMessage2 instA; // インスタンスの生成 instA = new DispMessage2(); // メソッドの呼び出し instA.helloDisp(); } } |
[表示結果]
|
1 |
こんにちは！ |
★ポイント
- インスタンスの生成は自分自身のクラスを基にしても、ほかのクラスを基にしても可能である。
- Javaにおいて機能の実現は、インスタンス化が基本となるが、ある条件においては、インスタンスを生成せずに利用することも可能である(奨励するという意味ではない)。
引数/戻り値を使用する
[ShisokuEnzan.java]
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 |
// パッケージの宣言 package chapter_4_4; /** * keisanクラス */ public class ShisokuEnzan { // keisanメソッド public int keisan( int atai1, int atai2, char shubetsu ) { // 変数の宣言 int kotae; // shubetsuを判定し、四則演算を実行 switch( shubetsu ) { case '加': kotae = atai1 + atai2; break; case '減' : kotae = atai1 - atai2; break; case '乗' : kotae = atai1 * atai2; break; case '除' : kotae = atai1 / atai2; break; default : kotae = 0; } // 戻り値 return kotae; } } |
[Rensyu404_01.java]
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 |
// パッケージの宣言 package chapter_4_4; /** * Rensyu404_01クラス */ public class Rensyu404_01 { // mainメソッド(最初に実行される特別なメソッド) public static void main(String[] args) { // 変数の宣言 int atai1 , atai2 , kekka; char enzan; // フィールドの定義 ShisokuEnzan instA; // 変数に値を代入 atai1 = 10; atai2 = 20; enzan = '乗'; // インスタンスの生成 instA = new ShisokuEnzan(); // メソッドの呼び出し(戻り値kekka) kekka = instA.keisan(atai1, atai2, enzan); // 画面表示 System.out.println("答えは " + kekka); } } |
[表示結果]
|
1 |
答えは 200 |
★ポイント
- 他のメソッドに引数を渡すにはメソッド名に続き()内に引数を記述する。引数は複数同時に引き渡すことができる。その場合は‘,‘(カンマ)で区切りに記述する。引数はフィールド(変数)または、定数での指定が可能。
クラスメソッド
[Rensyu405_02.java]
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
// パッケージの宣言 package chapter_4_5; /** * Rensyu405_02クラス */ public class Rensyu405_02 { // hyoujiメソッド(static宣言) public static void hyouji() { // 画面表示 System.out.println("Javaの世界へ"); } } |
[Rensyu405_01.java]
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
// パッケージの宣言 package chapter_4_5; /** * Rensyu405_01クラス */ public class Rensyu405_01 { // mainメソッド(最初に実行される特別なメソッド) public static void main(String[] args) { // メソッドの呼び出し(クラス名.メソッド名) Rensyu405_02.hyouji(); // 画面表示 System.out.println("ようこそ！"); } } |
[表示結果]
|
1 2 |
Javaの世界へ ようこそ！ |
★ポイント
- static宣言されたものを静的メンバーといい、メンバーにはメソッドとフィールドが含まれる
- 静的メソッドはクラスメソッドとも呼ばれ、その利用に際しインスタンスを生成することなく使用可能である
インスタンス変数とクラス変数
[Mult.java]
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 |
// パッケージの宣言 package chapter_4_6; /** * Multクラス */ public class Mult { // 変数の宣言 int baisu; static int c_kaisu = 0; int i_kaisu = 0; // コンストラクタ Mult(int kazu) { baisu = kazu; System.out.println(baisu+"倍するインスタンスが生成されました"); } // public int(この型はreturnで返す型) public int keisan(int atai) { int kotae; kotae = atai * baisu; // インクリメント c_kaisu++; i_kaisu++; // 戻り値 return kotae; } // hyoujiメソッド public void hyouji() { System.out.println(baisu+"倍するインスタンスの"); System.out.println(" インスタンス変数は " + i_kaisu); System.out.println(baisu+"倍するインスタンスの"); System.out.println(" クラス変数は " + c_kaisu); } } |
[Rensyu406_01.java]
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 |
// パッケージの宣言 package chapter_4_6; /** * Rensyu406_01クラス */ public class Rensyu406_01 { // mainメソッド(最初に実行される特別なメソッド) public static void main(String[] args) { // 変数の宣言 int kekka1, kekka2; // フィールドの定義 Mult m1, m2; // インスタンスの生成 m1 = new Mult(10); m2 = new Mult(100); // メソッドの呼び出し kekka1 = m1.keisan(5); // 画面表示 System.out.println("10倍した答えは " + kekka1); // メソッドの呼び出し m1.hyouji(); // メソッドの呼び出し kekka2 = m2.keisan(5); // 画面表示 System.out.println("100倍した答えは " + kekka2); // メソッドの呼び出し m2.hyouji(); } } |
[表示結果]
|
1 2 3 4 5 6 7 8 9 10 11 12 |
10倍するインスタンスが生成されました 100倍するインスタンスが生成されました 10倍した答えは 50 10倍するインスタンスの インスタンス変数は 1 10倍するインスタンスの クラス変数は 1 100倍した答えは 500 100倍するインスタンスの インスタンス変数は 1 100倍するインスタンスの クラス変数は 2 |
★ポイント
- フィールドの種別にはクラス変数、インスタンス変数、ローカル変数がある。
- クラス変数は、クラス内においてメソッドの外側で定義され、「static」とともに宣言されたフィールドであり、この領域はそれが定義されているクラス、およびそのクラスを基に生成される全インスタンス領域となる。
オーバーロード
[Rensyu407_02.java]
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 |
// パッケージの宣言 package chapter_4_7; /** * Rensyu407_02クラス */ public class Rensyu407_02 { // 変数の宣言 int ans_tasuA; double ans_tasuB; // tasuメソッド public void tasu(int atai1, int atai2) { tasu(atai1, atai2, 0); } // tasuメソッド public void tasu(int atai1, int atai2, int atai3) { ans_tasuA = atai1 + atai2 + atai3; System.out.println(ans_tasuA); } // tasuメソッド public void tasu(double atai1, double atai2) { ans_tasuB = atai1 + atai2; System.out.println(ans_tasuB); } } |
[Rnsyu407_01.java]
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
// パッケージの宣言 package chapter_4_7; /** * Rnsyu407_01クラス */ public class Rnsyu407_01 { // mainメソッド(最初に実行される特別なメソッド) public static void main(String[] args) { // フィールドの定義 Rensyu407_02 inst; // インスタンスの生成 inst = new Rensyu407_02(); // メソッドの呼び出し inst.tasu(1, 2); inst.tasu(10, 20, 30); inst.tasu(10.12, 0.345); } } |
[表示結果]
|
1 2 3 |
3 60 10.465 |
★ポイント
- オーバーロードとは引数の型もしくは数が異なれば、ひとつのクラス内に同じ名称のメソッドを定義することを許可するもの。
継承
[Hyouji.java]
|
1 2 3 4 5 6 7 8 9 10 11 12 |
// パッケージの宣言 package chapter_4_8; /** * Hyoujiクラス(スーパークラス) */ public class Hyouji { // dispメソッド public void disp(int atai1) { System.out.println("答え " + atai1); } } |
[Souwa.java]
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
// パッケージの宣言 package chapter_4_8; /** * Souwaクラス(サブクラス) */ public class Souwa extends Hyouji { // 変数の宣言 int kotae,i; // enzanメソッド public int enzan(int atai1) { kotae = 0; // ループ for(i = 1; i <= atai1; i++) { kotae = kotae + i; } return kotae; } } |
[Rensyu408_01.java]
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
// パッケージの宣言 package chapter_4_8; /** * Rensyu408_01クラス */ public class Rensyu408_01 { // mainメソッド(最初に実行される特別なメソッド) public static void main(String[] args) { // フィールドの定義 Souwa inst; int kekka; // インスタンスの生成 inst = new Souwa(); // メソッドの呼び出し kekka = inst.enzan(10); // メソッドの呼び出し inst.disp(kekka); } } |
[表示結果]
|
1 |
答え 55 |
[Pasocom.java]
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
// パッケージの宣言 package chapter_4_8; /** * Pasocomクラス(スーパークラス) */ public class Pasocom { // 変数の宣言 String maker; String modelNo; String cpuType; int memorySize; int diskSize; // enzanメソッド public void enzan() { System.out.println("演算しました"); } // dougaSaiseiメソッド public void dougaSaisei() { System.out.println("動画を再生しました"); } } |
[DPasocom.java]
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
// パッケージの宣言 package chapter_4_8; /** * DPasocomクラス(サブクラス) */ public class DPasocom extends Pasocom { // 変数の宣言 String moDrive; // tvRokugaメソッド public void tvRokuga() { System.out.println("テレビ録画中です"); } } |
[NPasocom.java]
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
// パッケージの宣言 package chapter_4_8; /** * NPasocomクラス(サブクラス) */ public class NPasocom extends Pasocom { // 変数の宣言 int batteryCapa; // mochihakobuメソッド public void mochihakobu() { System.out.println("持ち運び中です"); } } |
[Rensyu408_02.java]
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
// パッケージの宣言 package chapter_4_8; /** * Rensyu408_02クラス */ public class Rensyu408_02 { // mainメソッド(最初に実行される特別なメソッド) public static void main(String[] args) { // フィールドの定義 DPasocom inst1; NPasocom inst2; // インスタンスの生成 inst1 = new DPasocom(); inst2 = new NPasocom(); // メソッドの呼び出し inst1.enzan(); inst1.tvRokuga(); inst2.dougaSaisei(); inst2.mochihakobu(); } } |
[表示結果]
|
1 2 3 4 |
演算しました テレビ録画中です 動画を再生しました 持ち運び中です |
★ポイント
- 継承とはクラス間に親子関係を持たせることであり、extendsというキーワードを使用して記述する。これにより親クラスが持つフィールドやメソッドを子クラスが引き継ぎ利用することが可能となる。
オーバーライド
[Oya1.java]
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
// パッケージの宣言 package chapter_4_9; /** * Oya1クラス(スーパークラス) */ public class Oya1 { // morningメソッド public void morning() { System.out.println("おはうございます。"); } // eveningメソッド public void evening() { System.out.println("こんばんは。"); } } |
[Kodomo1.java]
|
1 2 3 4 5 6 7 8 9 10 11 12 |
// パッケージの宣言 package chapter_4_9; /** * Kodomo1クラス(サブクラス) */ public class Kodomo1 extends Oya1 { // オーバーライド public void morning() { System.out.println("おはよう！！"); } } |
[Rensyu409_01.java]
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 |
// パッケージの宣言 package chapter_4_9; /** * Rensyu409_01クラス */ public class Rensyu409_01 { // mainメソッド(最初に実行される特別なメソッド) public static void main(String[] args) { // フィールドの定義 Oya1 instOya; Kodomo1 instKodomo; // インスタンスの生成 instOya = new Oya1(); instKodomo = new Kodomo1(); System.out.println("親のメソッドを呼び出します。"); // メソッドの呼び出し instOya.morning(); instOya.evening(); System.out.println("子のメソッドを呼び出します。"); // メソッドの呼び出し instKodomo.morning(); instKodomo.evening(); } } |
[表示結果]
|
1 2 3 4 5 6 |
親のメソッドを呼び出します。 おはうございます。 こんばんは。 子のメソッドを呼び出します。 おはよう！！ こんばんは。 |
[Laundry1.java]
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
// パッケージの宣言 package chapter_4_9; /** * Laundry1クラス(スーパークラス) */ public class Laundry1 { // sentakuメソッド public void sentaku(String sentakumono) { System.out.println(sentakumono + "を洗いました。"); System.out.println(sentakumono + "を脱水しました。"); System.out.println(sentakumono + "を乾かしました。"); } } |
[Laundry2.java]
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
// パッケージの宣言 package chapter_4_9; /** * Laundry2クラス(サブクラス) */ public class Laundry2 extends Laundry1 { // オーバーライド public void sentaku(String sentakumono) { // 親のクラスのメソッドを呼び出し、利用する(親の全機能を利用出来る) super.sentaku(sentakumono); System.out.println(sentakumono + "にアイロンをかけました。"); } } |
[Rensyu409_02.java]
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
// パッケージの宣言 package chapter_4_9; /** * Rensyu409_02クラス */ public class Rensyu409_02 { // mainメソッド(最初に実行される特別なメソッド) public static void main(String[] args) { // フィールドの定義 String sentakumono = "シャツ"; Laundry1 inst1; Laundry2 inst2; // インスタンスの生成 inst1 = new Laundry1(); inst2 = new Laundry2(); System.out.println("Laundry1で洗濯します。"); // メソッドの呼び出し inst1.sentaku(sentakumono); System.out.println("Laundry2で洗濯します。"); // メソッドの呼び出し inst2.sentaku(sentakumono); } } |
[表示結果]
|
1 2 3 4 5 6 7 8 9 |
Laundry1で洗濯します。 シャツを洗いました。 シャツを脱水しました。 シャツを乾かしました。 Laundry2で洗濯します。 シャツを洗いました。 シャツを脱水しました。 シャツを乾かしました。 シャツにアイロンをかけました。 |
★ポイント
- オーバーライドとは継承したスーパークラスと同様のシグネチャを持つメソッドをサブクラス側に定義することである。
- オーバーライドの利点は、継承により効率的にスーパークラスの機能を流用しつつ、必要に応じてその機能を変更できることである。
抽象クラス
[Laundry1.java]
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
// パッケージの宣言 package chapter_4_9; /** * Laundry1クラス(スーパークラス) */ public class Laundry1 { // sentakuメソッド public void sentaku(String sentakumono) { System.out.println(sentakumono + "を洗いました。"); System.out.println(sentakumono + "を脱水しました。"); System.out.println(sentakumono + "を乾かしました。"); } } |
[Triangle.java]
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
// パッケージの宣言 package chapter_4_10; /** * Triangleクラス(サブクラス) */ public class Triangle extends Figure { // オーバーライド public void areaMethod(int su1, int su2) { System.out.println("面積は底辺×高さ÷2です。"); System.out.println(su1 + "×" + su2 + "÷2=" + su1 * su2 / 2); } } |
[Square.java]
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
// パッケージの宣言 package chapter_4_10; /** * Squareクラス(サブクラス) */ public class Square extends Figure{ // オーバーライド public void areaMethod(int su1, int su2) { System.out.println("面積は縦×横です。"); System.out.println(su1 + "×" + su2 + "=" + su1 * su2); } } |
[Rensyu410_01.java]
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 |
// パッケージの宣言 package chapter_4_10; /** * Rensyu410_01クラス */ public class Rensyu410_01 { // mainメソッド(最初に実行される特別なメソッド) public static void main(String[] args) { // フィールドの定義 Triangle inst1; Square inst2; // インスタンスの生成 inst1 = new Triangle(); inst2 = new Square(); System.out.println("三角形"); // メソッドの呼び出し inst1.apexes = 3; inst1.showApexes(); inst1.areaMethod(8,4); System.out.println("四角形"); // メソッドの呼び出し inst2.apexes = 4; inst2.showApexes(); inst2.areaMethod(8,4); } } |
[表示結果]
|
1 2 3 4 5 6 7 8 |
三角形 角の数は3個です 面積は底辺×高さ÷2です。 8×4÷2=16 四角形 角の数は4個です 面積は縦×横です。 8×4=32 |
★ポイント
- 抽象クラスとは抽象メソッドを持つクラスのことで、キーワードabstractを付けなければならない。
- 抽象メソッドはメソッド名、引数、戻り値のみを定義し、プログラムは記述しない。
インターフェース
[IntfComp.java]
|
1 2 3 4 5 6 7 8 9 10 |
// パッケージの宣言 package chapter_4_11; /** * インターフェース */ public interface IntfComp { // 抽象メソッド public int add(int su1, int su2); } |
[Keisan1.java]
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
// パッケージの宣言 package chapter_4_11; /** * Keisan1クラス(インターフェースの実装) */ public class Keisan1 implements IntfComp { // オーバーライド public int add(int su1, int su2) { int i,tmp,sum; // su1が小さくなるように入れ替え if(su1 > su2) { tmp = su1; su1 = su2; su2 = tmp; } // ループで合計を求める sum = 0; for(i = su1; i <= su2; i++) { sum = sum + i; } // 戻り値 return sum; } } |
[Keisan2.java]
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
// パッケージの宣言 package chapter_4_11; /** * Keisan2クラス(インターフェースの実装) */ public class Keisan2 implements IntfComp { // オーバーライド public int add(int su1, int su2) { int tmp,cnt,sum1,sum2; // su1が小さくなるように入れ替え if(su1 > su2) { tmp = su1; su1 = su2; su2 = tmp; } // ガウスの方法で合計を求める cnt = su2 - su1 + 1; sum1 = su1+su2; sum2 = sum1 * cnt / 2; return sum2; } } |
[Rensyu411_01.java]
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 |
// パッケージの宣言 package chapter_4_11; /** * Rensyu411_01クラス */ public class Rensyu411_01 { // mainメソッド(最初に実行される特別なメソッド) public static void main(String[] args) { // 変数の宣言 int sum; int i = 1, j = 10; // インスタンスの生成 Keisan1 kei1 = new Keisan1(); Keisan2 kei2 = new Keisan2(); System.out.println(i + "から" + j + "の和"); System.out.print("計算１："); // メソッドの呼び出し sum = kei1.add(i,j); System.out.println(sum); System.out.print("計算２："); // メソッドの呼び出し sum = kei2.add(i, j); System.out.println(sum); } } |
[表示結果]
|
1 2 3 |
1から10の和 計算１：55 計算２：55 |
[Cake.java]
|
1 2 3 4 5 6 7 8 9 10 11 12 |
// パッケージの宣言 package chapter_4_11; /** * Cakeクラス(スーパークラス) */ public class Cake { // hontaiメソッド public void hontai() { System.out.println("本体のスポンジケーキです。"); } } |
[Decorate.java]
|
1 2 3 4 5 6 7 8 9 10 |
// パッケージの宣言 package chapter_4_11; /** * インターフェース */ public interface Decorate { // 抽象メソッド public void kazaru(); } |
[StrawberryCake.java]
|
1 2 3 4 5 6 7 8 9 10 11 12 |
// パッケージの宣言 package chapter_4_11; /** * StrawberryCakeクラス(サブクラス、インターフェースの実装) */ public class StrawberryCake extends Cake implements Decorate { // オーバーライド public void kazaru() { System.out.println("イチゴで飾りました。"); } } |
[ChocolateCake.java]
|
1 2 3 4 5 6 7 8 9 10 11 12 |
// パッケージの宣言 package chapter_4_11; /** * ChocolateCakeクラス(サブクラス、インターフェース実装) */ public class ChocolateCake extends Cake implements Decorate { // オーバーライド public void kazaru() { System.out.println("チョコレートで飾りました。"); } } |
[Rensyu411_02.java]
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
// パッケージの宣言 package chapter_4_11; /** * Rensyu411_02クラス */ public class Rensyu411_02 { // mainメソッド(最初に実行される特別なメソッド) public static void main(String[] args) { // フィールドの定義 ChocolateCake cake1; StrawberryCake cake2; // インスタンスの生成 cake1 = new ChocolateCake(); cake2 = new StrawberryCake(); // メソッドの呼び出し cake1.hontai(); cake1.kazaru(); cake2.hontai(); cake2.kazaru(); } } |
[表示結果]
|
1 2 3 4 |
本体のスポンジケーキです。 チョコレートで飾りました。 本体のスポンジケーキです。 イチゴで飾りました。 |
★ポイント
- インターフェースは処理の実体を持たないメソッドの集まりであり、オーバーライドを前提とした仕様の定義である。
- インターフェースで宣言されるメソッドは、実装するクラス側で必ずオーバーライドしなければならない。
ポリモルフィズム
[Stroke1.java]
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
// パッケージの宣言 package chapter_4_12; /** * インターフェース */ public interface Stroke1 { // 抽象メソッド public int distance = 100; public void crawl(); public void breaststroke(); public void backstroke(); public void butterfly(); } |
[Kenhi.java]
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 |
// パッケージの宣言 package chapter_4_12; /** * Kenhiクラス(インターフェースの実装) */ public class Kenhi implements Stroke1{ // オーバーライド public void crawl() { System.out.print("健二はクロールが得意です。"); System.out.println(distance + "m泳ぎました。"); } // オーバーライド public void breaststroke() { System.out.print("健二は平泳ぎが苦手です。"); System.out.println(distance / 4 + "m泳ぎました。"); } // オーバーライド public void backstroke() { System.out.print("健二は背泳ぎが得意です。"); System.out.println(distance + "m泳ぎました。"); } // オーバーライド public void butterfly() { System.out.print("健二はバタフライが苦手です。"); System.out.println(distance / 4 + "m泳ぎました。"); } } |
[Kenzou.java]
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 |
// パッケージの宣言 package chapter_4_12; /** * Kenzouクラス(インターフェースの実装) */ public class Kenzou implements Stroke1 { // オーバーライド public void crawl() { System.out.print("健三はクロールが苦手です。"); System.out.println(distance / 4 + "m泳ぎました。"); } // オーバーライド public void breaststroke() { System.out.print("健三は平泳ぎが得意です。"); System.out.println(distance + "m泳ぎました。"); } // オーバーライド public void backstroke() { System.out.print("健三は背泳ぎが苦手です。"); System.out.println(distance / 4 + "m泳ぎました。"); } // オーバーライド public void butterfly() { System.out.print("健三はバタフライが得意です。"); System.out.println(distance + "m泳ぎました。"); } } |
[SwimmingSchool.java]
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
// パッケージの宣言 package chapter_4_12; /** * SwimmingSchoolクラス */ public class SwimmingSchool { // training1メソッド public void training1(Stroke1 inst) { System.out.println("トレーニング１です。"); inst.crawl(); inst.breaststroke(); } // training2メソッド public void training2(Stroke1 inst) { System.out.println("トレーニング２です。"); inst.backstroke(); inst.butterfly(); } } |
[Rensyu412_03.java]
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
// パッケージの宣言 package chapter_4_12; /** * Rensyu412_03クラス */ public class Rensyu412_03 { // mainメソッド(最初に実行される特別なメソッド) public static void main(String[] args) { // インスタンスの生成 Kenhi kenji = new Kenhi(); Kenzou kenzou = new Kenzou(); SwimmingSchool school = new SwimmingSchool(); // メソッドの呼び出し school.training1(kenji); school.training1(kenzou); school.training2(kenji); school.training2(kenzou); } } |
[表示結果]
|
1 2 3 4 5 6 7 8 9 10 11 12 |
トレーニング１です。 健二はクロールが得意です。100m泳ぎました。 健二は平泳ぎが苦手です。25m泳ぎました。 トレーニング１です。 健三はクロールが苦手です。25m泳ぎました。 健三は平泳ぎが得意です。100m泳ぎました。 トレーニング２です。 健二は背泳ぎが得意です。100m泳ぎました。 健二はバタフライが苦手です。25m泳ぎました。 トレーニング２です。 健三は背泳ぎが苦手です。25m泳ぎました。 健三はバタフライが得意です。100m泳ぎました。 |
★ポイント
- ポリモルフィズムとは同じ名前のメソッドを呼び出しても異なる処理を発生させる仕組みのことである。
- メソッドに引数としてオブジェクトを渡すとき、メソッド側ではインスタンス型で受け取ることができる。
コンストラクタ
[MyAge.java]
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
// パッケージの宣言 package chapter_4_13; /** * MyAgeクラス */ public class MyAge { // 変数の定義 int age; String name; // コンストラクタ public MyAge() { age = 20; name = "学園太郎"; } // showAgeメソッド public void showAge() { System.out.println(name + "です。" + age + "歳です。"); } } |
[Rensyu413_01.java]
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
// パッケージの宣言 package chapter_4_13; /** * Rensyu413_01クラス */ public class Rensyu413_01 { // mainメソッド(最初に実行される特別なメソッド) public static void main(String[] args) { // インスタンスを生成し、コンストラクタを呼び出し初期値の設定 MyAge inst = new MyAge(); // メソッドの呼び出し inst.showAge(); } } |
[表示結果]
|
1 |
学園太郎です。20歳です。 |
[Tashizan.java]
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
// パッケージの宣言 package chapter_4_13; /** * Tashizanクラス */ public class Tashizan { // 変数の定義 int sum = 0; int su; // コンストラクタ public Tashizan(int su) { // 引数の名前とフィールドの名前がsuでかぶってしますので、thisキーワードを修飾する this.su = su; } // addメソッド public void add() { sum = sum + su; System.out.println("sum=" + sum); } } |
[Rensyu413_02.java]
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
// パッケージの宣言 package chapter_4_13; /** * Rensyu413_02クラス */ public class Rensyu413_02 { // mainメソッド(最初に実行される特別なメソッド) public static void main(String[] args) { System.out.println("２ずつ足す"); // インスタンスを生成し、コンストラクタを呼び出し2を渡す Tashizan tasu2 = new Tashizan(2); // メソッドの呼び出し tasu2.add(); tasu2.add(); tasu2.add(); System.out.println("３ずつ足す"); // インスタンスを生成し、コンストラクタを呼び出し3を渡す Tashizan tasu3 = new Tashizan(3); // メソッドの呼び出し tasu3.add(); tasu3.add(); tasu3.add(); } } |
[表示結果]
|
1 2 3 4 5 6 7 8 |
２ずつ足す sum=2 sum=4 sum=6 ３ずつ足す sum=3 sum=6 sum=9 |
[Runner.java]
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 |
// パッケージの宣言 package chapter_4_13; /** * コンストラクタのオーバーロード */ public class Runner { String name; int dist; Runner() { name = "Nanashi"; dist = 10; } Runner(String name) { // 引数なしのコンストラクタを自ら呼び出す this(); // 名前を設定しなおしている this.name = name; } Runner(String name, int dist) { this.name = name; this.dist = dist; } // runningメソッド public void running() { System.out.println(name + "は" + dist + "km走りました。"); } } |
[Rensyu413_03.java]
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
// パッケージの宣言 package chapter_4_13; /** * Rensyu413_03クラス */ public class Rensyu413_03 { // mainメソッド(最初に実行される特別なメソッド) public static void main(String[] args) { // フィールドの定義 Runner man1, man2, man3; // インスタンスを生成し、コンストラクタを呼び出し man1 = new Runner(); man1.running(); // インスタンスを生成し、コンストラクタを呼び出し(純一郎)を渡す man2 = new Runner("純一郎"); man2.running(); // インスタンスを生成し、コンストラクタを呼び出し(普三, 20)を渡す man3 = new Runner("普三", 20); man3.running(); } } |
[表示結果]
|
1 2 3 |
Nanashiは10km走りました。 純一郎は10km走りました。 普三は20km走りました。 |
★ポイント
- コンストラクタはインスタンスの生成時に呼び出される特別なメソッドであり、フィールドの初期化処理に利用される。
- コンストラクタの名称はクラス名と同じになる。したがってメソッドの一種ではあるが先頭は大文字となる。
パッケージ
[Tashizan.java]
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
// パッケージの宣言 package package2; /** * Tashizanクラス */ public class Tashizan { // keisanメソッド public int keisan(int uke1, int uke2) { int kotae; kotae = uke1 + uke2; return kotae; } } |
[Rensyu501_01.java]
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
// パッケージの宣言 package package1; /** * Rensyu501_01クラス */ public class Rensyu501_01 { // mainメソッド(最初に実行される特別なメソッド) public static void main(String[] args) { // フィールドの定義 int atai1, atai2; int kekka; package2.Tashizan inst; atai1 = 10; atai2 = 20; // インスタンスを生成 inst = new package2.Tashizan(); // メソッドの呼び出し kekka = inst.keisan(atai1, atai2); System.out.println("答えは " + kekka); } } |
[表示結果]
|
1 |
答えは 30 |
★ポイント
- 同一パッケージ内では同一クラス名を使用することができない。※パッケージが異なれば同一クラス名を使用可能
インポート
[Rensyu502_01.java]
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
// パッケージの宣言 package chapter_5_2; // インポート import package2.Tashizan; /** * Rensyu502_01クラス */ public class Rensyu502_01 { // mainメソッド(最初に実行される特別なメソッド) public static void main(String[] args) { // フィールドの定義 int atai1, atai2; int kekka; Tashizan inst; atai1 = 10; atai2 = 20; // インスタンスを生成 inst = new Tashizan(); // メソッドの呼び出し kekka = inst.keisan(atai1, atai2); System.out.println("答えは " + kekka); } } |
[表示結果]
|
1 |
答えは 30 |
★ポイント
- クラス内で使用するクラスをインポートすることができる。※インポート句
- インポートしたクラスは「パッケージ名」+「クラス名」と記述しなくてもクラス名だけで使用することができる。
修飾子と可視性
[Syouhin.java]
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 |
// パッケージの宣言 package chapter_5_3; /** * Syouhinクラス */ public class Syouhin { // 変数の宣言 private int bangou; private String namae; private int kakaku; // hyojiメソッド public void hyoji() { System.out.println("商品番号は：" + bangou); System.out.println("商品名は：" + namae); System.out.println("商品価格は：" + kakaku); } /** * セッター群 */ public void setBangou(int bangou) { this.bangou = bangou; } public void setNamae(String namae) { this.namae = namae; } public void setKakaku(int kakaku) { this.kakaku = kakaku; } /** * ゲッター群 */ public int getBangou() { return this.bangou; } public String getNamae() { return this.namae; } public int getKakaku() { return this.kakaku; } } |
[Rensyu503_02.java]
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
// パッケージの宣言 package chapter_5_3; /** * Rensyu503_02クラス(カプセル化を踏まえている) */ public class Rensyu503_02 { // mainメソッド(最初に実行される特別なメソッド) public static void main(String[] args) { // フィールドの定義 Syouhin inst; // インスタンスを生成 inst = new Syouhin(); // セッターの呼び出し inst.setBangou(333); inst.setNamae("りんご"); inst.setKakaku(150); // メソッドの呼び出し inst.hyoji(); } } |
[表示結果]
|
1 2 3 |
商品番号は：333 商品名は：りんご 商品価格は：150 |
★ポイント
- 修飾子にはアクセス制限(可視性)を表すものと性質を表すものがある。
- カプセル化を意識するとアクセス制限は厳しい方がよい。
- 変数にはアクセス可能域の広さにより３種類が存在する。
- クラス変数
- インスタンス変数
- ローカル変数
例外処理
[Tashizan1.java]
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
// パッケージの宣言 package chapter_5_4; /** * Tashizan1クラス */ public class Tashizan1 { private int kekka = 0; // tasuメソッド(例外が発生する可能性がある) public int tasu(int su) throws Koeta25Exception { kekka = kekka + su; if(kekka > 25) { // クラスをスロー(投げる)します throw new Koeta25Exception (); } return kekka; } } |
[Koeta25Exception.java]
|
1 2 3 4 5 6 7 8 9 10 11 12 |
// パッケージの宣言 package chapter_5_4; /** * Koeta25Exceptionクラス(例外クラスを継承) */ public class Koeta25Exception extends Exception { // コンストラクタ Koeta25Exception () { System.out.println("25をオーバーしました"); } } |
[Rensyu504_01.java]
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 |
// パッケージの宣言 package chapter_5_4; /** * Rensyu504_01クラス */ public class Rensyu504_01 { // mainメソッド(最初に実行される特別なメソッド) public static void main(String[] args) { // フィールドの定義 int i, kekka; Tashizan1 inst; // インスタンスを生成 inst = new Tashizan1(); for(i=1; i<=10; i++) { // 例外が発生する可能性がある try { kekka = inst.tasu(i); System.out.println(kekka); // 例外が投げられたら捕らえる } catch(Koeta25Exception rei1) { System.out.println("25オーバーエラーをcatchしました！"); System.out.println(""); // catch句の有無に関わらず実行させたい処理がある場合に記述 } finally { System.out.println(i+ " 回目のfinallyを実行しました！"); } } } } |
[表示結果]
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 |
1 1 回目のfinallyを実行しました！ 3 2 回目のfinallyを実行しました！ 6 3 回目のfinallyを実行しました！ 10 4 回目のfinallyを実行しました！ 15 5 回目のfinallyを実行しました！ 21 6 回目のfinallyを実行しました！ 25をオーバーしました 25オーバーエラーをcatchしました！ 7 回目のfinallyを実行しました！ 25をオーバーしました 25オーバーエラーをcatchしました！ 8 回目のfinallyを実行しました！ 25をオーバーしました 25オーバーエラーをcatchしました！ 9 回目のfinallyを実行しました！ 25をオーバーしました 25オーバーエラーをcatchしました！ 10 回目のfinallyを実行しました！ |
[Rensyu504_04.java]
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
// パッケージの宣言 package chapter_5_4; /** * Rensyu504_04クラス */ public class Rensyu504_04 { // mainメソッド(最初に実行される特別なメソッド) public static void main(String[] args) { int i, kekka; for(i=2; i>=-2; i--) { // 例外が発生する可能性がある try { kekka = 100/i; System.out.println(kekka); // 例外が投げられたら捕らえる } catch(ArithmeticException rei1) { System.out.println("演算エラーです"); } } } } |
[表示結果]
|
1 2 3 4 5 |
50 100 演算エラーです -100 -50 |
★ポイント
例外処理とはプログラム内で発生する正常な動作以外の挙動に対する対応策を記述することであり、「システム例外」と「オリジナル例外」の２種類に大別される。
スレッド処理
[Aisatsu1.java]
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
// パッケージの宣言 package chapter_5_5; /** * Aisatsu1クラス */ public class Aisatsu1 extends Thread { String moji; // コンストラクタ Aisatsu1(String moji) { this.moji = moji; } // オーバーライド public void run() { int i; System.out.println("継承利用"); for(i=0; i<20; i++) { System.out.println(moji); } } } |
[Rensyu505_01.java]
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
// パッケージの宣言 package chapter_5_5; /** * Rensyu505_01クラス */ public class Rensyu505_01 { // mainメソッド(最初に実行される特別なメソッド) public static void main(String[] args) { // フィールドの定義 Aisatsu1 instA,instB; // インスタンス生成 instA = new Aisatsu1("こんにちは"); instB = new Aisatsu1("さようなら"); // メソッドの呼び出し instA.start(); instB.start(); } } |
[表示結果]
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 |
継承利用 こんにちは こんにちは こんにちは こんにちは こんにちは こんにちは こんにちは こんにちは こんにちは こんにちは こんにちは こんにちは こんにちは こんにちは こんにちは こんにちは こんにちは こんにちは こんにちは こんにちは 継承利用 さようなら さようなら さようなら さようなら さようなら さようなら さようなら さようなら さようなら さようなら さようなら さようなら さようなら さようなら さようなら さようなら さようなら さようなら さようなら さようなら |
[Midashi.java]
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
// パッケージの宣言 package chapter_5_5; /** * Midashiクラス(スーパークラス) */ public class Midashi { // 変数の宣言 String midashi; // midashiHyoujiメソッド public void midashiHyouji() { System.out.println(midashi); } } |
[Aisatsu2.java]
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
// パッケージの宣言 package chapter_5_5; /** * Aisatsu2クラス(サブクラス、インターフェース実装) */ public class Aisatsu2 extends Midashi implements Runnable{ String moji; // コンストラクタ Aisatsu2(String moji) { this.moji = moji; } // オーバーライド public void run() { int i; midashi = "インターフェース利用"; midashiHyouji(); for(i=0; i<20; i++) { System.out.println(moji); } } } |
[Rensyu505_02.java]
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
// パッケージの宣言 package chapter_5_5; /** * Rensyu505_02クラス */ public class Rensyu505_02 { // mainメソッド(最初に実行される特別なメソッド) public static void main(String[] args) { // フィールドの定義 Aisatsu2 instA,instB; Thread threadA,threadB; // インスタンス生成 instA = new Aisatsu2("こんにちは"); instB = new Aisatsu2("さようなら"); threadA = new Thread(instA); threadB = new Thread(instB); // メソッドの呼び出し threadA.start(); threadB.start(); } } |
[表示結果]
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 |
インターフェース利用 インターフェース利用 さようなら さようなら さようなら さようなら さようなら さようなら さようなら さようなら さようなら さようなら さようなら さようなら さようなら さようなら さようなら さようなら さようなら さようなら さようなら さようなら こんにちは こんにちは こんにちは こんにちは こんにちは こんにちは こんにちは こんにちは こんにちは こんにちは こんにちは こんにちは こんにちは こんにちは こんにちは こんにちは こんにちは こんにちは こんにちは こんにちは |
★ポイント
- スレッドとはプログラム内における実行単位のことである。
- スレッド処理を利用することにより複数のプログラムを見かけ上同時に実行することができる。
- スレッドに対応したプログラムにするための方法には以下の２種類が存在する。
- 継承によるスレッド実現…Threadクラスをextendsする。
- 実装によるスレッド実現…Runnableクラスをimplementsする。
コレクションクラス
[Rensyu506_01.java]
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 |
// パッケージの宣言 package chapter_5_6; // インポート import java.util.ArrayList; /** * Rensyu506_01クラス(データの追加、削除より参照の方が主体) */ public class Rensyu506_01 { // mainメソッド(最初に実行される特別なメソッド) public static void main(String[] args) { // フィールドの定義 ArrayList list; int i; Integer intInst; Double doubleInst; // インスタンス生成 list = new ArrayList(1); // メソッドの呼び出し list.add("文字列"); System.out.println("現在の要素数" + list.size()); // インスタンス生成 intInst = new Integer(100); // メソッドの呼び出し list.add(intInst); System.out.println("現在の要素数" + list.size()); // インスタンス生成 doubleInst = new Double(3.14); // メソッドの呼び出し list.add(doubleInst); System.out.println("現在の要素数" + list.size()); // オブジェクトを先頭から順番にArrayListクラスのget()メソッドを使用して取り出し、表示 for(i=0; i<list.size(); i++) { System.out.println(list.get(i)); } } } |
[表示結果]
|
1 2 3 4 5 6 |
現在の要素数1 現在の要素数2 現在の要素数3 文字列 100 3.14 |
[StackList.java]
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 |
// パッケージの宣言 package chapter_5_6; //インポート import java.util.LinkedList; /** * StackListクラス(データの参照より追加、削除の方が主体) */ public class StackList { LinkedList list; // コンストラクタ StackList() { list = new LinkedList(); } // pushメソッド(データをスタックに追加する) public int push(int youso) { // ラップしている。最後尾に追加 list.addLast(new Integer(youso)); System.out.println("追加した要素" + youso); // 現在の要素数を取得 return list.size(); } // popメソッド(データをスタックから取り出す) public int pop() { // 現在の最後尾にあるデータを取得 System.out.println("取り出した要素" + list.getLast()); // 現在の最後尾にあるデータを削除します list.removeLast(); // 現在の要素数を取得 return list.size(); } } |
[Rensyu506_03.java]
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
// パッケージの宣言 package chapter_5_6; /** * Rensyu506_03クラス */ public class Rensyu506_03 { // mainメソッド(最初に実行される特別なメソッド) public static void main(String[] args) { // フィールドの定義 StackList instA; int i; // インスタンス生成 instA = new StackList(); // メソッドの呼び出し instA.push(1); instA.push(2); instA.push(3); for(i=0; i<3; i++) { // データを取り出す instA.pop(); } } } |
[表示結果]
|
1 2 3 4 5 6 |
追加した要素1 追加した要素2 追加した要素3 取り出した要素3 取り出した要素2 取り出した要素1 |
[Rensyu506_04.java]
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 |
// パッケージの宣言 package chapter_5_6; // インポート import java.util.HashMap; import java.util.Map; import java.util.Iterator; /** * Rensyu506_04クラス(HashMapにデータを格納) */ class Rensyu506_04 { // mainメソッド(最初に実行される特別なメソッド) public static void main(String[] args) { // インスタンス生成 HashMap data = new HashMap(); int[] length = { 143, 194, 213, 322, 367, 249, 268}; String[] name = {"筑後川","江の川","天竜川","利根川","信濃川","最上川","石狩川"}; // HashMapにデータを追加する for(int i=0; i<length.length; i++) { // ラップしている data.put(new Integer(length[i]),name[i]); } // キー値を指定してデータを取得する System.out.println("キー：" + 213); System.out.println("値：" + data.get(213)); System.out.println(); // イテレータを利用し全件表示する System.out.println("*全件表示*"); // ビュー取得、データにアクセスできる Iterator it = data.entrySet().iterator(); // 次のデータはありますか？問い合わせる while(it.hasNext()) { // 次のデータを取得 Map.Entry set = (Map.Entry)it.next(); System.out.println(set.getValue()+"\t"+set.getKey()+"km"); } } } |
[表示結果]
|
1 2 3 4 5 6 7 8 9 10 11 |
キー：213 値：天竜川 *全件表示* 江の川 194km 利根川 322km 天竜川 213km 最上川 249km 石狩川 268km 筑後川 143km 信濃川 367km |
★ポイント
- コレクションクラスクラスは処理の途中で要素数を変化させることができる。※自動的に変化する
- コレクションクラスはどんな型のオブジェクトでも格納することができる。
- コレクションクラスには様々な種類があり、それぞれに特徴があるので処理に合ったクラスを選ぶことが大切である。
- データの追加、削除より参照の方が主体…ArrayList
- データの参照より追加、削除の方が主体…LinkdList
- キー値からデータを取得したい…HashMap
