一瞬で元に戻るディスク

1. 元ネタのディスクを/dev/mapper/testvg-testlvとします。
   
   
2. 次に，十分大きな（変更を保持できる）大きさのファイルを作ります。この時，dd の seek引数でオフセットを指定すれば，スパースファイルが作成されるので高速です。ここでは，testlv.img とします。
   
   
3. losetup で， testlv.img をループバックデバイスと結びつけます。/dev/loop0 を使うとします。
   
   
4. ここで，新しいブロックデバイス（/dev/mapper/testvg-disk）を作成するために dmsetupを使います。 /dev/mapper/testvg-disk に対するすべての書き込みを，testlv.img に行なうようにします。読み出しは，変更されていないセクタは直接/dev/mapper/testvg-lvtestから読み出されます。
   

   
   echo 0 $(blockdev --getsize /dev/mapper/testvg-testlv) snapshot /dev/mapper/testvg-testlv /dev/loop0 n 64 | dmestup create testvg-disk
   

   
   
   
5. 3を繰り替えして，別のファイル（testlv2.img）を/dev/loop1 と結びつけます。
   
   
6. ディスクを戻すタイミングで，次のコマンドを投入します。このコマンドを投入した時点で，書き込みはtestlv2.imgに行なわれるようになります。
   

   
   echo 0 $(blockdev --getsize /dev/mapper/testvg-testlv) snapshot /dev/mapper/testvg-testlv /dev/loop1 n 64 | dmestup reload testvg-disk
   dmsetup suspend testvg-disk
   dmsetup resume testvg-disk
   

   
   
   
7. /dev/loop0 と testlv.img が未使用になるので，それぞれ削除・再作成して次の切り替えに備えます。XFSなど，巨大ファイルの扱いが速いファイルシステムを使うと良いです。
   

開始セクタ 終了セクタ ターゲット ...

• 一部だけがエラーになるディスク
  
• 前半と後半で暗号化キーの異なるディスク
  

　前回、キーボード入力されたデータをそのまま計算しようとすると、

　型の関係でエラーが出てきました。

　これから何回かの記事にかけて、

　基本データ型（boolean、byte、short、int、long、float、double、char）において、

　型を変換できるパターンと、できないパターンをまとめていきたいと思います。

　この型変換に関する仕組みは、"Stringの森"のように、結構奥深いものです。

　ですので、遭難しない範囲で"型変換の洞窟"を探索してみたいと思います。

まずは、いくつか型変換をテストするプログラムをコンパイルして、

どのようになるか見てみたいと思います。

まずboolean型から他の基本データ型への変換です。

----------------------------------------------------

class TypeTest_Boolean{

public static void main(String args[]){

boolean test = false;

//booleanから各型へ変換
boolean bl = test;
byte bt = test;
short s = test;
int i = test;
long l = test;
float f = test;
double d = test;
char c = test;

}

}

----------------------------------------------------

このプログラムは、boolean型の変数testを宣言し、

それを他の基本データ型に入れるプログラムです。

早速、コンパイルしてみましょう。

・・・おもしろいぐらいにコンパイルエラーとなりました！（^_^；）

それでは、エラーの詳細を確認してみましょう。

エラーとなったのは、boolean型以外の基本データ型すべてでした。

エラー内容はすべて「互換性のない型」です。

ここからわかったのは、

boolean型は他の基本データ型に型変換することはできないということです。

それでは、続いてint型から他の基本データ型に変換してみましょう。

----------------------------------------------------

class TypeTest_Int{

public static void main(String args[]){

int test = 1;

//intから各型へ変換
boolean bl = test;
byte bt = test;
short s = test;
int i = test;
long l = test;
float f = test;
double d = test;
char c = test;

}

}

----------------------------------------------------

このプログラムは、

変数testをint型として宣言し、他の基本データ型に入れるものです。

このプログラムもコンパイルしてみましょう。

先ほどのプログラムよりはエラーの数は減りましたね。

1つ目のエラーは、int型からboolean型へは型変換できないというものです。

boolean型と他の基本データ型は型変換できないので、

これは先ほどと同じものですね。

残り３つのエラー内容は、「精度が落ちている可能性」というものです。

「精度が落ちている可能性」というのは、どういう意味でしょうか？

