つねひごろ

【Delphiでゲーム制作】ボールを動かす

noreply@blogger.com (Masahiro Atsumi) — Mon, 15 Oct 2018 00:00:00 +0000

【Delphiでゲーム制作】ボールを動かす

Delphiを利用したゲームの作成に挑戦します。ゲーム作成の経験がほとんどないので、インターネットで公開してくださっているゲーム制作の情報をつまみ食いしつつゲーム作りを進めます。

今回はウィンドウ内でボールを動かしてみようと思います。壁にぶつかると反射して反対方向に進みます。

まずは設計

ボールを動かす

ボールの動きをどのように考えるかですが、時間が経つにつれて、少しづつ座標を更新していけば動いているように見えそうです。

壁にぶつかったら反射

壁にぶつかったら反対方向に反射するというのは、ボールと壁の座標を比べて、交わったら向かってきた向きと反対の方向に座標を更新するというやり方がよさそうです。

画面作成とコーディング

コンポーネント配置

ボールにはTCircleを利用しました。画面に配置するだけで、ボールを作り出せます。時間が経つにつれてにはTTimerを使います。

TCircleとTTimerのコンポーネントをFormに配置できたら、それぞれプロパティの設定をします。まずはTCircleのサイズを適当な大きさに調整します。ここでは高さ、幅とも20としました。次にTTimerのIntervalを設定。これは20としてみました。

イベント作成

一番重要なのはTTimerのOnTimerイベントです。イベントが来たら、ボールの位置を求めます。ボールの位置と壁（フォームの端）の座標を比べて、壁と交わっているようだったら、向かう方向を反転します。

OnFormResizeイベントでは壁の位置をアップデートしています。途中でウィンドウサイズを変更したときうまく動くはずです（スマートフォンなどで動作させたときに、端末の向きが変わったときでも同じイベントが動くようです）

unit MoveBallForm;

interface

uses
  System.SysUtils, System.Types, System.UITypes, System.Classes,
  System.Variants,
  FMX.Types, FMX.Controls, FMX.Forms, FMX.Graphics, FMX.Dialogs, FMX.Objects;

type
  TfrmMoveBall = class(TForm)
    Timer1: TTimer;
    Circle1: TCircle;
    procedure Timer1Timer(Sender: TObject);
    procedure FormResize(Sender: TObject);
    procedure FormCreate(Sender: TObject);
  private
    { private 宣言 }
    vx, vy: Single;			// 動きの量
    xMax, xMin: Single;		// ボールが動く範囲（X軸）
    yMax, yMin: Single;		// ボールが動く範囲（Y軸）
  public
    { public 宣言 }
  end;

var
  frmMoveBall: TfrmMoveBall;

implementation

{$R *.fmx}

procedure TfrmMoveBall.FormCreate(Sender: TObject);
begin
  vx := 10;
  vy := 10;
end;

procedure TfrmMoveBall.FormResize(Sender: TObject);
begin
  // ウィンドウサイズが変わったときに
  // ボールが動く範囲をアップデートする
  xMin := 0;
  yMin := 0;
  xMax := frmMoveBall.ClientWidth - Circle1.Width;
  yMax := frmMoveBall.ClientHeight - Circle1.Width;
end;

procedure TfrmMoveBall.Timer1Timer(Sender: TObject);
var
  newX, newY: Single;
begin
  // ボールの位置を算出
  newX := Circle1.Position.X + vx;
  newY := Circle1.Position.Y + vy;

  // ボールの位置を更新
  Circle1.Position.X := newX;
  Circle1.Position.Y := newY;

  // 壁にぶつかったときにボールの移動方向を変更する
  if (newX <= xMin) then
  begin
    vx := abs(vx);
  end;
  if (xMax < newX) then
  begin
    vx := abs(vx) * -1;
  end;

  if (newY <= yMin) then
  begin
    vy := abs(vy);
  end;
  if (yMax < newY) then
  begin
    vy := abs(vy) * -1;
  end;
end;

end.

【Delphi Sample】Delphi と Google App Engine と Thrift と Java その3

noreply@blogger.com (Masahiro Atsumi) — Mon, 01 Oct 2018 00:00:00 +0000

【Delphi Sample】Delphi と Google App Engine と Thrift と Java その3

Google App Engine(GAE/J)とDelphi間をApache Thriftを使って通信するサンプルの第3回目です。今回はクライアント側の実装を進めます。

クライアントアプリケーション

クライアントはDelphiで作成します（Delphi 10.2 Community Editionを利用しています）

フォルダ構成

コマンドで出力したファイルをフォルダのままプロジェクトに追加します。フォルダを変更したいときは、IDLのnamespaceを編集して、再度ファイルを自動生成してください。
「Thrift」フォルダはThriftライブラリです。Apache ThriftのGitHubリポジトリからダウンロードすることができます。こちらもunit名にThriftとついていますから、Thriftフォルダに入れるとよいでしょう。

コーディング

今回は四則演算のうち、足し算の処理を呼び出してみます。

MainForm.fmx

足し算のインターフェイスはパラメータを二つ取り、整数値が戻ってくるという単純な形なので、

i32 add(1:i32 param1, 2:i32 param2)

画面にも同じようにパラメータ用と戻り値用のEditを配置します。処理を呼び出すトリガーとしてButtonも配置しておきます。Buttonを押すとパラメータの１と２をサーバーに送り、答えを返してもらうというわけです。

MainForm.pas

ポイントとなるのは次のことくらいでしょうか？

usesにThriftのライブラリを追加
HTTPを利用して通信するため、THTTPClientImplを利用
ServletにマッピングしたURLをTransportに与える
利用後はCloseを忘れないこと

unit MainForm;

interface

uses
  System.SysUtils, System.Types, System.UITypes, System.Classes,
  System.Variants, FMX.Types, FMX.Controls, FMX.Forms, FMX.Graphics, FMX.Dialogs, FMX.StdCtrls, FMX.Edit, FMX.Controls.Presentation, 
  Thrift, Thrift.Transport, Thrift.Protocol,
  ThriftInterface.Calculator;

type
  TfrmMain = class(TForm)
    Button1: TButton;
    Edit1: TEdit;
    Edit2: TEdit;
    Edit3: TEdit;
    Label1: TLabel;
    Label2: TLabel;
    Label3: TLabel;
    procedure Button1Click(Sender: TObject);
  private
    { private 宣言 }
  public
    { public 宣言 }
  end;

var
  frmMain: TfrmMain;

implementation

{$R *.fmx}

procedure TfrmMain.Button1Click(Sender: TObject);
var
  transport: ITransport;
  protocol: IProtocol;
  client: TCalculatorService.Iface;
  p1, p2, answer: integer;
begin
  try
    transport := THTTPClientImpl.Create('http://localhost:8080/calculator');
    protocol := TBinaryProtocolImpl.Create(transport);
    client := TCalculatorService.TClient.Create(protocol);

    p1 := StrToInt(Edit1.Text);
    p2 := StrToInt(Edit2.Text);

    transport.Open;
    answer := client.add(p1, p2);
    transport.Close;

    Edit3.Text := IntToStr(answer);

  except
    on e: Exception do
      WriteLn(e.ClassName + ': ' + e.Message);
  end;
end;

end.

サーバー側のサービスが増えるたびに（=URLのマッピングが増える）Transportを作成するときのURLが変わるので、この辺りは抽象化できるポイントだと思います。

動作確認

最後に動作確認です。

まずは、サーバー側¹を起動しておきます（ポート番号がDelphiで指定したURLと同じ番号で立ち上がっていることを確認してください）。

次にDelphi側でアプリケーションを実行し、パラメータ１とパラメータ２に適当な数値を入力し、ボタンを押してください。すると、答えに結果が表示されます。

サーバーと通信している最中は処理がブロッキングされますので、注意してください。

【Delphi Sample】Delphi と Google App Engine と Thrift と Java その2

noreply@blogger.com (Masahiro Atsumi) — Wed, 26 Sep 2018 00:00:00 +0000

