Teaching Programming - パート 6

JavaFXでWindowを表示する

JavaFXのアプリケーションはjavafx.application.Applicationを継承して作る。
ちなみにjavafx.application.Applicationは抽象クラス（アブストラクトクラス）。
startメソッドをオーバーライドして、そこで各種設定（部品配置等）を行う。startメソッドはJavaFXにおけるコンストラクタのような役割。
アプリケーションの起動は「Application.launch(アプリケーションのクラス名.class);」で行う。

package lesson13.d00000;

import javafx.application.Application;
import javafx.stage.Stage;

public class CounterApp extends Application {
    @Override
    public void start(Stage primaryStage) throws Exception {
        primaryStage.setTitle("カウンター");
        primaryStage.show();
    }
}

package lesson13.d00000;

import javafx.application.Application;

import javafx.stage.Stage;

public class CounterApp extends Application {

@Override

public void start(Stage primaryStage) throws Exception {

primaryStage.setTitle("カウンター");

primaryStage.show();

}

package lesson13.d00000;

import javafx.application.Application;

public class Main {
    public static void main(String[] args) {
        Application.launch(CounterApp.class);
    }
}

package lesson13.d00000;

import javafx.application.Application;

public class Main {

public static void main(String[] args) {

Application.launch(CounterApp.class);

}

ボタンなどを配置する

package lesson13.d00000;

import javafx.application.Application;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.control.Label;
import javafx.scene.layout.Pane;
import javafx.stage.Stage;

public class CounterApp extends Application {
    private Label label;
    private Button countButton;
    private Button resetButton;

    @Override
    public void start(Stage primaryStage) throws Exception {
        // ラベル
        label = new Label();
        label.setText("0");
        label.relocate(10, 10);

        // カウントボタン
        countButton = new Button();
        countButton.setText("カウント");
        countButton.relocate(10, 40);

        // リセットボタン
        resetButton = new Button();
        resetButton.setText("リセット");
        resetButton.relocate(10, 70);

        // ペイン（レイアウト）
        Pane pane = new Pane();
        pane.getChildren().add(label); // ペインにラベルを追加
        pane.getChildren().add(countButton); // ペインにカウントボタンを追加
        pane.getChildren().add(resetButton); // ペインにリセットボタンを追加

        // シーン
        Scene scene = new Scene(pane, 150, 200);
        primaryStage.setScene(scene); // シーンにペインをセット

        // 最初はこれだけ
        primaryStage.setTitle("カウンター");
        primaryStage.show();
    }
}

package lesson13.d00000;

import javafx.application.Application;

import javafx.scene.Scene;

import javafx.scene.control.Button;

import javafx.scene.control.Label;

import javafx.scene.layout.Pane;

import javafx.stage.Stage;

public class CounterApp extends Application {

private Label label;

private Button countButton;

private Button resetButton;

@Override

public void start(Stage primaryStage) throws Exception {

// ラベル

label = new Label();

label.setText("0");

label.relocate(10, 10);

// カウントボタン

countButton = new Button();

countButton.setText("カウント");

countButton.relocate(10, 40);

// リセットボタン

resetButton = new Button();

resetButton.setText("リセット");

resetButton.relocate(10, 70);

// ペイン（レイアウト）

Pane pane = new Pane();

pane.getChildren().add(label); // ペインにラベルを追加

pane.getChildren().add(countButton); // ペインにカウントボタンを追加

pane.getChildren().add(resetButton); // ペインにリセットボタンを追加

// シーン

Scene scene = new Scene(pane, 150, 200);

primaryStage.setScene(scene); // シーンにペインをセット

// 最初はこれだけ

primaryStage.setTitle("カウンター");

primaryStage.show();

}

イベントハンドラー（オブザーバー）

ボタンクラスはイベント（ボタンがクリックされた等）が発生した時に、何か処理をすること（させること）ができる。
「イベントが発生した時の処理」を担当するクラスを「イベントハンドラー（event handler）」という。
もっと詳しく知りたい人へ: Observerパターン
（JavaFxの場合）ButtonのイベントハンドラーはEventHandlerインターフェースを実装する。
ボタンに関するイベントが発生すると、ボタンに登録したイベントハンドラーのhandleメソッドが実行される。

package lesson13.d00000;

import javafx.event.ActionEvent;
import javafx.event.EventHandler;

public class ExampleHandler implements EventHandler<ActionEvent> {
    @Override
    public void handle(ActionEvent event) {
        System.out.println("イベント発生");
    }
}

package lesson13.d00000;

import javafx.event.ActionEvent;

import javafx.event.EventHandler;

public class ExampleHandler implements EventHandler<ActionEvent> {

@Override

public void handle(ActionEvent event) {

System.out.println("イベント発生");

}

        // ハンドラー
        EventHandler<ActionEvent> handler = new ExampleHandler();

        // カウントボタン
        countButton = new Button();
        countButton.setText("カウント");
        countButton.relocate(10, 40);
        countButton.setOnAction(handler);