以前基本データ型のデータの範囲を取り上げましたが、（こちら ）

int型の範囲は「-2147483648～+2147483647」でした。

それに対し、

byte型は「-128～+127」

short型は「-32768～+32767」

と、int型より範囲が狭くなります。

このように、ある型の値を、それより有効な値の範囲が狭い型に変換する事を、

「縮小交換(ナローイング交換)」と言います。

縮小交換すると、データが失われる可能性があります。

例えば、「int型で宣言した変数」に「40000」という値を入れたとしましょう。

「40000」という値は、byte型の最大値「127」、short型の最大値「32767」より大きい値になります。

それなのに、この「40000」という値をbyte型やshort型入れようとすると、

「40000」という値は失われてしまいます。

もちろん「int型で宣言した変数」に「1」を入れたとすれば、

byte型もshort型も問題なく入れることができます。

しかし、縮小交換をすると、値によってはデータが失われる場合があるため、

Javaのコンパイラは、縮小交換をエラーとして判定します。

それで、「精度が落ちている可能性」というエラー内容が表示されたわけです。

もう一点、char型に関してですが、これも「精度が落ちている可能性」とあります。

char型は1文字を表しますが、

これは、Unicode文字を4桁の16進数で表現しています。

そのため、char型の値を数字として対応することができます。

しかし、byte型、short型と同じく、データが失われる可能性があるため、

「精度が落ちている可能性」というエラー内容が表示されていました。

最後にこのプログラムで取り上げておきたい点が、

エラーとならなかった型変換は何かと言う点です。

int型から、long型・float型・double型への型変換はエラーとなっていません！

どうしてでしょうか？

これらの型の値の範囲を比較すると、その理由が見えてきます。（こちら ）

int型の範囲は「-2147483648～+2147483647」なのに対し、

long型が「-9223372036854775808～+9223372036854775807」、

float型が「±3.40282347E+38～±1.40239846E-45」、

double型が「±1.79769313486231570E+308～

　±4.94065645841246544E-324」です。

つまりこれらは、int型の値の範囲より、範囲が広い型です。

このようにある型の値を、その型より有効な値の範囲が広い型に変換するのを、

「拡張変換(ワイドニング交換)」と言います。

拡張変換はエラーが出ないということですから、

最後に、様々な拡張変換を試してみましょう。

----------------------------------------------------

class KakutyouTest{

public static void main(String args[]){

//①拡張変換

byte bt = 1;

short s = bt;

char c = s;

int i = c;

float f = i;

long l = f;

double d = l;

//②結果を表示する
System.out.println("byte => " + bt +
"\nshort => " + s +
"\nchar => " + c +
"\nint => " + i +
"\nfloat => " + f +
"\nlong => " + l +
"\ndouble => " + d);

}

}

----------------------------------------------------

コンパイル結果は・・・

２つだけエラーとなりました。

それは、short型からｃｈａｒ型への変換と、

float型からlong型への変換です。

逆に言うと、それ以外の型変換は問題なかったということを意味します。

この２つのエラーの意味については、次回取り上げたいと思います。

今回のポイントです。

「boolean型は他の基本データ型に型変換できない」

サイズの大きな型から小さい型に変換することを

　　「縮小変換（ナローイング変換）」といい、

サイズの小さな型から大きい型に変換することを

　　「拡張変換（ワイドニング変換）」という。

　前回、演算子の種類について概観してみました。

　今回は、いよいよ第３段階の目標であるキーボードで受け取ったデータを用いて、希望する計算結果を表示するプログラムを作成して見たいと思います。

以下は、第二段階で作成したプログラムです。

--------------------------------------------------------------------
class InputTest{

  public static void main(String args[]){

    java.io.BufferedReader myReader =
    new java.io.BufferedReader( new java.io.InputStreamReader(System.in),1);


    try{

      System.out.println("レシピにある分量を記してください");
      String myStringA = myReader.readLine();

      System.out.println(myStringA + "は、何人分か記してください");
      String myStringB = myReader.readLine();


      System.out.println("知りたい分量は何人分か記してください");
      String myStringC = myReader.readLine();

      System.out.println("レシピの分量＝「" + myStringA + "」");
      System.out.println("レシピの人数＝「" + myStringB + "人分」");
      System.out.println("知りたい分量＝「" + myStringC + "人分」");

    }catch(java.io.IOException e){
    }

  }

}
--------------------------------------------------------------------