【Delphi Sample】Delphi と Google App Engine と Thrift と Java その2

Google App Engine(GAE/J)とDelphi間をApache Thriftを使って通信するサンプルの第2回目です。今回はサーバー側の実装を進めます。

サーバーアプリケーション

Google App EngineではSpringやSparkといったWebフレームワークを利用することができますが、Thriftがインターフェイスを担ってくれるため今回はシンプルにServletとして実装を進めます。Servletの実装は公式のサンプルが参考になります。

フォルダ構成

まずはフォルダ構成を見ていきましょう。公式のサンプルに合わせてフォルダ構成を整えていきます。gen-javaに自動生成されたファイル群はcom.example.thriftに配置しています。前回も書きましたが、場所の調整はIDLのnamespaceで行うことができます。

コーディング

サーバー側でコーディングが必要なのはWebでの受け口と実際の処理を行う部分です。

CalculatorHandler.java

まずは受け口を見ていきましょう。＠WebServletを利用して、クラスとURLをマッピングします。もちろんweb.xmlに記述する方法でも構いません。

プロトコルにはTBinaryProtocolを利用しています。これは計算量（CPU資源）をできるだけ抑えたいと考えたからです。データ量を削減したいという場合はTCompactProtocolを使ってください。両者の比較を行ってくれている方もいました。

package com.example.handler;

import com.example.service.CalculatorServiceImpl;
import com.example.thrift.CalculatorService;
import org.apache.thrift.protocol.TBinaryProtocol;
import org.apache.thrift.server.TServlet;

import javax.servlet.annotation.WebServlet;

@WebServlet(name = "CalculatorHandler", urlPatterns = "/calculator")
public class CalculatorHandler extends TServlet {
    public CalculatorHandler() {
        super(new CalculatorService.Processor<>(new CalculatorServiceImpl()), new TBinaryProtocol.Factory());
    }
}

CalculatorServiceImpl.java

次に、実際の処理を行う部分を見ていきましょう。自動生成されたコード中のIfaceを実装します。ThriftのIDLで記述した内容がすべて盛り込まれているため、あとは処理の中身を実装していくだけです。
前回お話しした除算時のゼロ除算の例外処理もここで行います。

IDLで宣言した型情報が言語に合わせた形でコード生成されていることに注目してください。型も意識しつつインターフェイス設計するのがよさそうです。

package com.example.service;

import com.example.thrift.CalculatorService;
import com.example.thrift.TInvalidParameterException;
import org.apache.thrift.TException;

public class CalculatorServiceImpl implements CalculatorService.Iface {
    @Override
    public int add(int param1, int param2) throws TException {
        return param1 + param2;
    }

    @Override
    public int sub(int param1, int param2) throws TException {
        return param1 - param2;
    }

    @Override
    public int mul(int param1, int param2) throws TException {
        return param1 * param2;
    }

    @Override
    public int div(int param1, int param2) throws TInvalidParameterException {
        if (param2 == 0){
            throw new TInvalidParameterException("Divide by Zero.");
        }
        return param1 / param2;
    }
}

【Delphi Sample】Delphi と Google App Engine と Thrift と Java その1

noreply@blogger.com (Masahiro Atsumi) — Sun, 23 Sep 2018 00:00:00 +0000

【Delphi Sample】Delphi と Google App Engine と Thrift と Java その1

皆さんはサーバーとクライアントの通信にどのような方法を利用していますか？

この記事では、クライアントアプリケーションをDelphi、サーバーアプリケーションをGoogle App Engine (GAE/J)にて実装し、その間の通信には Apache Thriftを利用するサンプルを紹介します。

キーワード

実際のサンプルに入る前に主要なテクノロジーやソフトウエアについて少し触れてみます。

Google App Engine

Google が運営するPaaSです。サーバーのことをほとんど意識することなく、アプリケーション開発に集中できます。制限もありますが、特性を理解して適切に使うことができれば、ほかの環境では簡単に作成することができないアプリケーションを作ることができます。
Delphi

デルファイと読みます。Pascal言語を利用してアプリケーションを作ることができる開発環境です。フレームワークがとても強力で、多様なプラットフォームをサポートしています。GUIアプリケーションを作るうえで、これだけ安定している環境は得難いのではないでしょうか？
Thrift

スリフトと読みます。アプリケーション間で処理の呼び出しをサポートしてくれるフレームワークです。これを利用するとクライアントアプリケーションからサーバーアプリケーションの関数を呼び出すことができます。この類のテクノロジーはいくつも出ていましたが、使い勝手や保守性に優れており、特別な技術が使われているわけでもなくとてもシンプルに作られています。
そのシンプルさゆえ、いろいろな言語で利用することができます。同じ言語間の通信はもちろん、今回のようにJavaとDelphiなど異なる言語間でも通信を行うことができます。

インターフェイスを決める

サーバーとクライアントの間で何かやり取りをするということは、やり取りの方法を決める必要があります。具体的には、データと処理の呼出し口を決めます。

インターフェイスをしっかりと決めておくことで、以下のような利点があります。

サーバーとクライアントで分業できる。
インターフェイスを見るだけで、アプリケーションの全体像がつかめる。

JSONやXMLを使ってデータのやり取りを行うのがよく使われる方法ですが、インターフェイスを決める主導権はどちらか一方に偏りがちです。サーバー側での変更がクライアント側に伝わらず、いつの間にかデータ構造が変わっていたということもあるのではないでしょうか？

この問題をThriftはインターフェイス記述言語（IDL）というもので解決しています。つまり、インターフェイスそのものをコーディングするという考え方です。コーディングできるということはソースコード管理を行うことができますから、いつの間にか変わってしまったという現象を防ぐことができるのです。

インターフェイス設計

今回は四則演算のサービスを作成します。インターフェイスのコーディングにはIDLを利用します。Thrift専用の言語ですが、覚えることも少ないのでドキュメントを眺めながら進めていけばすぐに慣れると思います。

クラスにメソッドを宣言していくようなつもりで進めていくのがいいでしょう。JSONやXMLでのやり取りではデータが中心となってきますから、アプローチの方法が異なりますね。

ここで行うのはあくまでもインターフェイスの設計・宣言です。実装については誰が行ってくれるかというと、そこはThriftが担ってくれます。つまり、ソースコードはThriftが自動生成してくれるわけです。

calculator.thrift

計算サービスを定義していきます。コメントをつけたので、理解しやすいのではないでしょうか？namespaceを宣言するとグルーピングが行えます。ここではJavaとDelphiでグルーピング方法を変えています。細かく分割するのか、一つにまとめてしまうかは言語の作法に従うのがいいと思います。
また、includeを使って、ほかのIDLファイルを読み込むこともできます。
もう一つ注目してもらいたいのは、exceptionで例外を定義しているということです。今回の四則演算のサービスでは、割り算でゼロ除算を行ったときに例外を送出するよう考えています。言語間で例外をやり取りできるのは表現の幅が広がりますね。

namespace java com.example.thrift
namespace delphi ThriftInterface.Calculator

include "common.thrift"

/** 計算サービス */
service CalculatorService {
    /** 加算 */
    i32 add(1:i32 param1, 2:i32 param2),
    /** 減算 */
    i32 sub(1:i32 param1, 2:i32 param2),
    /** 乗算 */
    i32 mul(1:i32 param1, 2:i32 param2),
    /** 除算 */
    i32 div(1:i32 param1, 2:i32 param2) throws (1: common.TInvalidParameterException error)
}

common.thrift

calculator.thriftで利用した例外はこちらで宣言しています。後でサービスを追加することを想定して、ファイルを分けています。

namespace java com.example.thrift
namespace delphi ThriftInterface.Common

/** パラメータに誤りがあったときの例外 */
exception TInvalidParameterException {
    1: string message
}

ファイルの自動生成

Windowsを利用している人はここから実行ファイルをダウンロードしてください。コマンドラインプログラムなので、適当な場所に配置し、その場所をPathに追加すると使いやすいです。

