HashMapを使って次のようなプログラムを書きます。

package TestPackage;

import java.util.HashMap;
import java.util.Map;

public class LinkedListTest6 {

    /**
     * @param args
     */
    public static void main(String[] args) {

        Map<String, Integer> map = new HashMap<String, Integer>();

        //要素の追加
        map.put("test2", 100);
        map.put("qqq", 67);
        map.put("www", 34);
        map.put("eee", 81);

        System.out.println("map -> " + map);
        
        //ここに、コレクションの操作を記述する
        
    }

}

実行結果は次のようなります。

map -> {qqq=67, www=34, test2=100, eee=81}

「キー項目と値」のセットになっていることがわかります。
Hashmapはこのように、２つセットのものを、要素分、格納するコレクションと言えます。

次に、このコレクションを操作してみます。
「ここに、コレクションの操作を記述する」という箇所に次のようなプログラムを書いて見ます。

■キーと値を同時に取得する

    for (Map.Entry<String, Integer> entry : map.entrySet()){
        System.out.println(entry.getKey() + "=>" + entry.getValue());
    }

実行結果は次のようになります。

qqq=>67
www=>34
test2=>100
eee=>81

■キーを取得する

    for (String name : map.keySet()){
        System.out.println(name);
    }

実行結果は次のようになります。

qqq
www
test2
eee

■値を取得する

    for (Integer name : map.values()) {
        System.out.println(name);
    }

実行結果は次のようになります。

67
34
100
81

■キーと値を取得する

    for (String name : map.keySet()) {
        System.out.println(name + "->" + map.get(name));
    }

実行結果は次のようになります。

qqq->67
www->34
test2->100
eee->81

■あるキーをもとに値を取得する

    System.out.println(map.get("qqq"));

実行結果は 「67」 になります。

これは２つ目の要素の値を取得してきていることがわかります。

コレクションの使い方は上記のほかにもまだまだ使い方があるので、別途追求しようと思います。

HashSetを使ってみます。

HashSetは要素の集合に、目的の要素が含まれているかを調べるときに使います。

含まれているかどうかを調べる時に、要素の順番は関係ありません。

また、nullを追加することも可能です。

package TestPackage;

import java.util.HashSet;
import java.util.Set;

public class LinkedListTest5 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		Set<String> set = new HashSet<String>();

		//要素の追加
		set.add("test2");
		set.add("qqq");
		set.add("www");
		set.add("eee");

		System.out.println("set -> " + set);

		if (set.contains("www")){
			System.out.println("要素に含まれている");
		} else {
			System.out.println("要素に含まれていない");
		}

	}

}

実行結果は次のようになります。

set -> [qqq, www, test2, eee]
要素に含まれている

LinkedListをキューとして使ってみます。
プログラムは次のように記述します。

package TestPackage;

import java.util.LinkedList;
import java.util.Queue;

public class LinkedListTest2 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		Queue<String> queue = new LinkedList<String>();

		//要素の追加
		queue.offer("test2");
		queue.offer("ttt");
		queue.offer("mmm");
		queue.offer("ppp");

		//要素の中身を出力する
		System.out.println(queue);

		//先頭要素を取り出す
		queue.poll();

		//要素の中身を出力する
		System.out.println(queue);

		//要素の先頭を「参照」して変数へ代入する
		String peekStr = queue.peek();

		System.out.println(peekStr);

		//要素の中身を出力する
		System.out.println(queue);
}

}

実行結果は次のようになります。

[test2, ttt, mmm, ppp]
[ttt, mmm, ppp]
ttt
[ttt, mmm, ppp]

注意する点は、データ構造がキューを意味している点と、pollメソッドを使って要素を取り出す時には先に挿入したものから取り出されることです。(末尾から操作するメソッドも用意されています)

また、「参照」を行っている箇所は値そのものを取り出さず、値を見ているだけの動きになっています。(一旦、変数に代入してprint文をわかりやすくしているだけです)

LinkedListを使用したコレクションを書いて見ます。
LinkedListは要素の挿入と削除を高速に行います。

一見、ArrayListに似た記述になりますが、先頭に「rrr」を挿入する際のメソッドや宣言の仕方などが微妙に違います(詳しい使い方は別途調べて書いていくことにします)。

package TestPackage;

import java.util.LinkedList;

