どうも、kumaです。

 

 

先日「SoftBank World 2017」に

参加してきました。

 

 

今年はザ・プリンスパークタワー東京で

開催され、私は初日の孫正義の基調講演

のみ参加したのですが、かなり広い会場

で立ち見が出るほどの大盛況でした。

 

 

公演の内容を少しまとめると、

 

 

18世紀の産業革命

⇒ジェントリ(貴族・地主)が産業や

インフラに投資して成し遂げられた。

 

(ジェントリはジェントルマンの語源)

 

これから起こる情報革命

⇒ソフトバンクがジェントリになり

リスクを背負って技術に投資していく

 

 

的なことを言っていました。

 

 

あとはいつも通り買収の自慢話も

ありました。

 

 

その他、ARMをはじめソフトバンク

グループ傘下の会社のCEO達の

貴重なお話も聞けました。

 

 

ちなみに公式ではありませんが

youtubeから見れます。

https://www.youtube.com/watch?v=6vXr_lrypQ4

 

 

 

孫正義の話が直接聞けるのは

このSoftBankWorldだけだと

思うので、来年も参加したい

と思います。

 

 

 

ではまた!!

AD

 

どうも、kumaです。

 

 

先日2016年後半から2017年

前半にかけて最も使われた

プログラミング言語が発表

されました。

 

 

結果は以下の通りです。

 

  1. JavaScript (65%)
  2. HTML/CSS (60%)
  3. Java (47%)
  4. SQL (42%)
  5. Python (32%)
  6. PHP (30%)
  7. C# (20%)
  8. C++ (17%)
  9. C (15%)
  10. TypeScript (12%)

2017年に最も使われたプログラミング言語14選より

 

 

JavaScriptやHTMLは

クライアントサイドの

必修科目、

 

SQLはサーバーサイドの

必修科目ですので、実質

Javaがダントツで1番と

捉えても良さそうです。

 

 

特に気になったのがPythonの

躍進です。

 

 

元々数学系のライブラリが

充実していたのに加え、

近年はAIの分野でシェアを

増やしてきているようです。

 

 

唯一Javaの地位を脅かす

可能性がある言語かと

思います。

 

 

JavaでAIっていう話はあまり聞かない

ですが、Javaも常にバージョンアップを

重ねているため、今後に期待したい

ですね。

 

 

ではまた。

AD

 

 

どうも、kumaです。

 

 

今回はアクセス修飾子について

書いていきます。

 

 

アクセス修飾子とは、クラスや

そのメンバーがどこからアクセス

可能であるかを決定するものです。

 

 

アクセス修飾子にはpublicや

private等の種類があり、それぞれ

アクセス制限の強さが異なります。

 

 

このアクセス修飾子には具体的に

どのような役割があるのでしょうか。

 

 

アクセス修飾子の目的

 

アクセス修飾子には、メンバ変数に

不正な値が入らないように

外部からのアクセスに制限を

かける目的があります。

 

 

これはオブジェクト指向の3大要素

である「カプセル化」を実現する

ために役立っています。

 

 

アクセス修飾子が活躍する例として、

セッター、ゲッターが挙げられます。

 

 

セッター、ゲッターは

変数のアクセス修飾子をprivateと

して外部からの直接的なアクセスを

禁止しておき、

 

 

その変数に値を設定、取得する

ためのpublicなセッターメソッド、

ゲッターメソッドを用意するという

ものです。

 

 

セッターメソッドを利用することで、

受け取った値を本当にメンバ変数に

設定してよいのかを吟味できます。

 

 

ゲッターメソッドも、メンバ変数の

値をそのまま渡してしまって良いのか

判断するためにワンクッション

置くことが出来ます。

 

 

アクセス修飾子の種類

 

アクセス修飾子の種類と

その制限レベルを以下の表に

まとめます。

 

 

アクセス修飾子  制限レベル
public  どこからでもアクセス可能 
protected  サブクラス、または同じパッケージからアクセス可能 
なし  同じパッケージからアクセス可能 
private  同じクラス内からのみアクセス可能 

 

 