Macを利用している人はBrewを使って実行ファイルをセットアップしてください。

今回は2つのthriftファイルを作成したので、次のようにコマンドを実行します。common.thriftは参照されているので、初めに実行します。

rmdir /s /q gen-java
rmdir /s /q gen-delphi

thrift --gen java --gen delphi IDL/common.thrift
thrift --gen java --gen delphi IDL/calculator.thrift

コード生成の前にgen-java gen-delphiのフォルダを削除するコマンドを入れておくと、間違いが少なくなりますね。

フォルダ構成

gen-javaとgen-delphiという二つのフォルダができています。中にはそれぞれJavaのソースファイルとDelphiのUnitが生成されているのが分かるでしょうか？
namespaceの宣言によってフォルダ構成やファイルの分かれ方も変わってきます。いろいろと試してみてください。

【Delphi Sample】ジェネリックスを使う

noreply@blogger.com (Masahiro Atsumi) — Wed, 29 Aug 2018 00:00:00 +0000

【Delphi Sample】ジェネリックスを使う

TListやTStringListにはそれぞれポインタや文字列を格納することができます。ジェネリックスを利用することで、より汎用的に、より安全に利用することができます。

上では難しく言っていますが、つまるところクラスに対して型を限定できるということです。型を限定することで、コンパイル時にエラーを発見することができるため、より安全になるというわけです。

それではジェネリックスの利用方法について見てみましょう。

以下のコードをざっと見てください。TListの後ろに<Integer>という記述を見つけられると思います。このように指定することによって、TListにはInteger型しか代入することができなくなります。

また、コンパイラがlistに入っているのは、Integer型と判断してくれるため、取り出すときに無駄なキャストを行う必要がありません。

procedure TForm1.Button1Click(Sender: TObject);
var
  list: TList<Integer>;
  i: Integer;
  s: string;
begin
  list := TList<Integer>.Create;
  list.Add(100);
  list.Add(100.15);  // コンパイルエラー
  list.Add('111');   // コンパイルエラー

  i := list[0];
  s := IntToStr(list[0]);
end;

プログラムを記述するときに型を意識することで、自然にバグの少ないプログラムを記述できるというわけです。

【Delphi Sample】並列プログラミング1

noreply@blogger.com (Masahiro Atsumi) — Sun, 26 Aug 2018 00:00:00 +0000

【Delphi Sample】並列プログラミング1

Delphiの並列プログラミングのサンプルです。XE6あたりまではTThreadを利用していたと思いますが、XE7のカテゴリを見てみると、System.Threading ユニットが追加されています。

System.Threadingには並列プログラミングを作る際に便利なクラス群が実装されています。usesにSystem.Threadingを追加しておきましょう。

今回は一番基本的なITask、TTaskを利用してみます。
まず、並列「ではない」プログラミングを見てみましょう。以下のプログラムでは、１秒ごとにカウントをとっています。…しかし、この書き方では思った通りに動作しません。ボタンを押して数秒後にループの最後の数字である5が表示されます。

procedure TForm1.Button1Click(Sender: TObject);
var
  i : integer;
begin
  for i := 0 to 5 do
  begin
    Sleep(1000);
    Edit1.Text := IntToStr(i);
  end;
end;

上記の問題をITask、TTaskを利用して再度プログラミングをしてみます。

procedure TForm1.Button2Click(Sender: TObject);
var
  task: ITask;
begin
  task := TTask.Create(procedure()
    var
      i: integer;
    begin
      for i := 0 to 5 do
      begin
        Sleep(1000);
        TThread.Synchronize(nil, procedure()
          begin
            Edit2.Text := IntToStr(i);
          end);
      end;
    end);
  task.Start;
end;

TTask.Createの引数にプロシージャを与えるという、一見変わったスタイルになります。このように記述することで、プロシージャ内の処理は並列（非同期）で実行されます。

また、並列で実行しているときにEditなどのUIにアクセスしたい場合は、TThread.Synchronizeを利用します。これはUIはTTaskとは違う軸で処理されているからです。

【KotlinとJava】Mapとプロパティ

noreply@blogger.com (Masahiro Atsumi) — Mon, 30 Jul 2018 00:00:00 +0000

KotlinとJava

Kotlinでは代入の際にMapを利用することができる。Javaのサンプルと比較するとよく分かるが、とても簡潔に記述できるようになっている。

Properties in map.kt

class User(val map: Map<String, Any?>) {
    val name: String by map
    val age: Int     by map
}

fun main(args: Array<String>) {
    val user = User(mapOf(
        "name" to "John Doe",
        "age"  to 25
    ))
    println("name = ${user.name}, age = ${user.age}")
}

Mapのキー名は文字列で指定しているが、間違っていると実行時にエラーが発生するので注意すること。このあたり、コンパイラのサポートはないようだ。

リンク

Javaで記述

対比ができるようにJavaでも同じものを記述してみよう。

public class User {  
    private String name;  
    private Integer age;  
  
    public User(Map<String, Integer> map) {  
        for (String key : map.keySet()) {  
            this.name = key;  
            this.age = map.get(key);  
            break;
        }  
    }  
  
    public String getName() {  
        return name;  
    }  
  
    public Integer getAge() {  
        return age;  
    }  
}

public class Exp21 {  
    public static void main(String[] args) {  
        Map<String, Integer> map = new HashMap<>();  
        map.put("John Doe", 25);  
  
        User user = new User(map);  
  
        String template = "name = %s, age = %d";  
        System.out.println(String.format(template, 
	        user.getName(), user.getAge()));  
  }  
}

非常に苦しい書き換えとなってしまった。

【KotlinとJava】Null不可プロパティ

noreply@blogger.com (Masahiro Atsumi) — Fri, 27 Jul 2018 00:00:00 +0000

KotlinとJava

Kotlinではnullの扱いにとても注意を払っている。今回はメンバー変数にnullを代入しないようにするための機能を紹介する。

NotNull property.kt

import kotlin.properties.Delegates

class User {
    var name: String by Delegates.notNull()

    fun init(name: String) {
        this.name = name
    }
}

fun main(args: Array<String>) {
    val user = User()
    // user.name -> IllegalStateException
    user.init("Carl")
    println(user.name)
}

リンク

内部的に以前紹介した委譲プロパティ（デリゲート）が展開されるため、大量のメンバー変数（プロパティ）があるクラスファイルなどでは扱いに注意しよう。

Javaで記述

対比ができるようにJavaでも同じものを記述してみよう。

public class User {  
    private String name;  
  
    public void init(String name) {  
        if (name == null) {  
            throw new IllegalStateException();  
        }  
        this.name = name;  
    }  
  
    public String getName() {  
        if (name == null) {  
            throw new IllegalStateException();  
        }  
        return name;  
    }  
}

public class Exp20 {  
    public static void main(String[] args) {  
        final User user = new User();  
        user.init("Carl");  
        System.out.println(user.getName());  
    }  
}

Kotlinの場合、変数にnullを代入しようとすると、コンパイル時にエラーが発生してしまい、nullを代入することができない（代入する方法もある）。

Javaではそういった仕組みがないので、代入したときに例外が発生するという書き方をさせてもらった。

コンパイル時と実行時の差は大きい。

【KotlinとJava】プロパティの監視

noreply@blogger.com (Masahiro Atsumi) — Tue, 24 Jul 2018 00:00:00 +0000

KotlinとJava

委譲プロパティではDelegateを宣言してプロパティの入出力を監視する方法を紹介した。ラムダ式を利用するとより簡単に実装できる。

Observable property.kt

import kotlin.properties.Delegates  
  
class User {  
    var name: String by Delegates.observable("no name") {  
        prop, old, new ->
            println("$old -> $new")  
    }  
}  
  
fun main(args: Array<String>) {  
    val user = User()  
    user.name = "first"  
    user.name = "second"  
}

リンク

observable and vetoable

Delegates.observableを利用することで、値が変化したタイミングに処理を挟むことができる。Delegates.observableは値が変わってしまった後に呼ばれるため、値が変わる前のタイミングに挟み込みたいときはDelegates.vetoableを利用する。

