パッケージとは

※wikipedia引用

Javaパッケージは名前空間の中にあるJavaクラスをまとめるメカニズムである。 Javaパッケージは、JARファイルと呼ばれる圧縮ファイルの中に保存することができ、クラス群を一つのグループとしてまとめた方が1つずつダウンロードするよりも高速化される。プログラマも一般に同じカテゴリに属しているクラスや類似した機能を提供するクラスをまとめたパッケージを使う。
階層構造を持たず、クラス名の衝突を避けるために存在する。またそのパッケージ内にあるクラスに対しては、package privateといった設定が可能であり、package privateなクラスはパッケージ外部のクラスからのアクセスが禁止され、カプセル化による情報隠蔽を実現できる。

Javaを開発しているとクラスやインターフェースを再利用したいときがあります。そのとき、例えばAさんが作ったクラスとBさんが作ったクラスを再利用したいのですが、クラス名が重なってしまいました。重複のたびにクラス名を修正していくのは結構手間です。そこでAさんが作ったクラスは「makeA」というパッケージに入れ、Bさんが作ったクラスは「makeB」のパッケージに入れておくと、クラスの重複が起こったときにどのパッケージのクラスを利用すると指定することができます。
外部に公開するときはなおさらクラス名の重複が起こりやすいです。外部公開のときは「ドメイン名を逆から書いたものをパッケージ名にする」などの暗黙の規則があるようですが、パッケージの目的の1つに「クラス名の衝突を避ける」ということがあります。
他にも同じカテゴリや類似した機能をパッケージとしてまとめることによりクラスやインターフェースを使いやすくなります。

パッケージの宣言

【makeA > PackageSample.java】

package makeA;
public class PackageSample {
	public void show(){
		 System.out.println("makeAパッケージです。");
	}
}

【makeB > PackageSample.java】

package makeB;
public class PackageSample {
	public void show(){
		 System.out.println("makeBパッケージです。");
	}
}

2つの「PackageSample」という名前のクラスを作成します。通常ならクラス名の重複はエラーになりますが、パッケージを別にすることで同じクラス名でも作成することができます。

package　パッケージ名；

どのパッケージに属するかは、ソースファイルの先頭に「package」キーワードで宣言します。パッケージを宣言しない場合はデフォルト・パッケージに属します。サンプルでは「makeA」と「makeB」という別のパッケージに属性しているのでクラス名の重複があってもエラーになりません。

パッケージの参照

【Sample.java】

public class Sample{
    public static void main(String[] args) {
    	makeA.PackageSample makeA_Obj = new makeA.PackageSample();
    	makeB.PackageSample makeB_Obj = new makeB.PackageSample();
    	makeA_Obj.show();
    	makeB_Obj.show();
    }
}

パッケージ名.クラス名 ○○ = new パッケージ名.クラス名();

パッケージのクラスを参照するには、クラス名の前に「パッケージ名+ドット」をつけます。どのパッケージに属するどのクラスと指定するわけです。呼び出し元と呼び出し先が同じパッケージに属しているならば、「パッケージ名+ドット」は省略できます。

単純名と限定名

import makeA.PackageSample;
public class Sample{
    public static void main(String[] args) {
    	makeA.PackageSample Obj1 = new makeA.PackageSample();
    	PackageSample Obj2 = new PackageSample();
    	Obj1.show();
    	Obj2.show();
    }
}

単純名とは「単一の識別子のみで構成される名前」のことです。簡単に言えば「パッケージ名+ドット」がなくクラス名だけで記述するのが単純名で、「パッケージ名+ドット」付きで書くのが限定名です。
呼び出し元と呼び出し先が同じパッケージに属しているならば、「パッケージ名+ドット」は省略できました。呼び出し元で呼び出し先をインポートすることで同様なことができます。

import パッケージ名．*；
import パッケージ名．クラス名；

クラスをインポートするには、importキーワードを使います。「パッケージ名・クラス名」で特定のクラスのみをインポートすることができますし、「パッケージ名・*」 とアスタリスクで指定するとそのパッケージに属する全てのクラスがインポートされます。

 import makeA.PackageSample;

1行目でmakeAパッケージのPackageSampleクラスをインポートしました。これでデフォルトパッケージに属するSampleクラスからでも「パッケージ名+ドット」のない単純名で参照することができます。

makeA.PackageSample Obj1 = new makeA.PackageSample();
PackageSample Obj2 = new PackageSample();

4行目は限定名でインスタンスを生成していますが、5行目は単純名でインスタンスを生成しています。同じクラスなのでメソッドの結果も当然同じです。

同名クラスをインポート

import makeA.PackageSample;
import makeB.PackageSample;
public class Sample{
    public static void main(String[] args) {
    }
}

パッケージmakeAのPackageSampleクラスとパッケージBのPackageSampleクラスをインポートしてみます。結果はエラーになります。同名のクラスを指定してインポートできません。