        // リセットボタン
        resetButton = new Button();
        resetButton.setText("リセット");
        resetButton.relocate(10, 70);
        resetButton.setOnAction(handler);

// ハンドラー

EventHandler<ActionEvent> handler = new ExampleHandler();

// カウントボタン

countButton = new Button();

countButton.setText("カウント");

countButton.relocate(10, 40);

countButton.setOnAction(handler);

// リセットボタン

resetButton = new Button();

resetButton.setText("リセット");

resetButton.relocate(10, 70);

resetButton.setOnAction(handler);

ExampleHandlerをきちんと動作させる（カウントボタンでラベルに表示されるカウンターを増やし、リセットボタンで0にする）には次の2つができるようにすればいいが、煩雑なコードになる。

labelのsetTextメソッドを呼べるようにする
countButtonとresetButtonのどちらからイベントが発生したか区別できるようにする

カウンターの機能をうまく実現するには、CounterAppがイベントを処理するようにするのが簡潔になる。

package lesson13.d00000;

import javafx.application.Application;
import javafx.event.ActionEvent;
import javafx.event.EventHandler;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.control.Label;
import javafx.scene.layout.Pane;
import javafx.stage.Stage;

public class CounterApp extends Application implements EventHandler<ActionEvent> {
    private Label label;
    private Button countButton;
    private Button resetButton;
    private int count = 0;

    @Override
    public void start(Stage primaryStage) throws Exception {
        // ラベル
        label = new Label();
        label.setText("0");
        label.relocate(10, 10);

        // カウントボタン
        countButton = new Button();
        countButton.setText("カウント");
        countButton.relocate(10, 40);
        countButton.setOnAction(this);

        // リセットボタン
        resetButton = new Button();
        resetButton.setText("リセット");
        resetButton.relocate(10, 70);
        resetButton.setOnAction(this);

        // ペイン（レイアウト）
        Pane pane = new Pane();
        pane.getChildren().add(label); // ペインにラベルを追加
        pane.getChildren().add(countButton); // ペインにカウントボタンを追加
        pane.getChildren().add(resetButton); // ペインにリセットボタンを追加

        // シーン
        Scene scene = new Scene(pane, 150, 200);
        primaryStage.setScene(scene); // シーンにペインをセット

        // 最初はこれだけ
        primaryStage.setTitle("カウンター");
        primaryStage.show();
    }

    @Override
    public void handle(ActionEvent event) {
        Object source = event.getSource(); // イベントの発生源となっているインスタンスを取得する
        if (source.equals(countButton)) {
            count++;
        } else if (source.equals(resetButton)) {
            count = 0;
        }
        label.setText(Integer.toString(count));
    }
}

package lesson13.d00000;

import javafx.application.Application;

import javafx.event.ActionEvent;

import javafx.event.EventHandler;

import javafx.scene.Scene;

import javafx.scene.control.Button;

import javafx.scene.control.Label;

import javafx.scene.layout.Pane;

import javafx.stage.Stage;

public class CounterApp extends Application implements EventHandler<ActionEvent> {

private Label label;

private Button countButton;

private Button resetButton;

private int count = 0;

@Override

public void start(Stage primaryStage) throws Exception {

// ラベル

label = new Label();

label.setText("0");

label.relocate(10, 10);

// カウントボタン

countButton = new Button();

countButton.setText("カウント");

countButton.relocate(10, 40);

countButton.setOnAction(this);

// リセットボタン

resetButton = new Button();

resetButton.setText("リセット");

resetButton.relocate(10, 70);

resetButton.setOnAction(this);

// ペイン（レイアウト）

Pane pane = new Pane();

pane.getChildren().add(label); // ペインにラベルを追加

pane.getChildren().add(countButton); // ペインにカウントボタンを追加

pane.getChildren().add(resetButton); // ペインにリセットボタンを追加

// シーン

Scene scene = new Scene(pane, 150, 200);

primaryStage.setScene(scene); // シーンにペインをセット

// 最初はこれだけ

primaryStage.setTitle("カウンター");

primaryStage.show();

}

@Override

public void handle(ActionEvent event) {

Object source = event.getSource(); // イベントの発生源となっているインスタンスを取得する

if (source.equals(countButton)) {

count++;

} else if (source.equals(resetButton)) {

count = 0;

}

label.setText(Integer.toString(count));

}

JavaFXについて知る

インターフェース（復習）

クラスと同様で、型を定義できる。
クラスと違って、単体では使えない（インスタンスを作ることができない）。クラスに実装（implements）する。
インターフェースで記述できるメソッドは抽象メソッド（本体がない）。したがってクラスでそのメソッドをオーバーライドして実装しなければ（本体を書かなければ）ならない。

例えると:

クラス: 設計図（どのような機能があるのか、その機能をどのような処理で実現するのかが書いてある）。
インスタンス: 製品・生産物・実体（設計図に基づいて作られるもの）。
インターフェース: 規格（設計の時点で持つべき機能が定義されている。どのように実現するのかは書いていない）。

設計図が違っても、同じ規格に準拠していれば、それらの設計図から作られた実体は同じように扱うことができる（その規格の範囲内では）。

例えばスマホ内蔵のバッテリーは特に標準規格がないので、あるスマホバッテリーを他のスマホで使うことはできない。
乾電池は形・サイズ・電圧の規格（単一、単二等）が合っていれば（インターフェースが合っていれば）、メーカや電池系（マンガン、アルカリ等）が違っても（処理の実装が違っても）入れ替えて使うことができる（注: 厳密には、電池系についても規格があるのでマンガンとアルカリで入れ替えてはダメな場合等もある）。

インターフェース

キャッシュレジスターをプログラムする。

レジで会計する（税込の合計金額を計算してレシートを印刷する）ときに必要なのは、商品の値段と商品名だ。だから、Bookクラスに「値段を取得するメソッド」と「商品名を取得するメソッド」があればOK。

では、Bookで表現できないものをレジで会計するには、どのようにすればいいのか？

Book以外も受け付けるようにレジを改良する（クラスごとに保存、計算するプログラムが必要になる）。
Bookより上位のクラス（例えば商品クラス）を定義し、それを継承するように書き直す（Java言語は単一継承のためうまく実現できない場合も）。
getPriceメソッドをなんとかして呼ぶ（リフレクションを使う）。ちなみに、ダック・タイピングをサポートする言語ならば簡単だが、Java言語はそうでは無い。
商品を表すインターフェースを定義し、レジで扱いたいクラスはそれを実装（implements）する。
etc…

インターフェースとは

クラスに特定のメンバー（メソッドとフィールド、主にメソッド）が存在することを保証する仕組み。クラスと同様に型として扱うことができる。

インターフェースには「クラスが持っていてほしいメンバー」を定義する。ただしメソッドの本体（実際に実行される部分）は無い（抽象メソッドという）。
インターフェースをimplementsしたクラスは、そのインターフェースに定義されているメンバー全体を実装する（メソッドの本体も書く）。

まずはBookだけを計算できるレジ

package lesson12.d00000;

import lesson11.d00000.Book;

import java.util.ArrayList;

public class CashRegister {
    private ArrayList<Book> bookArrayList;

