java – ページ 3 – サイゼントの技術ブログ

2021年5月5日

java：例外を先に生成して後でthrowする

通常のjavaのソースコードでは、例外を発生させると同時にthrowしていると思います。
しかし、例外クラスもクラスの一つであり、newするとオブジェクトが生成されますので、先に例外クラスのオブジェクトを生成し、オブジェクトとしてやりとりした後、後でthrowすることが可能です。

以下、サンプルコードです。
FileNotFoundExceptionを生成した後にIOExceptionを生成・上書きし、IOExceptionを返すというサンプルコードです。

【サンプルコード】

・ExceptionTest.java

import java.io.FileNotFoundException;
import java.io.IOException;

public class ExceptionTest {

    public static void main(String［］ args) {

        Exception ex = null;
        ex = exceptionMaker();

        try {
            throw ex;
        } catch (FileNotFoundException e1) {
            System.out.println("FileNotFoundException");
        } catch (IOException e2) {
            System.out.println("IOException");
        } catch (Exception e3) {
            System.out.println("Exception");
        }

    }

    static Exception exceptionMaker() {

        Exception ex = null;

        ex = new FileNotFoundException();
        ex = new IOException();

        return ex;

    }

}

import java.io.FileNotFoundException;

import java.io.IOException;

public class ExceptionTest {

public static void main(String［］ args) {

Exception ex = null;

ex = exceptionMaker();

try {

throw ex;

} catch (FileNotFoundException e1) {

System.out.println("FileNotFoundException");

} catch (IOException e2) {

System.out.println("IOException");

} catch (Exception e3) {

System.out.println("Exception");

}

static Exception exceptionMaker() {

Exception ex = null;

ex = new FileNotFoundException();

ex = new IOException();

return ex;

}

【実行結果】

IOException

1	IOException

いかがでしたでしょうか。

今回の記事では、先に例外クラスのオブジェクトを生成して後でthrowできることを確認しました。
しかし、通常、後でthrowするようなソースコードは書かないと思います。
少なくとも、今回のような例では、フラグ変数でどの例外を返すかの情報を保持し、後で例外オブジェクトを1回だけ生成するべきです（オブジェクトの生成にはリソースが必要なため）。

実務の中で後からthrowしたいという話が出たので、そもそもできるのかというのを確認したのですが、できたとしてもトリッキーな印象は否めないので、このようなソースコードを書くことには慎重になった方が良いと思います。

2020年11月29日

リスコフの置換原則とは

リスコフの置換原則とはオブジェクト指向の設計の原則の一つであり、「基本クラスをサブクラスに入れ替えても問題なく動かなけらばならない」という原則です。
もしサブクラスに入れ替えると正しく動かなくなるのであれば、クラスを利用する側はサブクラスを使用してはならないというのを意識しながらコーディングしなければならず、保守性が低下します。

クラスの入力・出力に目を向けると、以下の条件を満たすとリスコフの置換原則を満たすことができます。

１．サブクラスの入力のパターンは、基本クラスの入力のパターンよりも緩い

２．サブクラスの出力のパターンは、基本クラスの入力のパターンよりも厳しい
　

もし、サブクラスの入力のパターンが基本クラスの入力のパターンよりも厳しいと、利用する側はサブクラスを利用する際にサブクラスが許容する入力であるかどうかを意識する必要が出てきてしまいます。
また、サブクラスの出力のパターンが基本クラスの出力のパターンよりも緩いと、利用する側はサブクラスを利用する際にサブクラスが予期せぬ出力をしないか意識する必要が出てきてしまいます。

以下のサンプルコードは、割り算を行う基本クラスであるDivideクラスを、サブクラスのDivideBusinessクラス・DivideBad1クラス・DivideBad2クラスで入れ替えてみるサンプルです。

DivideBusinessクラスは、基本クラスが許容する入力パターンに加え分母=0のパターンも許容し、基本クラスが出力することがある負数を出力しません。Divideクラスと入れ替えても特に考慮するパターンが増えることはなく、リスコフの置換原則を満たした良いクラスです。
しかし、DivideBad1クラスは、基本クラスが許容する分子=負数のパターンを許容せず、基本クラスと入れ替えた場合は分子が負数になっていないか意識する必要が出てきてしまいます。
また、DivideBad2クラスは、基本クラスと異なりnullを出力するパターンがあり、基本クラスと入れ替えた場合は出力がnullになる場合を意識する必要が出てきてしまいます。

【サンプルコード】

・DivideMain.java

public class DivideMain {

    public static void main(String［］ args) {

        Divide divide［］ = new Divide［4］;
        divide［0］ = new Divide();
        divide［1］ = new DivideBusiness();
        divide［2］ = new DivideBad1();
        divide［3］ = new DivideBad2();

        for (int i = 0; i ＜ 4; i++) {
            System.out.println("［テストその" + (i + 1) + "］");
            Calc(divide［i］,6,2);
            Calc(divide［i］,-6,2);
            Calc(divide［i］,6,0);
            Calc(divide［i］,null,2);
        }
    }

    public static void Calc
        (Divide divide, Integer numerator, Integer denominator) {

        System.out.println("クラス名：" + divide.getClass().getName());
        System.out.println("分子　　：" + numerator);
        System.out.println("分母　　：" + denominator);

        try {
            Integer result = divide.Calc(numerator, denominator);
            if (result == null) {
                System.out.println("結果　　：想定外の値！");
            } else {
                System.out.println("結果　　：" + result);
            }

        } catch (Exception e) {
            System.out.println("結果　　：想定外の例外！");
        }

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

public class DivideMain {

public static void main(String［］ args) {

Divide divide［］ = new Divide［4］;

divide［0］ = new Divide();

divide［1］ = new DivideBusiness();

divide［2］ = new DivideBad1();

divide［3］ = new DivideBad2();

for (int i = 0; i ＜ 4; i++) {

System.out.println("［テストその" + (i + 1) + "］");

Calc(divide［i］,6,2);

Calc(divide［i］,-6,2);

Calc(divide［i］,6,0);

Calc(divide［i］,null,2);

}

public static void Calc

(Divide divide, Integer numerator, Integer denominator) {

System.out.println("クラス名：" + divide.getClass().getName());

System.out.println("分子　　：" + numerator);

System.out.println("分母　　：" + denominator);

try {

Integer result = divide.Calc(numerator, denominator);

if (result == null) {

System.out.println("結果　　：想定外の値！");

} else {

System.out.println("結果　　：" + result);

}

} catch (Exception e) {

System.out.println("結果　　：想定外の例外！");

}

System.out.println("");

}

・Divide.java

// 入力：分母はnullや0は不可（例外送出）
// 出力：整数（負になり得る）
public class Divide {

    public Integer Calc(Integer numerator, Integer denominator)
        throws Exception {

        int numeratorTemp;
        int denominatorTemp;

        if (numerator == null) {
            numeratorTemp = 0;
        } else {
            numeratorTemp = numerator;
        }

        if (denominator == null) {
            denominatorTemp = 0;
        } else {
            denominatorTemp = denominator;
        }

        return numeratorTemp / denominatorTemp;
    }
}

// 入力：分母はnullや0は不可（例外送出）

// 出力：整数（負になり得る）

public class Divide {

public Integer Calc(Integer numerator, Integer denominator)

throws Exception {

int numeratorTemp;

int denominatorTemp;

if (numerator == null) {

numeratorTemp = 0;

} else {

numeratorTemp = numerator;

}

if (denominator == null) {

denominatorTemp = 0;

} else {

denominatorTemp = denominator;

}

return numeratorTemp / denominatorTemp;

}

・DivideBusiness.java

// 入力：分母はnullや0も許容
// 出力：整数（負にはならない）
public class DivideBusiness extends Divide {

    public Integer Calc(Integer numerator, Integer denominator)
        throws Exception {

        int numeratorTemp;
        int denominatorTemp;

        if (numerator == null || numerator ＜ 0) {
            numeratorTemp = 0;
        } else {
            numeratorTemp = numerator;
        }

        if (denominator == null || denominator ＜ 0) {
            denominatorTemp = 0;
        } else {
            denominatorTemp = denominator;
        }

        if (denominatorTemp == 0) {
            denominatorTemp = 1;
        }

        return numeratorTemp / denominatorTemp;
    }
}

// 入力：分母はnullや0も許容

// 出力：整数（負にはならない）

public class DivideBusiness extends Divide {

public Integer Calc(Integer numerator, Integer denominator)

throws Exception {

int numeratorTemp;

int denominatorTemp;

if (numerator == null || numerator ＜ 0) {

numeratorTemp = 0;

} else {

numeratorTemp = numerator;

}

if (denominator == null || denominator ＜ 0) {

denominatorTemp = 0;

} else {

denominatorTemp = denominator;

}

if (denominatorTemp == 0) {

denominatorTemp = 1;

}

return numeratorTemp / denominatorTemp;

}

・DivideBad1.java

// 入力：分子は負数は不可（例外送出）、分母はnullや0未満は不可（例外送出）
// 出力：整数（負になり得る）
public class DivideBad1 extends Divide {

    public Integer Calc(Integer numerator, Integer denominator)
        throws Exception {

        int numeratorTemp;
        int denominatorTemp;

        if (numerator == null) {
            numeratorTemp = 0;
        } else {
            numeratorTemp = numerator;
        }

        if (denominator == null) {
            denominatorTemp = 0;
        } else {
            denominatorTemp = denominator;
        }

        if (numeratorTemp ＜ 0 || denominatorTemp ＜ 0) {
            throw new Exception();
        }

        return numeratorTemp / denominatorTemp;
    }
}

// 入力：分子は負数は不可（例外送出）、分母はnullや0未満は不可（例外送出）

// 出力：整数（負になり得る）

public class DivideBad1 extends Divide {

public Integer Calc(Integer numerator, Integer denominator)

throws Exception {

int numeratorTemp;

int denominatorTemp;

if (numerator == null) {

numeratorTemp = 0;

} else {

numeratorTemp = numerator;

}

if (denominator == null) {

denominatorTemp = 0;

} else {

denominatorTemp = denominator;

}

if (numeratorTemp ＜ 0 || denominatorTemp ＜ 0) {

throw new Exception();

}

return numeratorTemp / denominatorTemp;

}

・DivideBad2.java

// 入力：分子はnull許容、分母は0は不可（例外送出）
// 出力：整数（負になり得る）、ただし分子や分母がnullの場合はnull
public class DivideBad2 extends Divide {

    public Integer Calc(Integer numerator, Integer denominator)
        throws Exception {

        int numeratorTemp;
        int denominatorTemp;

        if (numerator == null) {
            return null;
        } else {
            numeratorTemp = numerator;
        }

        if (denominator == null) {
            return null;
        } else {
            denominatorTemp = denominator;
        }

        return numeratorTemp / denominatorTemp;
    }
}

// 入力：分子はnull許容、分母は0は不可（例外送出）

// 出力：整数（負になり得る）、ただし分子や分母がnullの場合はnull

public class DivideBad2 extends Divide {

public Integer Calc(Integer numerator, Integer denominator)

throws Exception {

int numeratorTemp;

int denominatorTemp;

if (numerator == null) {

return null;

} else {

numeratorTemp = numerator;

}

if (denominator == null) {

return null;

} else {

denominatorTemp = denominator;

}

return numeratorTemp / denominatorTemp;

}

【結果】

［テストその1］
クラス名：Divide
分子　　：6
分母　　：2
結果　　：3

クラス名：Divide
分子　　：-6
分母　　：2
結果　　：-3

クラス名：Divide
分子　　：6
分母　　：0
結果　　：想定外の例外！

クラス名：Divide
分子　　：null
分母　　：2
結果　　：0

［テストその2］
クラス名：DivideBusiness
分子　　：6
分母　　：2
結果　　：3

クラス名：DivideBusiness
分子　　：-6
分母　　：2
結果　　：0

クラス名：DivideBusiness
分子　　：6
分母　　：0
結果　　：6

クラス名：DivideBusiness
分子　　：null
分母　　：2
結果　　：0

［テストその3］
クラス名：DivideBad1
分子　　：6
分母　　：2
結果　　：3

クラス名：DivideBad1
分子　　：-6
分母　　：2
結果　　：想定外の例外！

クラス名：DivideBad1
分子　　：6
分母　　：0
結果　　：想定外の例外！

クラス名：DivideBad1
分子　　：null
分母　　：2
結果　　：0

［テストその4］
クラス名：DivideBad2
分子　　：6
分母　　：2
結果　　：3

クラス名：DivideBad2
分子　　：-6
分母　　：2
結果　　：-3

クラス名：DivideBad2
分子　　：6
分母　　：0
結果　　：想定外の例外！

クラス名：DivideBad2
分子　　：null
分母　　：2
結果　　：想定外の値！

［テストその1］

クラス名：Divide

分子　　：6

分母　　：2

結果　　：3

クラス名：Divide

分子　　：-6

分母　　：2

結果　　：-3

クラス名：Divide

分子　　：6

分母　　：0

結果　　：想定外の例外！

クラス名：Divide

分子　　：null

分母　　：2

結果　　：0

［テストその2］

クラス名：DivideBusiness

分子　　：6

分母　　：2

結果　　：3

クラス名：DivideBusiness

分子　　：-6

分母　　：2

結果　　：0

クラス名：DivideBusiness

分子　　：6

分母　　：0

結果　　：6

クラス名：DivideBusiness

分子　　：null

分母　　：2

結果　　：0

［テストその3］

クラス名：DivideBad1

分子　　：6

分母　　：2

結果　　：3

クラス名：DivideBad1

分子　　：-6

分母　　：2

結果　　：想定外の例外！

クラス名：DivideBad1

分子　　：6

分母　　：0

結果　　：想定外の例外！

クラス名：DivideBad1

分子　　：null

分母　　：2

結果　　：0

［テストその4］

クラス名：DivideBad2

分子　　：6

分母　　：2

結果　　：3

クラス名：DivideBad2

分子　　：-6

分母　　：2

結果　　：-3

クラス名：DivideBad2

分子　　：6

分母　　：0

結果　　：想定外の例外！

クラス名：DivideBad2

分子　　：null

分母　　：2

結果　　：想定外の値！

いかがでしたでしょうか。

ポリモーフィズムを利用するとソースコードを簡潔にできるのですが、それを実現するためにはリスコフの置換原則を満たすことが必要です。
デザインパターン等で良い設計に触れている方なら自然に満たせるものかもしれませんが、今一度意識してみるのも良いかもしれません。

2020年11月20日

単一責任の原則とは

オブジェクト指向の設計ではいくつかの原則があります。
その中でも有名な原則の一つが「単一責任の原則」です。

この原則は、その名の通り「一つのクラスに持たせる責任は一つにする」という原則です。
この原則が何のために用いられるのかと言うと、複数の理由で１つのクラスを修正するのを防ぐためです。
ここで言う「理由」を「案件」、「クラス」を「ソース」と捉えると分かりやすいと思います。
複数の案件で１つのソースを修正する必要が出てしまうと、並行開発手順やバージョン管理等が煩雑になってしまい、品質に悪影響が及びます。

「一つのクラスに持たせる責任は一つにする」と捉えると具体的なイメージが浮かびにくいと思うのですが、「複数の案件で１つのソースを修正しないような粒度で設計する」と捉えると分かりやすいと思います。

以下では、javaのソースコードで例を出します。
商品の名前と値段を登録し、それを表示するという例です。

まずは悪い例からです。

【サンプルコード１】

・CommodityMain.java

public class CommodityMain {

    public static void main(String［］ args) {

        RegistShowCommodity registShowCommodity = new RegistShowCommodity();
        String commodityName = "PC";

        // 商品の登録
        registShowCommodity.setCommodityPrice(commodityName, 100000);

        // 商品の表示
        registShowCommodity.showCommodityPrice(commodityName);

    }

}

public class CommodityMain {

public static void main(String［］ args) {

RegistShowCommodity registShowCommodity = new RegistShowCommodity();

String commodityName = "PC";

// 商品の登録

registShowCommodity.setCommodityPrice(commodityName, 100000);

// 商品の表示

registShowCommodity.showCommodityPrice(commodityName);

}

・RegistShowCommodity.java

import java.util.HashMap;
import java.util.Map;

public class RegistShowCommodity {

    private Map＜String, Integer＞ commodityMap 
        = new HashMap＜String, Integer＞();

    public void setCommodityPrice (String commodityName,int price) {
        commodityMap.put(commodityName,price);
    }

    public void showCommodityPrice (String commodityName) {
        System.out.println(commodityName + ":" +
            commodityMap.get(commodityName) + " yen");
    }

}

import java.util.HashMap;

import java.util.Map;

public class RegistShowCommodity {

private Map＜String, Integer＞ commodityMap

= new HashMap＜String, Integer＞();

public void setCommodityPrice (String commodityName,int price) {

commodityMap.put(commodityName,price);

}

public void showCommodityPrice (String commodityName) {

System.out.println(commodityName + ":" +

commodityMap.get(commodityName) + " yen");

}

【実行結果１】

PC:100000 yen

1	PC:100000 yen

ここで、「商品の税込み価格を計算可能にする」という案件と、「表示を綺麗にする」という案件が発生したとします。
今の設計だと、どちらの案件も RegistShowCommodityクラスの修正となってしまいます。

そこで、商品の登録を行う RegistCommodityクラス、商品の価格計算を行う CalcCommodityクラス、価格表示を行う ShowCommodityクラスの３クラスに分割します。

【サンプルコード２】

・CommodityMain.java

public class CommodityMain {

    public static void main(String［］ args) {

        RegistCommodity registCommodity = new RegistCommodity();
        CalcCommodity calcCommodity = new CalcCommodity();
        ShowCommodity showCommodity = new ShowCommodity();
        String commodityName = "PC";

        // 商品の登録
        registCommodity.setCommodityPrice(commodityName, 100000);

        // 商品の表示
        showCommodity.showCommodityPrice(commodityName,
            calcCommodity.calcPrice(
                registCommodity.getCommodityPrice(commodityName)));

    }

}

public class CommodityMain {

public static void main(String［］ args) {

RegistCommodity registCommodity = new RegistCommodity();

CalcCommodity calcCommodity = new CalcCommodity();

ShowCommodity showCommodity = new ShowCommodity();

String commodityName = "PC";

// 商品の登録

registCommodity.setCommodityPrice(commodityName, 100000);

// 商品の表示

showCommodity.showCommodityPrice(commodityName,

calcCommodity.calcPrice(

registCommodity.getCommodityPrice(commodityName)));

}

・RegistCommodity.java

import java.util.HashMap;
import java.util.Map;

public class RegistCommodity {

    private Map＜String, Integer＞ commodityMap 
        = new HashMap＜String, Integer＞();

    public void setCommodityPrice (String commodityName,int price) {
        commodityMap.put(commodityName,price);
    }

    public int getCommodityPrice (String commodityName) {
        return commodityMap.get(commodityName);
    }

}

import java.util.HashMap;

import java.util.Map;

public class RegistCommodity {

private Map＜String, Integer＞ commodityMap

= new HashMap＜String, Integer＞();

public void setCommodityPrice (String commodityName,int price) {

commodityMap.put(commodityName,price);

}

public int getCommodityPrice (String commodityName) {

return commodityMap.get(commodityName);

}

・CalcCommodity.java

public class CalcCommodity {

    public int calcPrice (int price) {
        return price;
    }

}

public class CalcCommodity {

public int calcPrice (int price) {

return price;

}

・ShowCommodity.java

public class ShowCommodity {

    public void showCommodityPrice (String commodityName,int price) {
        System.out.println(commodityName + ":" +
            price + " yen");
    }

}

public class ShowCommodity {

public void showCommodityPrice (String commodityName,int price) {

System.out.println(commodityName + ":" +

price + " yen");

}

【実行結果２】

PC:100000 yen

1	PC:100000 yen

３クラスに分割した結果、「商品の税込み価格を計算可能にする」という案件は CalcCommodityクラスの修正、「表示を綺麗にする」という案件は ShowCommodityクラスの修正で対応できるようになり、別々の案件で１つのクラスを修正する状態を防ぐことができました。

【サンプルコード３】

・CommodityMain.java

public class CommodityMain {

    public static void main(String［］ args) {

        RegistCommodity registCommodity = new RegistCommodity();
        CalcCommodity calcCommodity = new CalcCommodity();
        ShowCommodity showCommodity = new ShowCommodity();
        String commodityName = "PC";

        // 商品の登録
        registCommodity.setCommodityPrice(commodityName, 100000);

        // 商品の表示
        showCommodity.showCommodityPrice(commodityName,
            calcCommodity.calcPriceWithTax(
                registCommodity.getCommodityPrice(commodityName)));

    }
}

public class CommodityMain {

public static void main(String［］ args) {

RegistCommodity registCommodity = new RegistCommodity();

CalcCommodity calcCommodity = new CalcCommodity();

ShowCommodity showCommodity = new ShowCommodity();

String commodityName = "PC";

// 商品の登録

registCommodity.setCommodityPrice(commodityName, 100000);

// 商品の表示

showCommodity.showCommodityPrice(commodityName,

calcCommodity.calcPriceWithTax(

registCommodity.getCommodityPrice(commodityName)));

}

・RegistCommodity.java

import java.util.HashMap;
import java.util.Map;

public class RegistCommodity {

    private Map＜String, Integer＞ commodityMap 
        = new HashMap＜String, Integer＞();

    public void setCommodityPrice (String commodityName,int price) {
        commodityMap.put(commodityName,price);
    }

    public int getCommodityPrice (String commodityName) {
        return commodityMap.get(commodityName);
    }

}

import java.util.HashMap;

import java.util.Map;

public class RegistCommodity {

private Map＜String, Integer＞ commodityMap

= new HashMap＜String, Integer＞();

public void setCommodityPrice (String commodityName,int price) {

commodityMap.put(commodityName,price);

}

public int getCommodityPrice (String commodityName) {

return commodityMap.get(commodityName);

}

・CalcCommodity.java

public class CalcCommodity {

    private double taxRate = 1.1;

    public int calcPrice (int price) {
        return price;
    }

    // 「商品の税込み価格を計算可能にする」案件
    public int calcPriceWithTax (int price) {
        return (int) (price * taxRate);
    }

}

public class CalcCommodity {

private double taxRate = 1.1;

public int calcPrice (int price) {

return price;

}

// 「商品の税込み価格を計算可能にする」案件

public int calcPriceWithTax (int price) {

return (int) (price * taxRate);

}

・ShowCommodity.java

public class ShowCommodity {

    // 「表示を綺麗にする」案件
    public void showCommodityPrice (String commodityName,int price) {
        System.out.println("■CommodityName :" + commodityName);
        System.out.println("■CommodityPrice:" + price + " yen");
    }

}

public class ShowCommodity {

// 「表示を綺麗にする」案件

public void showCommodityPrice (String commodityName,int price) {

System.out.println("■CommodityName :" + commodityName);

System.out.println("■CommodityPrice:" + price + " yen");

}

【実行結果３】

■CommodityName :PC
■CommodityPrice:110000 yen

1 2	■CommodityName :PC ■CommodityPrice:110000 yen

いかがでしたでしょうか。

オブジェクト指向の設計と言うと覚えることが多くて大変だという印象を持つかもしれませんが、いくつかの原則を抑えるだけでも良い設計ができます。
（デザインパターンも、原則に則って設計を考えると自ずと導き出されるものだと思っています）

単一責任の原則は代表的な原則の一つなので、覚えておいて損はないと思います。

2020年10月30日

クラス図とjavaソースの対応一覧

クラス図とはUMLの一種で、以下のような形でクラスの定義と各クラスの関係を表す設計図のことです。

今回は、クラス図で使われる記法とjavaソースの対応について、一覧にしてみました。
参考になれば幸いです。

【クラス定義】

【各クラスの関係】

いかがでしたでしょうか？

クラス図を書かなくともjavaのプログラムは作れてしまうので、情報を伝達したり整理したりするためにクラス図を書かなければならないとなった時に書き方を忘れてしまうことは意外とあると思います。
javaのプログラムに慣れた方であれば、日本語で説明されるよりもソースで説明された方がわかりやすいと思ったので、このような記事を書いてみました。

2020年10月23日

java：関数を引数として渡す

C#では、こちらの記事のようにdelegateの仕組みを利用して関数を変数として扱うことができます。
例えば、引数と引き渡してコールバック処理を実現することができます。

javaでも、8以降であれば関数型インターフェースを利用して関数を変数として扱うことができます。
以下、サンプルコードです。

【サンプルコード】

・FunctionMain.java

import java.util.function.Function;

public class FunctionMain {
    public static void main(String［］ args) {

        // Function型の変数の定義
        // 変数の中身はFunctionMainクラスのmakeEndMessage関数
        Function＜String, String＞ function = FunctionMain::makeEndMessage;

        // 関数を引数として渡す
        somethingFunc(function);
    }

    public static void somethingFunc(Function&lt;String, String> endFunc) {
        System.out.println("DoSomething");
        // 引き渡された関数を実行
        System.out.println(endFunc.apply("Something"));
    }

    // 今回引き渡す関数
    public static String makeEndMessage(String s) {
        return "End" + s;
    }

}

import java.util.function.Function;

public class FunctionMain {

public static void main(String［］ args) {

// Function型の変数の定義

// 変数の中身はFunctionMainクラスのmakeEndMessage関数

Function＜String, String＞ function = FunctionMain::makeEndMessage;

// 関数を引数として渡す

somethingFunc(function);

}

public static void somethingFunc(Function<String, String> endFunc) {

System.out.println("DoSomething");

// 引き渡された関数を実行

System.out.println(endFunc.apply("Something"));

}

// 今回引き渡す関数

public static String makeEndMessage(String s) {

return "End" + s;

}

【実行結果】

DoSomething
EndSomething

1 2	DoSomething EndSomething

上記のようにFunction型を用いるのが基本的な形なのですが、いくつか発展的な記法が存在します。

例えば、引数と戻り値が同じ型である場合は、UnaryOperator型を使用することでジェネリクスの表記を省略することができます。
（他にも、戻り値がvoidの場合に適用できるConsumer型、戻り値がboolean型の場合に適用できるPredicate型等が存在します）

また、引き渡す関数をラムダ式で表記することで、関数の定義を省略することができます。

【サンプルコード】

・FunctionMain.java

import java.util.function.UnaryOperator;

public class FunctionMain {
    public static void main(String［］ args) {

        // 引数と戻値が同じ場合はUnaryOperatorで簡略化できる
        // ラムダ式で関数の記述を簡略化できる
        UnaryOperator＜String＞ function = (x) -＞ {return "End" + x;};

        somethingFunc(function);
    }

    public static void somethingFunc(UnaryOperator＜String＞ endFunc) {
        System.out.println("DoSomething");
        System.out.println(endFunc.apply("Something"));
    }

}

import java.util.function.UnaryOperator;

public class FunctionMain {

public static void main(String［］ args) {

// 引数と戻値が同じ場合はUnaryOperatorで簡略化できる

// ラムダ式で関数の記述を簡略化できる

UnaryOperator＜String＞ function = (x) -＞ {return "End" + x;};

somethingFunc(function);

}

public static void somethingFunc(UnaryOperator＜String＞ endFunc) {

System.out.println("DoSomething");

System.out.println(endFunc.apply("Something"));

}

【実行結果】

DoSomething
EndSomething

1 2	DoSomething EndSomething

いかがでしたでしょうか。

最近ではJava8以降の文法が使われる機会が多く、今回紹介したような関数型インターフェースも使われることが少なくありません。
従来のJavaと比べると書き方が独特に感じるかもしれませんが、慣れておくと実際の案件で困ることが少なくなると思います。