import makeA.*;
import makeB.*;
public class Sample{
    public static void main(String[] args) {
    	PackageSample Obj = new PackageSample();
    }
}

Exception in thread "main" java.lang.Error: Unresolved compilation problem
型 PackageSample はあいまいです

アスタリスクを使ってパッケージ全体をインポートすると、クラス名が重なってもエラーにならずにインポートできます。しかしクラスを参照するときは単純名ではできません。単純名ではどのパッケージのクラスなのかわからない為、一意になるように限定名で参照します。

クラスメソッドとは

※wikipedia引用

クラスメソッド (class method) とはクラスに属するメソッドのことであり、インスタンスを生成せずにクラスから直接呼び出すことができる。基本的に、その振る舞いは非オブジェクト指向言語における関数と変わらない。

クラス変数と考え方は同じです。1つのクラスから複数のインスタンスが生成できます。インスタンスメソッドを参照するときは、どのインスタンスのメソッドなのか指定して参照します。同様にクラスメソッドの場合は、どのクラスのメソッドなのか指定して参照します。インスタンスメソッドは各インスタンスに属するのに対し、クラスメソッドはクラスに属します。

クラスメソッドの宣言

【StaticSample.java】

public class StaticSample {
    static void method_1(){
    	System.out.println("クラスメソッドです。");
    }
    void method_2(){
    	System.out.println("クラスメソッドではありません。");
    }
}