それぞれどこからのアクセスが

必要でどこからアクセスされたら

困るのかをちゃんと意識して

実装するようにしましょう。

 

 

 

 

ではまた!!

AD

どうも、kumaです。

 

 

前回の記事にリクエストを

いただいたので、

 

 

ファイルのクローズ処理やDB

コネクションのクローズ処理

について書いていきます。

 

 

まず今回はDBコネクションの

クローズ処理について説明して

いきたいと思います。

 

 

DBアクセスの処理を実装した

ことがある方はわかると思い

ますが、JavaでDBに接続する

処理を書く場合、

 

以下のようJDBCドライバーの

ロードとコネクションの取得が

必要になります。

 

 

//JDBCドライバーのロード(Oracleの場合)
Class.forName("oracle.jdbc.driver.OracleDriver");

//コネクションを取得
Connection conn = DriverManager.getConnection(
            "jdbc:oracle:thin:@ホスト名( or IPアドレス):ポート番号:DB名",
            "ユーザ名",
            "パスワード"
);

 

DBアクセスの処理では、

DBとの接続(コネクション)は

用が済んだら解放してあげる

必要があります。

 

 

まずはその解放の仕方を

見ていきましょう。

 

 

クローズの仕方

 

DBコネクションのクローズ処理

自体はそんなに難しくなく、

Connectionクラスのclose機能を

使用します。

 

コネクション.close();

 

 

ここで注意しなければならいのは、

DBアクセスの処理は必ず例外処理

処理を用いてtryブロックの中で

実装するということです。

 

 

そして、クローズ処理は必ず実行

されるよう、finallyブロックの中で

実装します。

 

 

そうしないとDBの操作でエラー

となり例外が発生した場合に

DBに接続しっぱなしになって

しまうからです。

 

 

実際にDBにアクセスし、操作する

ための機能を実装してみましょう。

 

 

[DbAccess.java]

import java.sql.DriverManager;
import java.sql.Connection;

class DbAccess {

    public void dbOperate() {

        Connection conn = null;
        String url = "jdbc:oracle:thin:@ホスト名( or IPアドレス):ポート番号:DB名";
        String user = "ユーザ名";
        String password = "パスワード";

        try {
            conn = DriverManager.getConnection(url, user, password);

            // データベースに対する処理を実装

        } catch (SQLException e) {
            // 例外処理
        } finally {
            // コネクションの解放
            conn.close();
        }
    }
}

 

 

こんな感じで、DBコネクションは

クローズ処理を忘れないように

しましょう。

 

 

また、そもそもDBに接続する

ところでエラーとなりコネクションが

確立されていない場合もあります。

 

 

その場合、connはnullのまま

ですので、クローズ処理をすると

NullPointerExceptionが発生します。

 

 

それを避けるため、コネクションの

クローズは以下のように実装して

あげると良いかと思います。

 

 

if (conn != null) conn.close();

 

 

 

さて、このクローズ処理ですが、

書き忘れたらどうなるのでしょうか。

 

 

close処理は必要か?

 

DBコネクションですが、Java側では

プロセスが終了すれば自然と

クローズされます。

 

 

しかし、DB接続時はOracleDB側でも

内部的にカーソルオブジェクトが

生成されるため、

 

closeメソッドを呼んであげないと

そのうちカーソル数の上限に

達してしまいます。

 

 

また、1プロセスの中で複数回DBに

アクセスするのであれば、前回の

DB接続が確立されたままになる

ため、少しずつ負荷が増していきます。

 

 

DBコネクションの クローズ処理は、

気を付けないと結合テストは大丈夫

だったけど負荷テストで落ちた、

 

なんてことの原因になるので

しっかり意識して実装する

ようにしましょう。

 

 

ではまた!!

 

 

 

どうも、kumaです。

 

 

今回はインターフェースの宣言

の仕方とその実装方法について

書いてきます。

 

 

 

