1月, 2018 | Teaching Programming

クラスの継承（まとめ）

継承とは

継承するとメンバーを受け継ぐ（メンバーのアクセス修飾子に注意）
継承の元となるクラス（親）は「スーパークラス」、継承によって作られた新しいクラス（子）は「サブクラス」
Javaの継承は「単一継承（親は1つだけ）」で、すべてのクラスの祖先となるのはObjectクラス（extendsを書かないクラスはextends Objectが省略されていると考えれば良い）。

（メンバーを受け継ぐことに加え）サブクラスでできること

メンバーを加えることができる（メンバーを加えない≒スーパークラスと同じ、なので加えないと意味がない）
「super」でサブクラスからスーパークラスのメソッド（コンストラクタを含む）を呼び出すことができる
スーパークラスにあるメソッドをオーバーライド（上書き）することができる

継承の使い所

（なんらかの理由でクラスのメンバーの追加・修正ができない場合に）継承して機能を拡張する。
共通部分をスーパークラスとしてまとめ、個別の機能をサブクラスで記述する（この用途には「抽象クラス（教科書P.114）」が適切な場合がある）
同じように呼び出すことができるメソッドを持たせる（この用途には「インタフェース（教科書P.116）」が適切な場合がある）。
etc…

クラスの継承(2)

前回のまとめ

継承するとメンバーを受け継ぐ
ただしメンバーのアクセス修飾子に注意
継承の元となるクラスは「スーパークラス」、継承によって作られた新しいクラスは「サブクラス」
super: サブクラスからスーパークラスのメソッド（コンストラクタを含む）を呼び出すことができる
スーパークラスにあるメソッドをオーバーライド（上書き）することができる

サブクラスからスーパークラスへのキャスト

コード全体: Main1.java

サブクラスはスーパークラスのメンバーをすべて持っている。
よって、サブクラスのインスタンスはスーパークラスのインスタンスとみなしても（として扱っても）大丈夫だ。

実際に、次のようなコードが書ける。

package d00000.lecture12;

import d00000.lecture11.Book;
import d00000.lecture11.Comic;


public class Main1 {
    public static void main(String[] args) {

        Book book = new Book("ブック", "作者A", 1000);
        Comic comic = new Comic("コミック", "作者B", 2000, 1, false);

        // スーパークラスのインスタンスとして名前をつけることができる。
        Book comicAsBook = (Book)comic;

        // comicとcomicAsBookは同じインスタンスだが、comicAsBookで使うとBookのインスタンスという扱いになる。
        // つまりBookのメンバーしか使えない
        System.out.println(comic.getTitleWithVolume());
        // System.out.println(comicAsBook.getTitleWithVolume()); // コンパイルエラーになるためコメントにしてある

        // スーパークラスの配列にサブクラスのインスタンスを入れることができる。
        Book[] bookList = new Book[2];
        bookList[0] = book;
        bookList[1] = comic;
        // 上記は
        // bookList[1] = comicAsBook;
        // あるいは
        // bookList[1] = (Book)comic;
        // と同じ

        // comicAsBookの場合と同様にbookList[1]に入っているのはComicクラスのインスタンスだが
        // Comicクラスのメソッドは使えない。
        // System.out.println(bookList[1].getTitleWithVolume()); // コンパイルエラーになるためコメントにしてある

        // オーバーライドしたメソッドはどちらが使われるか。
        System.out.println(comic.getTaxIncludedPrice());
        System.out.println(comicAsBook.getTaxIncludedPrice());
        // どちらの型で呼ばれているかに関係なく、インスタンスの型のメソッドが使われる
        // 配列の場合も同様
        for (int i=0; i<bookList.length; i++) {
            System.out.println(bookList[i].getInfoAsCsv());
        }
    }
}

Book book = new Book("ブック", "作者A", 1000);

Comic comic = new Comic("コミック", "作者B", 2000, 1, false);

// スーパークラスのインスタンスとして名前をつけることができる。

Book comicAsBook = (Book)comic;

これは、次のような状況だ。

サブクラスからスーパークラスへのキャスト

comicで使う場合はComicクラスのインスタンスとして扱うことができるが（当たり前）、comicAsBookで使う場合はBookクラスのメンバーしか使えない。つまり

System.out.println(comic.getTitleWithVolume());

1	System.out.println(comic.getTitleWithVolume());

は実行できるが、

System.out.println(comicAsBook.getTitleWithVolume());

1	System.out.println(comicAsBook.getTitleWithVolume());

はコンパイルエラーになる。

これができると何が嬉しいのだろうか？1つは「BookとComicを（Bookの情報だけになるが）同じように扱える」ということだ。前回は
BookとComicでそれぞれ配列を作ってデータを扱っていたが、まとめてBookの配列として扱うことができる。つまり、

package d00000.lecture12;

import d00000.lecture11.Book;
import d00000.lecture11.Comic;