以下のように記述すれば、マイナスの数値の代入を試みても、メンバー変数（プロパティ）の内容は変化しない。

var age: Int by Delegates.vetoable(15) {  
    prop, old, new ->  
        0 <= new  
}

Javaで記述

対比ができるようにJavaでも同じものを記述してみよう。

public class User {  
    private String name = "no name";  

    public void setName(String newValue) throws NoSuchFieldException {  
        String oldValue = this.name;  
        this.name = newValue;  
        onChange(this.getClass().getDeclaredField("name"), oldValue, newValue);  
    }  
  
    private void onChange(Field prop, String oldValue, String newValue) {  
        String template = "%s -> %s";  
        System.out.println(String.format(template, oldValue, newValue));  
    }  
}

public class Exp19 {  
    public static void main(String[] args) throws NoSuchFieldException {  
        final User user = new User();  
        user.setName("first");  
        user.setName("second");  
    }  
}

observableはメンバー変数（プロパティ）に代入した後に発生するというのがポイント。

【KotlinとJava】遅延プロパティ

noreply@blogger.com (Masahiro Atsumi) — Sat, 21 Jul 2018 00:00:00 +0000

KotlinとJava

プロパティの遅延評価なんてものもKotlinは言語の機能として持っている。コンピュータは電力を消費してプログラムを実行する。実行しなくともよいのであれば、実行しないに越したことはないのだ。

Lazy property.kt

class LazySample {
    val lazy: String by lazy {
        println("computed!")
        "my lazy"
    }
}

fun main(args: Array<String>) {
    val sample = LazySample()
    println("lazy = ${sample.lazy}")
    println("lazy = ${sample.lazy}")
}

リンク

解説の前に動きを確認してみよう。1度目とも2度目も、lazyの内容を出力するのに変わりないが、1度目のみ「computed!」の出力とlazyへの代入が実行される。

上記のサンプルだと「computed!」と表示するだけなので、あまりありがたみを感じないかもしれないが、表示の代わりに、たとえばリストの中身を合計するなどの処理をするとしたらどうだろうか？2度目は合計は計算済みなので、結果だけ返却することになる。もっというのなら、リストの合計をしない場合だって考えられる。使われない合計を計算するのは電機を無駄にするだけだ。

Javaで記述

対比ができるようにJavaでも同じものを記述してみよう。

public class LazySample {  
    private String lazyValue;  
  
    public synchronized String getLazyValue() {  
        if (lazyValue == null) {  
            System.out.println("computed!");  
            lazyValue = "my lazyValue";  
        }  
        return lazyValue;  
    }  
}

public class Exp18 {  
    public static void main(String[] args) {  
        final LazySample sample = new LazySample();  
        System.out.println("lazyValue = " + sample.getLazyValue());  
        System.out.println("lazyValue = " + sample.getLazyValue());  
    }  
}

このテクニックはどんな言語でも利用できる。しかし、言語が仕組みを持っているのは頼もしく感じる。

【KotlinとJava】委譲プロパティ

noreply@blogger.com (Masahiro Atsumi) — Wed, 18 Jul 2018 00:00:00 +0000

KotlinとJava

Javaでは外部のライブラリを使用しなければできなかったことがKotlinでは言語の機能として実装されているものがいくつかある。今回の委譲プロパティもその一つだ。

メンバー変数（プロパティ）への値の代入や取り出しを監視したいことはないだろうか？そんな要望もKotlinは快く受け入れてくれる。

今回は委譲プロパティの記述方法を紹介する。

Custom delegate.kt

import kotlin.reflect.KProperty

class Example {
    var p: String by Delegate()
    override fun toString() = "Example Class"
}

class Delegate() {
    operator fun getValue(thisRef: Any?, prop: KProperty<*>): String {
        return "$thisRef, thank you for delegating '${prop.name}' to me!"
    }

    operator fun setValue(thisRef: Any?, prop: KProperty<*>, value: String) {
        println("$value has been assigned to ${prop.name} in $thisRef")
    }
}

fun main(args: Array<String>) {
    val e = Example()
    println(e.p)
    e.p = "NEW"
}

リンク

delegate property

メンバー変数（プロパティ）にデリゲートを設定することができる。値の代入と取り出しを別のクラスに委譲しているわけだ。パッケージのインポートを見るとわかるように、リフレクションを利用して機能を実現しているようだ。

override

ここでは中心の話題ではないが、関数のオーバーライドが登場したため、あわせて紹介しておこう。

override fun toString() = "Example Class"

の記述を省略せずに記述すると、次のようになる。

override fun toString(): String {
 return "Example Class"
}

ブロックを使わずに記述するほうは戻り値の型もreturnも必要ない。

Javaで記述

対比ができるようにJavaでも同じものを記述してみよう。

public class Example {  
  
    private String p;  
  
    public String getP()
        throws NoSuchFieldException {  
        return Delegate.getValue(this, this.getClass().getDeclaredField("p"));  
    }  
  
    public void setP(String value)
        throws NoSuchFieldException, IllegalAccessException {  
        Delegate.setValue(this, this.getClass().getDeclaredField("p"), value);  
    }  
  
    @Override  
    public String toString() {  
        return "Example Class";  
    }  
}

import java.lang.reflect.Field;
public class Delegate {  
  
    static String getValue(Object thisRef, Field prop) {  
        String template = "%s, thank you for delegating '%s' to me!";  
        return String.format(template, thisRef, prop.getName());  
    }  
  
    static void setValue(Object thisRef, Field prop, String value)
        throws IllegalAccessException {  
        // 値の代入  
        prop.setAccessible(true);  
        prop.set(thisRef, value);  
  
        String template = "%s has been assigned to %s in %s";  
        System.out.println(String.format(template, 
            value, prop.getName(), thisRef));  
    }  
}

public class Exp17 {  
    public static void main(String[] args)
        throws NoSuchFieldException, IllegalAccessException {  
        Example e = new Example();  
        System.out.println(e.getP());  
        e.setP("NEW");  
    }  
}

だいぶテクニカルなコードとなった。検査例外も多い。

【KotlinとJava】Data型の自動関数宣言

noreply@blogger.com (Masahiro Atsumi) — Sun, 15 Jul 2018 00:00:00 +0000

KotlinとJava

データ型を宣言すると、暗黙的にいくつかの関数を利用することができる。Javaでは手作業で作っていたものがライブラリなしで使うことができるのだ。

Autogenerated functions.kt

data class User(val name: String, val id: Int)

fun main(args: Array<String>) {
    val user = User("Alex", 1)
    println(user) // toString()

    val secondUser = User("Alex", 1)
    val thirdUser = User("Max", 2)

    println("user == secondUser: ${user == secondUser}")
    println("user == thirdUser: ${user == thirdUser}")

    // copy() function
    println(user.copy())
    println(user.copy("Max"))
    println(user.copy(id = 2))
    println(user.copy("Max", 2))
}

リンク

toString

実行するとメンバー変数の内容を以下のように展開してくれる。

User(name=Alex, id=1)

JavaではtoStringをオーバーライドして作りこむ必要があったので、とても便利。

operator “==”

当たり前のようにクラスを==で比較しているが、これはJavaでは行えない芸当だ。

また、後述の「Javaで記述」ではequalsメソッドで代用しているが、実はそれでも足りない。上記コードの実行結果では一つ目の比較はなんとtrue、二つ目の比較はfalseとなる。
Javaはオブジェクトの比較はオブジェクトが格納されているアドレスを比較するため、メンバー変数を比較するためにはequalsメソッドのオーバーライドが必要なのだ。

Kotlinはこんなことをこともなげに行ってくれる。

copy

元のインスタンスをコピーして、新しいインスタンスを得るという機能だが、Kotlinは一部のメンバー変数の書き換えもサポートしてくれる。