    public CashRegister() {
        this.bookArrayList = new ArrayList<Book>();
    }

    public void addBook(Book p) {
        bookArrayList.add(p);
    }

    public void clear() {
        this.bookArrayList.clear();
    }

    public void printReceipt() {
        int total = 0;
        for (Book p : bookArrayList) {
            System.out.println(p.title + "\t" + p.getPrice() + "円");
            total += p.getPrice();
        }
        int tax = (int)(0.08 * total);
        System.out.println("------------------------");
        System.out.println("小計" + "\t" + total + "円");
        System.out.println("税" + "\t" + tax + "円");
        System.out.println("合計" + "\t" + (total + tax) + "円");
    }

}

package lesson12.d00000;

import lesson11.d00000.Book;

import java.util.ArrayList;

public class CashRegister {

private ArrayList<Book> bookArrayList;

public CashRegister() {

this.bookArrayList = new ArrayList<Book>();

}

public void addBook(Book p) {

bookArrayList.add(p);

}

public void clear() {

this.bookArrayList.clear();

}

public void printReceipt() {

int total = 0;

for (Book p : bookArrayList) {

System.out.println(p.title + "\t" + p.getPrice() + "円");

total += p.getPrice();

}

int tax = (int)(0.08 * total);

System.out.println("------------------------");

System.out.println("小計" + "\t" + total + "円");

System.out.println("税" + "\t" + tax + "円");

System.out.println("合計" + "\t" + (total + tax) + "円");

}

        CashRegister cashRegister = new CashRegister();
        cashRegister.addBook(new Book("Java逆引きレシピ", "竹添他", 2800));
        cashRegister.addBook(new Comic("ドラゴンボール", "鳥山", 500, 1));
        cashRegister.printReceipt();
        cashRegister.clear();

CashRegister cashRegister = new CashRegister();

cashRegister.addBook(new Book("Java逆引きレシピ", "竹添他", 2800));

cashRegister.addBook(new Comic("ドラゴンボール", "鳥山", 500, 1));

cashRegister.printReceipt();

cashRegister.clear();

商品を表すProduct

クラスと同様にメンバー（フィールド、メソッド）を持つ。
ただし、メソッドは本体がない（抽象メソッド）。

package lesson12.d00000;

public interface Product {
    int getPrice(); // 価格を取得するメソッド
    String getName(); // 商品名を取得するメソッド
}

package lesson12.d00000;

public interface Product {

int getPrice(); // 価格を取得するメソッド

String getName(); // 商品名を取得するメソッド

}

Productを実装（implements）

package lesson11.d00000;

import lesson12.d00000.Product;

public class Book implements Product {
    public String title;
    public String author;
    private int price;

    public Book(String title, String author, int price) {
        this.title = title;
        this.author = author;
        this.price = price;
    }

    public String getInfo() {
        String info = title + ", " + author +", " + price + "円";
        return info;
    }

    @Override
    public String toString() {
        return getInfo();
    }

    @Override
    public int getPrice() {
        return price;
    }

    @Override
    public String getName() {
        return title + "（" + author + "）";
    }

}

package lesson11.d00000;

import lesson12.d00000.Product;

public class Book implements Product {

public String title;

public String author;

private int price;

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

this.title = title;

this.author = author;

this.price = price;

}

public String getInfo() {

String info = title + ", " + author +", " + price + "円";

return info;

}

@Override

public String toString() {

return getInfo();

}

@Override

public int getPrice() {

return price;

}

@Override

public String getName() {

return title + "（" + author + "）";

}

package lesson12.d00000;

public class BoxedLunch implements Product {
    private String name; // 商品名
    private int unitPrice; // 100グラムあたりの値段
    private int amount; // 購入する量（グラム）

    public BoxedLunch(String name, int unitPrice, int amount) {
        this.name = name;
        this.unitPrice = unitPrice;
        this.amount = amount;
    }

    @Override
    public int getPrice() {
        return (int)(unitPrice/100.0 * amount);
    }

    @Override
    public String getName() {
        return name + "（" + amount + "グラム）";
    }

}

package lesson12.d00000;

public class BoxedLunch implements Product {

private String name; // 商品名

private int unitPrice; // 100グラムあたりの値段

private int amount; // 購入する量（グラム）

public BoxedLunch(String name, int unitPrice, int amount) {

this.name = name;

this.unitPrice = unitPrice;

this.amount = amount;

}

@Override

public int getPrice() {

return (int)(unitPrice/100.0 * amount);

}

@Override

public String getName() {

return name + "（" + amount + "グラム）";

}

Product対応レジ

package lesson12.d00000;

import java.util.ArrayList;

public class CashRegister {
    private ArrayList<Product> productList;