public class LinkedListTest {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		LinkedList<String> list = new LinkedList<String>();

		//要素の追加
		list.add("test2");
		list.add("ttt");
		list.add("mmm");
		list.add("ppp");

		//要素の中身を出力する
		System.out.println(list);

		//先頭に「rrr」を挿入
		list.addFirst("rrr");

		//要素の中身を出力する
		System.out.println(list);

	}

}

上記を実行した結果は次のように出力されます。

[test2, ttt, mmm, ppp]
[rrr, test2, ttt, mmm, ppp]

ArrayListを使用したコレクションを書いて見ます。

package TestPackage;

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

public class ArrayListTestX {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		List<String> list = new ArrayList<String>();

		//要素の追加
		list.add("test1");
		list.add("aaa");
		list.add("bbb");
		list.add("ccc");

		//要素の中身を出力する
		System.out.println("最初->" + list.get(0));
		System.out.println("最後->" + list.get(list.size() - 1));

		//すべての要素を出力する
		for (int i = 0; i < list.size(); i++) {
			System.out.println(list.get(i));
		}

		//bbbが格納されている要素の添え字を調べる
		//(要素は0から始まるので、出力結果は2と表示される)
		System.out.println(list.indexOf("bbb"));

	}

}

上記を実行した結果は次のように出力されます。

最初->test1
最後->ccc
test1
aaa
bbb
ccc
2

javaの引数パラメータに渡したパス(指定ディレクトリ)の中にあるファイルを一覧表示するプログラムを書きます。

実行した結果は、引数で指定したディレクトリ内のディレクトリとファイルが混在された形でコンソールに表示されます。

package TestPackage;

import java.io.File;

public class DirShow {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		if (args.length != 1) {
			System.out.println("args not");
			System.exit(0);
		}

		String dirname = args[0];

		File dir = new File(dirname);

		String[] dirlist = dir.list();

		for (int i=0; i < dir.length(); i++) {
			System.out.println(dirlist[i]);
		}

	}

}

javaからファイルに書き込みを行うプログラムを書いてみました。

実行する時はeclipseの実行→実行構成で引数を２つ指定する必要があるので注意です。
下記画像は引数を設定した例をキャプチャしたものです(ご参考までに)

package TestPackage;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;

public class WriteFile {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		String inputData = args[0];
		String filename = args[1];

		try{
			BufferedReader reader = new BufferedReader(new FileReader(inputData));

			PrintWriter writer = new PrintWriter(new BufferedWriter(new FileWriter(filename)));

			String line;

			// ファイルの中を開いて1行ずつに出力用変数に代入します
			while ((line = reader.readLine()) != null){
				writer.println(line);
			}

			// reader削除します
			reader.close();
			writer.close();

		} catch(FileNotFoundException e){
			System.out.println("filename -> なし");
		} catch(IOException e){
			System.out.println(e);
		}

	}
}

ファイルの読み込みを書いてみます。

package TestPackage;

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class ShowFile {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		if (args.length != 1) {
			System.out.println("len 1 !");
			System.exit(0);
		} else {
			System.out.println("len 2 !");
		}

		String filename = args[0];

		try{
			BufferedReader reader = new BufferedReader(new FileReader(filename));
			String line;
			//ファイルの中を開いて1行ずつコンソールに出力する
			while ((line = reader.readLine()) != null){
				System.out.println(line);
			}
		} catch(FileNotFoundException e){
			System.out.println("filename -> なし");
		} catch(IOException e){
			System.out.println(e);
		}

	}

}

上記のソースを書いてプログラムを実行するのですが、ひとつ気をつけなければならないことは

String filename = args[0];

の部分で、プログラム実行時の引数に値が渡ってくる。という概念があります。

eclipseの場合は、メニューの「実行」→「実行構成」から別ウィンドウを開き、その中でJAVAの目的のソースコード名を選択して、「引数」タブ内に引数情報を入力することでプログラムの動作を確認しました。

下記のようなソースを書きます。

package ThreadPackage;

public class JoinTest extends Thread {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		JoinTest th = new JoinTest();

		System.out.println("main start");

		th.start();

		System.out.println("main wait");

		try{
			th.join();
		} catch(InterruptedException e){
			System.out.println(e);
		}