このプログラムはキーボードで入力されたデータを、

そのまま画面に表示するという単純なものでしたが、

今回は、ここで得たデータを使って、計算結果を表示するようにしたいと思います。

作成するにあたって、
以下の第３段階（その１）で作成したプログラムも参考にしたいと思います。

----------------------------------------------------------

class TestKeisan{

  public static void main(String args[]){

    // ①

    double bunryou = 25;

    int ninzuuA = 2;

    int ninzuuB = 10;

    double kekka;

    // ②

    kekka = bunryou / ninzuuA * ninzuuB;

    // ③

    System.out.println(ninzuuB + "人分の分量は、" + kekka + "です。");

  }

}

----------------------------------------------------------

まあ、ふたつのデータをあわせるだけですから簡単簡単！

--------------------------------------------------------------------
class InputTest2{

  public static void main(String args[]){

    java.io.BufferedReader myReader =
    new java.io.BufferedReader( new java.io.InputStreamReader(System.in),1);


    try{

      // ①

      System.out.println("レシピにある分量を記してください");
      String myStringA = myReader.readLine();

      System.out.println(myStringA + "は、何人分か記してください");
      String myStringB = myReader.readLine();


      System.out.println("知りたい分量は何人分か記してください");
      String myStringC = myReader.readLine();

      // ②

      double bunryou = myStringA;

      int ninzuuA = myStringB;

      int ninzuuB = myStringC;

      double kekka;

      kekka = bunryou / ninzuuA * ninzuuB;

      // ③

      System.out.println(ninzuuB + "人分の分量は、" + kekka + "です。");

    }catch(java.io.IOException e){
    }

  }

}
--------------------------------------------------------------------
と簡単に作成できてしまいました！

このプログラムを解説しますと、

まずクラス名を「InputTest2」としました。

そして①で一問一答方式でキーボード入力してもらい、

②で受け取ったデータを、計算する用の変数に当てはめて、計算しています。

③でその結果を画面に表示します。

まあ、これぐらい朝飯前ていうところですかね！

では、このプログラムをコンパイルしてみます。

・

・

・

！！ええっ！！

コンパイルエラーとなりました！しかも3個も！！

特にエラーになりそうなことはしていないはずなんですが・・・

・・・とりあえず落ち着いてエラーの内容を読んでみたいと思います。

まず「InputTest2.java：26」とあります。

これは、エラーとなったところがどこかを示しています。

「InputTest2.java」の中の「26行目」ということですね

続いてエラー内容が「互換性のない型」とあります。

具体的には、

「検出値　：　java.lang.String」

「期待値　：　double」

「double bunryuo = myStringA；」とあります。

どうやら型に関するエラーとなっているようです。（型についてはこちら ）

「mySringA」というのは、String型変数として宣言していました。

そして「bunryou」というのは、double型変数として宣言しています。

それで、double型である変数bunryouに、

String型変数のデータを入れようとしたことが、

エラーとなった原因でした。

実は、Javaは強く型付けされている言語です。

基本データ型（boolean、byte、short、int、long、float、double、char）や

参照型（Stringなど）と、様々な型があります。
Javaの場合、変数は、どの型か宣言しなければなりません。

そして、ある型のデータを、別の型に変換できる場合と、できない場合があります。

先ほどの、String型からdouble型へは変換できません。

そのため、エラー内容が「互換性のない型」となったのでした。

詳しくは次回以降で取り上げたいと思います。

次回は、基本データ型の組み合わせごとに変換可否について取り上げます。

今回のポイントです。

　データを変数に入れる場合、型をよく考えて作成する必要がある。

　11月8日23時目標と宣言していましたが、

　結局2日遅れのアップとなってしまいましたm(_ _；)m

　前回、簡単な計算プログラムを作成しました。

　今回、その際に登場した「演算子」について詳しく取り上げたいと思います。

　Javaで利用できる演算子には以下のものがあります。

優先順位

　演算が行われる順番を表しています。

　例えば、「10 - 35 / 7」という式の場合、

　「-」は優先順位は「5」、「/」は優先順位は「4」です。

