1. 事前準備
   • 用意するもの
   • ドライバの仕組み
2. 2つの方法があるから注意ね
3. 接続手順
   • 接続するための構文
   • データを取得する構文

事前準備

用意するもの

用意するものは以下の通りです。jarファイルとテストデータです。

今回はOracleDBに接続するので、jarファイルをOracleサイトからダウンロード後に「WEB-INF/lib」ディレクトリの直下に配置します。

注意してほしいのがDBのバージョンとJDKのバージョンにあったjarファイルでないと、接続が上手く行かないので注意してください。(僕は1日潰れました。泣)

テストデータは、下記テーブルのデータとします。

SQL> desc AAA;
 Name					   Null?    Type
 ----------------------------------------- -------- ----------------------------
 NO						    NUMBER
 NAME						    VARCHAR2(10)



SQL> SELECT * FROM AAA;

	NO NAME
---------- ----------
	 1 aiueo

ドライバの仕組み

ここで言うドライバとは先程事前に準備すると書いたjarファイルのことを指します。

ドライバを使用することでDBごとの特色を可能な限り考えなくて済むようになり、プログラム(Java)とDBを連携しやすくする事が目的のファイルらしいです。。

あまり、難しく考えすぎるとあれなのでJavaとDBを繋げる時には必要なファイルという事を覚えてもらえば良いです。

2つの方法があるから注意ね

JDBCドライバを使用して接続する方法は「OCI接続」と「Thin接続」があります。

両者にはOracle Clientがインストールされているかの違いがあります。

Thin接続ではOracle Clientがインストールされている必要がなく、現在の主流の接続方法らしいです。

接続手順

接続するための構文

今回はThin接続を行います。

以下が接続するために必要な構文の手順です。

1. JDBCドライバの読み込み
2. データベース接続

//①の構文
final String path = "oracle.jdbc.driver.OracleDriver";
Class.forName(path);

//②の構文
final String URL = "jdbc:oracle:thin:usr1/mypassword@//localhost:1521/ORCLPDB1";
Connection con = DriverManager.getConnection(URL);

データを取得する構文

以下がデータを取得する構文です。

1. 変数文字列にSQL文を格納
2. PreparedStatementに変数を格納
3. ResultSetに実行結果を格納
4. 結果をループ処理で出力

//①
String sql = "SELECT * FROM AAA";

//②
PreparedStatement ps = con.prepareStatement(sql);

//③
ResultSet rs = ps.executeQuery();

//④
while(rs.next()) {
System.out.println(rs.getInt("no"));
System.out.println(rs.getString("name"));
}

1. テストの目的
2. テストの考え方
3. mainメソッドが無いクラスのテスト方法
   • 上手なテスト
4. JUnitで簡単にテストできるよ

テストの目的

テストとは開発したコードに不具合がないか確認し、仕様通りの開発を達成しているかを確認する事を指します。

仕様書で定めた目的を達成するためには作ったらおしまいではなく、あらゆるパターンを考え、そのパターンに対応することができているかを証明しなければいけません。

証明することで品質が保証されるとともに仕様書定めた目的も達成することができます。

本来であれば開発した後には単体テストや結合テスト、システムテストという工程がプログラム開発には含まれている事がほとんどなので、テスト仕様書通りにテストを実施しなければいけません。

しかし、今回は自分が書いたコードが目的の動作なのかを自分で確認する方法を紹介します。

テストの考え方

下記の考え方を大事にしましょう。

• 書いたら試す
• 人が手を加えたものにはミスが起こると考える
• ミスを少しでも0に近づけるために実施

mainメソッドが無いクラスのテスト方法

自分で書いたコードはそのまま実行すれば動作を確認することができますよね。

しかし、mainメソッドがない機能を実装している場合は確認することが実行する事ができないので正常に動くかどうかがわかりません。

そんな時はmainメソッドを持つテストクラスを新規作成し、自分が書いたコードを試しましょう。

public class Animal {
　public String Name;
    public int Age;

    public void ShowProfile(){
        System.out.println( "名前は、" + Name + "、" + Age + "歳です。" );
    }

    public void Speak(){
        System.out.println( "......" );
    }
}

public class TestAnimal {
　public static void main(String args[]){
        showProfile();　 --メソッドテスト
        speak();              --メソッドテスト
    }

　public String Name;
    public int Age;

    public void showProfile(){
        System.out.println( "名前は、" + Name + "、" + Age + "歳です。" );
    }

    public void speak(){
        System.out.println( "......" );
    }
}