    public CashRegister() {
        this.productList = new ArrayList<Product>();
    }

    public void addProduct(Product p) {
        productList.add(p);
    }

    public void clear() {
        this.productList.clear();
    }

    public void printReceipt() {
        int total = 0;
        for (Product p : productList) {
            System.out.println(p.getName() + "\t" + p.getPrice() + "円");
            total += p.getPrice();
        }
        int tax = (int)(0.08 * total);
        System.out.println("------------------------");
        System.out.println("小計" + "\t" + total + "円");
        System.out.println("税" + "\t" + tax + "円");
        System.out.println("合計" + "\t" + (total + tax) + "円");
    }

}

package lesson12.d00000;

import java.util.ArrayList;

public class CashRegister {

private ArrayList<Product> productList;

public CashRegister() {

this.productList = new ArrayList<Product>();

}

public void addProduct(Product p) {

productList.add(p);

}

public void clear() {

this.productList.clear();

}

public void printReceipt() {

int total = 0;

for (Product p : productList) {

System.out.println(p.getName() + "\t" + p.getPrice() + "円");

total += p.getPrice();

}

int tax = (int)(0.08 * total);

System.out.println("------------------------");

System.out.println("小計" + "\t" + total + "円");

System.out.println("税" + "\t" + tax + "円");

System.out.println("合計" + "\t" + (total + tax) + "円");

}

        CashRegister cashRegister = new CashRegister();
        cashRegister.addProduct(new Book("Java逆引きレシピ", "竹添他", 2800));
        cashRegister.addProduct(new Comic("ドラゴンボール", "鳥山", 500, 1));
        cashRegister.addProduct(new BoxedLunch("鶏肉と里芋の煮物", 178, 200));
        cashRegister.printReceipt();
        cashRegister.clear();

CashRegister cashRegister = new CashRegister();

cashRegister.addProduct(new Book("Java逆引きレシピ", "竹添他", 2800));

cashRegister.addProduct(new Comic("ドラゴンボール", "鳥山", 500, 1));

cashRegister.addProduct(new BoxedLunch("鶏肉と里芋の煮物", 178, 200));

cashRegister.printReceipt();

cashRegister.clear();

getterとsetter

getter/setterとは

getterはフィールドを取得（ゲット）するためのメソッド。メソッド名は「getフィールド名」とする。フィールド名の最初を大文字に変える。対応するフィールドをreturnする。　
setterはフィールドに設定（セット）するためにメソッド。メソッド名は「setフィールド名」とする。フィールド名の最初を大文字に変える。引数をフィールドにセットする。

getter/setterでフィールドにアクセスする利点（例）

フィールドをprivateとしてgetterだけ用意すれば読み出し専用のフィールドとなる。
セッターでセットする値をチェックすることができる。
etc…

Bookの改良

Bookのpriceを後から書き換えられないようにしよう。

package lesson11.d00000;

public class Book {
    public String title;
    public String author;
    private int price;

    public Book(String title, String author, int price) {
        this.title = title;
        this.author = author;
        this.price = price;
    }

    public String getInfo() {
        String info = title + ", " + author +", " + price + "円";
        return info;
    }

    @Override
    public String toString() {
        return getInfo();
    }

    public int getPrice() {
        return price;
    }

}

package lesson11.d00000;

public class Book {

public String title;

public String author;

private int price;

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

this.title = title;

this.author = author;

this.price = price;

}

public String getInfo() {

String info = title + ", " + author +", " + price + "円";

return info;

}

@Override

public String toString() {

return getInfo();

}

public int getPrice() {

return price;

}

継承: Objectクラス

（Objectクラスを除く）全てのクラスはObjectクラスを継承している

extendsを書かない場合は、自動的にObjectクラスを継承する（「extends Object」と同じ）。
Objectのメソッドをオーバーライドして動作を変えることができる。

UMLによる継承の関係の図示

Diagram

toStringメソッド

System.out.printlnで表示しようしたり、文字列（Stringクラスのインスタンス）を+演算子で繋げようとすると、ObjectクラスにあるtoStringメソッドが呼ばれて、そのインスタンスを表す文字列型が取り出される。

例えば、

System.out.println(book2);

1	System.out.println(book2);

とすると、

lesson11.d00000.Comic@5e481248

等と表示される。これは、ObjectのtoStringが

public String toString() {
    return getClass().getName() + "@" + Integer.toHexString(hashCode());
}

public String toString() {

return getClass().getName() + "@" + Integer.toHexString(hashCode());

}

と定義されているから（例えば、JDK6のソースコードhttp://hg.openjdk.java.net/jdk6/jdk6/jdk/file/48e891c51be5/src/share/classes/java/lang/Object.java#l235）。

オーバーライドして、インスタンスの情報を見やすく表示するようにしてみよう。Bookクラスに

    @Override
    public String toString() {
        return getInfo();
    }

@Override

public String toString() {

return getInfo();

}

を加えることで、

System.out.println(book2);

1	System.out.println(book2);

の表示が変わる（Bookを継承しているComicの場合も）。

継承: スーパークラスとサブクラス

書籍を表すBookクラスを継承して、漫画本（巻という概念がある）を表すクラスを作ろう。

ソースコード

package lesson11.d00000;

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 String getInfo() {
        String info = title + ", " + author +", " + price + "円";
        return info;
    }
}

package lesson11.d00000;

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 String getInfo() {

String info = title + ", " + author +", " + price + "円";

return info;

}

package lesson11.d00000;

public class Comic extends Book {
    public int volume;