		System.out.println("main end");
	}

	public void run(){
		System.out.println("run start");

		try {
			Thread.sleep(3000);
		}catch(InterruptedException e){
			System.out.println(e);
		}
		System.out.println("run end");
	}

}

実行すると次のようなメッセージがコンソールに表示されます

main start
main wait
run start
run end
main end

いったい何が起きているのかというと、

JoinTest th = new JoinTest();

でいったんスタートしたthというスレッドのインスタンスが実行している間に、

th.join();

というメソッドが起動したタイミングで

public void run(){

のメソッドで定義した別スレッドが起動され、その終了をthというスレッドが待っている状態になっています。

他のスレッドの終了を待ってからメインだったスレッドが再開する。という動作ができます。

注意として、joinというメソッドの使い方には3つの方法があります。

//タイムアウトなし、スレッドの終了を待つ
void join() throws InterruptedException

//タイムアウトあり、スレッドの終了を待つ(ミリ秒)
void join(long msec) throws InterruptedException

//タイムアウトあり、スレッドの終了を待つ(ミリ秒+ナノ秒)
void join(long msec, int nsec) throws InterruptedException

スレッド動作を指定秒ストップさせることができます。

次のようなプログラムを作成して実行してみます。

package ThreadPackage;

public class Ts {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		//スレッドの動作がsleep秒ごとにどんどん遅くなっていく
		for(int i=0; i<10; i++){
			int tm = i  * 1000;
			System.out.println("Start tm -> " + tm);
			try {
				Thread.sleep(tm);
			}catch(InterruptedException e){

			}
		}

	}

}

実行結果は以下のようになり、下に行けば行くほど表示する時間間隔が長くなっていきます。

Start tm -> 0
Start tm -> 1000
Start tm -> 2000
Start tm -> 3000
Start tm -> 4000
Start tm -> 5000
Start tm -> 6000
Start tm -> 7000
Start tm -> 8000
Start tm -> 9000

単純にとあるループ処理を10回繰り返すだけですが、ループ中に

Thread.sleep(tm);

と記載し、tm秒ごとに処理を一時停止しています。

既に実行しているスレッドを止める場合には以下のよう書きます。

public void stopRunning() {
    running = false;
}

使い方については上記のメソッドを起動するタイミング(操作)を既存のスレッドを利用しているプログラムに適用するように使います。
(実際の例は別途追記)

ひとつ前の記事と違う方法でスレッドを書いてみます。

package ThreadPackage;

public class ThreadTest2 implements Runnable {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		ThreadTest2 tt2 = new ThreadTest2();
		Thread th = new Thread(tt2);

		th.start();
		for (int i = 0; i < 10; i++) {
			System.out.println("main : i -> " + i);
		}

	}

	public void run() {
		for (int i = 0; i < 10; i++) {
			System.out.println("run : i -> " + i);
		}
	}

}

実行した結果は次のようになります。

run : i -> 0
main : i -> 0
run : i -> 1
main : i -> 1
run : i -> 2
run : i -> 3
main : i -> 2
run : i -> 4
main : i -> 3
run : i -> 5
run : i -> 6
main : i -> 4
run : i -> 7
main : i -> 5
run : i -> 8
main : i -> 6
run : i -> 9
main : i -> 7
main : i -> 8
main : i -> 9

前回の記事と同じ、ログの出力はランダムな順になります。
呼び出し方が違うことに注意する以外は、考え方とログの出方は一緒です。

スレッド処理を書いて動かしてみます

package ThreadPackage;

public class ThreadTest1 extends Thread {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		ThreadTest1 tt = new ThreadTest1();
		tt.start();

		for(int i=0; i<10; i++){
			System.out.println("main:i->" + i);
		}
	}

	public void run() {
		for (int i=0; i<10; i++) {
			System.out.println("sub:i->" + i );
		}
	}

}

実行した結果は次のようになります。
1回目

sub:i->0
sub:i->1
sub:i->2
sub:i->3
sub:i->4
sub:i->5
main:i->0
sub:i->6
sub:i->7
sub:i->8
sub:i->9
main:i->1
main:i->2
main:i->3
main:i->4
main:i->5
main:i->6
main:i->7
main:i->8
main:i->9

2回目