public class Main1 {
    public static void main(String[] args) {

        Book book = new Book("ブック", "作者A", 1000);
        Comic comic = new Comic("コミック", "作者B", 2000, 1, false);

        // スーパークラスのインスタンスとして名前をつけることができる。
        Book comicAsBook = (Book)comic;

        // comicとcomicAsBookは同じインスタンスだが、comicAsBookで使うとBookのインスタンスという扱いになる。
        // つまりBookのメンバーしか使えない
        System.out.println(comic.getTitleWithVolume());
        // System.out.println(comicAsBook.getTitleWithVolume()); // コンパイルエラーになるためコメントにしてある

        // スーパークラスの配列にサブクラスのインスタンスを入れることができる。
        Book[] bookList = new Book[2];
        bookList[0] = book;
        bookList[1] = comic;
        // 上記は
        // bookList[1] = comicAsBook;
        // あるいは
        // bookList[1] = (Book)comic;
        // と同じ

        // comicAsBookの場合と同様にbookList[1]に入っているのはComicクラスのインスタンスだが
        // Comicクラスのメソッドは使えない。
        // System.out.println(bookList[1].getTitleWithVolume()); // コンパイルエラーになるためコメントにしてある

        // オーバーライドしたメソッドはどちらが使われるか。
        System.out.println(comic.getTaxIncludedPrice());
        System.out.println(comicAsBook.getTaxIncludedPrice());
        // どちらの型で呼ばれているかに関係なく、インスタンスの型のメソッドが使われる
        // 配列の場合も同様
        for (int i=0; i<bookList.length; i++) {
            System.out.println(bookList[i].getInfoAsCsv());
        }
    }
}

// スーパークラスの配列にサブクラスのインスタンスを入れることができる。

Book[] bookList = new Book[2];

bookList[0] = book;

bookList[1] = comic;

とすることができる。ただし、bookList[1]は本来Comicだが、Book扱いになる。

Book扱いになる（つまりComicで追加されたメンバーは使えない）が、オーバーライドされたメソッドはどういう扱いになるのだろうか。
次の実行結果を確認しよう。

package d00000.lecture12;

import d00000.lecture11.Book;
import d00000.lecture11.Comic;


public class Main1 {
    public static void main(String[] args) {

        Book book = new Book("ブック", "作者A", 1000);
        Comic comic = new Comic("コミック", "作者B", 2000, 1, false);

        // スーパークラスのインスタンスとして名前をつけることができる。
        Book comicAsBook = (Book)comic;

        // comicとcomicAsBookは同じインスタンスだが、comicAsBookで使うとBookのインスタンスという扱いになる。
        // つまりBookのメンバーしか使えない
        System.out.println(comic.getTitleWithVolume());
        // System.out.println(comicAsBook.getTitleWithVolume()); // コンパイルエラーになるためコメントにしてある

        // スーパークラスの配列にサブクラスのインスタンスを入れることができる。
        Book[] bookList = new Book[2];
        bookList[0] = book;
        bookList[1] = comic;
        // 上記は
        // bookList[1] = comicAsBook;
        // あるいは
        // bookList[1] = (Book)comic;
        // と同じ

        // comicAsBookの場合と同様にbookList[1]に入っているのはComicクラスのインスタンスだが
        // Comicクラスのメソッドは使えない。
        // System.out.println(bookList[1].getTitleWithVolume()); // コンパイルエラーになるためコメントにしてある

        // オーバーライドしたメソッドはどちらが使われるか。
        System.out.println(comic.getTaxIncludedPrice());
        System.out.println(comicAsBook.getTaxIncludedPrice());
        // どちらの型で呼ばれているかに関係なく、インスタンスの型のメソッドが使われる
        // 配列の場合も同様
        for (int i=0; i<bookList.length; i++) {
            System.out.println(bookList[i].getInfoAsCsv());
        }
    }
}

// オーバーライドしたメソッドはどちらが使われるか。

System.out.println(comic.getTaxIncludedPrice());

System.out.println(comicAsBook.getTaxIncludedPrice());

// どちらの型で呼ばれているかに関係なく、インスタンスの型のメソッドが使われる

// 配列の場合も同様

for (int i=0; i<bookList.length; i++) {

System.out.println(bookList[i].getInfoAsCsv());

}

コメントにも書いてある通り、「どのクラスとして扱っているか」ではなく、「インスタンス化した時のクラス」の実装が使われる。

すべてのクラスはObjectクラスを継承している

コード全体: Magazine.java, Main2.java, Main3.java

雑誌を表すMagazineクラスを作ってみよう。

public class Magazine extends Book {
    public int year;
    public int month;

    public Magazine(String title, String author, int price, int year, int month) {
        super(title, author, price);
        this.year = year;
        this.month = month;
    }

    @Override
    public String getInfoAsCsv() {
        return super.getInfoAsCsv() + "," + year + "年" + month + "月";
    }
}