「StaticSample」クラスでは2つのメソッドがあります。メソッドは基本的にインスタンスが生成されると、そのインスタンスに属するインスタンスメソッドとなりますが、あるキーワードを付けることによりクラスメソッドにすることができます。

    static void method_1(){

static 返却値の型 クラスメソッド名{ ・・・}

「static」キーワードをメソッド宣言時につけることによりクラスメソッドとなり、クラスに属するメソッドとなります。

クラスメソッドの参照

【Sample.java】

public class Sample{
    public static void main(String[] args) {
    	StaticSample.method_1();
    }
}

3行目でクラス名を指定してメソッドを参照しています。クラスに属しているので直接クラスから参照できます。数学の公式を計算をするメソッドなど、いちいちインスタンスを生成せず「非オブジェクト指向言語における関数」のように使いたい場合に便利です。

では、クラスメソッドでない「method_2」メソッドをクラスを指定して直接参照するとどうなるかみてみます。

    StaticSample.method_2();

Exception in thread "main" java.lang.Error: Unresolved compilation problem
型 StaticSample の非 static メソッド method_2() を static 参照することはできません

結果はエラーになります。クラスメソッドでないメソッドは、インスタンス生成後にインスタンスメソッドとなります。各インスタンスに属するメソッドなのでクラス指定では参照できません。

クラスメソッドの注意点

public class StaticSample {
	int field;
	static void method(){
        this.field = 100;
    }
}

クラスメソッドはクラスメソッドに属してるので、クラスメソッドの処理の中にインスタンスに属する変数は書けません。サンプルではクラスメソッドの中で変数fieldを使っていますがこの変数はインスタンス後にインスタンス変数になります。クラスに属するメソッドにインスタンスに属する変数が混ざるのでエラーになります。

Exception in thread "main" java.lang.Error: Unresolved compilation problem
static コンテキストでは this を使用できません

クラスに属するクラス変数なら使うことができます。

今回はクラス変数についてみていきます。

クラス変数とは

※wikipedia引用

クラス変数（class variable）とは、同一クラス・派生クラスで共有される変数である。 そのため、関連クラスに渡って共通に使用できる大域変数(グローバル変数)であるともいえる。
これに対して、インスタンスごとに確保される変数のことを、インスタンス変数あるいは単にフィールド (計算機科学)、データメンバ、メンバ変数などと呼ぶ。

1つのクラスから複数のインスタンスを生成できます。インスタンス変数を参照するときは、どのインスタンスの変数なのか指定して参照します。同様にクラス変数の場合は、どのクラスの変数なのか指定して参照します。インスタンス変数はインスタンスごとに独立して確保される変数に対し、クラス変数はクラスごとに確保される変数です。

クラス変数の宣言

【StaticSample.java】

public class StaticSample {
    static int allPageNo = 0;
    int pageNo;

    StaticSample(int pageNo){
    	this.pageNo = pageNo;
    	allPageNo++;
    }
    void displayPage(){
    	System.out.println(this.pageNo + "/" + allPageNo);
    }
}

「StaticSample」クラスでは2つのフィールド宣言があります。フィールドは基本的にインスタンスが生成されると、そのインスタンスで独立した変数となりますが、あるキーワードを付けることによりクラス変数にすることができます。

   static int allPageNo = 0;

static  型 クラス変数名

「static」キーワードをフィールド宣言時につけることによりクラス変数となり、クラス自身が確保する変数となります。

   allPageNo++;

サンプル「StaticSample」クラスでのクラス変数の処理ですが、コンストラクタ内で「+1」しています。つまりインスタンスの生成ごとに「+1」されるので,このクラスから生成したインスタンスの数を表しています。

【Sample.java】

public class Sample{
    public static void main(String[] args) {
    	StaticSample page1 = new StaticSample(1);
    	StaticSample page2 = new StaticSample(2);
    	StaticSample page3 = new StaticSample(3);

    	page1.displayPage();
    	page2.displayPage();
    	page3.displayPage();
    }
}

３行目で１つ目のインスタンスを生成しています。この時点でクラス変数「allPageNo」は１足され値は「1」となっています。
4行目で2つ目のインスタンスを生成しています。この時点もクラス変数「allPageNo」は１足され値は「2」となっています。
５行目も同様です。クラス変数「allPageNo」の値は「3」になります。
結果をみれば、クラス変数「allPageNo」の値は「3」になっていることがわかります。

クラス変数の参照

【StaticSample.java】

public class StaticSample {
    static int allPageNo = 0;
    int pageNo = 0;
}

【Sample.java】

public class Sample{
    public static void main(String[] args) {
    	System.out.println(StaticSample.allPageNo);
    }
}

クラス変数はクラス自身が持つ変数です。ですのでインスタンスを生成しなくても直接クラスを指定して参照することができます。

クラス名.クラス変数名

では、クラス変数でないpageNoフィールドをクラスを指定して直接参照するとどうなるかみてみます。

    System.out.println(StaticSample.pageNo);

Exception in thread "main" java.lang.Error: Unresolved compilation problem
非 static フィールド StaticSample.pageNo を static 参照できません

結果はエラーになります。クラス変数でないフィールドは、インスタンス生成後にインスタンス変数となります。インスタンスごとに確保される変数なのでクラス指定では参照できません。

多重継承とは

複数のクラスから継承することを多重継承といいます。Javaでは複数のクラスからの多重継承は認められていません。クラスの多重継承が認められれば、スーパークラスのメンバに同じ名前があった場合、「どちらのメンバを継承するのか」などややこしい問題が出てきます。
それに対してインターフェースは、メソッドの宣言だけを行い具体的な処理がない抽象メソッドでした。具体的な処理はインターフェースの実装クラスで記述するので、同じメソッド名を継承しても問題ありません。

クラスとインターフェースの継承（1）

【SuperClass.java】

class SuperClass{
    void method(){
    	System.out.println("スーパークラス : メソッド");
    }
}

【InterfaceSample.java】

interface InterfaceSample {
	void method2();
}

【SubClass.java】

class SubClass extends SuperClass implements InterfaceSample{
    //メソッド
    public void method2(){  //オーバーライド
    	System.out.println("サブクラス : メソッド");
    }
}

クラスとインタフェースを同時に継承しています。class宣言のときに「extends」と「implements」の両方のキーワードを用いるわけですが、「extends」の方を先に書かないと構文エラーになります。

class ｻﾌﾞｸﾗｽ名 extends ｽｰﾊｰﾟｸﾗｽ名 implementes ｲﾝﾀｰﾌｪｰｽ名

インターフェースのメソッドは抽象メソッドなのでオーバーライドする必要があります。抽象メソッドは具体的な処理が記述されていないメソッドであり、実装クラスでオーバーライドして具体的な処理を記述することを強制しています。

【Sample.java】

public class Sample{
    public static void main(String[] args) {
    	SubClass obj = new SubClass();
    	obj.method();
    	obj.method2();
    }
}

4行目はスーパークラス「SubClass」から継承してそのまま使っています。
５行目はインターフェース「InterfaceSample」から継承したメソッドをサブクラス「SubClass」でオーバーライドしています。
インターフェースのメソッドは実装クラスでオーバーライドしないといけないので多重継承としては少し微妙ですが、一応Javaでの多重継承となります。インターフェースの性質上、インターフェースは「実装クラスで宣言しなければならない最低限のメソッドを指示している」と考えた方がわかりやすいですが。。。

クラスとインターフェースの継承（2）

【SuperClass.java】

class SuperClass{
    void method(){
    	System.out.println("スーパークラス : メソッド");
    }
}

【InterfaceSample.java】

interface InterfaceSample {
	void method();
}

【SubClass.java】

class SubClass extends SuperClass implements InterfaceSample{
}

次はスーパークラスとインターフェースに同じメソッド名がある場合、どのような処理がされるかみていきます。サブクラス「SubClass」には、インターフェースのメソッドをあえてオーバーライドしませんでした。結果はどのようになるかというと、

Exception in thread "main" java.lang.Error:
                     Unresolved compilation problem:
継承メソッド SuperClass.method() は InterfaceSample 内の
public 抽象メソッドを隠蔽できません

とエラーになりました。スーパークラスに具体的な処理が記述されているので、こちらを優先してくれることを期待したのですが、期待に反して「継承メソッドより抽象メソッドの方が強い」という結果です。ということでインターフェースのメソッドは必ずオーバーライドする必要があります。

複数のインターフェースの継承

【InterfaceSample.java】

interface InterfaceSample {
	void method();
}

【InterfaceSample2.java】

interface InterfaceSample2 {
	void method2();
}

【SubClass.java】

class SubClass implements InterfaceSample , InterfaceSample2{
	public void method (){
		System.out.println("InterfaceSample メソッド");
	}
	public void method2(){
		System.out.println("InterfaceSample2メソッド");
	}
}

複数のインターフェースを実装したい場合は、「implements」キーワードの後に実装したいインターフェース名をカンマ区切りで並べるだけです。

class ｻﾌﾞｸﾗｽ名  implementes ｲﾝﾀｰﾌｪｰｽ名 , ｲﾝﾀｰﾌｪｰｽ名2　, ・・・

実装クラスでは全てのインターフェースのメソッドをオーバーラードする必要があります。また複数のインターフェースを実装すると同じ抽象メソッド名が継承される場合がありますが、特に気にする必要はありません。インターフェースなのでメソッドには具体的な処理はどれも記述されてませんし、実装クラスでオーバーライドします。どのインターフェースから継承するかは問題になりません。

定数とは

※「Wikipedia」から引用します。

プログラミングにおいて定数とは、変数同様プログラムのソースコードにおいて、扱われるデータを一定期間記憶し必要なときに利用できるようにするために、データに固有の名前を与えたものである。 ただし変数とは異なり、一度初期化するとその内容を変更することはできない。

変数と似ていますが、代入されている値が変化するか固定かの違いです。

クラスと定数

【Constant.java】

public class Constant {
	final int CONSTANT = 100;
}

まずはクラスでの定数です。クラスのフィールドを定数にしたい場合は、定数名の前に「final」キーワードをつけます。

final  型  定数名

定数にすると代入した値を変更できなくなります。javaでは大文字にするのが慣例です。

【Sample.java】

public class Sample {
    public static void main(String[] args) {
    	Constant obj = new Constant();
    	obj.CONSTANT = 200;
    }
}

Exception in thread "main" java.lang.Error:
                     Unresolved compilation problem:
final フィールド Constant.CONSTANT には代入できません

４行目で定数の値を変更しようとしました。定数は値を変更できないのでエラーになります。

インターフェースと定数

【InterfaceConst.java】

interface InterfaceConst {
	int CONSTANT = 100;
}

インターフェースでフィールドを宣言しました。「CONSTANT」の宣言には「final」がありません。クラスでは「final」がなければ定数ではなく変数となり、値を自由に変更することができました。インターフェースではどのようになるかみてみます。

【Sample.java】

public class Sample implements InterfaceConst{
    public static void main(String[] args) {
    	InterfaceConst.CONSTANT = 200;
    }
}

Exception in thread "main" java.lang.Error:
                     Unresolved compilation problem:
final フィールド InterfaceConst.CONSTANT には代入できません

「final」キーワードをつけていないのに、エラーメッセージをみてみると「CONSTANT」はfinalフィールドであると言っています。つまりCONSTANTは定数扱いされているので値を変更できないためエラーになります。なぜこのようになるかというと、

インターフェースのフィールドは 「public static final」 に自動的になる

からです。よって「final」を指定しなくても「final」に自動的になっているため値を変更しようとするとエラーになります。

インターフェースフィールドの参照

【InterfaceConst.java】

interface InterfaceConst {
	int CONSTANT = 100;
}

【Sample.java】

public class Sample implements InterfaceConst{
    public static void main(String[] args) {
    	System.out.println(InterfaceConst.CONSTANT);
    	System.out.println(CONSTANT);
    }
}

インターフェースのフィールドは、３行目のようにインターフェース名を指定して参照することもできますし、４行目のようにインターフェース名を省略して参照することもできます。

インターフェースとは

インターフェースとは何か？「IT用語辞典　e-Words」さんから引用します。

二つのものの間に立って、情報のやり取りを仲介するもの。また、その規格。
ソフトウェアインターフェースは、プログラム間でデータをやり取りする手順や形式を定めたもの。

Javaでのインターフェースは、定数とメソッドの形式を定めたものの集まりです。「メソッド名」、「引数」、「戻り値の型」などを決め、具体的な処理は書きません。具体的な処理はインターフェースを実装したクラスで記載します。クラスを使う人はインターフェースをみるだけでどのような機能があるのかわかり、同じインターフェースを実装していれば処理内容が違っていても、同じようにメソッドを使うことができます。

インタフェースの宣言

【CompareInterface.java】

interface CompareInterface {
    //比較する
	int compareTo(Object obj);
}

「比較」に関するインターフェースです。このサンプルでは「compareTo」というメソッドがあり、結果は整数型で返します。サンプルをみてもわかるようにインターフェースのメソッドには具体的な処理の記述はありません。このインターフェースを実装したクラスで「compareTo」メソッドをオーバーライドし具体的な処理を記述します。

インターフェースについて簡単に言えば、「比較する」という機能は様々なクラスで使うだろうから、クラスを使う人が使いやすいようにメソッド名や引数、戻り値の型を統一しましょうってことです。メソッドの作り方の規約です。当然、比較するという具体的な処理はクラスごとに違いインターフェースでは記述できないので、インターフェースを実装したクラスで記述します。

インターフェースは設計図で例えられるクラスとは性質が異なります。そこでインターフェースの宣言では「class」の代わりに「interface」というキーワードを使って宣言します。

interface インターフェース名 {　・・・ }

インターフェースの実装

【Test.java】

class Test implements CompareInterface{
    int math;		//数学
    int English;	//英語
    int science;	//理科

    //コンストラクタ
    Test(int math , int English , int science){
    	this.math    = math;
    	this.English = English;
    	this.science = science;
    }
    //平均値
    public int average(){
    	return (math + English + science) / 3;
    }
	//【比較する】 ※インターフェースのメソッドをオーバーライド
	public int compareTo(Object x){
		Test obj = (Test)x;
		return this.average() - obj.average();
	}
}

class Test implements CompareInterface{

インターフェースを実装していきます。インターフェースはクラスとは別の性質であり、「インタフェースを拡張する」 という感じではありません 。そこで「extends」ではなく「implements」キーワードを用いて実装します。

class　クラス名　implements　インタフェース名　｛ ・・・ }

	public int compareTo(Object x){

17行目でインターフェースにあるメソッドをオーバーライドしています。インターフェースのメソッドには具体的な処理が記述されていないので、実装したクラスで記述しなければなりません。もしオーバーライドしなければエラーになります。

Exception in thread "main" java.lang.Error:
                     Unresolved compilation problem:
型 Test は継承された抽象メソッド CompareInterface.compareTo(Object)
を実装する必要があります

【Human.java】

class Human implements CompareInterface{
    String name;  //名前
    int height;   //身長
    int weight;   //体重

    //コンストラクタ
    Human(String name , int height , int weight){
    	this.name   = name;
    	this.height = height;
    	this.weight = weight;
    }
	//【比較する】 ※インターフェースのメソッドをオーバーライド
	public int compareTo(Object x){
		Human obj = (Human)x;
		return this.height - obj.height;
	}
}

もうひとつ「CompareInterface」インターフェースを実装したクラスをつくります。
TestクラスのcompareToメソッドはテストの平均点を比較する処理が記載されていましたが、HumanクラスのcompareToメソッドは身長を比較しています。

【Sample.java】

public class Sample {
    public static void main(String[] args) {
    	Test  Taro_test   = new Test(65 , 40 , 70);
    	Test  Hanako_test = new Test(55 , 80 , 60);
    	Human Taro        = new Human("太郎" , 170 , 60);
    	Human Hanako      = new Human("花子" , 160 , 50);

    	System.out.print("テスト比較：");
    	System.out.println(Taro_test.compareTo(Hanako_test));
    	System.out.print("身長比較：");
    	System.out.println(Taro.compareTo(Hanako));
    }
}

インターフェースを実装したクラスをインスタンス化して使ってみます。Javaマニュアルのようにインターフェースの仕様書を作成すれば、それを見ることによりどのようなクラスにそのインターフェースが使われているかわかります。逆に言えば、そのインターフェースを実装したクラス全てにおいて、インターフェースで宣言したメソッドを含まれおり、さらにメソッドの使い方が同じです。
ではサンプルをみてみます。「compareTo」メソッドはオブジェクト同士を比較し、結果を整数の差で返してきます。

System.out.println(Taro_test.compareTo(Hanako_test));

９行目はテストの平均点を比較しています。結果から太郎の平均点は花子の平均点より７点低いことがわかります。

System.out.println(Taro.compareTo(Hanako));

11行目は身長を比較しています。結果から太郎の身長は花子より10cm高いことがわかります。

処理内容は全く違いますが、「compareTo」メソッドの使い方は全く同じことが確認できたと思います。インターフェースを実装することによりメソッドの使い方を強制的に同じにしてるともいえます。処理は違うが同じように使えるというオブジェクト指向の特徴のひとつ「ポリモーフィズム（=多様性)」です。

抽象とは

抽象という意味を「goo辞書」で調べてみました。

事物や表象を、ある性質・共通性・本質に着目し、それをひき出して把握すること

反対語をみてみると「具体」とあったので簡単にいえば

抽象とは具体的でないこと

プログラムでのイメージをつかめればいいのでこの程度の理解でいいでしょう。
では何が具体的でないのか詳しくみていきます。

(1)動物ロボットの設計図

動物ロボットの共通的性質や機能を集めた設計図です。動物ロボットには「寝る」という機能と「鳴く」という機能をつけます。「寝る」という機能は犬や猫でも共通プログラムとして設計できたとします。しかし「鳴く」という機能は、犬は「ﾜﾝﾜﾝ」と鳴き、猫は「ﾆｬﾝﾆｬﾝ」と鳴き異なります。そこで「鳴く」という処理は、設計を書く枠だけ準備しといて具体的な処理の内容は犬ロボット担当者や猫ロボット担当者に任せるとします。どんな鳴き方かは全く示さないで、とりあえず「鳴く」という機能がほしいと抽象的に書いています。未完成な設計図だといえます。

(2)犬ロボット、猫ロボットの拡張設計

動物ロボットの設計図は未完成でした。「鳴く」機能の設計が書かれていません。そこで犬ロボットと猫ロボットの担当者が「鳴く」機能について具体的な設計を記述します。これはベースとなる設計図の機能を変更するとも考えることができます。このような考えは「オーバーライド」で記事にしたのでこちらを参考にしてください。

(3)設計図の見方

設計図にはベースとなる部分が書かれたものと、変更（具体的記載）が書かれたものがあります。実際にロボット製作するときは当然両方の設計図をみて作成します。上図では、「寝る」という機能は犬ロボットと猫ロボット共通ですが、「鳴く」という機能は犬は「ﾜﾝﾜﾝ」、猫は「ﾆｬﾝﾆｬﾝ」と異なります。

サンプル

【Animal.class】

abstract class  Animal{
	// 寝る（通常メソッド）
    void sleep(){
    	System.out.println("寝ています ZZzz…");
    }
	// 鳴く（抽象メソッド）
	abstract void bark();
}

動物ロボットの共通機能を集めた設計図です。「sleepメソッド（※寝る）」には具体的な処理が書かれていますが「barkメソッド（※鳴く）」には何も処理が書かれていません。「鳴く」という処理は犬ロボットや猫ロボットで処理内容が異なるのでここでは何も記述せず、とりあえず「鳴く」という機能がほしいと抽象的に書いています。「barkメソッド（※鳴く）」は必ず犬ロボット担当者や猫ロボット担当者に具体的な処理を書いてもらわないといけないので合図が必要です。そこで抽象メソッドであることを示すためメソッド名の前に「abstract」と記述します。

abstract 返却値の型 メソッド名 (引数・・・) {}

これで継承先である犬ロボットクラスや猫ロボットクラスは「barkメソッド（※鳴く）」を記述しないと設計図が未完成のままであるためインスタンス化できなくなります。
また、このクラスは未完成であると合図しておきます。合図は同じで「abstract」です。

abstract class クラス名 {　・・・ }

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

【Dog.class】

class Dog extends Animal{
	// 鳴く
	void bark(){
		System.out.println("ﾜﾝﾜﾝ");
	}
}

【Cat.class】

class Cat extends Animal{
	// 鳴く
	void bark(){
		System.out.println("ﾆｬﾝﾆｬﾝ");
	}
}

DogクラスとCatクラスは抽象クラスであるAnimalクラスを継承しています。抽象クラスは未完成な設計図でした。そこで具体的処理の書いていない抽象メソッドをオーバーライドして処理を記述します。これで全ての機能の処理が書かれ設計図が完成しました。

【Sample.java】

public class Sample {
    public static void main(String[] args) {
    	Dog dog_robot = new Dog();
    	Cat cat_robot = new Cat();

    	dog_robot.sleep();
    	dog_robot.bark();
    	cat_robot.sleep();
    	cat_robot.bark();
    }
}

完成した設計図ができればインスタンス化ができます。ここまでの処理の流れは「オーバーライド」と同じです。抽象クラスにすることにより「オーバーライド」を強制的にしています。

抽象クラスからインスタンスを生成できない

public class Sample {
    public static void main(String[] args) {
    	Animal robot = new Animal();
    }
}

Exception in thread "main" java.lang.Error:
                     Unresolved compilation problem:
	型 Animal のインスタンスを生成できません

抽象クラスからインスタンスを生成してみます。結果はエラーになります。抽象クラスは未完成な設計図でした。設計図が完成していないのですからその設計図から物をつくることはできません。

抽象メソッドをオーバーライドしない場合

class Dog extends Animal{
}

Exception in thread "main" java.lang.Error:
                     Unresolved compilation problem:
	型 Dog は継承された抽象メソッド Animal.bark() を
　　　　　　　　実装する必要があります

抽象クラスを継承して抽象メソッドをオーバーライドしない場合、エラーになります。このDogクラスには「abstract」がないので完成した設計図を表します。しかし抽象メソッドをオーバーライドしていないので具体的な処理が書かれていないメソッドが残っています。完成したと言っておきながら未完成要素が残っているのでエラーになります。このDogクラスも抽象クラスにすればエラーになりません。未完成なクラスと言っているので未完成要素が含まれていても問題ありません。最終的に未完成要素がなくなればOKです。

サンプル

【SuperClass.java】

class SuperClass {
    //メソッド
    void method(){
    	System.out.println("スーパークラス : メソッド");
    }
    //メソッド
    void method(int x){
    	System.out.println("スーパークラス : メソッド（引数あり)");
    }
}

スーパークラスではメソッドを2つ用意しました。2つともメソッド名は「method」で仮引数の型や個数が違う「オーバーロード」です。仮引数の型や個数が違うので、引数のパターンからどの「method」メソッドを実行するのか区別できます。

【SubClass.java】

class SubClass extends SuperClass {
    //メソッド
    void method(){
    	System.out.println("サブクラス : メソッド");
    }
    void method(char x){
    	System.out.println("サブクラス : メソッド (引数あり)");
    }
}

「SubClass」は「SuperClass」を継承しているので「SuperClass」の2つのメソッドを引き継ぎます。さらに「SubClass」でも同じ名前のメソッドを2つ追加しました。
「SubClass」で追加した2つの「method」メソッドについて詳しくみていきます。

void method(){

3行目で宣言したメソッドです。メソッド名「method」で引数なしのパターンはスーパークラスで既に宣言しています。このままでは引数なしの「method」メソッドを呼び出したときにスーパークラスで宣言したメソッドなのかサブクラスで宣言したメソッドなのかわかりません。そこでこのような場合はサブクラスで宣言したメソッドを実行します。実質スーパークラスのメソッドをサブクラスで上書きしたことになり、このような処理を「オーバーライド」といいます。

void method(char x){

6行目で宣言したメソッドです。仮引数が char型の「method」メソッドはスーパークラスにはありません。よってこのメソッドの追加は拡張です。しかし「method」という名前は他に既にあるのでオーバーロード対象のメソッドになります。

【Sample.java】

public class Sample {
    public static void main(String[] args) {
    	SubClass obj = new SubClass();
    	obj.method();
    	obj.method(1);
    	obj.method('a');
    }
}

「SubClass」で利用できるメソッドは、引数パターンが異なる「method」メソッド３種類でした。
４行目は引数がありません。引数のないパターンはスーパークラスにもサブクラスにもありましたが、オーバーライドによりサブクラスの宣言で上書きされています。サブクラスの処理が実行されていることがわかります。５行目は int型の引数をもつパターンです。スーパークラスで宣言しそのまま継承されています。６行目はchar型の引数をもつパターンです。サブクラスで新規に宣言しました。

以上で「オーバーロード」と「オーバーライド」についてみてきました。同じ名前のメソッド名を複数扱うなど似ている箇所もありますが、意味や処理が全く違うので間違えないように注意してください。

オーバーライドとは

※wikipedia引用

オブジェクト指向プログラミングにおいてオーバーライド (override)とは、スーパークラスで定義されたメソッドをサブクラスで定義しなおし動作を上書きすることである。
あるクラスAにメソッドMethodがあり、あるクラスSubAがクラスAを継承したとする。そのとき、クラスSubAはクラスAにあるメソッドMethodをオーバーライドすることにより、再定義することができる。これはオブジェクト指向プログラミングにおけるポリモーフィズムを実現する際によく使われる。

動物ロボットの設計図をサンプルとして考え方を説明します。

(1)動物ロボットの設計図

動物ロボットの機能を集めた設計図です。「食べる・寝る」といった機能仕様が書かれています。

(2)哺乳類動物ロボット、鳥類動物ロボットの拡張設計

「犬は歩き、鳥は空を飛び、魚は泳ぐ」など動物ロボットの種類によっては特有の属性や機能がでてきます。また「寝る」という機能も動物によって違いがでてきます。そのような場合、ベースとなる動物ロボット設計図はそのまま利用し、属性や機能の拡張部分や変更部分を別の設計図として作ります。サンプルでは犬や猫などの哺乳類ロボット設計図には「歩く」という機能を追加し、鳥類ロボットの設計図には「飛ぶ」という機能を追加しました。また鳥類ロボットは「寝る」という機能を変更しています。

(3)設計図の見方

設計図にはベースとなる部分が書かれたものと、拡張や変更が書かれたものがあります。実際にロボット製作するときは当然両方の設計図をみて作成します。サンプルでは、哺乳類ロボットはベース部分に「歩く」という機能が追加されたもの、鳥類ロボットはベース部分に「飛ぶ」という機能が追加されたものができます。また鳥類ロボットは「寝る」という機能が変更されていますので変更内容も反映します。

サンプル

【Animal.java】

class Animal {
    //メソッド
    void eat(){        //食べる
    	System.out.println("食べています ﾑｼｬﾑｼｬ");
    }
    void sleep(){      //寝る
    	System.out.println("寝ています ZZzz…");
    }
}

動物ロボットの共通機能を集めた設計図です。「eat : 食べる」と「sleep : 寝る」の2つのメソッドがあります。

【Mammal.java】

class Mammal extends Animal {
    //メソッド
    void walk(){
    	System.out.println("歩いています");
    }
}

【Birds.java】

class Birds extends Animal {
    //メソッド
    void fly(){
    	System.out.println("飛んでいます");
    }
    void sleep(){   //※オーバーロード
    	System.out.println("寝ています。すやすや ");
    }
}

哺乳類ロボットの拡張部分の「Mammal」クラスと、鳥類ロボットの拡張部分「Birds」クラスです。「Birds」クラスにはスーパークラスと同じメソッド名の「sleep」があります。これはサブクラスで「sleep」メソッドを上書きしています。サブクラスでスーパークラスと同じメソッド名を定義することにより、スーパークラスのメソッド内容を変更することができます。この上書き定義を「オーバーライド」といいます。

【Sample.java】

public class Sample {
    public static void main(String[] args) {
    	Mammal mammal_robot = new Mammal();
    	Birds  birds_robot  = new Birds();

    	mammal_robot.sleep();
    	System.out.println("--------------");
    	birds_robot.sleep();
    }
}

6行目では「mammal」クラスのインスタンスのsleepメソッドを実行しています。8行目では「Birds」クラスのインスタンスのsleepメソッドを実行しています。同じsleepメソッドですが実行結果が違います。「mammal」クラスはスーパークラスのsleepメソッドを継承しそのまま内容を実行しています。それに対して「Birds」クラスはスーパークラスのsleepメソッドを上書きし、上書きした内容が実行されています。

スーパークラスのコンストラクタを実行

【Animal .java】

class Animal {
    Animal (){        //(1)
    	System.out.println("スーパークラスのコンストラクタ1");
    }
    Animal (int x){   //(2)
    	System.out.println("スーパークラスのコンストラクタ2");
    }
}

スーパークラスです。コンストラクタをオーバーロードしています。

【Birds.java】

class Birds extends Animal {
    Birds (){
    	super(1);
    	System.out.println("サブクラスのコンストラクタ");
    }
}

コンストラクタはインスタンスの生成時に一度だけ呼び出されます。別のコンストラクタを呼び出すときもコンストラクタ内からでないとエラーになります。スーパークラスのコンストラクタの呼び出しは4行目のように

で記述します。superに指定した引数の型や引数の数により、スーパークラスのどのコンストラクタを呼び出すか判断されます。スーパークラスののコンストラクタを実行した後、自分のコンストラクタ処理の続きを行います。

【Sample.java】

public class Sample {
    public static void main(String[] args) {
    	Birds birds  = new Birds();
    }
}

Birdsクラスの3行目の super でスーパークラスであるAnimal クラスのコンストラクタ(2)が呼び出され、その後に自分のコンストラクタの続きが実行されているのがわかります。

super(仮引数,　・・・）の位置

class Birds extends Animal {
    Birds (){
    	System.out.println("サブクラスのコンストラクタ");
    	super(1);
    }
}

Exception in thread "main" java.lang.Error:
                     Unresolved compilation problem:
	コンストラクター呼び出しは、コンストラクター内の
        最初のステートメントである必要があります

「super」の位置には制約があります。コンストラクタの一番最初に記述しなければなりません。サンプルのようにコンストラクタの最初のステートメントに書かないとエラーになります。

super(仮引数,　・・・）の省略

サブクラスのコンストラクタでスーパークラスのコンストラクタの呼び出す処理を記述しない場合、どのような処理がされるかみていきます。

【Animal .java】

class Animal {
    Animal (){        //(1)
    	System.out.println("スーパークラスのコンストラクタ1");
    }
    Animal (int x){   //(2)
    	System.out.println("スーパークラスのコンストラクタ2");
    }
}

【Birds.java】

class Birds extends Animal {
    Birds (){
    	System.out.println("サブクラスのコンストラクタ");
    }
}

※コンストラクタに super(仮引数,　・・・） の記述がない

【Sample.java】

public class Sample {
    public static void main(String[] args) {
    	Birds birds  = new Birds();
    }
}

サブクラスであるBirdsクラスのコンストラクタにスーパークラスの呼び出し super(..) がありません。結果をみてみると「スーパークラスのコンストラクタ1」が表示されています。この処理はスーパークラスの引数がないコンストラクタの処理です。つまり、

サブクラスでスーパークラスのコンストラクタの呼び出しを記述しない場合は、自動的にスーパークラスの引数なしのコンストラクタが実行される。

サブクラスでスーパークラスの呼び出しを記述しない場合、スーパークラスには必ず引数なしのコンストラクタを準備する必要があります。もし記述しなければ呼び出し先がないためにエラーになります。しかしスーパークラスにコンストラクタの定義が1つもない場合は、デフォルトコンストラクタが呼び出されるのでエラーにはなりません。引数のあるコンストラクタのみをスーパークラスで定義するときは注意が必要です。

※デフォルトコンストラクタについては「コンストラクタ」記事を参考に