main:i->0
main:i->1
sub:i->0
sub:i->1
sub:i->2
sub:i->3
main:i->2
main:i->3
sub:i->4
main:i->4
main:i->5
sub:i->5
sub:i->6
sub:i->7
sub:i->8
sub:i->9
main:i->6
main:i->7
main:i->8
main:i->9

3回目

main:i->0
main:i->1
sub:i->0
sub:i->1
sub:i->2
main:i->2
main:i->3
sub:i->3
sub:i->4
sub:i->5
sub:i->6
sub:i->7
sub:i->8
sub:i->9
main:i->4
main:i->5
main:i->6
main:i->7
main:i->8
main:i->9

3回実行した結果を載せたのは、スレッドのスタートタイミングが実行時でそれぞれランダムなので掲載した。

1つのスレッドのみのプログラムの場合は、毎回同じタイミングで同じログが出力されるだけだが、スレッドを利用したプログラムでは、1つ目のプログラムが走る裏でもうひとつのプログラムが走るので、処理が同時に平行してタイミングがまちまちにログが出力されていることがわかります。

インターフェイスを拡張することをができます

interface FastRunnable extends Runnable {
	void fastrun();
}

FastRunnableはRunnableのサブインターフェイス
Runnable はFastRunnable のスーパーインターフェイス
といいいます。

サブインターフェイスはスーパーインターフェイスのメソッドを継承します。

実際にインターフェイスを書いてみます

//Lockableインターフェイスの宣言
interface Lockable {
	//↓これは抽象メソッド
	//abstractキーワードがない場合、自動的に抽象メソッドになります
	boolean lock();
	boolean unlock();
}

インターフェイスの宣言は↑のように行います。

上記のインターフェイスを実装するには、implementsキーワードを使って以下のように書きます。

/*
インターフェイスが持つフィールドは必ず定数
インターフェイスが持つメソッドは必ず抽象メソッド
インターフェイスはインスタンスを作ることはできない
*/

//インターフェイスの実装
class Kinko implements Lockable {

	public boolean lock() {
		return true;
	}

	public boolean unlock() {
		return false;

	}

}

インターフェイスはインスタンスを作ることはできません。

//これはできない
Lockable obj = new Lockable();

インターフェイス型の変数を使うことはできます。

Lockable obj = new Kinko();

obj.lock();
という形で呼び出すことができます。

インターフェイスは、公開すべき必要な操作をまとめたクラスの仕様(取り決め)です。
実際に行う処理の内容は、インターフェイスには記述しないです。
インターフェイスは抽象クラスと同様にインスタンス化はできません。
宣言方法は次のようにします。

interface xxxxx {}

インターフェイスは次の特徴があります。
・インターフェイスで宣言できるメソッドは抽象メソッドのみ
・インターフェイスではpublic staticな定数を宣言できる。定数なので初期化しておく。
・インスタンス化はできず、利用する場合は実装クラスを作成し、実装クラス側では抽象メソッドをオーバーライドして使用する
・実装クラスを定義するにはimplementsキーワードを使用する
・インターフェイスを元にサブインターフェイスを作成する場合はextendsキーワードを使用する

下記のように、catch文を連続して書く方法もあります。

try {

} catch (例外クラス名1 変数名) {

} catch (例外クラス名2 変数名) {

} catch (例外クラス名3 変数名) {

}

ただし、注意しないといけないのは、クラスに継承関係がある場合は、必ずサブクラス側から順に書かないとコンパイルエラーになることです。

ダメな例

try {

} catch (例外クラス名1(親クラス) 変数名) {

} catch (例外クラス名2(子クラス) 変数名) {

} catch (例外クラス名3(子クラス) 変数名) {

}

良い例

try {

} catch (例外クラス名1(子クラス) 変数名) {

} catch (例外クラス名2(子クラス) 変数名) {

} catch (例外クラス名3(親クラス) 変数名) {

}

プログラム内のエラーを受け、例外処理を行った後、最後に必ず実行したい処理を書く領域(ブロック)

構文は以下のように書きます

try {

} catch (例外クラス名 変数名) {

} finally {
    //ここに必ず実行したい処理を書きます
}

■注意点
finallyの中にreturn文を書くことはできないです。

例外処理を行っている「e」の変数に対し、printStackTraceを使うと、コールスタックが表示されます。
e.printStackTrace()と書くと、どのメソッドから例外が投げられたのかを表示することができます。

package TestPackage;

public class ExecptionTest1 {