public class Magazine extends Book {

public int year;

public int month;

public Magazine(String title, String author, int price, int year, int month) {

super(title, author, price);

this.year = year;

this.month = month;

}

@Override

public String getInfoAsCsv() {

return super.getInfoAsCsv() + "," + year + "年" + month + "月";

}

Objectクラス

オーバーライドする時にIDEを使うと、候補となるメソッドが表示されるが、Bookクラスで定義していないメソッドがあるのが確認できるはず。これはObjectクラスのメソッドである。
実は（Objectクラスを除く）すべてのクラスはObjectクラスを継承している。正確には「extends」で指定しない場合には、Objectクラスが自動的に継承される。
つまり「Objectを継承したBook」を継承しているのがMagazineという関係である。

すべてのクラスがObjectを継承しているのなら、Objectの配列は参照型ならすべて格納できる、ということになる。

package d00000.lecture12;

import d00000.lecture11.Book;
import d00000.lecture11.Comic;

public class Main2 {
    public static void main(String[] args) {
        Object[] objectList = new Object[4];
        objectList[0] = "文字列";
        objectList[1] = new Book("ブック", "著者1", 1000);
        objectList[2] = new Comic("コミック", "著者2", 2000, 2, false);
        objectList[3] = new Magazine("雑誌", "編集部", 500, 2018, 1);

        // System.out.printlnでそのまま表示
        System.out.println("そのまま表示");
        for (int i  = 0; i<objectList.length; i++) {
            System.out.println(objectList[i]);
        }
        System.out.println();

        // Bookとして扱えるものだけCSVを出力する
        System.out.println("Bookとして扱えるものだけCSVを出力する");
        for (int i  = 0; i<objectList.length; i++) {
            if (objectList[i] instanceof Book) {
                Book b = (Book)objectList[i];
                System.out.println(b.getInfoAsCsv());
            }
        }
        System.out.println();
    }
}

Object[] objectList = new Object[4];

objectList[0] = "文字列";

objectList[1] = new Book("ブック", "著者1", 1000);

objectList[2] = new Comic("コミック", "著者2", 2000, 2, false);

objectList[3] = new Magazine("雑誌", "編集部", 500, 2018, 1);

toStringメソッド

ここでは、toStringメソッドをオーバーライドしてみよう。これにより、System.out.printlnの引数として指定した時に表示する文字列を指定することができる。

package d00000.lecture12;

import d00000.lecture11.Book;

public class Magazine extends Book {
    public int year;
    public int month;

    public Magazine(String title, String author, int price, int year, int month) {
        super(title, author, price);
        this.year = year;
        this.month = month;
    }

    @Override
    public String getInfoAsCsv() {
        return super.getInfoAsCsv() + "," + year + "年" + month + "月";
    }

    @Override
    public String toString() {
        return title + " " + year + "年" + month + "号";
    }