しかも、変数名を指定することができるため、より柔軟に記述することができる。メンバー変数が10以上あるクラスを考えてみてほしい。そのクラスの5番目の変数だけ変更して新しいインスタンスが欲しいなどというときはぞっとしないだろうか？

Javaで記述

対比ができるようにJavaでも同じものを記述してみよう。

public class User {  
    private final String name;  
    private final int id;  
  
    public User(String name, int id) {  
        this.name = name;  
        this.id = id;  
    }  
  
    public String getName() {  
        return name;  
    }  
    public int getId() {  
        return id;  
    }  
  
    public User copy() {  
        return new User(this.name, this.id);  
    }  
    public User copy(String name) {  
        return new User(name, this.id);  
    }  
    public User copy(int id) {  
        return new User(this.name, id);  
    }  
    public User copy(String name, int id) {  
        return new User(name, id);  
    }  
  
    public String toString() {  
        String template = "User(name=%s, id=%d)";  
        return String.format(template, name, id);  
    }  
  
    @Override  
    public boolean equals(Object o) {  
        User u = (User)o;  
        // チェック手抜き  
        if (!(this.name.equals(u.name))) {  
            return false;  
        }  
        if (this.id != u.id) {  
            return false;  
        }  
        return true;  
    }  
}
public class Exp16 {  
    public static void main(String[] args) {  
        final User user = new User("Alex", 1);  
        System.out.println(user);  
  
        final User secondUser = new User("Alex", 1);  
        final User thirdUser = new User("Max", 2);  
  
        System.out.println("user.equals(secondUser)" + user.equals(secondUser));  
        System.out.println("user.equals(thirdUser)" + user.equals(thirdUser));  
  
        System.out.println(user.copy());  
        System.out.println(user.copy("Max"));  
        System.out.println(user.copy(2));  
        System.out.println(user.copy("Max", 2));  
    }  
}

Kotlinと同じ機能のクラスにするためには多くのコーディング追加が必要なことが分かる。toString, copy, equalsを記述していることに気が付くだろうか？

【KotlinとJava】Mapクラスを使う

noreply@blogger.com (Masahiro Atsumi) — Thu, 12 Jul 2018 00:00:00 +0000

KotlinとJava

今回はKotlinにおける、Mapをざっと見てみよう。念のために、Mapの概念を説明しておこう。Mapというのは一言でいうと「名前の付けられる配列」である。言語によっては辞書や連想配列などと呼ばれる。辞書を引くときは単語や語句から意味を調べるから、イメージしやすいだろう。

Traversing a map.kt

fun main(args: Array<String>) {
    val map = hashMapOf<String, Int>()
    map.put("one", 1)
    map.put("two", 2)

    for ((key, value) in map) {
        println("key = $key, value = $value")
    }
}

リンク

mapという変数にhashMapOfという関数を利用してMapのインスタンスを格納している。型推論によってMap型というのが分かるので、変数には型を指定する必要がない。

for文のところでも以前紹介した分解宣言が登場している。mapは文字列と整数のペアで構成されているので、分解宣言によってその二つの要素にアクセスできるということだ。

Javaで記述

対比ができるようにJavaでも同じものを記述してみよう。

public class Exp15 {  
    public static void main(String[] args) {  
        final Map<String, Integer> map = new HashMap<>();  
        map.put("one", 1);  
        map.put("two", 2);  
  
        for (Map.Entry<String, Integer> m : map.entrySet()) {  
            String template = "key = %s, value = %d";  
            System.out.println(String.format(template, m.getKey(), m.getValue()));  
        }  
    }  
}

Javaには分解宣言という仕組みがないので、for文で一つ一つの要素にアクセスするときはEntryという型に値を格納することになる。

【KotlinとJava】データ型の宣言

noreply@blogger.com (Masahiro Atsumi) — Mon, 09 Jul 2018 00:00:00 +0000

KotlinとJava

JavaにはC言語のような構造体がなく、クラスを利用してデータを格納する。Kotlinではデータを扱うための仕組みが用意されている。ここからはしばらくデータ型についての記事となる。じっくり読み進めていってほしい。

Data classes.kt

data class User(val name: String, val id: Int)

fun getUser(): User {
    return User("Alex", 1)
}

fun main(args: Array<String>) {
    val user = getUser()
    println("name = ${user.name}, id = ${user.id}")

    // or

    val (name, id) = getUser()
    println("name = $name, id = $id")

    // or

    println("name = ${getUser().component1()}, id = ${getUser().component2()}")
}

リンク

data class

データを扱う仕組みとはいえ、その実態はクラスであるようだ。

分解宣言も行うことができる。また、componentNを利用して内部の変数にアクセスすることもできる。前回のPairクラスはデータクラスといって差し支えないだろう。

Javaで記述

対比ができるようにJavaでも同じものを記述してみよう。

public class User {  
    private final String name;  
    private final int id;  
  
    private User(String name, int id) {  
        this.name = name;  
        this.id = id;  
    }  
  
    public static User getUser() {  
        return new User("Alex", 1);  
    }  
  
    public String getName() {  
        return name;  
    }  
  
    public int getId() {  
        return id;  
    }  
}

public class Exp14 {  
    public static void main(String[] args) {  
        final User user = User.getUser();  
  
        String template = "name = %s, id = %d";  
        System.out.println(String.format(template, user.getName(), user.getId()));  
  
        // or  
  
        final String name = user.getName();  
        final int id = user.getId();  
        System.out.println(String.format(template, name, id));  
  
        // or  
  
        System.out.println(String.format(template, user.getName(), user.getId()));  
  }  
}

上でも触れたとおり、Javaにはデータそのものを格納するものはない。通常のクラスを利用して、Dataの格納を行っている。

【KotlinとJava】分解宣言

noreply@blogger.com (Masahiro Atsumi) — Fri, 06 Jul 2018 00:00:00 +0000

13 分解宣言

KotlinとJava

今回は変数に値を代入するサンプルなのだが、一見何を行っているのかがわからないかもしれない。Javaのサンプルと見比べて理解を進めてほしい。

非構造化宣言や分解宣言、分割代入などと呼ばれるようだ。

Destructuring declarations.kt

fun main(args: Array<String>) {  
    val pair = Pair(1, "one")  
  
    val (num, name) = pair  
  
    println("num = $num, name = $name")  
}  
  
class Pair<K, V>(val first: K, val second: V) {  
    operator fun component1(): K {  
        return first  
    }  
  
    operator fun component2(): V {  
        return second  
    }  
}

リンク

重要なポイントはval (num, name) = pairの部分である。オブジェクトが二つの変数に代入されているように見える。これは次のように解釈される。

val num = pair.component1()
val name = pair.component2()

この方法を利用することで、関数は複数の戻り値を持つことができる。上記の例では、2つの値を戻しているが、componentNの部分を増やしていけば、その分だけ戻り値が増えていく。分割宣言を行うためには、関数の頭にoperatorをつける必要がある。

これを見ていて「Mapに似ているな」と気が付いたあなたは鋭い。MapのKey-ValueにはそれぞれcomponentNが割り当てられているのだ。

operator fun <K, V> Map.Entry<K, V>.component1() = getKey()  
operator fun <K, V> Map.Entry<K, V>.component2() = getValue()

この後のサンプルで出てくるので、お楽しみに。

Javaで記述

対比ができるようにJavaでも同じものを記述してみよう。

public class Exp13 {  
    public static void main(String[] args) {  
        final Pair<Integer, String> pair = new Pair<>(1, "one");  
        final int num = pair.getFirst();  
        final String name = pair.getSecond();  
  
        String template = "num = %d, name = %s";  
        System.out.println(String.format(template, num, name));  
    }  
}
  
public class Pair<K, V> {  
    private final K first;  
    private final V second;  
  
    public Pair(K first, V second) {  
        this.first = first;  
        this.second = second;  
    }  
  
    public K getFirst() {  
        return first;  
    }  
  
    public V getSecond() {  
        return second;  
    }  
}

Javaではもはや同じ記述ができない。通常のgetterで我慢してほしい。

【KotlinとJava】whenを使う