	public static void main(String[] args) {

		int[] TestArray = new int[3];

		System.out.println("Void Main start !");

		try {
			System.out.println("Try start !");
			TestFunc(TestArray, 100, 0);
			System.out.println("Try end !");
			//TestArray[50] = 0;
		} catch (Exception e) {
			//スタックトレースを使うと、コールスタックが表示され、
			//どのメソッドの中から例外が投げられているのかがわかります
			e.printStackTrace();
			System.out.println("例外 -> " + e);
		}

		System.out.println("Void Main end !");
	}

	static void TestFunc(int[] arr, int index, int value) {
		System.out.println("TestFunc start !");
		arr[index] = value;
		System.out.println("TestFunc end !");
	}

}

出力結果は以下のようになります

Void Main start !
Try start !
java.lang.ArrayIndexOutOfBoundsException: 100
	at TestPackage.ExecptionTest1.TestFunc(ExecptionTest1.java:28)
	at TestPackage.ExecptionTest1.main(ExecptionTest1.java:13)
TestFunc start !
例外 -> java.lang.ArrayIndexOutOfBoundsException: 100
Void Main end !

こうすることで、(ExecptionTest1.java:28)と(ExecptionTest1.java:13)という情報がわかるので、そのソースファイルのエラー原因(上記の場合は配列のインデックスを超えて代入しようとした際のエラー)を注意深く追うことができます。

JAVAの例外クラスは、Throwableというクラスがあります。

throw文で投げることができ、catch節で受け止めることができるクラスはすべてThrowableクラスが元になっています。

Throwableは、大きく分けてErrorとExceptionの2つに分類でできます。

• Error

もはや動作を継続するのは期待できないときに投げられるエラー

• Exception

正しく例外処理を行って、動作が継続することを期待するときのエラー
————————————————————————
さらに「Exception」は2種類に分けられます

• Exception → RuntimeException

実行中に起こり、コンパイラによって前もってチェックされない例外(unchecked例外とも言う)

• Exception → RuntimeException以外のエラー

コンパイラによって前もってチェックされる例外(checked例外とも言う)

————————————————————————
checked例外とunchecked例外の2種類に分かれます。

それぞれ取り扱う例外の種類が違うので、以下にまとめます。

• unchecked例外

実行中のプログラムが原因で発生する例外(任意記述)
メモリ不足やプログラムの例外処理では復旧できない例外

• checked例外

必ず任意の例外処理を記述しなければならないです。(必須記述)
記述しない場合はコンパイルエラーになります。
DBが原因だったり、java実行環境以外の環境が原因の例外

checked例外の場合、次の2種類の方法で必ず例外処理を書かなければなりません

• ①メソッド内のcatch節でその例外をキャッチします

void Test() {
	try {
		throw new IOException();
	} catch (IOException e) {
		
	}
}

• ②メソッド内のthrows節でその例外を投げることを宣言します

void Test() throws IOException {
	throw new IOException();
}

例外処理は自分自身で起動することができます。
次のようにコーディングします。
予約語throwの後に投げたい例外のインスタンスを書きます。

throw new IOException();

例外時のエラー処理を行った場合、通常のメソッドのreturn時の挙動とは異なります。

通常のreturn時には、メソッドのひとつ前に戻る。動作を行いますが、例外時のエラーはcatchに飛びます。catchに飛ぶ場所は、コーディングの仕方によってケースバイケースなので、ひとつ前のcatchに飛ぶこともあり、メソッドが何重にも深いところから呼ばれている場合には、おおもとのcatchまで飛んでいくケースもあるので注意が必要です。

この何重にもcatchが書かれている場合のことをコールスタックと呼びます。

javaの例外は、プログラムの誤りを通知し、適切なエラー処理を行う為の機能になります。

例外をうまく使うことで、エラーが起こった時にうまく処理する仕組みにすることができます。

例外の例

ArrayIndexOutOfBoundsException 配列の長さを超えている
FileNotFoundException ファイルが見つからなかった
IllegalArgumentException 引数が異常な値だった
OutOfMemoryError メモリが足りなくなった

等のエラーを拾うことができ、エラー内容に応じた処理にするとキレイなコードになります。

実際にテストコードを書いて、例外をおこしてみます。
下記のコードを書いてコンパイルすると、コンパイルエラーがおきます。