    public Comic(String title, String author, int price, int volume) {
        super(title, author, price);
        this.volume = volume;
    }
}

package lesson11.d00000;

public class Comic extends Book {

public int volume;

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

super(title, author, price);

this.volume = volume;

}

mainメソッドで、それぞれ使ってみよう。

Book book1 = new Book("Javaの絵本", "アンク", 1580);
System.out.println(book1.getInfo());
Comic comic1 = new Comic("ドラえもん", "藤子不二雄", 500, 1);
System.out.println(comic1.getInfo());

Book book1 = new Book("Javaの絵本", "アンク", 1580);

System.out.println(book1.getInfo());

Comic comic1 = new Comic("ドラえもん", "藤子不二雄", 500, 1);

System.out.println(comic1.getInfo());

実行結果:

Javaの絵本, アンク, 1580円ドラえもん, 藤子不二雄, 500円

Comicのコンストラクタ

継承したクラス（サブクラス）のコンストラクタでは、スーパークラスのコンストラクタを最初に呼ばなければならない。
スーパークラスのコンストラクタはsuper(引数)で呼ぶことができる。
スーパークラスに引数なしのコンストラクタ（デフォルトコンストラクタを含む）がある場合、「super();」という記述を省略することができる（つまり書かなくても呼ばれる）。

オーバーライド

スーパークラスと同じメソッドを定義するとそのメソッドを上書きすることができる。
スーパークラスのメソッドは super.メソッド名(引数)で呼び出すことができる。
@Overrideはなくてもいいが、つけておくとオーバーライドできているかチェックしてくれる（アノテーション）。

    @Override
    public String getInfo() {
        String info = super.getInfo() + ", " + volume + "巻";
        return info;
    }

@Override

public String getInfo() {

String info = super.getInfo() + ", " + volume + "巻";

return info;

}

実行結果:

Javaの絵本, アンク, 1580円ドラえもん, 藤子不二雄, 500円, 1巻

合計金額を計算する(1)

ArrayList<Book> bookList = new ArrayList<Book>();
bookList.add(new Book("Java逆引きレシピ", "竹添他", 2800));
bookList.add(new Book("Kotlinスタートブック", "長澤", 3500));
ArrayList<Comic> comicList = new ArrayList<Comic>();
comicList.add(new Comic("ドラゴンボール", "鳥山", 500, 1));
comicList.add(new Comic("ドラゴンボール", "鳥山", 500, 2));

int totalPrice1 = 0;
for (int i=0; i<bookList.size(); i++) {
    Book b = bookList.get(i);
    totalPrice1 += b.price;
}
for (Comic c : comicList) { // 拡張for文[教科書P.170]
    totalPrice1 += c.price;
}
System.out.println("合計金額は" + totalPrice1 + "円です。");

ArrayList<Book> bookList = new ArrayList<Book>();

bookList.add(new Book("Java逆引きレシピ", "竹添他", 2800));

bookList.add(new Book("Kotlinスタートブック", "長澤", 3500));

ArrayList<Comic> comicList = new ArrayList<Comic>();

comicList.add(new Comic("ドラゴンボール", "鳥山", 500, 1));

comicList.add(new Comic("ドラゴンボール", "鳥山", 500, 2));

int totalPrice1 = 0;

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

Book b = bookList.get(i);

totalPrice1 += b.price;

}

for (Comic c : comicList) { // 拡張for文[教科書P.170]

totalPrice1 += c.price;

}

System.out.println("合計金額は" + totalPrice1 + "円です。");

代入記号の意味

プリミティブ型（基本型）は「箱」のイメージ。代入によって、値がコピーされて箱に格納される。

Assignment1

クラス型（参照型）は「タグ」のイメージ。
代入によって、同じインスタンスに結びつく。

Assignment2

もっと色々知りたい人のために:

タグが1つも付いていないインスタンスはどうなるのか？→GC（ガベージコレクション、ゴミ集め）によってメモリから消えて無くなる。[教科書P.82]
Null Pointer（ヌルポ）とは、タグの先にインスタンスがない状態のこと。
クラス型のインスタンスをコピーするのはどうするのか？→自分で実装する。大抵はcloneメソッドをオーバーライドする。
インスタンスをコピーするコードを書いたけど、思った通りにコピーされてない。→シャローコピー（shallow copy）とディープコピー（deep copy）について調べよう。

サブクラスのインスタンスをスーパークラスのインスタンスとして扱う

Comicクラスのインスタンスは、Bookクラスのインスタンスとして扱うことができる。なぜならComicクラスはBookクラスを受け継いでいるから（継承しているから）。

多態性[教科書P.108]

Comic comic2 = new Comic("ワンピース", "尾田", 500, 1);
Book book2 = (Book)comic2;
System.out.println(book2.getInfo());

Comic comic2 = new Comic("ワンピース", "尾田", 500, 1);

Book book2 = (Book)comic2;

System.out.println(book2.getInfo());

comic2で呼び出すときは、Comicとして扱うので、volumeフィールドにアクセスできる。
book2で呼び出すときは、Bookとして扱うので、volumeフィールドにアクセスできない。
book2.getInfo()は上書きした方（ComicのgetInfo）が呼び出される（Bookとして扱う場合であっても、実体はComicクラスのインスタンスだから）。

合計金額を計算する(2)

ArrayList<Book> bookAndComicList = new ArrayList<>();
bookAndComicList.add(new Book("Java逆引きレシピ", "竹添他", 2800));
bookAndComicList.add(new Book("Kotlinスタートブック", "長澤", 3500));
bookAndComicList.add(new Comic("ドラゴンボール", "鳥山", 500, 1));
bookAndComicList.add(new Comic("ドラゴンボール", "鳥山", 500, 2));
int totalPrice2 = 0;
for (Book b : bookAndComicList) {
    totalPrice2 += b.price;
}
System.out.println("合計金額は" + totalPrice2 + "円です。");

ArrayList<Book> bookAndComicList = new ArrayList<>();

bookAndComicList.add(new Book("Java逆引きレシピ", "竹添他", 2800));

bookAndComicList.add(new Book("Kotlinスタートブック", "長澤", 3500));

bookAndComicList.add(new Comic("ドラゴンボール", "鳥山", 500, 1));

bookAndComicList.add(new Comic("ドラゴンボール", "鳥山", 500, 2));

int totalPrice2 = 0;

for (Book b : bookAndComicList) {

totalPrice2 += b.price;

}

System.out.println("合計金額は" + totalPrice2 + "円です。");

ArrayListに数値を入れる

キーボードから入力した整数の和と積を計算しよう！（ArrayListにintを入れる）

ポイント

ArrayListにはプリミティブ型は入れられないが、ラッパークラス（プリミティブ型に対応したクラス型）を使うことで入れることができる。（教科書P.144）
文字列から整数に変換するにはInteger.parseIntメソッドを使う。（教科書P.145）
「quit」以外の文字列を入力すると、例外（エラー）が発生してプログラムがそこで終了する。例外が発生してもきちんと動くプログラム（例えばエラーメッセージを出して再入力させる等）にするには、例外処理を行うようにする。（教科書P.122）

package lesson10.d00000;

import java.util.ArrayList;
import java.util.Scanner;

public class MainCalc {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        ArrayList<Integer> numList = new ArrayList<Integer>();