noreply@blogger.com (Masahiro Atsumi) — Tue, 03 Jul 2018 00:00:00 +0000

12 whenを使う

KotlinとJava

if文ともう一つの制御構文when文だ。連続したif文を書くことはなくなる。

Use when.kt

fun main(args: Array<String>) {  
    cases("Hello")  
    cases(1)  
    cases(0L)  
    cases(MyClass())  
    cases("hello")  
}  
  
fun cases(obj: Any) {  
    when (obj) {  
        1 -> println("One")  
        "Hello" -> println("Greeting")  
        is Long -> println("Long")  
        !is String -> println("Not a string")  
        else -> println("Unknown")  
    }  
}  
  
class MyClass() {  
}

リンク

when

Javaのswitchと似ているが、分岐の条件はそろえる必要はない。サンプルのようにいろいろな条件が重なることは少ないだろうが、switch文より柔軟な記述をすることが可能だ。

Javaで記述

対比ができるようにJavaでも同じものを記述してみよう。

public class Exp12 {  
    public static void main(String[] args) {  
        cases("Hello");  
        cases(1);  
        cases(0L);  
        cases(new MyClass());  
        cases("hello");  
    }  
  
    private static void cases(Object obj) {  
        if (new Integer(1).equals(obj)) {  
            System.out.println("One");  
        } else if ("Hello".equals(obj)) {  
            System.out.println("Greeting");  
        } else if (obj instanceof Long) {  
            System.out.println("Long");  
        } else if (!(obj instanceof String)) {  
            System.out.println("Not a string");  
        } else {  
            System.out.println("Unknown");  
        }  
    }  
}

public class MyClass {  
}

前述の説明ではswitch文に似ていると書いたが、switch文では記述することができない。

if文が並ぶと、とても読みにくいことがわかる。その場でコーディングしている人にはわかるのかもしれないが、ぱっと見どんな条件なのかと言われると、目を凝らす必要があるだろう。

【KotlinとJava】範囲（レンジ）を使う

noreply@blogger.com (Masahiro Atsumi) — Sat, 30 Jun 2018 00:00:00 +0000

11 範囲（レンジ）を使う

KotlinとJavaサンプルで理解

前回のforではリストや配列のループについてのサンプルだった。今回は範囲を自分で設定してループを行うサンプルとなる。
少し長いがコードはいくつかのパートに分かれている。少しづつ読み進めていこう。

Use ranges and in.kt

fun main(args: Array<String>) {  
    val x = args[0].toInt()  
    //Check if a number lies within a range:  
    val y = 10  
    if (x in 1..y - 1) {  
        println("OK")  
    }  
  
    //Iterate over a range:  
    for (a in 1..5) {  
        print("$a ")  
    }  
  
    //Check if a number is out of range:  
    println()  
    val array = arrayListOf<String>()  
    array.add("aaa")  
    array.add("bbb")  
    array.add("ccc")  
  
    if (x !in 0..array.size - 1) {  
        println("Out: array has only ${array.size} elements. x = $x")  
    }  
  
    //Check if a collection contains an object:  
    if ("aaa" in array) { // collection.contains(obj) is called  
        println("Yes: array contains aaa")  
    }  
  
    if ("ddd" in array) { // collection.contains(obj) is called  
        println("Yes: array contains ddd")  
    } else {  
        println("No: array doesn't contains ddd")  
    }  
}

リンク

range

rangeというのは範囲のことである。範囲は連続した数値の集まりで、たとえば「1から10」のようなものだ。Javaでは範囲を直接扱うことができない。より大きい（たとえば、10 < x）、より小さい（たとえば y < 50）といった具合だ。他には、いったんリストを作成し、リストに含まれるかどうかを確認する方法だ。しかしこの場合はリスト内の数値が連続しているかどうか保証はできない。

downTo, step, until

連続した数字を作る方法はいくつか用意されている。
まずは普通の方法。「1から10」を示す。

1..10    // 1 to 10

次は大きい数字から小さい数字。「10から1」を示す。
残念だが、10..1とは記述できない。

10 downTo 1    // 10 to 1

一定の間隔をあけて数値を作るとき。「1, 3, 5, 7, 9」を示す。

1..10 step 2    // 1, 3, 5, 7, 9

最後の数値を含めたくない場合。「1から9」を示す。

1 until 10    // 1 to 9(10は含まない)

in

inの否定形が出てきた。

x !in 0..10

だ。こりゃまたわかりやすい。

!(x in 0..10)

より、直感的に感じる。

Javaで記述

対比ができるようにJavaでも同じものを記述してみよう。

public class Exp11 {  
  
    public static void main(String[] args) {  
        final int x = Integer.parseInt(args[0]);  
  
        final List<Integer> yRange = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);  
        if (yRange.contains(x)) {  
            System.out.println("OK");  
        }  
  
        final List<Integer> aRange = Arrays.asList(1, 2, 3, 4, 5);  
        for (Integer a : aRange) {  
            System.out.println(a);  
        }  
  
        System.out.println();  

        final List<String> array = new ArrayList<>();  
        array.add("aaa");  
        array.add("bbb");  
        array.add("ccc");  
  
        if (!(0 <= x && x <= (array.size() - 1)))
            String template = "Out: array has only %d elements. x = %d";  
            System.out.println(String.format(template, array.size(), x));  
        }
  
        if (array.contains("aaa")) {  
            System.out.println("Yes: array contains aaa");  
        }  
  
        if (array.contains("ddd")) {  
            System.out.println("Yes: array contains ddd");  
        } else {  
            System.out.println("No: array doesn't contains ddd");  
        }  
    }  
}

以下の部分の書き換えに悩んだ。集合が動的になるとJavaの表現力では追い付かない。

if (x !in 0..array.size - 1)

次のように、いったんリストを作成する方法もあるが、回りくどい感じがする。

// 連続した数値のリストを作成
final List<Integer> bRange = new ArrayList<>();  
for (int i = 0; i < array.size() - 1; i++) {  
    bRange.add(i);  
}  
// リストに含まれるかを確認  
if (!bRange.contains(x)) {  
    String template = "Out: array has only %d elements. x = %d";  
  System.out.println(String.format(template, array.size(), x));  
}

【KotlinとJava】forループを使う

noreply@blogger.com (Masahiro Atsumi) — Wed, 27 Jun 2018 00:00:00 +0000

10 forループを使う

KotlinとJava

今回はリストや配列に対してループを行うサンプルだ。いわゆるforEach形式のfor文である。

Use a for-loop.kt

fun main(args: Array<String>) {
    for (arg in args) {
        println(arg)
    }

    println()

    // or
    for (i in args.indices) {
        println(args[i])
    }
}

リンク

for

繰り返し処理するのが単行の場合はブレース{}は省略できるが、筆者のポリシーとしてつけさせていただいた。

すべての要素をについて繰り返し処理を行いたいのなら、上の書式を使えばよい。配列に対してインデックスを使ってアクセスを行うと、初期化やインクリメントで問題が発生することがある。

…と思っていたら、Kotlinではインデックスアクセスにもうまい方法が提供されていた。それがfor (i in args.indices)だ。インデックスの変数が提供されているのだから、ブロックの中でiの値を変更できてしまうのでは？つまり、次のようなことのできるのでは？と思うかもしれない。

for (i in args.indices) {
	i++
	println(args[i])
}

しかし、このような書き方はコンパイラが許してくれない。iという変数はval（つまり変更不可）で宣言されているようだ。これでインデックスアクセスもだいぶ間違いを排除することができるはずだ。

Javaで記述

対比ができるようにJavaでも同じものを記述してみよう。

public class Exp10 {  
    public static void main(String[] args) {  
        for (String arg : args) {  
            System.out.println(arg);  
        }  
  
        System.out.println();  
  
        // or  
        for (int i = 0; i < args.length; i++) {  
            System.out.println(args[i]);  
        }  
    }  
}

こちらはもはやおなじみだろう。

【KotlinとJava】whileループを使う