上記の様にすることで、mainメソッドのないクラスでも自分の環境でテストを行うことができます。

mainメソッドを追加する場合は、本番稼働するコードには追加せず、Test〜〜の様に新規にクラスを用意してテストしてください！

本番稼働するコードに直接mainメソッドを追加してしまうと、コードを提出する際にmainメソッドを削除しなければいけません。
人が手を加えるという事は何らかのエラーが起きる可能性があるので、せっかくのテストが無駄になってしまいます。

新規にテストクラスを用意してmainメソッドの記述をしましょう。

上手なテスト

上手なテスト方法として正常系と異常系のテスト方法があります。

• 正常系→開発したプログラムが正常に動くか試す
• 異常系→引数に想定外の値を渡す。

正常系は動くかどうかを調べるだけなので簡単なのですが、異常系は工夫をしなければいけません。

下記コードでは足し算をおこなっているのですが、異常系を試す場合だと引数にマイナスの値やNULL値などの予想外の値を入れたりしてテストします。

public class Calc{
  int num1;
  int num2;
  int total;

  public int numTotal(num1,num2){
    this.num1 = num1;
    this.num2 = num2;
    total = num1 + num2;
    return total;
  }
}

JUnitで簡単にテストできるよ

JUnitというJavaの機能を使えばmainメソッドのないクラスでも簡単にテストできるよ。

この記事がJUnitの使用方法を上手に丁寧に説明しているので見てみてください〜〜

EclipseでJUnitを動かす方法

1. オーバーライド
2. オーバーライド

オーバーライド

オーバライドとは親クラスで定義したメソッドを子クラスで子クラス専用のメソッドに書き換える技です。

Javaでは継承をよく使用するのですが、親クラスのメソッドを子クラス用にアレンジしたいなって時に使います。

下記コードはAnimalクラスを継承したDogクラスでAnimalクラスのSpeakメソッドを書き換えています。

public class Animal {
    public void Speak(){
    System.out.println( "......" );
  }
}

public class Dog extends Animal{
  //オーバーライド
  public void Speak(){
    System.out.println("わんわん");
  }
  public static void main(String args[]){
    Dog dog = new Dog();
    dog.Speak(); //わんわんが出力
}

オーバーライド

オーバライドとは引数の違いによって同一のメソッドを呼び出した時に違う処理をさせる技です。

本来であれば処理内容が異なれば別メソッドを用意しなければいけないのですが、オーバライドの技術を使用すれば呼び出し時に引数の数に違いをもたせればいいだけです。

メソッド名は同一なのに処理内容を変更できるのがオーバライドの強みですね！

下記コードは引数が一つある場合の処理と２つある場合の処理です。

public class Animal{
  public void Speak(int i){
    System.out.println("一人で黙々と眠る");
  }