        // 数値を入力
        while (true) {
            System.out.print("数値かquitを入力: ");
            String input = scanner.next();
            if (input.equals("quit")) {
                break;
            } else {
                int num = Integer.parseInt(input);
                numList.add(num);
            }
        }

        // 和と積を計算して表示する
        int sum = 0;
        int product = 1;
        for (int i=0; i<numList.size(); i++) {
            int num = numList.get(i);
            sum += num;
            product *= num;
        }
        System.out.println("和: " + sum);
        System.out.println("積: " + product);
    }
}

package lesson10.d00000;

import java.util.ArrayList;

import java.util.Scanner;

public class MainCalc {

public static void main(String[] args) {

Scanner scanner = new Scanner(System.in);

ArrayList<Integer> numList = new ArrayList<Integer>();

// 数値を入力

while (true) {

System.out.print("数値かquitを入力: ");

String input = scanner.next();

if (input.equals("quit")) {

break;

} else {

int num = Integer.parseInt(input);

numList.add(num);

}

// 和と積を計算して表示する

int sum = 0;

int product = 1;

for (int i=0; i<numList.size(); i++) {

int num = numList.get(i);

sum += num;

product *= num;

}

System.out.println("和: " + sum);

System.out.println("積: " + product);

}

キーボードから文字列を入力

キーボードから文字列を入力しよう。

ポイント:

Scannerクラス（教科書P.176）
文字列を比較する（教科書P.53）

package lesson10.d00000;

import java.util.Scanner;

public class MainScanner {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while (true) {
            System.out.print("入力してください: ");
            String input = scanner.next();
            if (input.equals("quit")) {
                break;
            } else {
                System.out.println("入力された文字: "+input);
            }
        }
    }
}

package lesson10.d00000;

import java.util.Scanner;

public class MainScanner {

public static void main(String[] args) {

Scanner scanner = new Scanner(System.in);

while (true) {

System.out.print("入力してください: ");

String input = scanner.next();

if (input.equals("quit")) {

break;

} else {

System.out.println("入力された文字: "+input);

}

ArrayListとは（リストとは）

ArrayListは「順序付きのデータコンテナ」を表すクラスで、配列のように複数の変数（インスタンス）を入れておくことができる。

配列との違い:

プリミティブ型の変数は入れられない（ただしラッパークラスを使えばいいので支障はない）
入れられる個数が変えられる。というか、追加できる（個数が増えていく）
要素を操作する便利なメソッドがある
etc…

利用例

package lesson09.d00000;

import lesson05.d00000.Book;

import java.util.ArrayList;

public class MainList {

    public static void main(String[] args) {
        ArrayList<Book> bookList = new ArrayList<Book>();
        Book book1 = new Book("タイトル1", "著者1", 1000);
        bookList.add(book1);
        Book book2 = new Book("タイトル2", "著者2", 2000);
        bookList.add(book2);
        bookList.add(new Book("タイトル3", "著者3", 3000));

        System.out.println(bookList.size() + "冊のデータがあります。");
        for (int i=0; i<bookList.size(); i++) {
            Book b = bookList.get(i); // リストの中からi番目を取り出す
            b.printInfo();
        }

        bookList.add(new Book("タイトル4", "著者4", 4000));
        System.out.println(bookList.size() + "冊のデータがあります。");
        for (int i=0; i<bookList.size(); i++) {
            bookList.get(i).printInfo();
        }

        bookList.clear();
        System.out.println(bookList.size() + "冊のデータがあります。");
        for (int i=0; i<bookList.size(); i++) {
            bookList.get(i).printInfo();
        }
    }

}

package lesson09.d00000;

import lesson05.d00000.Book;

import java.util.ArrayList;

public class MainList {

public static void main(String[] args) {

ArrayList<Book> bookList = new ArrayList<Book>();

Book book1 = new Book("タイトル1", "著者1", 1000);

bookList.add(book1);

Book book2 = new Book("タイトル2", "著者2", 2000);

bookList.add(book2);

bookList.add(new Book("タイトル3", "著者3", 3000));

System.out.println(bookList.size() + "冊のデータがあります。");

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

Book b = bookList.get(i); // リストの中からi番目を取り出す

b.printInfo();

}

bookList.add(new Book("タイトル4", "著者4", 4000));

System.out.println(bookList.size() + "冊のデータがあります。");

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

bookList.get(i).printInfo();

}

bookList.clear();

System.out.println(bookList.size() + "冊のデータがあります。");

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

bookList.get(i).printInfo();

}

インスタンス化は、ArrayList<中に入れる型> インスタンス名 = new ArrayList<中に入れる型>();とする。
要素の数は指定しない。最初は0。追加すれば勝手に増えていく。
追加するにはaddメソッドを使う。
sizeメソッドで要素の数が取得できる。
取り出す時はgetメソッドを使う。引数は0から始まる順番を指定する。
全部消すにはclearメソッドを使う。

配列

C言語の配列

C言語では、データをまとめて扱う方法（の1つ）として、「配列」があった。例えば、int型の変数を5つ扱う場合には、

int a[5];

int a[5];

と宣言することによって、a[0]、a[1]、a[2]、a[3]、a[4]という5つの変数が使える。

Java言語の配列

Java言語でも配列が使えるが、C言語とは違うところがある。

宣言とインスタンス化

int[] a = new int[5];

1	int[] a = new int[5];

Java言語では、「int型の配列」は「「int型の配列」という型」があると考えた方が良い。だからというわけでもないが、C言語のように変数名の後ろにかっこがくるのではなく、「int[]」を型として扱うように書く。そして「インスタンス化」が必要。インスタンス化はnew演算子を用いる。

注意して欲しいのは、プリミティブ型の配列の場合、インスタンス化時に各要素は勝手に初期化されてしまう、ということ。例えば、

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

1 2	int b; System.out.println(b);

は、bが初期化（値の代入）がされていないのでエラーだが、

int[] a = new int[5];
System.out.println(a[0]);

1 2	int[] a = new int[5]; System.out.println(a[0]);

はエラーにならない。aの各要素は0で初期化されている。もちろん、

int[] a;

int[] a;

はaの宣言だけでインスタンス化がされていないので、何もできない。次のように宣言とインスタンス化を分けるのはOK。

int[] a;
a = new int[5];

1 2	int[] a; a = new int[5];

要素へのアクセス

C言語と同様に添え字でアクセスできる。

a[0] = 1; // 0番目の要素に1を代入
int b = a[0]; // 0番目の要素から値を取得しbに代入

1 2	a[0] = 1; // 0番目の要素に1を代入 int b = a[0]; // 0番目の要素から値を取得しbに代入

添え字に変数を使うこともできるので、for文を使ってアクセスすることもできる。例えば、全ての値を表示するには次のようにする。

package lesson09.d00000;

import lesson05.d00000.Book;

public class MainArray {

    public static void main(String[] args) {
        // プリミティブ型の配列
        int[] a = new int[5];
        for (int i=0; i<a.length; i++) {
            System.out.println(a[i]); // プリミティブ型の要素は初期値が入ってる。
        }

        // lesson05で作ったBookの配列
        Book[] bookArray = new Book[3]; // bookArrayをインスタンス化しただけであって、要素はインスタンス化されてない！

        for (int i=0; i<bookArray.length; i++) {
            bookArray[i].printInfo(); // Null Pointer Exception
        }

        // 個別に要素をインスタンス化
        bookArray[0] = new Book("Java言語入門", "たろう", 1000);
        bookArray[1] = new Book("C言語入門", "じろう", 2000);
        bookArray[2] = new Book("Kotlin入門", "はなこ", 3000);
        bookArray[3] = new Book("PHP入門", "たけし", 4000); // ArrayIndexOutOfBoundsException

        // 各要素のprintInfoを実行
        for (int i=0; i<bookArray.length; i++) {
            bookArray[i].printInfo();
        }

        // forで要素をインスタンス化
        for (int i=0; i<bookArray.length; i++) {
            int num = i+1;
            bookArray[i] = new Book("タイトル"+num, "著者"+num, 1000*num);
        }

        for (int i=0; i<bookArray.length; i++) {
            bookArray[i].printInfo();
        }
    }

}

int[] a = new int[5];

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

System.out.println(a[i]); // プリミティブ型の要素は初期値が入ってる。

}

ここで、a.lengthに注目しよう。これは「配列aの要素数」を表している。

実は、配列というのは、クラスのインスタンスのようなもので、lengthというフィールドを持っているように扱える（ただし読み出し専用）。配列の要素も、「添え字でアクセスできる特殊なフィールド」と考えて良い。

つまり、

int[] a = new int[5];

1	int[] a = new int[5];

のイメージはこんな感じ。

クラス型（参照型）の配列

参照型の配列も同様だが、各要素はそれぞれインスタンス化する必要がある。
例えば、lesson05で作成したBookクラスの配列を作ってみよう。

package lesson09.d00000;

import lesson05.d00000.Book;

public class MainArray {