インターフェースはメンバ変数や

メソッドの定義にいくつかルールが

あるためこの機会に覚えて

おきましょう。

 

 

 

インターフェースの宣言

 

インターフェースはクラスと違い、

「interface インターフェース名」

で宣言します。

 

 

 

インタフェースは定数と抽象メソッドだけ

メンバーとして持つことが出来ます。

 

 

 

また、抽象メソッドには引数と

戻り値の型のみが定義できます。

 

 

 

インターフェースのコードは

以下のようになります。

 

[Runnable.java]

interface Runnable {

    // メンバ変数(定数のみ定義可能)
    int SPEED = 60;

    // 抽象メソッド(引数も設定可能)
    void run();

}

 

 

気を付けなければならないのは、

メンバ変数と抽象メソッドの修飾子は

全てpublicである必要があるという

点です。

 

 

 

ただし、publicは省略可能で、

何も指定しなければ修飾子は

publicとして扱われます。

 

 

 

また、メンバ変数は定数の扱いと

なるため、「static final」が省略された

状態となっています。

 

 

 

さらに、インターフェース自身も

修飾子はpublicとなります。

 

 

 

したがって、インターフェースを

何も省略しない形で書くと

以下のようになります。

(この形で書いても問題ありません。)

 

 

[Runnable.java(省略なしver)]

public interface Runnable {

    // メンバ変数(定数のみ定義可能)
    public static final int SPEED = 60;

    // 抽象メソッド(引数も設定可能)
    public void run();

}

 

 

インターフェースの実装

 

次にインターフェースを実装

する側のコードを見てみましょう。

 

 

 

インターフェースを実装する場合は

クラス名の後ろに

「implements インターフェース名」

と書きます。

 

 

 

上のRunnable.javaを実装した

コードは以下の通りです。

 

 

class Car implements Runnable {

    // インターフェースの抽象メソッドの中身を実装(必須)
    public void run() {
        System.out.println("時速" + SPEED + "kmで走行");
    }
}

 

 

インターフェースを実装したクラスでは

インターフェースに定義された抽象

メソッドを実装しないとコンパイルエラー

になるので注意してください。

 

 

 

また、インターフェースに定義された

抽象メソッドのアクセス修飾子は

必ずpublicのため、実装したメソッドの

アクセス修飾子は必ずpublicとします。

 

 

 

⇒これは省略不可となります。

 

 

理由はアクセス修飾子なしの

アクセス範囲がpublicよりも

狭いためです。

 

 

インターフェースの多重継承

 

インターフェースの特徴として、

抽象クラスとは違って多重継承が

可能という点が挙げられます。

 

 

実装先のクラスで

「implements インターフェース名1, インターフェース名2」

と書くことで多重継承が可能です。

 

 

[Hv.java]

class Hv implements Runnable, RunnableByBattery {

    // インターフェース1(Runnable.java)の抽象メソッドの中身を実装(必須)
    public void run() {
        System.out.println("時速" + SPEED + "kmで走行");
    }

    // インターフェース2(Runnable.java)の抽象メソッドの中身を実装(必須)
    public void runByBattery(int speedByBattery) {
        System.out.println("バッテリーを使い、時速" + speedByBattery + "kmで走行");
    }
}

 

 

 

このとき多重継承でつながっている

インタフェース内で、一つの変数名が

複数箇所で定義されていると

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

 

 

上の例だとRunnable.javaと

RunnableByBattery.javaの両方に

「SPEED」という変数がある場合に

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

 

 

インターフェースによるインターフェースの継承

 

インターフェースは他の

インターフェースを継承する

ことが認められています。

 

 

 

実装ではなく「継承(extends)」

である点にご注意ください。

 

 

[RunnableByBattery.java]

interface RunnableByBattery extends Runnable {

    // 定数のためメンバ変数は上書き不可
    // NG int SPEED = 60;

    // 抽象メソッド(インターフェースのため親の抽象メソッドを実装する必要なし)
    void runByBattery(int speedByBattery);

}

 

 