  public void Speak(int i , int y){
    System.out.println("二人で仲良く眠る");
  }
  public static void main(String args[]){
    Animal animal = new Animal();
    animal.Speak(1); //"一人で黙々と眠る"が出力
    animal.Speak(1,2); //"二人で仲良く眠る"が出力
  }
}

◯使い方
①Randumクラスをインポートしてインスタンス化。
Randum rm = new Randum();

②nextInt()メソッドの呼び出し
rm.nextInt();

③整数の範囲を指定
引数に指定した数の範囲の数が生成される。
例：
引数に10を指定した場合は、0〜9の10個の数字。
引数に6を指定した場合は、0〜5の6個の数字。

rm.nextInt(10);

④ランダムの数字をプログラムに当てはめる
例：500、100、50、10、5、１の６個の数字を格納したint型の配列をランダムに出力するプログラム

int coinCase[] = new int[6];
coinCase[0] = 500;
coinCase[1] = 100;
coinCase[2] = 50;
coinCase[3] = 10;
coinCase[4] = 5;
coinCase[5] = 1;

Randum rm = new Randum();
int no = rm.nextInt(6);

System.out.println(coinCase[no]);

//noに０〜５のランダムな数字が割り当てられ、配列のインデックスに指定することで５００〜１の数字をランダムに出力する。

例外処理のfinallyは重要なのか

例外処理を記述する時に思い浮かぶのがファイルの読み書き処理やDB接続などが挙げられるので今回はファイルの読み書き処理を基に解説したい。

public static void main (String[] args){
  try{
    FileWriter fr = new FileWriter("読み書きするファイル名" , true);
    //ファイルに書き込み
    fw.write('aiueo');
    //ファイルの書き込み実行
    fw.flush();
    //ファイルを閉じる
    fw.close();
  }
}

1つ目の構文ではtryの中にファイルの定義からファイルの終了までの一連の処理を記述しているのですが、②の処理「ファイルの書き込み実行」のあとに例外が発生してしまうとファイルを閉じることができなくなってしまう。

その結果ファイルを開けなくなったり、ファイル自体が壊れてしまったりする場合が出てきてしまう。

そうならないためにも下記のようにfinallyにファイルを閉じる処理を記述し、絶対にファイルを閉じる処理にしてしまうのが大切。

public static void main (String[] args){
  try{
    FileWriter fr = new FileWriter("読み書きするファイル名" , true);
    //ファイルに書き込み
    fw.write('aiueo');
   //ファイルの書き込み実行
   fw.flush();
  }catch(IOException e){
    e.printStackTrace();
  }finally{
    //ここでファイルを閉じる
    fw.close();
  }
}

この処理だと例外が起ころうが最後は絶対にファイルを閉じるのでファイルの破損などの障害を未然に防ぐことができる。
この処理にしてしまえばミスが減りますね〜〜〜！

裏技的な例外処理

javaに限りますが、閉じなければいけない処理を書く場合下記のような記述ができます。

public static void main(String[] args){
  try(FileWriter fr = new FileWriter("記述したいテキスト名" , true)){
    //ファイルに書き込み
    fw.write('aiueo');
    //ファイルの書き込み実行
    fw.flush();
  }catch(IOException e){
    e.printStackTrace();
  }
}

この記述は「try-with-resources」構文と呼ばれています。
この構文ではtry()の部分に閉じなければいけない処理を記述することでjavaが自動的に閉じてくれます。

try-catch-finallyと比べて記述も少なく例外が起きようが起きまいが絶対に閉じてくれるので、推奨されています。

1. 前提知識のインターフェース
2. ラムダ式とは
   • ラムダ式の目的
   • メソッドを変数として扱う
   • 関数型インターフェースを楽に記述

前提知識のインターフェース

ラムダ式の話の前にインターフェースの話です。分かる人は飛ばして下さい。

インターフェースとは「クラス内に含まれるメソッドの具体的な処理は記述せずに変数とメソッドの型を定義したもの」になります。

例えば、Phoneというインターフェースを利用してCallクラスやMaileクラスを作成していきます。

--インターフェースPhone
interface Phone{
  String call = "電話をかけます";
  String mail = "メールを送ります";
}

--インターフェースを利用してCallクラスを実装
class Call implements Phone{
  public tell_call(){
    System.out.println(call);  --インターフェースで定義した変数callの呼び出し
  }
}

--インターフェースを利用してMailクラスを実装
class Mail implements Phone{
  public void send_mail(){
    System.out.println(mail);  --インターフェースで定義した変数mailの呼び出し 
  }