    public static void main(String[] args) {
        // プリミティブ型の配列
        int[] a = new int[5];
        for (int i=0; i<a.length; i++) {
            System.out.println(a[i]); // プリミティブ型の要素は初期値が入ってる。
        }

        // lesson05で作ったBookの配列
        Book[] bookArray = new Book[3]; // bookArrayをインスタンス化しただけであって、要素はインスタンス化されてない！

        for (int i=0; i<bookArray.length; i++) {
            bookArray[i].printInfo(); // Null Pointer Exception
        }

        // 個別に要素をインスタンス化
        bookArray[0] = new Book("Java言語入門", "たろう", 1000);
        bookArray[1] = new Book("C言語入門", "じろう", 2000);
        bookArray[2] = new Book("Kotlin入門", "はなこ", 3000);
        bookArray[3] = new Book("PHP入門", "たけし", 4000); // ArrayIndexOutOfBoundsException

        // 各要素のprintInfoを実行
        for (int i=0; i<bookArray.length; i++) {
            bookArray[i].printInfo();
        }

        // forで要素をインスタンス化
        for (int i=0; i<bookArray.length; i++) {
            int num = i+1;
            bookArray[i] = new Book("タイトル"+num, "著者"+num, 1000*num);
        }

        for (int i=0; i<bookArray.length; i++) {
            bookArray[i].printInfo();
        }
    }

}

Book[] bookArray = new Book[3]; // bookArrayをインスタンス化しただけであって、要素はインスタンス化されてない！

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

bookArray[i].printInfo(); // Null Pointer Exception

}

これは、18行目でエラーになる。bookArrayの要素bookArray[0]がインスタンス化されていない（つまりbookArray[0]という入れ物が空っぽ）だからだ。これが有名な「ヌルポ」である。

だから、各要素をインスタンス化（あるいはインスタンスを代入）してやらなければならない。17〜19行目を削除して、次を追加しよう。

package lesson09.d00000;

import lesson05.d00000.Book;

public class MainArray {