上記のように、RunnableByBattery.javaも

Runnable.javaと同様にインターフェースで

あるため、親の抽象メソッドを実装する

必要はありません。

 

 

 

RunnableByBattery.javaを実装する先の

クラスに両インターフェースの

抽象メソッドを実装します。

 

 

また、Runnableクラスに定義された

メンバ変数は定数であるため、

再定義(上書き)不可となります。

 

 

 

このように、インターフェースは

様々な活用方法があり、システム開発の

現場でも頻繁に使われ、重要な役割を

果たしています。

 

 

 

もし皆さんの仕事先でJavaを使って

いるのであれば、interfaceがどのように

使われているのか見てみてください。

 

 

 

たくさんソースコードを見ることで

インターフェースについての知見が

より深まると思います。

 

 

 

ではまた!!

 

 

 

どうも、kumaです。

 

 

今回はインターフェースについて

書いていきます。

 

 

インターフェースと聞いて、

「なんのためにあるの?」

 

「抽象クラスと何が違うの?」

 

 

と思っている方も多いのでは

ないでしょうか。

 

 

インターフェースはシステム開発の

現場では頻繁に用いられるため、

その役割と使い方をしっかり理解

しておく必要があります。

 

 

インターフェースの役割

 

インターフェースとは、プログラムの

機能の概要のみを記述したものです。

 

 

クラスにはこのインターフェースを

実装することができ、インターフェースに

書いた機能概要の詳細は実装した

先のクラスに書きます。

 

 

つまり、インターフェースには

”このプログラムではこの機能

を持たせる”ということをあらかじめ

書いておくことができます。

 

 

私はこのインターフェースが

コーディングの際に外部設計的な

役割をしてくれていると思っています。

 

 

プログラムの細かい処理を

記述する前に、インターフェースという

機能概要を用意してあげることで、

あとは誰かがその中身を実装

することでプログラムが完成します。

 

 

以上のことから複数人でプログラムを

仕上げる場合はインターフェースは

重要な役割を果たすものと考えます。

 

 

抽象クラスとの使い分け

 

インターフェースには複数のクラスに

実装できるという利点があります。

 

 

よく抽象クラスとどう違うのか?と比較を

されることがありますが、抽象クラスを

継承する場合は複数のスーパークラスの

継承(多重継承)が認められていないため、

1つのサブクラスに1つの抽象クラスしか

継承できません。

 

 

その他抽象クラスとインターフェースでは

もろもろ違うところがあるのですが、結論

どっちを使えば良いのか?

 

 

まず、あるクラスとクラスで

「A is B」の関係が成り立つ場合。

 

 

例えば、

「ハイブリッドカー(A)は車(B)です。」

という関係が成り立つ場合は

抽象クラスを使ってクラスとクラスとの

間に継承関係を持たせるべきです。

 

public abstract class Car {}
public class Hv extends Car {}

 

 

そして、「A have B」の関係が

成り立つ場合。

 

 

例えば

「ハイブリッドカー(A)は走る(B)

 という機能を持ちます。」

という関係が成り立つ場合は

インターフェースを使って機能の

詳細を実装先のクラスに書くべきです。

 

public interface Runable {}
public class Hv implements Runable {}

 

 

言い切ってしまいましたが、

抽象クラスやインターフェースの

考え方は難しく、若干個人的な

見解が入っているかもです。

 

 

 

さて、次回は今回紹介した

インターフェースを宣言する方法と

その中身を実装する方法について

書きたいと思います。

 

 

インターフェースを使いこなせるように

なって、Javaのスキルを極めましょう。

 

 

 

ではまた!!

 

どうも、kumaです。

 

 

皆さんは変数名やメソッド名を

付けるとき、悩まずにスッと

命名できていますか?

 

 

私は無理です。

 

 

ちょっと前までGoogle翻訳を

ブックマークしていたのですが、

最近便利なサービスを発見

しました。

 

 

それが、codicです。

 

 