　それで、優先順位の高い「35/7」を計算し、続いて「10 - 5」を計算します。

結合規則

　同じ優先順位の演算子が複数ある場合、この規則により順番が決まります。

　例えば、「33 - 15 + 27」という式の場合、

　「-」「+」ともに優先順位は「4」です。

　同じ優先順位の演算子が2つありますので、計算する順番は結合規則によりますので、

　優先順位「4」の結合規則は、「左」から計算するタイプです。

　それで、まず「33 - 15」を計算し、続いて「18 + 27」を計算します。

オペランドの型

　その演算子の対象となる値や変数を「オペランド」と言います。

　その「オペランド」の型と、オペランドの数を表します。

　例えば、優先順位「2」にある「単項マイナス」の「-」は、「-1000」などと使います。

　この演算子は、オペランドの型は「数値(boolean以外の基本データ型 )」で、

　オペランドの数は「１つ」のみです。

　オペランド１つのだけ操作する演算子を「単項演算子」と言います。

　また、優先順位「4」にある「乗算」の「*」は、「3 * 5」などと使います。

　この演算子のオペランドの型は「数値、数値」で、

　オペランドの数は「２つ」あります。（例では「(3」「5」の２つ）

　オペランド２つの演算子のことを「二項演算子」と言います。

　最後に、優先順位「14」にある「条件式(三項式)」の「 ? : 」は、「(i < 100) ? i : 100」などと使います。

　この演算子のオペランドの型は「boolean、任意、任意」で、

　オペランドの数は「３つ」あります。（例では「(i < 100)」「i」「100」の３つ）

　オペランド３つの演算子のことを「三項演算子」と言います。

以上が簡単な説明となります。

さらに詳しくは、今後プログラム作成の必要に応じて、取り上げて行きたいと思います。

さて、前回取り上げたプログラムにはいくつ演算子があったでしょうか？

このプログラムでした。

----------------------------------------------------------

class TestKeisan{

public static void main(String args[]){

// ①

double bunryou = 25;

int ninzuuA = 2;

int ninzuuB = 10;

double kekka;

// ②

kekka = bunryou / ninzuuA * ninzuuB;

// ③

System.out.println(ninzuuB + "人分の分量は、" + kekka + "です。");

}

}

----------------------------------------------------------

この中で、演算子をすべて太字で表示してみると･･･

----------------------------------------------------------

class TestKeisan{

public static void main(String args[]){

// ①

double bunryou = 25;

int ninzuuA = 2;

int ninzuuB = 10;

double kekka;

// ②

kekka = bunryou / ninzuuA * ninzuuB;

// ③

System.out.println(ninzuuB + "人分の分量は、" + kekka + "です。");

}

}

----------------------------------------------------------

全部で１４ありました。

こんな簡単なプログラムでもたくさんの演算子が関係しているのですね。

今回、演算子について概要を理解できましたので、

次回は、第２段で作成したキーボードで受け取ったデータを計算して、

希望する値を表示できるように改良したいと思います。

今回のポイントです。

　・計算する式を作るには、２つの要素が必要。

　　１つは、計算する記号を表わす「演算子」と、

　　もうひとつは、その演算子の対象となる値または変数である「オペランド」。

　・オペランドを１つだけ操作する演算子を「単項演算子」

　　２つ操作する演算子を「二項演算子」

　　３つ操作する演算子を「三項演算子」という。

久しぶりの投稿です。

徐々に気温も下がり、秋から冬へと季節の変化を感じるようになりました。

皆さま、お変わりないでしょうか。

「七転び八起き、Javaの道」シリーズの記事も早いもので3ヶ月たちました。

少なくとも週1回更新するよう頑張っていますが、

空いた時間を見つけての投稿の為、更新タイミングがまちまちになりがちですが、

定期的に訪問してくださったり、ペタをつけてくださったり、ありがとうございます。

また、最近では、

読者登録してくださる方や、コメント投稿してくださる方もおられるようになりました。

記事の投稿でいっぱいいっぱいのところもあり、なかなかお礼が言えてないのですが、この場をお借りし、感謝いたします。

しばらく投稿が空いてしまいましたが、今後とも頑張っていきます！！！！！！

「七転び八起き」ですから、目標達成までは、頑張り続けます！

今後ともよろしくお願い致します。

では、本題に入って行きたいと思います。

ついに、前回までで、第２段階「キーボード入力から意図したデータを受け付ける」ことができました。

今回以降、第３段階として「受け付けたデータから簡単な計算をし、結果を表示する」ことを目標に頑張って行きたいと思います。

ところで、どんな計算をしましょうか？

第２段階で、

　　「分量」
　　「（入力した人数が）何人分の分量か」
　　「何人の分量を知りたいか」
の３つのデータを受け取れるようにしました。

第３段階では、この受け取ったデータを使って、

希望する人数の分量を表示するように改良したいと思います。

この計算を出すには、

「分量」÷「分量の人数」×「知りたい人数の分量」

という計算をすることになります。

ではまずは、簡単な計算プログラムを作ってみましょう。

　　今回も、切干大根２人分の分量25gを、

　　１０人分にした際の分量を計算してみたいと思います。

----------------------------------------------------------

class TestKeisan{

public static void main(String args[]){

// ①

　 double bunryou = 25;

int ninzuuA = 2;

int ninzuuB = 10;

double kekka;

// ②

kekka = bunryou / ninzuuA * ninzuuB;

// ③

System.out.println(ninzuuB + "人分の分量は、" + kekka + "です。");

}

}

----------------------------------------------------------

①で、レシピの分量・人数、知りたい人数、計算結果を入れる変数「kekka」を宣言し、

②で、その計算をして、その結果を変数「kekka」に入れ、

③で、結果を画面表示しています。

このプログラムをコンパイルし、実行すると、

となりました。

簡単ですね！

ここでのポイントは「演算子」を使うことでした。

　さて、上のプログラムでは演算子が何種類出てきたでしょうか？

　次回は、この答えを含め、演算子について詳しく取り上げます。

今週はしばらく忙しい日が続きますので、

次回更新は、１１月８日２３時位を目標に頑張りたいと思います。

どうぞよろしくお願い致します。

前回でついに、"Stringの森"ハイキングコースを踏破したわけですが、
今回からは本題に戻って、料理分量計算ツールのアレンジの続きをしていきたいと思います。

今回の説明は、こちら の記述の続きとなります。

さて、以下の文を改良しようとしているわけですが、
【改良前のプログラム】
--------------------------------------------------------------------
class InputTest{

  public static void main(String args[]){

    java.io.BufferedReader myReader =
      new java.io.BufferedReader( new java.io.InputStreamReader(System.in),1);


    try{

      System.out.println("文字を入力してください"); //①

      String myString = myReader.readLine(); //②

      System.out.println("入力された文字：　" + myString); //③

    }catch(java.io.IOException e){
    }

  }

}
--------------------------------------------------------------------

この記述から、
　　「分量」
　　「（入力した人数が）何人分の分量か」
　　「何人の分量を知りたいか」
の３つのデータを受け取れるようにアレンジしたいと思います。

それで、前回取り上げたように、
①を、
--------------------------------------------------------------------
System.out.println("レシピにある分量を記してください");
--------------------------------------------------------------------
に変更し、

②を、
--------------------------------------------------------------------
String myStringA = myReader.readLine();
--------------------------------------------------------------------
にします。

これで「分量」を受け取れるようにしましたが、

続いて、
「（入力した人数が）何人分の分量か」
「何人の分量を知りたいか」
も受け取れるようにアレンジしたいと思います。

それで、
--------------------------------------------------------------------
System.out.println(myStringA + "は、何人分か記してください");
String myStringB = myReader.readLine();

System.out.println("知りたい分量は何人分か記してください");
String myStringC = myReader.readLine();
--------------------------------------------------------------------
という記述を加えたいと思います。

ところで、ここで一つだけ新しい要素を考えてみたいと思います。
--------------------------------------------------------------------
System.out.println(myStringA + "は、何人分か記してください");
--------------------------------------------------------------------
の「myStringA + "は、何人分か記してください"」という部分です。

「myStringA」は、何度か取り上げたようにString型の参照型変数でした。
「"は、何人分か記してください"」の部分も、前回取り上げたように
「ダブルクォート("")」は特殊な文法で、Stringの実データを作成するものです。

では、String型(文字列)とString型（文字列）の間にある「＋」は何でしょうか？

…これは、演算子です。

演算子と言うのは、足し算や引き算などでよく使われますが、
ここでは文字列と文字列を連結する役割を持っています。
演算子については、今回は簡単に触れるだけにしたいと思います。
詳しくは、次の第３段階に入ってから取り上げたいと思います。

以上で、欲しい３種類のデータが受け取れるようになりました。

次に③の部分ですが、
今回は計算はせず、入力されたデータをそのまま表示させたいと思います。
それで
--------------------------------------------------------------------
System.out.println("レシピの分量＝「" + myStringA + "」");
System.out.println("レシピの人数＝「" + myStringB + "人分」");
System.out.println("知りたい分量＝「" + myStringC + "人分」");
--------------------------------------------------------------------
としたいと思います。

以上で、意図した入力を受け付けることができるようにアレンジできました。

アレンジしたあとの記述は以下のようになります。
--------------------------------------------------------------------
class InputTest{

  public static void main(String args[]){

    java.io.BufferedReader myReader =
      new java.io.BufferedReader( new java.io.InputStreamReader(System.in),1);


    try{

      System.out.println("レシピにある分量を記してください");
      String myStringA = myReader.readLine();

      System.out.println(myStringA + "は、何人分か記してください");
      String myStringB = myReader.readLine();


      System.out.println("知りたい分量は何人分か記してください");
      String myStringC = myReader.readLine();

      System.out.println("レシピの分量＝「" + myStringA + "」");
      System.out.println("レシピの人数＝「" + myStringB + "人分」");
      System.out.println("知りたい分量＝「" + myStringC + "人分」");

    }catch(java.io.IOException e){
    }

  }

}
--------------------------------------------------------------------

では、いつも通り、これを実行してみましょう。

（※復習される場合、以下を参照。
①プログラムを保存（こちら ）
②コマンドプロンプトの設定（こちら ）
③コンパイル（こちら ）
④実行（こちら とこちら ））

ちなみに、今回、例として「切干大根の煮物」のレシピにある
「切干大根」の分量を入力してみたいと思います。

レシピには「２人分、切干大根25グラム…」と書かれています。
もちろん切干大根以外にも、人参や油揚げなどの分量も書かれていますが、
現段階では、「切干大根」だけに的を絞りたいと思います。


実行すると、まず以下のように表示されます。

レシピに書かれている「切干大根」分量は25グラムでしたので、
「25」と入力し、Enterを押します。



入力した「25」グラムが何人分の分量かですが、
レシピは「２人分」となっていましたので、
「2」と入力し、Enterを押します。

ちなみに、先ほど「myStringA」と「"は、何人分か記してください"」の間に「＋」演算子がありましたが、ここで見事に文字列が連結されたことがわかりますね！



今入力したレシピの分量をもとに何人分の分量を知りたいかですが、
特にこだわりはないのですが、今回は「10人分」としようと思いますので、
「10」と入力し、Enterを押します。



全ての入力したデータが、
最後にまとめて表示されました。

もちろん、わたしが最終的に目指すのは計算して結果を出すことですが、
まず第２段階の目標としては、意図した入力を受け付けることでしたので、
「分量」「人数」「知りたい分量」を受け付けられたという点で、
第２段階の目標は達成としたいと思います。

次回は第三段階として、
この受け付けた値を使って計算を行ない、結果を表示できるように、
さらにアレンジしたいと思います。

最後に、今回の復習です。

　文字列と文字列を連結するには、演算子「＋」を使う！

前回、参照型変数と実データをどのように作成するか考えてみました。

今回は、参照型のひとつString型についてもう少し詳しく見ていきたいと思います。

さて、前回以下の記述がどうなるか課題を作ってみました。

【プログラム１】

----------------------------------------

class TestString{
  public static void main(String[] args) {

    String myString;

    myString = new String("Test1"); //①

    System.out.println(myString);

    System.out.println("Test2"); //②

  }

}

---------------------------------------

いつもどおり、以上のプログラムを実行すると、

となりました。

・・・まぁ、予想通りですよね！

ところで、ここで考えたい点が、

通常「参照型」の変数と実データを作成する場合、

------------------------------------

型名 変数名；

変数名 = new 型名()；
------------------------------------

と記述すると前回取り上げました。

それで【プログラム１】の①でもそのように記述しているわけです。

しかし、②にある文字列はどうでしょうか。

「new」の文字は見当たりません。

しかし、同じように文字を表示させることができているのです。

なぜ、このようなことができるのでしょうか？

ここがString型の特殊な部分です。

特殊な参照型変数「String」型

今まで取り上げてきたとおり、

通常、実データを作成するには「new」キーワードを使います。

しかし、Stringが扱う文字列というのは、

プログラムが扱う型の中でも、特に重要な型です。

それで、「String」は参照型ではあるのですが、

Javaでは、このきわめて重要な「String」型に対して、

実データを作成する特別な文法が使えるようにしています。

それは、文字列をダブルクォート（” ”）で囲むという方法です。

では、次の記述を実行してみましょう。

【プログラム２】

----------------------------------------

class TestString{

  public static void main(String[] args) {

    String myString1 = new String("Test1"); //①
    System.out.println(myString1);

    String myString2 = "Test2"; //②
    System.out.println(myString2);

---------------------------------------

どうなったでしょうか？

・

・

・

・

・

・

・

・・・やはり、予想通りの結果となりましたね！

では、このプログラムを分析していきたいと思いますが、

【プログラム２】の①について

----------------------------------------------

　　String myString1 = new String("Test1");　//①

----------------------------------------------

としました。

【プログラム１】の①では、「参照型」の変数と実データを作成する場合、

------------------------------------

型名 変数名；

変数名 = new 型名()；
------------------------------------

と書きましたが、これを省略して、

------------------------------------

型名 変数名 = new 型名()；
------------------------------------

と１行で２行分書く方法にしています

続いて、②について

---------------------------------------

　　String myString2 = "Test2"; //②

---------------------------------------

と書くことで、

実データ「Test2」が、どこかの場所に作成され、

その場所(メモリアドレス)を、参照型変数「myString2」に入れています。

このような特殊な記述をJavaが提供しているために、

「String」は参照型変数であるにもかかわらず、

基本データ型のような記述ができてしまうわけです。

そして、かなり大雑把な説明をすると、

「"Test2"」は、「new String("Test2")」と同じ動作と言えます。

厳密にJavaを理解している方には、

全く同じ動作とは言えないと指摘されることと思いますが、

少なくとも現時点ではそのように考えることとします。

それで、最後に次の記述を考えてみましょう。

【プログラム３】

-----------------------------------

class TestString{
  public static void main(String[] args) {

    System.out.println(new String("Test1")); //①

    System.out.println("Test2"); //②

  }
}

---------------------------------------

このプログラムを実行すると・・・

・・・結果はいつも同じなので、もう見飽きましたね！（=_=；）

ただ、【プログラム３】の①②ともに、

実データがどこにあるかを示す「"ロッカーの鍵"を入れる"ロッカー"」を作成することなく

つまり、「参照型変数」を作成することなく、直接文字を表示させているという点で、

いままでとは違うパターンと言えます。

これで、長かった"Stringの森"ハイキング初心者コースは何とか踏破したこととしたいと思います。

実際には、"Stringの森"はもっと深い部分があるのですが、

わたしの今の実力では、遭難の恐れがあるので（^-^；）、今回はここまでとしたいと思います。

それで、この森を入るきっかけとなった次の文をまとめたいと思います。

もう忘れかけているのですが・・・（こちら の記事のことです）

--------------------------------------

String myStringA = myReader.readLine();

--------------------------------------

という記述ですが、

この「myStringA」というのは、文字列を入れる「String」型の変数ということでした。

この中には実データが入っているのではなく、実データの場所がどこかを示す"鍵"が入っていました。

そして、「myString」を「myStringA」に変えたのは、

1度目に入力されたデータを入れる場所（myStringA）と、

そのあと2度目に入力されたデータを入れる場所(myStringB)を

別個に用意する必要があったからでした。

それでは、これまでしばらく"Stringの森"に寄り道しましたが、

次回は、本題に戻って、料理分量ツールのアレンジの続きをしていきたいと思います。

久しぶりですが、今日のポイントです！

「String」型は、参照型変数ではあるが、

よく使う変数なので、ダブルクォート("")で囲むことによって、

実データが作成され、かつ基本データ型のように記述することができる。