noreply@blogger.com (Masahiro Atsumi) — Sun, 24 Jun 2018 00:00:00 +0000

09 whileループを使う

KotlinとJava

このあとループの記事が続く。制御構文についての知識が深ければ、よりシンプルな方法でコードを記述できる。頭を使ってシンプルにするってのは、プログラマらしいではないか。

Use a while-loop.kt

fun main(args: Array<String>) {
    var i = 0
    while (i < args.size) {
        println(args[i++])
    }
}

リンク

while

これはあまりJavaと変わらない。
繰り返し処理するのが単行の場合はブレース{}は省略できるが、筆者のポリシーとしてつけさせていただいた。

Javaで記述

対比ができるようにJavaでも同じものを記述してみよう。

public class Exp09 {  
    public static void main(String[] args) {  
        int i = 0;  
        while (i < args.length) {  
            System.out.println(args[i++]);  
        }  
    }  
}

【KotlinとJava】is チェックとスマートキャスト

noreply@blogger.com (Masahiro Atsumi) — Thu, 21 Jun 2018 00:00:00 +0000

08 isチェックとスマートキャスト

KotlinとJava

今回はスマートキャストのサンプルだ。Kotlinはとても賢く、プログラムする人の気持ちを分かってくれるようだ！？

is-checks and smart casts.kt

fun main(args: Array<String>) {
    println(getStringLength("aaa"))
    println(getStringLength(1))
}

fun getStringLength(obj: Any): Int? {
    if (obj is String) {
        return obj.length // String型へのキャストは必要なし
    }
    return null
}

リンク

getStringLength関数はどんな型の変数も許容してくれる、any型の変数を持ち、それがString型であったらその長さを返却するという処理を行っている。

下部のJavaのコードと比較を行いながら読み進めてほしい。

is チェック

if (obj is String)の中のisはオブジェクトがその型であるかを判断してくれる。Javaでいうところのinstanceofと同じ機能だろうか。

ちなみに否定形はif (!(obj is String))ではなくif (obj !is String)である。英語の文章のようだ。

スマートキャスト

if文の次の行をKotlinとJavaで比較してみよう。

return obj.length

return ((String) obj).length();

JavaのほうはString型にキャストされている。Kotlinのコードを見ると、キャストせずに、obj変数があたかもString型であるかのようにふるまっている。

よく考えると、直前のif文で型の判断をしているのだから、if文のブロック内ではString型であることが当たり前である。Kotlinはこんなところにも気を配ってくれるのだ。

Javaで記述

対比ができるようにJavaでも同じものを記述してみよう。

public class Exp08 {  
    public static void main(String[] args) {  
        System.out.println(getStringLength("aaa"));  
        System.out.println(getStringLength(1));  
    }  
  
    private static Integer getStringLength(Object obj) {  
        if (obj instanceof String) {  
            return ((String) obj).length();  
        }  
        return null;  
    }  
}

String型にキャストしているところは一見何をしているのかわからないね。

【KotlinとJava】NULLチェック

noreply@blogger.com (Masahiro Atsumi) — Mon, 18 Jun 2018 00:00:00 +0000

07 NULLチェック

KotlinとJava

Kotlinは基本的にNULLをできるだけ排するよう考えられている。NULLはつまり、割り当てる値がないということなのだが、プログラムの工夫や仕様の制限などである程度は回避することができる。しかし、どうしてもNULLが発生してしまう場合もある。
KotlinはそうしたNULLが発生する状況についてどのような答えを出したのだろうか？

Null-checks.kt

fun parseInt(str: String): Int? {  
    try {  
        return str.toInt()  
    } catch (e: NumberFormatException) {  
        println("One of the arguments isn't Int")  
    }  
    return null  
}  
  
fun main(args: Array<String>) {  
    if (args.size < 2) {  
        println("No number supplied")  
    } else {  
        val x = parseInt(args[0])  
        val y = parseInt(args[1])  
  
        if (x != null && y != null) {  
            print(x * y)
        } else {  
            println("One of the arguments is null")  
        }  
    }  
}

リンク

先ほどの答えだが、Kotlinは「NULLかもしれない」という場所にマークをつけることにしたのだ。fun parseInt(str: String): Int?の戻り値のInt?にクエスチョンマークがついているのに気が付いただろうか？これはこのparseIntという関数がNULLを返却する場合もあると教えてくれている。

関数を利用する側はNULLが発生するという前提に基づいてプログラムを組むことになる。上記のコード中でif (x != null && y != null)とNULLのチェックを行っているが、これを取ってしまうと、コンパイルエラーが発生するのだ。

コンパイルエラーが出るのはうっとおしい気がするかもしれないが、実行時にNullPointerException例外が発生するよりはずっとましだろう。

Javaで記述

対比ができるようにJavaでも同じものを記述してみよう。

public class Exp07 {  
    private static Integer parseInt(String str) {  
        try {  
            return Integer.parseInt(str);  
        } catch (NumberFormatException e) {  
            System.out.println("One of the arguments isn't Integer");  
        }  
        return null;  
    }  
  
    public static void main(String[] args) {  
        if (args.length < 2) {  
            System.out.println("No number supplied");  
        } else {  
            final Integer x = parseInt(args[0]);  
            final Integer y = parseInt(args[1]);  
            if (x != null && y != null) {  
                System.out.println(x * y);  
            } else {  
                System.out.println("One of the arguments is null");  
            }  
        }  
    }  
}

parseInt関数の戻り値の型がIntegerとなっている。これはint型がNULLを許容しないためだ。

【KotlinとJava】条件式の利用

noreply@blogger.com (Masahiro Atsumi) — Thu, 14 Jun 2018 00:00:00 +0000

06 条件式の利用

KotlinとJava

またもやif文が登場するが、今度は式として利用できるというサンプルだ。式というのは処理に対して値を返却するという性質を持つ。

Use a conditional expression.kt

fun main(args: Array<String>) {
    println(max(args[0].toInt(), args[1].toInt()))
}

fun max(a: Int, b: Int) = if (a > b) a else b

リンク

関数の宣言fun max(a: Int, b: Int)に対して、if (a > b) a else bという式が関数に代入されている。maxにreturnがないのは、if文が値を返却する特性があるからか。

ちなみに、次のように間に改行をいれても問題ないので、when文でも同じようなことができるだろう。

fun max(a: Int, b: Int)  
        = if (a > b) a else b

また、Sting#toIntが用意されているのはうれしいね。

Javaで記述

対比ができるようにJavaでも同じものを記述してみよう。

public class Exp06 {  
    public static void main(String[] args) {  
        System.out.println(
            max(Integer.parseInt(args[0]), Integer.parseInt(args[1])));  
    }  
  
    private static int max(int a, int b) {  
        return (a > b) ? a : b;  
    }  
}

Kotlinと比べると、所々で冗長な書き方となっている。max関数の戻り値のintをKotlinで宣言しないのは、型推論が働いているのだろう。
もちろん、Kotlinのmax関数は以下のように明示的に宣言することもできる。

fun max(a: Int, b: Int) : Int = if (a > b) a else b

【KotlinとJava】オブジェクト指向な「Hello, world」

noreply@blogger.com (Masahiro Atsumi) — Tue, 12 Jun 2018 00:00:00 +0000

05 オブジェクト指向な「Hello, world」

KotlinとJava

やっとクラスが出てきた。このサンプルには実に様々な要素が詰め込まれている。少しづつ紐解いていこう。

An object-oriented Hello.kt

class Greeter(private val name: String) {  
    fun greet() {  
        println("Hello, $name")  
    }  
}  
  
fun main(args: Array<String>) {  
    Greeter(args[0]).greet()  
}

リンク

クラス

まずはクラスの宣言からだ。クラス名Greeterの後ろに(private val name: String)といった引数がついている。これは、クラスの宣言と同時に、コンストラクタを宣言しているのだ。引数付きのコンストラクタであるから、もちろんデフォルトコンストラクタは利用できなくなる。