    public static void main(String[] args) {
        // プリミティブ型の配列
        int[] a = new int[5];
        for (int i=0; i<a.length; i++) {
            System.out.println(a[i]); // プリミティブ型の要素は初期値が入ってる。
        }

        // lesson05で作ったBookの配列
        Book[] bookArray = new Book[3]; // bookArrayをインスタンス化しただけであって、要素はインスタンス化されてない！

        for (int i=0; i<bookArray.length; i++) {
            bookArray[i].printInfo(); // Null Pointer Exception
        }

        // 個別に要素をインスタンス化
        bookArray[0] = new Book("Java言語入門", "たろう", 1000);
        bookArray[1] = new Book("C言語入門", "じろう", 2000);
        bookArray[2] = new Book("Kotlin入門", "はなこ", 3000);
        bookArray[3] = new Book("PHP入門", "たけし", 4000); // ArrayIndexOutOfBoundsException

        // 各要素のprintInfoを実行
        for (int i=0; i<bookArray.length; i++) {
            bookArray[i].printInfo();
        }

        // forで要素をインスタンス化
        for (int i=0; i<bookArray.length; i++) {
            int num = i+1;
            bookArray[i] = new Book("タイトル"+num, "著者"+num, 1000*num);
        }

        for (int i=0; i<bookArray.length; i++) {
            bookArray[i].printInfo();
        }
    }

}

bookArray[0] = new Book("Java言語入門", "たろう", 1000);

bookArray[1] = new Book("C言語入門", "じろう", 2000);

bookArray[2] = new Book("Kotlin入門", "はなこ", 3000);

これで、先ほどのループも実行できる（28〜30行目を追加）。

もちろん（条件が合えば）for文を使って各要素のインスタンス化をしても良い。

package lesson09.d00000;

import lesson05.d00000.Book;

public class MainArray {

    public static void main(String[] args) {
        // プリミティブ型の配列
        int[] a = new int[5];
        for (int i=0; i<a.length; i++) {
            System.out.println(a[i]); // プリミティブ型の要素は初期値が入ってる。
        }

        // lesson05で作ったBookの配列
        Book[] bookArray = new Book[3]; // bookArrayをインスタンス化しただけであって、要素はインスタンス化されてない！

        for (int i=0; i<bookArray.length; i++) {
            bookArray[i].printInfo(); // Null Pointer Exception
        }

        // 個別に要素をインスタンス化
        bookArray[0] = new Book("Java言語入門", "たろう", 1000);
        bookArray[1] = new Book("C言語入門", "じろう", 2000);
        bookArray[2] = new Book("Kotlin入門", "はなこ", 3000);
        bookArray[3] = new Book("PHP入門", "たけし", 4000); // ArrayIndexOutOfBoundsException

        // 各要素のprintInfoを実行
        for (int i=0; i<bookArray.length; i++) {
            bookArray[i].printInfo();
        }

        // forで要素をインスタンス化
        for (int i=0; i<bookArray.length; i++) {
            int num = i+1;
            bookArray[i] = new Book("タイトル"+num, "著者"+num, 1000*num);
        }

        for (int i=0; i<bookArray.length; i++) {
            bookArray[i].printInfo();
        }
    }

}

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

int num = i+1;

bookArray[i] = new Book("タイトル"+num, "著者"+num, 1000*num);

}

mainメソッドの引数

mainメソッドの引数はString[]である。これはコマンドラインから実行するときに指定することができる。つまり、プログラムの実行時に（コンパイル時ではなく）値を渡すことができる!!

その他のトピックス

他にも、初期化や多次元配列に関して知っておいた方がいいことがあるが、本講義では取り扱わない。実用の観点からは配列よりもコレクションフレームワークを使うことの方が多く、その説明に時間を使いたいからである。ただし、処理二よっては配列を使った方が都合が良い場合もあるので、ぜひ調べてみて欲しい。