    // 注: このequalsメソッドはサンプルのため不十分
    // IDEで生成するかLombokを利用する方が良い
    @Override
    public boolean equals(Object object) {
        if (!(object instanceof Magazine)) {
            return false;
        }
        Magazine another = (Magazine)object;
        if (!title.equals(another.title)) {
            return false;
        }
        if (!author.equals(another.author)) {
            return false;
        }
        if (price != another.price) {
            return false;
        }
        if (year != another.year) {
            return false;
        }
        if (month != another.month) {
            return false;
        }
        return true;
    }
}

@Override

public String toString() {

return title + " " + year + "年" + month + "号";

}

では、確認しよう。

package d00000.lecture12;

import d00000.lecture11.Book;
import d00000.lecture11.Comic;

public class Main2 {
    public static void main(String[] args) {
        Object[] objectList = new Object[4];
        objectList[0] = "文字列";
        objectList[1] = new Book("ブック", "著者1", 1000);
        objectList[2] = new Comic("コミック", "著者2", 2000, 2, false);
        objectList[3] = new Magazine("雑誌", "編集部", 500, 2018, 1);

        // System.out.printlnでそのまま表示
        System.out.println("そのまま表示");
        for (int i  = 0; i<objectList.length; i++) {
            System.out.println(objectList[i]);
        }
        System.out.println();

        // Bookとして扱えるものだけCSVを出力する
        System.out.println("Bookとして扱えるものだけCSVを出力する");
        for (int i  = 0; i<objectList.length; i++) {
            if (objectList[i] instanceof Book) {
                Book b = (Book)objectList[i];
                System.out.println(b.getInfoAsCsv());
            }
        }
        System.out.println();
    }
}

// System.out.printlnでそのまま表示

System.out.println("そのまま表示");

for (int i = 0; i<objectList.length; i++) {

System.out.println(objectList[i]);

}

System.out.println();

instanceof演算子とスーパークラスからサブクラスへのキャスト

Object型のままだと、その中のインスタンスが何であってもできることが限られる。実際のインスタンスの型を判別してキャストしよう。型の判別にはinstanceof演算子（教科書P.126）を使う。instanceof演算子で、「指定した型にキャストできるか」を判断することができる。Bookクラスにキャストできる（つまりBookクラスかBookの子孫となるクラス）かどうか判別してCSVを出力してみよう。

package d00000.lecture12;

import d00000.lecture11.Book;
import d00000.lecture11.Comic;

public class Main2 {
    public static void main(String[] args) {
        Object[] objectList = new Object[4];
        objectList[0] = "文字列";
        objectList[1] = new Book("ブック", "著者1", 1000);
        objectList[2] = new Comic("コミック", "著者2", 2000, 2, false);
        objectList[3] = new Magazine("雑誌", "編集部", 500, 2018, 1);

        // System.out.printlnでそのまま表示
        System.out.println("そのまま表示");
        for (int i  = 0; i<objectList.length; i++) {
            System.out.println(objectList[i]);
        }
        System.out.println();

        // Bookとして扱えるものだけCSVを出力する
        System.out.println("Bookとして扱えるものだけCSVを出力する");
        for (int i  = 0; i<objectList.length; i++) {
            if (objectList[i] instanceof Book) {
                Book b = (Book)objectList[i];
                System.out.println(b.getInfoAsCsv());
            }
        }
        System.out.println();
    }
}

// Bookとして扱えるものだけCSVを出力する

System.out.println("Bookとして扱えるものだけCSVを出力する");

for (int i = 0; i<objectList.length; i++) {

if (objectList[i] instanceof Book) {

Book b = (Book)objectList[i];

System.out.println(b.getInfoAsCsv());

}

System.out.println();

equalsメソッド

参照型の比較には==が使えない場合が多い。比較が必要なクラスはObjectクラスのequalsメソッドをオーバーライドする、という慣例になっている（「慣例」と書いたが、多くのライブラリが前提としてるので、ほぼルールと言って良い）。
例えば、文字列の比較の例を見てみよう。

package d00000.lecture12;

import d00000.lecture11.Book;

public class Main3 {
    public static void main(String[] args) {
        String s1 = "あいうえお".substring(1, 4); // いうえ
        String s2 = "あいうえお".substring(1, 4); // いうえ

        // 文字列の==による比較
        if (s1 == s2) {
            System.out.println("s1とs2は同じ");
        } else {
            System.out.println("s1とs2は違う");
        }

        // 文字列のequalsメソッドによる比較
        if (s1.equals(s2)) {
            System.out.println("s1とs2は同じ");
        } else {
            System.out.println("s1とs2は違う");
        }

        // equalsメソッドをオーバライドしていないBookの比較
        Book b1 = new Book("ブック", "著者", 1000);
        Book b2 = new Book("ブック", "著者", 1000);
        if (b1.equals(b2)) {
            System.out.println("b1とb2は同じ");
        } else {
            System.out.println("b1とb2は違う");
        }

        // equalsメソッドをオーバライドしているMagazineの比較
        Magazine m1 = new Magazine("雑誌", "編集部", 500, 2018, 1);
        Magazine m2 = new Magazine("雑誌", "編集部", 500, 2018, 1);
        if (m1.equals(m2)) {
            System.out.println("m1とm2は同じ");
        } else {
            System.out.println("m1とm2は違う");
        }

    }
}

String s1 = "あいうえお".substring(1, 4); // いうえ

String s2 = "あいうえお".substring(1, 4); // いうえ

// 文字列の==による比較

if (s1 == s2) {

System.out.println("s1とs2は同じ");

} else {

System.out.println("s1とs2は違う");

}

// 文字列のequalsメソッドによる比較

if (s1.equals(s2)) {

System.out.println("s1とs2は同じ");

} else {

System.out.println("s1とs2は違う");

}

Magazineのequalsメソッドをオーバーライドしてみよう。

package d00000.lecture12;

import d00000.lecture11.Book;

public class Magazine extends Book {
    public int year;
    public int month;

    public Magazine(String title, String author, int price, int year, int month) {
        super(title, author, price);
        this.year = year;
        this.month = month;
    }

    @Override
    public String getInfoAsCsv() {
        return super.getInfoAsCsv() + "," + year + "年" + month + "月";
    }

    @Override
    public String toString() {
        return title + " " + year + "年" + month + "号";
    }

    // 注: このequalsメソッドはサンプルのため不十分
    // IDEで生成するかLombokを利用する方が良い
    @Override
    public boolean equals(Object object) {
        if (!(object instanceof Magazine)) {
            return false;
        }
        Magazine another = (Magazine)object;
        if (!title.equals(another.title)) {
            return false;
        }
        if (!author.equals(another.author)) {
            return false;
        }
        if (price != another.price) {
            return false;
        }
        if (year != another.year) {
            return false;
        }
        if (month != another.month) {
            return false;
        }
        return true;
    }
}

// 注: このequalsメソッドはサンプルのため不十分

// IDEで生成するかLombokを利用する方が良い

@Override

public boolean equals(Object object) {

if (!(object instanceof Magazine)) {

return false;

}

Magazine another = (Magazine)object;

if (!title.equals(another.title)) {

return false;

}

if (!author.equals(another.author)) {

return false;

}

if (price != another.price) {

return false;

}

if (year != another.year) {

return false;

}

if (month != another.month) {

return false;

}

return true;

}

結果を確認しよう。

package d00000.lecture12;

import d00000.lecture11.Book;

public class Main3 {
    public static void main(String[] args) {
        String s1 = "あいうえお".substring(1, 4); // いうえ
        String s2 = "あいうえお".substring(1, 4); // いうえ

        // 文字列の==による比較
        if (s1 == s2) {
            System.out.println("s1とs2は同じ");
        } else {
            System.out.println("s1とs2は違う");
        }

        // 文字列のequalsメソッドによる比較
        if (s1.equals(s2)) {
            System.out.println("s1とs2は同じ");
        } else {
            System.out.println("s1とs2は違う");
        }

        // equalsメソッドをオーバライドしていないBookの比較
        Book b1 = new Book("ブック", "著者", 1000);
        Book b2 = new Book("ブック", "著者", 1000);
        if (b1.equals(b2)) {
            System.out.println("b1とb2は同じ");
        } else {
            System.out.println("b1とb2は違う");
        }

        // equalsメソッドをオーバライドしているMagazineの比較
        Magazine m1 = new Magazine("雑誌", "編集部", 500, 2018, 1);
        Magazine m2 = new Magazine("雑誌", "編集部", 500, 2018, 1);
        if (m1.equals(m2)) {
            System.out.println("m1とm2は同じ");
        } else {
            System.out.println("m1とm2は違う");
        }

    }
}

// equalsメソッドをオーバライドしていないBookの比較

Book b1 = new Book("ブック", "著者", 1000);

Book b2 = new Book("ブック", "著者", 1000);

if (b1.equals(b2)) {

System.out.println("b1とb2は同じ");

} else {

System.out.println("b1とb2は違う");

}

// equalsメソッドをオーバライドしているMagazineの比較

Magazine m1 = new Magazine("雑誌", "編集部", 500, 2018, 1);

Magazine m2 = new Magazine("雑誌", "編集部", 500, 2018, 1);

if (m1.equals(m2)) {

System.out.println("m1とm2は同じ");

} else {

System.out.println("m1とm2は違う");

}

クラスの継承(1)

前回のまとめ

型は大別してプリミティブ型と参照型の2つ。
プリミティブ型は「箱」のイメージでOK。代入は「値をコピー」
参照型は「商品タグ」のイメージ。インスタンスを指し示すのがインスタンス名（変数名）。代入は「商品タグが同じところに繋がる（ポインターのコピー）」
プリミティブ型と参照型では、代入や比較等で（初学者にとって）直感的でない違いがあるので注意する。この違いはコードを実行して確かめること。
文字列や配列は参照型。よく使われるので「特別扱い」されている（使いやすくなっている）。

クラスの継承

本を管理する

（書店を経営しているつもりになって、あるいは自分の蔵書について）本を管理するソフトを作ることを考えよう。まず、本（小説とか）を管理するクラスを作ろう。

package d00000.lecture11;

public class Book {
    /** 書籍名 */
    public String title;
    /** 著者 */
    public String author;
    /** 本体価格 */
    public int price;

    /** コンストラクタ */
    public Book(String title, String author, int price) {
        this.title = title;
        this.author = author;
        this.price = price;
    }

    /** 税込価格を算出 */
    public int getTaxIncludedPrice() {
        return (int) (price * 1.08);
    }

    /** 情報をCSV形式（カンマ区切り）で取得 */
    public String getInfoAsCsv() {
        String csv = title + "," + author + "," + getTaxIncludedPrice();
        return csv;
    }

}

package d00000.lecture11;

public class Book {

/** 書籍名 */

public String title;

/** 著者 */

public String author;

/** 本体価格 */

public int price;

/** コンストラクタ */

public Book(String title, String author, int price) {

this.title = title;

this.author = author;

this.price = price;

}

/** 税込価格を算出 */

public int getTaxIncludedPrice() {

return (int) (price * 1.08);

}

/** 情報をCSV形式（カンマ区切り）で取得 */

public String getInfoAsCsv() {

String csv = title + "," + author + "," + getTaxIncludedPrice();

return csv;

}

このクラスを使った例を次に示す。

package d00000.lecture11;

public class Main1 {
    public static void main(String[] args) {
        Book[] bookList = new Book[4];
        bookList[0] = new Book("走れメロス", "太宰治", 2000);
        bookList[1] = new Book("羅生門", "芥川龍之介", 1000);
        bookList[2] = new Book("怪人二十面相", "江戸川乱歩", 3000);
        bookList[3] = new Book("ハリー・ポッター", "J・K・ローリング", 2000);

        // 価格が最も高い本を探す（ただし同じ価格は考慮しない）
        Book expensiveBook = bookList[0];
        for (int i = 1; i < bookList.length; i++) {
            if (expensiveBook.price > bookList[i].price) {
                expensiveBook = bookList[i];
            }
        }
        System.out.println("最も値段が高い本は" + expensiveBook.title + "で" + expensiveBook.getTaxIncludedPrice() + "円です。");

        System.out.println("-- CSV出力 ここから --");
        for (int i = 0; i < bookList.length; i++) {
            System.out.println(bookList[i].getInfoAsCsv());
        }
        System.out.println("-- CSV出力 ここまで --");
    }
}

package d00000.lecture11;

public class Main1 {

public static void main(String[] args) {

Book[] bookList = new Book[4];

bookList[0] = new Book("走れメロス", "太宰治", 2000);

bookList[1] = new Book("羅生門", "芥川龍之介", 1000);

bookList[2] = new Book("怪人二十面相", "江戸川乱歩", 3000);

bookList[3] = new Book("ハリー・ポッター", "J・K・ローリング", 2000);

// 価格が最も高い本を探す（ただし同じ価格は考慮しない）

Book expensiveBook = bookList[0];

for (int i = 1; i < bookList.length; i++) {

if (expensiveBook.price > bookList[i].price) {

expensiveBook = bookList[i];

}

System.out.println("最も値段が高い本は" + expensiveBook.title + "で" + expensiveBook.getTaxIncludedPrice() + "円です。");

System.out.println("-- CSV出力ここから --");

for (int i = 0; i < bookList.length; i++) {

System.out.println(bookList[i].getInfoAsCsv());

}

System.out.println("-- CSV出力ここまで --");

}

GitHubで見る:

「巻」を管理できるように拡張する

漫画などは「第1巻」、「第2巻」と、同じタイトルでシリーズになっているものが多い。この「巻」の管理はBookクラスではできないので新しくComicクラスを作ることを考えよう。ただし、1から新しく作るのではなく、Bookクラスを元に「巻」に関する情報が扱えるように拡張することを考える。

package d00000.lecture11;

public class Comic extends Book {
    /** 巻数 */
    public int volume;
    /** 全1巻か? */
    public boolean inOneVolume;

    /** コンストラクタ */
    public Comic(String title, String author, int price, int volume, boolean inOneVolume) {
        super(title, author, price); // スーパークラスのコンストラクタを呼ぶ
        this.volume = volume;
        this.inOneVolume = inOneVolume;
    }

    /** 税込価格を算出（オーバーライド） */
    @Override
    public String getInfoAsCsv() {
        if (inOneVolume) {
            // 全1巻の場合は巻数を出力しない（Bookと同じ）
            return super.getInfoAsCsv();
        } else {
            // 複数巻の場合は巻数を出力する
            return super.getInfoAsCsv() + "," + volume;
        }
    }

    /** タイトルと巻数 */
    public String getTitleWithVolume() {
        if (inOneVolume) {
            return title + "（全1巻）";
        } else {
            return title + "（第" + volume + "巻）";
        }
    }

}

package d00000.lecture11;

public class Comic extends Book {

/** 巻数 */

public int volume;

/** 全1巻か? */

public boolean inOneVolume;

/** コンストラクタ */

public Comic(String title, String author, int price, int volume, boolean inOneVolume) {

super(title, author, price); // スーパークラスのコンストラクタを呼ぶ

this.volume = volume;

this.inOneVolume = inOneVolume;

}

/** 税込価格を算出（オーバーライド） */

@Override

public String getInfoAsCsv() {

if (inOneVolume) {

// 全1巻の場合は巻数を出力しない（Bookと同じ）

return super.getInfoAsCsv();

} else {

// 複数巻の場合は巻数を出力する

return super.getInfoAsCsv() + "," + volume;

}

/** タイトルと巻数 */

public String getTitleWithVolume() {

if (inOneVolume) {

return title + "（全1巻）";

} else {

return title + "（第" + volume + "巻）";

}

ポイント:

3行目: 「extends Book」で「Bookクラスを継承する」という意味になる。
- この場合、Bookクラスが「スーパークラス」、Comicクラスが「サブクラス」ととなる。
- Bookクラスにあるメンバー（フィールドとメソッド）が引き継がれる（使える）。
- アクセス修飾子（教科書P.170）によって違いがあるので注意する。
4-7行目: Comicクラスだけで使えるフィールド
9-14行目: Bookクラスとは違うコンストラクタにしたい（インスタンス化時に追加したフィールドに値をセットしたい）ので定義する
11行目: superをメソッドのように使う（括弧をつけて引数を渡す）とスーパークラス（この場合Bookクラス）のコンストラクタが実行される。
16-28行目: 巻の情報も出力したいので、getInfoCSVメソッドを上書き（オーバーライド）する。
17行目: @Overrideアノテーション（教科書P.180）
21,24行目: オーバーライドする前の元のメンバーを使いたい場合は、superに「.」をつけてアクセスする（thisと同じような感じ）。
28-35行目: Comicクラスだけで使えるメソッド

このクラスを使った例を次に示す。

package d00000.lecture11;

public class Main2 {
    public static void main(String[] args) {
        Comic[] comicList = new Comic[5];
        comicList[0] = new Comic("ドラえもん", "藤子・F・不二雄", 500, 1, false);
        comicList[1] = new Comic("ドラえもん", "藤子・F・不二雄", 500, 2, false);
        comicList[2] = new Comic("永沢君", "さくらももこ", 700, 1, true);
        comicList[3] = new Comic("クレヨンしんちゃん", "臼井儀人", 800, 1, false);
        comicList[4] = new Comic("クレヨンしんちゃん", "臼井儀人", 800, 2, false);

        // タイトル一覧
        System.out.println("タイトル一覧");
        for (Comic comic : comicList) {
            System.out.println(comic.getTitleWithVolume());
        }

        System.out.println("-- CSV出力 ここから --");
        for (Comic comic : comicList) {
            System.out.println(comic.getInfoAsCsv());
        }
        System.out.println("-- CSV出力 ここまで --");
    }
}

package d00000.lecture11;

public class Main2 {

public static void main(String[] args) {

Comic[] comicList = new Comic[5];

comicList[0] = new Comic("ドラえもん", "藤子・F・不二雄", 500, 1, false);

comicList[1] = new Comic("ドラえもん", "藤子・F・不二雄", 500, 2, false);

comicList[2] = new Comic("永沢君", "さくらももこ", 700, 1, true);

comicList[3] = new Comic("クレヨンしんちゃん", "臼井儀人", 800, 1, false);

comicList[4] = new Comic("クレヨンしんちゃん", "臼井儀人", 800, 2, false);

// タイトル一覧

System.out.println("タイトル一覧");

for (Comic comic : comicList) {

System.out.println(comic.getTitleWithVolume());

}

System.out.println("-- CSV出力ここから --");

for (Comic comic : comicList) {

System.out.println(comic.getInfoAsCsv());

}

System.out.println("-- CSV出力ここまで --");

}

GitHubで見る:

プリミティブ型（基本型）と参照型（クラス型）

The types of the Java programming language are divided into two categories: primitive types and reference types.

Java言語の型は次の2つのカテゴリーに分けられる: プリミティブ型と参照形。

プリミティブ型（基本型）

次の8種類。整数はすべて符号付きで、C言語と違ってunsignedはない。

型	格納できる値	備考
boolean	真偽値（trueもしくはfalse）
char	1文字	Unicodeのコードを表す16ビットの整数。教科書P.12
byte	整数（8ビット）	教科書P.10
short	整数（16ビット）	教科書P.10
int	整数（16ビット）	教科書P.10
long	整数（32ビット）	教科書P.10
float	実数（32ビット）	教科書P.11
double	実数（64ビット）	教科書P.11

基本型の変数は、「箱」のイメージで問題ない。変数名は箱についている名前。

では、次のコードを実行してみよう（コード全体）。

package d00000.lecture10;

public class Main1 {
    public static void main(String[] args) {
        // (1) プリミティブ型の宣言と初期化
        int a = 0;
        int b = 1;
        System.out.println("a: " + a);
        System.out.println("b: " + b);

        // (2) プリミティブ型の代入
        b = a;
        System.out.println("a: " + a);
        System.out.println("b: " + b);

        // (3) プリミティブ型の代入
        a = 2;
        System.out.println("a: " + a);
        System.out.println("b: " + b);

        // (4) 参照型のインスタンス化とフィールドへの代入
        Circle c1 = new Circle();
        c1.radius = 0;
        Circle c2 = new Circle();
        c2.radius = 1;
        System.out.println("c1.radius: " + c1.radius);
        System.out.println("c2.radius: " + c2.radius);

        // (5) 参照型の代入
        c2 = c1;
        System.out.println("c1.radius: " + c1.radius);
        System.out.println("c2.radius: " + c2.radius);

        // (6) 参照型のフィールドに代入
        c1.radius = 2;
        System.out.println("c1.radius: " + c1.radius);
        System.out.println("c2.radius: " + c2.radius);
    }
}

// (1) プリミティブ型の宣言と初期化

int a = 0;

int b = 1;

System.out.println("a: " + a);

System.out.println("b: " + b);

// (2) プリミティブ型の代入

b = a;

System.out.println("a: " + a);

System.out.println("b: " + b);

// (3) プリミティブ型の代入

a = 2;

System.out.println("a: " + a);

System.out.println("b: " + b);

(1)では、aに0、bに1を代入している。

(1) プリミティブ型の宣言と初期化

(2)で代入という操作をすると、aの値がコピーされてbに入る。

Primitive2

(3)で、aに代入するとaの値が変わる。bの値は変わらない。

Primitive3

参照型（クラス型）

参照型はクラス型ともいい、要するに、クラスによる型のこと。クラス型の変数は、クラス（やインターフェース）の実体（インスタンス）を格納する。

例えば、円（通貨じゃなくて図形の方）を表すCircleクラスを定義して、インスタンス化することを考えよう。半径を表すフィールドを持つクラスである。

package d00000.lecture10;

/**
 * 円を表すクラス
 */
public class Circle {
    /** 半径を表すフィールド */
    public int radius;
}

package d00000.lecture10;

/**

* 円を表すクラス

public class Circle {

/** 半径を表すフィールド */

public int radius;

}

この場合の変数は、プリミティブ型の時と違って、「箱」のイメージではない！「商品タグ」のイメージが適切である。特に代入演算子を使った時の処理について注意が必要だ。実際に実行して、代入がどのような操作なのか確認しよう。

package d00000.lecture10;

public class Main1 {
    public static void main(String[] args) {
        // (1) プリミティブ型の宣言と初期化
        int a = 0;
        int b = 1;
        System.out.println("a: " + a);
        System.out.println("b: " + b);

        // (2) プリミティブ型の代入
        b = a;
        System.out.println("a: " + a);
        System.out.println("b: " + b);

        // (3) プリミティブ型の代入
        a = 2;
        System.out.println("a: " + a);
        System.out.println("b: " + b);

        // (4) 参照型のインスタンス化とフィールドへの代入
        Circle c1 = new Circle();
        c1.radius = 0;
        Circle c2 = new Circle();
        c2.radius = 1;
        System.out.println("c1.radius: " + c1.radius);
        System.out.println("c2.radius: " + c2.radius);

        // (5) 参照型の代入
        c2 = c1;
        System.out.println("c1.radius: " + c1.radius);
        System.out.println("c2.radius: " + c2.radius);

        // (6) 参照型のフィールドに代入
        c1.radius = 2;
        System.out.println("c1.radius: " + c1.radius);
        System.out.println("c2.radius: " + c2.radius);
    }
}

// (4) 参照型のインスタンス化とフィールドへの代入

Circle c1 = new Circle();

c1.radius = 0;

Circle c2 = new Circle();

c2.radius = 1;

System.out.println("c1.radius: " + c1.radius);

System.out.println("c2.radius: " + c2.radius);

// (5) 参照型の代入

c2 = c1;

System.out.println("c1.radius: " + c1.radius);

System.out.println("c2.radius: " + c2.radius);

// (6) 参照型のフィールドに代入

c1.radius = 2;

System.out.println("c1.radius: " + c1.radius);

System.out.println("c2.radius: " + c2.radius);

(4)では、インスタンス化して、フィールドに値を代入している。変数名（インスタンス名）は商品タグのようにインスタンスに紐づいている。

(4) 参照型のインスタンス化とフィールドへの代入

(5)で、代入の操作を行っているが、これは「c2の紐付け先をc1のものと同じにする」という意味になる（C言語がわかっている人向けの説明: ポインタのコピー）。元々c2が紐づいていたインスタンスはどこからも使われていない状態になったので、ガベージコレクタ（教科書P.92）によって、そのうちメモリから消される。

Reference2

(6) c1のフィールドの値を代入によって変更すると、c2のフィールドも同じになる（というか同じものを指し示している）。

Reference3

このように、参照型では（初学者にとっては）直感と違う処理が行われるので注意する。この辺りについては「シャローコピー」や「ディープコピー」といった単語で検索してみると理解が深まるだろう。

比較

代入だけではなく、比較についても注意しなければならない。次のコードを実行して見よう（コード全体）。

package d00000.lecture10;

public class Main2 {
    public static void main(String[] args) {
        int a = 1;
        int b = 1;

        if (a == b) {
            System.out.println("aとbは同じ");
        } else {
            System.out.println("aとbは違う");
        }

        Circle c1 = new Circle();
        c1.radius = 1;
        Circle c2 = new Circle();
        c2.radius = 1;

        if (c1 == c2) {
            System.out.println("c1とc2は同じ");
        } else {
            System.out.println("c1とc2は違う");
        }
    }
}

int a = 1;

int b = 1;

if (a == b) {

System.out.println("aとbは同じ");

} else {

System.out.println("aとbは違う");

}

Circle c1 = new Circle();

c1.radius = 1;

Circle c2 = new Circle();

c2.radius = 1;

if (c1 == c2) {

System.out.println("c1とc2は同じ");

} else {

System.out.println("c1とc2は違う");

}

参照型の比較は、「指し示しているインスタンスが同じか」という比較をしているので、フィールドの値がすべて同じであったとしても指し示しているインスタンスが違えばfalseとなる。参照型は、普通は「==」で比較してはいけない、と覚えておこう（もちろん、同じインスタンスを指し示しているか、という判別が必要なときはこれで良い）。

では、参照型で比較したい場合はどうしたらいいのだろうか？これは、地味にフィールドを比較していくしかない。Circleクラスの場合はフィールドが1つだけなので簡単だが、フィールドがたくさんある場合は大変だ。なので、比較が必要なクラスは比較するためのメソッドを作っておくのが良い。じゃあ、どうやって作るか、利用するか、ということは今後の講義で解説する。

参照型あれこれ

文字列

Javaの文字列はStringクラスのインスタンスだ。つまり参照型だ。だから、比較などでは注意しなければならない。また、文字列は非常によく使われるので、特別扱いされている。

特別扱い1: 普通のクラスはnew演算子でインスタンス化を行うが、文字列のインスタンス化はダブルクォーテーションで囲むことによってインスタンス化することができる！

ちなみに、ダブルクォーテーションを使わず、charの配列から文字列を作ると次のようになる。

char[] helloCharArray = {'こ', 'ん', 'に', 'ち', 'は'};
String hello = new String(helloCharArray);

1 2	char[] helloCharArray = {'こ', 'ん', 'に', 'ち', 'は'}; String hello = new String(helloCharArray);

特別扱い2: +演算子で結合ができる！（教科書P.13、ちなみに、「演算子のオーバーロード」という機能がある言語では、+演算子の機能を変えることができる）

Javaの文字列は様々なメソッドが用意されているので使ってみよう。

配列

配列も参照型である。

lengthという読み取り専用の特殊なフィールドのようなものがある（教科書P.23）。

例えば、for文でループ回数に使えば、文字列の長さが変わってもその部分のコードを書き換える必要はなくなる。

char[] aiueo = "あいうえお".toCharArray();
for (int i=0; i<aiueo.length; i++) {
    System.out.println(aiueo[i]);
}

char[] aiueo = "あいうえお".toCharArray();

for (int i=0; i<aiueo.length; i++) {

System.out.println(aiueo[i]);

}