さて、name: Stringはどのような扱いになるのか気になるのではないだろうか？これはnameというメンバー変数が作られるのだ。greetメソッドを見てみると、nameメンバー変数にアクセスしているのがわかるはずだ。

次は呼び出し側についてみていこう。Kotlinではインスタンスを生成するために、newキーワードは必要ない。クラス名()とすることでインスタンスを生成できる。もちろん、生成したインスタンスを変数に格納することも可能だ。

変数

val name: Stringのvalに注目してほしい。kotlinにおいて、変数の宣言は2種類の方法がある。違いは代入した後に中身を変えられるかどうかだ。

var Chanable = "OK!"      // 再代入可能
val canNotChange = "NG!"  // 再代入不可能

: Stringが付いていないのに気が付いただろうか？上記のように宣言と同時に値が決まる場合、コンパイラが自動的に型を判断してくれるため、型を記述する必要はない（もちろん記述してもよいが冗長であるとヒントが出る）。関数やメソッドの引数の場合は判断することができないため、型を記述する必要がある。

Javaで記述

public class Greeter {  
    private final String name;  
  
    public Greeter(String name) {  
        this.name = name;  
    }  
  
    public void greet() {  
        System.out.println(String.format("Hello, %s", this.name));  
    }  
}

public class Exp05 {  
    public static void main(String[] args) {  
        new Greeter(args[0]).greet();  
    }  
}

private final String nameのときに初期化をしなくても大丈夫かって？コンストラクタで初期化を行えば間に合うんだよね。

【KotlinとJava】複数言語での「Hello, world」

noreply@blogger.com (Masahiro Atsumi) — Sat, 09 Jun 2018 00:00:00 +0000

04 複数言語での「Hello, world」

KotlinとJava

ifに続き、もうひとつの条件分岐であるwhenの登場だ。

A multi-language Hello.kt

fun main(args: Array<String>) {
    val language = if (args.size == 0) "EN" else args[0]
    println(when (language) {
        "EN" -> "Hello!"
        "FR" -> "Salut!"
        "IT" -> "Ciao!"
        else -> "Sorry, I can't greet you in $language yet"
    })
}

リンク

if

まずはif文だ。この記述方法はJavaでいうところの三項演算子に似ている。しかし、ここで注目すべきなのは、if文は式としても利用することができるということだ。リファレンスを見ると、通常のスタイルのif文でも値を返却していることがわかる。

val max = if (a > b) {  
    print("Choose a")  
    a  
} else {  
    print("Choose b")  
    b  
}

when

次にwhen文である。Javaのswitch文に似ているが、こちらも式扱いで、値を返すことができる。->（アロー演算子）の先は{}で囲むことで以下のように記述ができる。ただし、最後の Hey! が式の結果として返却されるため、Hello! はThe expression is unusedという警告が出る。

println(when (language) {  
    "EN" -> {  
        println("Hello!")  
        "Hello!"  
        "Hey!"
    }  
    "FR" -> "Salut!"  
    "IT" -> "Ciao!"  
    else -> "Sorry, I can't greet you in $language yet"
})

whenに与える変数の型が決まっている場合、分岐先の型もそれに合わせる必要がある。つまり、次のような書き方はできない。（languageはString型であるため、5 -> "Five"のところでコンパイルエラーが出てしまう）

val launguage: String = args[0]
println(when (language) {
    "EN" -> "Hello!"
    "FR" -> "Salut!"
    "IT" -> "Ciao!"
    5 -> "Five!"
    else -> "Sorry, I can't greet you in $language yet"
})

しかし式の結果は型がそろわなくとも許容してくれる（変数に代入する場合は警告が出る）

val result = when(language) {  
    "EN" -> "Hello"  
    "FR" -> 100  
    else -> false  
}  
println(result)

Javaで記述

public class Exp04 {  
    public static void main(String[] args) {  
        String language = args.length == 0 ? "EN" : args[0];  
        switch (language) {  
        case "EN":  
            System.out.println("Hello!");  
            break; 
        case "FR":  
            System.out.println("Salut!");  
            break;
        case "IT":  
            System.out.println("Ciao!");  
            break;
        default:  
            String template = "Sorry, I can't greet you in %s yet!";
            System.out.println(String.format(template, language));
            break;
        }  
    }  
}

だいぶ記述量が増えてきた。
式記述のif文のところは三項演算子を利用したが、場合によっては使えないこともあるだろう。
when文はswitch文¹を利用した。

switch文のインデントには流派があると思うが、スペースを優先させていただいた。 ↩︎

【KotlinとJava】複数個のコマンドライン引数

noreply@blogger.com (Masahiro Atsumi) — Wed, 06 Jun 2018 00:00:00 +0000

03 複数個のコマンドライン引数

KotlinとJava

次はfor文だ。これも直感的にわかるだろう。argsの数ぶん繰り返し処理を行う。argsに入っているものが増えても減っても問題なく動作する。args[0]のように、配列に序数を使ってアクセスしないので、入っているもの以上に誤ってアクセスしなくて済む。

Reading many names from the command line.kt

fun main(args: Array<String>) {
    for (name in args)
        println("Hello, $name!")
}

リンク

ここでもString Templateが利用されている。以前のサンプルでは${args[0]}と記述していた。ここでは{と}で囲まずに$nameと記述している。この違いは、変数をそのまま表示するか、もしくは式¹の結果を表示するかのようだ。args[0]は配列にアクセスする式なのだ。ちなみに、${args[0]}を$args[0]として実行すると、argsのアドレスが表示される。

Javaで記述

public class Exp03 {  
    public static void main(String[] args) {  
        for (String name : args) {  
            System.out.println(String.format("Hello, %s!", name));  
        }  
    }  
}

式ということは${name + (5+3)}という記述ができるということだ。 ↩︎

つねひごろ

【Delphiでゲーム制作】ボールを動かす

【Delphiでゲーム制作】ボールを動かす

まずは設計

ボールを動かす

壁にぶつかったら反射

画面作成とコーディング

コンポーネント配置

イベント作成

【Delphi Sample】Delphi と Google App Engine と Thrift と Java その3

【Delphi Sample】Delphi と Google App Engine と Thrift と Java その3

クライアントアプリケーション

フォルダ構成

コーディング

MainForm.fmx

MainForm.pas

動作確認

スポンサーリンク

【Delphi Sample】Delphi と Google App Engine と Thrift と Java その2

【Delphi Sample】Delphi と Google App Engine と Thrift と Java その2

サーバーアプリケーション

フォルダ構成

コーディング

CalculatorHandler.java

CalculatorServiceImpl.java

スポンサーリンク

【Delphi Sample】Delphi と Google App Engine と Thrift と Java その1

【Delphi Sample】Delphi と Google App Engine と Thrift と Java その1

キーワード

インターフェイスを決める

インターフェイス設計

calculator.thrift

common.thrift

ファイルの自動生成

フォルダ構成

スポンサーリンク

【Delphi Sample】ジェネリックスを使う

【Delphi Sample】ジェネリックスを使う

【Delphi Sample】並列プログラミング1

【Delphi Sample】並列プログラミング1

【KotlinとJava】Mapとプロパティ

KotlinとJava

Properties in map.kt

Javaで記述

【KotlinとJava】Null不可プロパティ

KotlinとJava

NotNull property.kt

Javaで記述

【KotlinとJava】プロパティの監視

KotlinとJava

Observable property.kt

observable and vetoable

Javaで記述

【KotlinとJava】遅延プロパティ

KotlinとJava

Lazy property.kt

Javaで記述

【KotlinとJava】委譲プロパティ

KotlinとJava

Custom delegate.kt

delegate property

override

Javaで記述

【KotlinとJava】Data型の自動関数宣言

KotlinとJava

Autogenerated functions.kt

toString

operator “==”

copy

Javaで記述

【KotlinとJava】Mapクラスを使う

KotlinとJava

Traversing a map.kt

Javaで記述

【KotlinとJava】データ型の宣言

KotlinとJava

Data classes.kt

data class

Javaで記述

【KotlinとJava】分解宣言