  public static void main(String args[]){
    Call c = new Call();
    Mail m = new Mail();
    c.tell_call; --「電話をかけます」が出力
　　　 m.send_mail;  --「メールを送ります」が出力
  }
}

簡単にインターフェースを表すと下記のイメージで問題ないです。

• インターフェースを土台として捉える
• その土台で定義されている空の変数やメソッドなどの道具を取り出し、
• その道具を使える状態(実装)にしていく

ただ、ここで問題になってくるのが抽象クラス(abstract)と似ている問題です。

ここでは詳しく解説しないのですが、抽象クラスは多重継承ができないので一つのクラスしか継承できないので限定的な処理をしたい時に使用します。

反対にインターフェースは多重継承が許されているので色々なインターフェースを継承することができます。

イメージ的にはiPhoneインターフェースとAndroidインターフェースを利用して新しい携帯を作るみたいな感じです。(分かりづらかったらゴメンさなさい)

ラムダ式とは

ラムダ式の目的

ラムダ式の目的は記述を簡略化する事です。構文としては以下の通りです。

引数を渡して処理内容を記述するだけで、普段メソッドを使用する時と何ら変わりません。

(引数) -> {処理内容}

メソッドを変数として扱う

ラムダ式の良いところの1つ目はメソッドを変数のように扱える点です。

使い方としては、インスタンス化する時にメソッドをそのまま記述します。たったこれだけでメソッドを使用することができます。

interface Phone{
　public String Call(String name);
}

public class Main{
　public static void main(String[] args){
　　Phone p = (name) -> { return name + "へ電話をかけます"; };
　　System.out.println(h.method("ビートルズ"));  --ビートルズへ電話をかけます
　}
}

関数型インターフェースを楽に記述

Javaには関数型インターフェースと呼ばれる抽象メソッドを一つだけ持つインターフェースが存在します。
(抽象メソッド→具体的な処理が記述されていないメソッド。定義されているのは型やアクセス修飾子。)

抽象メソッドは先程のメソッドを変数のように扱うでも使用したのが自分が作成した関数型インターフェースや、ConsumerやFunctionといったJavaが用意している関数型インターフェースが存在します。

Javaが用意している関数型インターフェースは説明が長くなってしまうので下記のサイトを見て下さい。めっちゃ分かりやすいです。

https://www.yoheim.net/blog.php?q=20160410

1. 気をつけること
2. 補足

気をつけること

JavaでSQLを扱う際に気をつけないといけないのが「SQLから受け取った値を扱える型をJava側で用意する」ことです。

もしJava側でSQLの値を扱える型が用意できなければ、DBに保存されている値を間違った形で取得してしまい、整合性のないプログラムになってしまいます。

まずは、SQLとJavaの型の対応を見ていきましょう。(OracleDBで自分がよく使うデータ型)

ここで気をつけなければ行けないのが日付を扱うDATE型とTIMESTAMP型です。

DATE型とは「年・月・日」を扱うデータ方に対してTIMESTAMP型は日付と時刻を扱うデータ型になります。

−−DATE型(YYYY/MM/DD) 
2021/08/20

--TIMESTAMP型(YYYY/MM/DD HH:MM:SS)
2021/08/20 12:30:25

日付を扱うDATE型やTIMESTAMP型も文字列を扱う際のようにString一つで扱えたら良いのですが、Javaではそこが難しいです。

下記のようなコードで対応しましょう。

/*DATE*/
String sql = "SELECT 登録日 FROM SAMPLE LIMIT1";
PreparedStatement ps = con.preparedStatement(sql);
ResultSet rs = ps.excuteQuery();

java.util.Date date = new java.util.Date();  −−DATE型を扱えるパッケージの呼び出し
date = rs; 

/*TIMESTAMP*/
String sql = "SELECT 登録日 FROM SAMPLE LIMIT1";
PreparedStatement ps = con.preparedStatement(sql);
ResultSet rs = ps.excuteQuery();

java.sql.Timestamp ts = rs.getTimesatamp(1);
java.util.Date date = new Date(1);

補足

日付型の変換はよく使用するので紹介しておきます。

この方法を使えばSQLの型をあまり気にせずにJava側で値を受け取ることができまーす。

/*日付型を文字列に変換*/
SELECT TO_CHAR('登録日, YYYY/MM/DD'),
               TO_CHAR('登録日, YYYY/MM/DD HH12:MM:SS')  --12時間形式
               TO_CHAR('登録日, YYYY/MM/DD HH24:MM:SS')  --２４時間形式

/*文字列を日付型に変換*/
SELECT TO_DATE('登録日, YYYY/MM/DD'),TO_DATE('登録日, YYYY/MM/DD HH12:MM:SS') --12時間形式
TO_DATE('登録日, YYYY/MM/DD HH24:MM:SS') --２４時間形式

1. 概略
2. ラッパークラスとは
3. 難しく考えない

概略

基本型の値が格納されている変数をオブジェクトとして扱うためのもの。

「オブジェクトとして扱う＝クラスとして定義する」なので、自分の目的に合わせて基本型の値を加工することができます。

ラッパークラスとは

Javaでは型安全という考え方があるので型に対して厳格な姿勢が求められるため、一度定義した型に対して途中で変更するとJVMさんが「型を勝手に変えるな！」と怒ってエラーを吐きます。

しかし下記のようにプログラムによっては途中で定義した型を変更したい時があると思います。

public static void main(String args[]){
  int i = 2021;
  
  //文字列として扱いたい！
 　String sr = u;  // error

これだとエラーになるのですが、
Javaではラッパークラスという「ラッピングするクラス」で基本型の値を包んであげることでデータの加工ができるようになります。

下記のコードのようにint型の変数iを様々な形に加工することができます。このコードでは数字を扱うことしかできなかった変数iを加工するためにラッパークラスとして扱うようにしています。

int i = 1; //int型の変数

Integer itg = new Integer(i); //ラッパークラスの定義

String s = Integer.parseInt(i);　//文字列に変換
System.out.println(s); //文字列型の1が出力

難しく考えない

基本型の変数を包んであげるだけです。
基本型を加工するために変数を

「メソッドを使用するためにはクラスがないと使えないので様々な加工方法(メソッド)を持っているラッパークラスでラッピングする」くらいの認識で大丈夫です。

1. 前提条件
2. ジェネリクスとは
   • ジェネリクスの使用目的
3. 便利な使い方

前提条件

Javaには型安全という考え方があります。

型安全という考え方は名前の通り、「変数やメソッドに型を指定して安全にプログラムを組み立てていきましょう！」という考え方です。

例えば、型の指定をしていない変数mojiに1を代入したとします。

この変数mojiには1という文字が入っているのですが、文字なのか数字を判別することができませんよね。

自分からすると文字の1だと考えて定義した変数が自分以外の誰かからすると数字の1と捉えてしまう可能性があります。

その可能性を潰すためにも型を指定することがJavaのルールになっています。

public class Num {
   public static void main(String args[]) {
     String moji = "1";

      System.out.println(moji);

     System.out.print(moji + moji);　　　　//11

    /*変数mojiがint型だった場合
        System.out.println(moji + moji);
        --2
    */
    }

}

ちなみにJavaを勉強する前はPHPを独学で学んでいたのですが、PHPのような変数やメソッドに型を指定しない言語を動的型付け言語と言いいます。
それに対してJavaのような明示的に型を指定しないといけない言語を静的型付け言語と言います。
僕のようにPHPのような動的片付け言語から移行してきたから人からするとストレスを感じる部分なので少しづつなれていきましょう！

ジェネリクスとは

Javaは型を指定して安全にプログラムを組まないといけない言語という事が理解できたところで本題です。

ジェネリクスとは、コレクションに対して型を指定する方法です！

コレクションとは値の追加、保持などができるjava特有の配列のようなものです。（厳密には配列ではない）

下記のコードを見れば分かると思うのですが、

boxという名前のコレクションの型をStringとして指定することにより、文字列しか格納できないコレクションになりました。

//<>の部分にStringを指定！文字列しか格納できないコレクション
List<String> box = new ArrayList<String>();
box.add("hello");
box.add("bye");

for(String i: box) {
	System.out.println(i);
	}

ジェネリクスの使用目的

ジェネリクスの使用目的を考える前にコレクションの使用目的を考えてみましょう。

コレクションは複数の値を好きなだけ入れきれることができる配列のようなもなので、何かに関連したデータをまとめて扱いたい時に使用しますよね。

• ポジション→｛ガード、フォワード、センター｝
• 美味しいご飯→｛寿司、蟹、ハンバーグ、味噌汁、｝

上記のようにまとめることで関連する情報をまとめておくことで後で使用する時に何かと便利です。

そのためコレクションを使用するときはまとめた情報を繰り返し処理するループ処理などと併用されます。

ここで、問題になってくるのがコレクションには複数の値を入れきれるということです。

例えば下記のようなコレクションがあった時はどうでしょうか？

public static void main(String args[]){
  List<> box = new ArrayList<>();
  box.add(1);
  box.add("aiueo");
  box.add("hello");
  //boxの中身→｛数字の1、文字列のaiueo、文字列のhello｝

for(String i: box){
  System.out.println(box);  //文字列でループ処理を回す処理なのでエラーになる
}

このようなコードだと様々な型が格納されておりループ処理の中で使用するのができません。

そこで、ジェネリクスを使用してコレクションの型を指定し一つの型だけを格納できるコレクションとしてせんげんしてあげます。

public static void main(String args[]){
  List<String> box = new ArrayList<String>();  //String型として扱う宣言
  box.add("1");
  box.add("aiueo");
  box.add("hello");

  for(String i: box){
    System.out.println(box);  //文字列しか格納していないのでエラーにならない
  }
}

このように<型名>を記述することでコレクションをどのように扱うかを定めたるものがジェネリクスになります。

こうすることで一つの型しか格納できなくなるので型安全が保てますよね！

便利なコレクションを安全に使うことができるジェネリクスです！

便利な使い方

ジェネリクスを便利に使うなら宣言時にEという文字を設定して宣言しておき、呼び出す時に型を定義するという方法があります。

<E>と記述した部分は「T」でも「Z」でも「aiueo」等なんでも問題ないです。

このような代替文字を置いておくことで「呼び出し時に型を定義してね」という意味になります。

メソッドを例えば個人が作成したHero型に設定することも可能なので、ケースに合わせた型宣言が可能になります。

//メソッドの型をEとしておく
public void Box<E>{
  System.out.println("ジェネリクス");
}

public static void main(String args[]){
  Box<String> b = new Box<String>;
  Box<int> b = new Box<Integer>;
}