codicは、プログラマーのための

ネーミングツールです。

 

 

日本語でどんなワードや文を

ネーミングしたいかを入力すると

それに応じたネーミングが

生成されます。

 

 

このサービスの便利なところは、

ネーミング規則がパスカルケース、

スネークケース、キャメルケースに

それぞれ対応しているというところです。

 

 

そして、ログインしなくても使える

という点もポイント高いです。

 

 

codicの使い方をちょっとだけ

ご紹介します。

 

 

codicの使い方

 

codicは普通に検索するか、

以下のURLでアクセスできます。

 

https://codic.jp/

 

 

アクセスすると次の画面が出ます。

 

 

 

ログインしなくても使えるので、

このまま「使ってみる」を押します。

 

 

 

変換画面が表示されます。

左側に日本語を入力する形に

なっています。

 

 

 

左上の「aA」を押すと記法を選択

できます。

 

 

とりあえずパスカルケースを

選択して、いつも例で使っている

「ハイブリッド車」クラスを変換

してみます。

 

 

 

なるほど。

 

 

いつも「Hv」で使っていましたが、

「HybridVehicle」の略なんですね。

(知ってましたが。。)

 

 

次にキャメルケースを選択して

メソッド名を入れてみます。

 

 

 

義務教育で英語を習ったけど

「At」じゃなかったと思う。

 

 

日本語は複雑ですからね。

 

 

「で」が意味するのが「場所」であれば

「At」は正しいです。

 

 

ちょっと変えてみます。

 

 

 

これですね。

 

 

確かいつも「runWithBattery」を

使ってしまっていたので今後

気を付けます。

 

 

この辺はいいのですが、codicが

本気を出すのは以下の場合です。

 

 

 

これをGoogle翻訳に任せると。

 

 

 

このように、codicを使えば

プログラミングでよく使われる

文はいい感じにネーミングして

くれます。

 

 

これからはcodicをブックマーク

しておいて、ネーミングに時間を

掛けないようにしましょう。

 

 

ではまた!!

 

 

 

どうも、kumaです。

 

 

今回は抽象クラスを使用する

ことのメリットについて

書いていきます。

 

 

抽象クラスのメリットを考える

前に、抽象クラスにはどんな

特徴があるのかおさらいして

おきましょう。

 

  • インスタンス化できない
  • サブクラスに機能を継承することが前提
  • 抽象クラスで宣言された抽象メソッドは継承されたサブクラス側で必ずオーバーライドする 
 
この3点が抽象クラスの
特徴となります。
 
 
ではなぜこんなものを
用いる必要があるのか。
 
 
そのメリットについて
考察してみます。
 
 

抽象クラスを使うメリットとは?

 

抽象クラスを使うことのメリットとして、

以下の点が挙げられると思います。

 

  • サブクラスを定義した際に、メソッドの実装忘れやメソッド名に間違いがあればコンパイルエラーが起き、コーディングミスを避けることができる
 
要するに、複数人で開発を行う
場合に実装レベルのルールを
作れるという形で私は捉えて
います。
 
 
例えば、「鳥」というクラスがある
とします。
 
 
「鳥」というのは抽象的なもので、
実際は「ハト」やら「スズメ」が
「鳥」の実態となります。
 
 
もし「ハト」クラスに「飛ぶ」という
機能をつけ忘れてしまった場合、
そのハトは飛べない「ハト」になって
しまいます。
 
 
そこで「鳥」の遺伝子は
「鳥」という抽象クラスに「飛ぶ」という
抽象メソッドを用意します。
 
 
そして、「鳥」クラスのサブクラス
である「ハト」クラスは「飛ぶ」機能を
実装しないとエラーになるのです。
 
 
プログラマーの中にはコーディングを
任せると独自ルールで作ってしまう
人が結構います。
(私も気付くとそうなってる時があります。)
 
 
開発の現場では大人数で一つの
システムを作り上げるので、決まった
路線から外れたことをされないように
抽象クラスを使うのだと思います。
 
 
 