public class TestException {

    public static void main(String[] args) {
        
        int[] TestArray = new int[3];
        
        TestArray[50] = 0;
        
    }

}

上のコードのエラーを、例外をキャッチしてエラー処理を行うようにしてみます。

public class TestException {

    public static void main(String[] args) {
        
        int[] TestArray = new int[3];
        
        try {
            TestArray[50] = 0;
        } catch(Exception e) {
            System.out.println("例外 -> " + e);
        }
        
    }

}

これを実行すると、次のような結果が出力されます。

例外 -> java.lang.ArrayIndexOutOfBoundsException: 50

さらに、public static void mainの中でメソッドを呼び、そのメソッドの中で例外を発生させる。

package TestPackage;

public class ExecptionTest1 {

	public static void main(String[] args) {

		int[] TestArray = new int[3];

		System.out.println("Void Main start !");

		try {
			System.out.println("Try start !");
			TestFunc(TestArray, 100, 0);
			System.out.println("Try end !");
			//TestArray[50] = 0;
		} catch (Exception e) {
			System.out.println("例外 -> " + e);
		}

		System.out.println("Void Main end !");
	}

	static void TestFunc(int[] arr, int index, int value) {
		System.out.println("TestFunc start !");
		arr[index] = value;
		System.out.println("TestFunc end !");
	}

}

上記のコードを実行すると、次のような出力になる。

Void Main start !
Try start !
TestFunc start !
例外 -> java.lang.ArrayIndexOutOfBoundsException: 100
Void Main end !

Tryの中でTestFuncメソッドが呼ばれ、そのメソッド内で例外が発生したら、
もともとのTryにあるcatchが働き、例外処理がされる。

抽象クラスについて勉強します。

クラスの前にまずは、抽象メソッドについてです。
抽象メソッドとは、メソッドの名前と引数の型だけが定まっているものを言います。
別名でabstractメソッドとも言います。

abstract class TestClass{
    public abstract void TEST();
}

TESTというメソッドを宣言していても、中身はありません。(抽象メソッド)

このように、中身がないメソッドを含むクラスのことを抽象クラスといいます。

抽象クラスに書いた抽象メソッドは、中身がないので、具体的な挙動はサブクラスのほうで書く必要がある。
サブクラスで動作を書くことを前提として抽象クラスを設計するケースが多く、プログラムをする時にはその意図を汲み取ってコーディングをする。

修飾子のfinalをクラスにつけて宣言すると、そのクラスは拡張が禁止されます。

拡張が禁止されたクラスのことをfinalクラスと言います。

finalクラスの例

final class FClass {

}

例えば、FClassを継承したクラスを作ろうとすると

class FSUBClass extends FClass {

}

とするとコンパイルエラーになります。

クラスを数多くあつめたものをクラスライブラリと呼びます。

また、関連のあるクラスを1つのグループにまとめたものをパッケージと呼びます。
利用する場合には「import」宣言をして呼び出します。
パッケージを作る場合は「package」宣言を行って作ります。

この辺りは実際に作ってみないとまだまだ実感がわかない概念です。
今後の為に言葉だけは覚えておこうと思います。

両者の違いはなにか?

privateメソッドは、サブクラスに継承されないメソッド。

finalメソッドは、サブクラスに継承されるが、内容を変更できないメソッド。

クラス内のフィールドの修飾子についてのメモ。

一般的にはクラスを設計する際には、クラス内のフィールドについては、privateに設定しておくのが良いとされています。

フィールド自体はprivateで、その値を参照したり、代入したりするのは、その専用のメソッドを書くのが設計上よいです。

そこで、フィールドの内容を取得するメソッドのことをアクセスメソッドまたはアクセサと呼びます。

フィールドの値をprivateにしておくことによって、他のクラスからの直接的な参照を防ぐ考えを、情報隠蔽という。
クラスの設計をする際には、この考え方をベースにしたほうがよさそうです。

少し時間が空いてしまいました。

久しぶりのブログになりますが、今日はスーパークラスとサブクラスの関係について、もうすこし詳しく勉強します。

クラスの、スーパークラスのフィールドとメソッドを継承するという動作について、ひとつ掘り進んで考えてみます。

一口に継承といっても、スーパークラス側でprivateの修飾子で宣言されたメソッドについては継承することができません。