ではまた!!
 

【Java】抽象クラス

テーマ:

 

 

どうも、kumaです。

 

 

今回はリクエストをいただいた

ので、抽象クラスについて書きます。

 

 

抽象クラスについて、なんとなく

概念はわかっているけど詳しい

ところはよくわからない。

 

 

インターフェースとどう違うのか

よくわからない。

 

 

そんな声をよく耳にします。

 

 

そんな疑問を解消すべく、この

記事を書いていきたいと

思います。

 

 

抽象クラスとは

 

抽象クラスとは、

文字通り抽象的なクラスであり、

具体的な処理はこれを継承した

クラスに記述させるというものです。

 

 

抽象クラスの中には抽象メソッドを

定義し、継承先のクラスで

オーバーライドして具体的な

処理を書きます。

 

 

通常のクラスとの違いは、

抽象クラス単体ではインスタンスを

生成できないという点です。

 

 

あくまで抽象的な存在であり、

それ自身のオブジェクトは

作れないようになっています。

 

 

抽象クラスの書き方

 

抽象クラスを定義するときは、

クラスの宣言の前に

abstract」をつけます。

 

 

そしてその中に定義する

抽象メソッドは、中身を実装

しないため、「{}」をつけずに

「;」で閉じます。

 

 

修飾子や戻り値の型、引数は通常の

メソッドと同じように書きます。

 

// 抽象クラス
abstract class Car {

    // 抽象メソッド
    public void run(int speed);

}

 

 

この抽象クラスを継承する場合、

通常のクラスの継承と同様に

extends」で継承します。

 

// 抽象クラスを継承
class Hv extends Car {

    // 抽象メソッドをオーバーライド
    public void run(int speed) {
        System.out.println("時速" + speed + "kmで走行可能。");
    }

}

 

 

ここでもし抽象メソッドを

オーバーライドするのを

忘れたり、メソッド名や

戻り値の型を間違えたりすると

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

 

 

抽象クラスの書き方と概念は

なんとなくわかっていただけた

でしょうか。

 

 

使い方はわかったけど

実際どういう場面で

使えば良いのか?

 

 

抽象クラスを使うことの

メリットは何なのか?

 

 

その辺を次回の記事で書きたい

と思いますので、これからも

ブログを読んでいただけると

ありがたいです。

 

 

 

ではまた!!

 

【Java】super!

テーマ:

どうも、kumaです。

 

 

今回もタイトルがかっこいい

シリーズです。

 

 

Javaにおけるクラスの考え方の

一つに、子クラスは親クラスの

機能を継承するというものが

あります。

 

 

なので当然親クラスが持つ

コンストラクタも子クラス

に引き継がれます。

 

 

では親クラスのコンストラクタ

を呼び出す場合、どう実装すれば

よいのでしょうか。

 

 

正解は、「何もしない」です。

 

 

どういうことかと言うと、

子クラスのインスタンスを

生成したタイミングで

勝手に呼び出されます。

 

 

今回もいつも通りCarクラスの例を

使って見ていきましょう。

 

 

[Carクラス]

class Car {
    // Carクラスのコンストラクタ
    public Car() {
        System.print.out("ガソリンを使い、時速60kmで走行可能。");
    }
}

 

[Hvクラス]

class Hv extends Car {
    // 子クラスのコンストラクタ
    public Hv() {
        System.print.out("さらに、バッテリーを使い、時速60kmで走行可能。");
    }
}

 

[Mainクラス]

class Main {

    public static void main(String[] args) {
        Hv hv = new Hv();
    }
}

 

[実行結果]

ガソリンを使い、時速60kmで走行可能。
さらに、バッテリーを使い、時速60kmで走行可能。

 

 

このように、子クラスの

インスタンスを生成すれば

自動的に親クラスのコンストラクタ

も呼ばれます。

 

 

このときに重要なのが、

親クラスのコンストラクタ

の方が先に呼び出される

いうことです。

 

 

ではもし親クラスが複数の

コンストラクタを持っていたら

どうでしょう。

 

 

[Carクラス]

class Car {
    // Carクラスのコンストラクタ①
    public Car() {
        System.print.out("ガソリンを使い、時速60kmで走行可能。");
    }

    // Carクラスのコンストラクタ②
    public Car(int speed) {
        System.print.out("ガソリンを使い、時速" + speed + "kmで走行可能。");
    }
}

 

[Hvクラス]

class Hv extends Car {
    // 子クラスのコンストラクタ
    public Hv() {
        System.print.out("さらに、バッテリーを使い、時速60kmで走行可能。");
    }
}

 

[Mainクラス]

class Main {

    public static void main(String[] args) {
        Hv hv = new Hv();
    }
}

 

[実行結果]

ガソリンを使い、時速60kmで走行可能。
さらに、バッテリーを使い、時速60kmで走行可能。

 

この場合、引数無しの

コンストラクタ①がデフォルトで

呼ばれます。

 

 

さて、ここでコンストラクタ②を

呼びたいとなった場合に登場する

のがsuper()です。

 

 

super()は親クラスの

コンストラクタを明示的に

呼び出す機能になります。

 

 

通常親クラスのコンストラクタは

何もしなくても勝手に呼び出される

のですが、引数付きのコンストラクタ

はそうはいきません。

 

 

そこでsuper()が登場するわけです。

 

 

super()には引数を渡すことが

できるので、子クラスの

コンストラクタの中で書いて

あげることで呼び出すことが出来ます。

 

 

上の例でコンストラクタ②

を呼び出したい場合は、

Hvクラスを以下のように

修正します。

 

 

[Hvクラス]

class Hv extends Car {
    // 子クラスのコンストラクタ
    public Hv() {

        // コンストラクタ②を明示的に呼び出し
        super(70);
        System.print.out("さらに、バッテリーを使い、時速60kmで走行可能。");
    }
}

 

[実行結果]

ガソリンを使い、時速70kmで走行可能。
さらに、バッテリーを使い、時速60kmで走行可能。

 

このように、親クラスの

コンストラクタ②が最初に

呼ばれます。

 

 

そして、お分かりかと思いますが

コンストラクタ①は呼ばれていません。

 

 

superで呼び出すコンストラクタを

指定した場合はデフォルトの

コンストラクタは呼び出されない

のです。

 

 

さて、このsuper()を使う際に

気をつけなければならない点

がいくつかあります。

 

 

一つは、superで呼び出せるのは

1世代上の親クラスのコンストラクタ

だということです。

 

 

上の例で、もしHvクラスのさらに

子クラス(Carクラスの孫クラス)

でPriusというクラスがあったと

します。

 

 

このPriusクラスからsuper()を

呼び出した場合、Carクラスでは

なくHvクラスのコンストラクタ

が呼び出されます。

 

 

そしてもう一つ、super()を

書ける場所についてです。

 

 

super()はコンストラクタの

中にしか書けません。

 

 

そして、コンストラクタの中で

一番先頭に書かなくては

なりません。

 

 

なので、以下の書き方はNGと

なります。

 

 

[Hvクラス]

class Hv extends Car {
    // 子クラスのコンストラクタ
    public Hv() {

        // OK コンストラクタの一番先頭でのみsuper()を呼び出し可能
        super();
        System.print.out("さらに、バッテリーを使い、時速60kmで走行可能。");
        // NG コンストラクタの先頭以外ではsuper()を呼び出せない
        // super(70);
    }

    public void runSlow() {
        // NG コンストラクタ以外のメソッドでsuper()は呼び出せない
        // super();
    }
}

 

 

このようにsuperを使う時は

注意点がたくさんあり、今すぐ

使いこなせるようになるのは

難しいかもしれません。

 

 

もし開発の現場でsuper()が使わ

れているソースコードを見かけ

たらそれがどんな役割を担って

いるのか注目してみてください。

 

 

ではまた!!