「型 変数名;」と書くことが「変数宣言」である。

たとえば「int i;」と書いた場合「int型の変数iを宣言した」と言う。　

このように書くことが、メモリ上に型のサイズ分の領域を確保し、「この領域を変数として使用する」と「宣言」することになるので、「変数宣言」という。

変数宣言は、宣言箇所によって以下の2種類存在する。

・ローカル変数

・フィールド

ローカル変数の場合、変数宣言を「ローカル変数宣言」と言う。

フィールドの場合、変数宣言を「フィールド宣言」と言う。

また、上記2種類以外にも、以下の2箇所でも変数宣言を行うことができる。

・メソッドの引数

・catchの例外パラメーター

ただし、この2つは厳密には変数宣言ではない。

メソッドの引数は、引数の作成と同時に「初期化」を行うことができない。

また、catchの例外パラメーターは「初期化」「複数宣言」「Throwableクラスのサブクラス以外の型の宣言」を行う事ができない。

そのため変数宣言とは別物ではあるが、「型を指定して変数を作る」という点では同じであるため、実際に使用する分には区別する必要はないだろう。

変数宣言は「修飾子 型 識別子;」という形式で記述する。

「修飾子」は変数の性質を決定する予約語を指定する。

ローカル変数はfinalのみ使用可能。

フィールド変数の場合は「フィールド修飾子」が使用可能。

修飾子は省略可能。ローカル変数の場合には省略することが多い。フィールドの場合にはアクセス修飾子のみ付けることが多い。

「型」は変数の型を指定する。

この型によって、変数に入れられる値の種類が決まる。逆に言えば、型で定義された値以外は変数に入れられない。

型には「プリミティブ型」や「クラス」を指定する。

また、配列にしたい場合には、型名の後ろに「[]」を付ける。

型にクラスや配列を指定した場合には、変数は参照型変数となる。

「識別子」が、変数名である。

この変数名を使用して、値の格納や演算、メソッドの呼び出し等を行う。

配列の場合、「型」ではなく「識別子」に「[]」を付けることで配列の宣言を行うこともできる。

複数の変数を同時に宣言する場合には「識別子」を「識別子1, 識別子2」というように、カンマで変数名を区切る。

「識別子」の箇所で、変数の「初期化」を行うことができる。

「識別子 = 初期値;」という形式で、変数を初期化する。

上記のカンマによる複数宣言を行った場合には、それぞれの変数に対して初期化を行う必要があるため注意すること。つまり「int i1, i2 = 100;」と記述した場合には変数i2しか初期化されない。

変数は、使用できる範囲と「寿命」を決定する「スコープ」が存在する。

スコープは、ローカル変数の場合には宣言をしたブロックによって決まる。

フィールドの場合にはアクセス修飾子によって決まる。

変数は、あくまで「値を入れておくための入れ物」である。

クラスや配列の場合、インスタンスを作成しなければ使用できないため注意すること。

クラスと配列にとっては、変数は参照値を格納するための変数でしかない。

以上、詳細については各項目を参照。

データを格納する「変数」は、「型 変数名;」と書くことで作られる（これを「変数を宣言する」という）。

こうして作られた変数は「変数 = 値;」という形で値を格納することができる（これを「変数に代入する」という）。

この「値」は、どんな値でも入れられるわけではなく、変数を作ったときに指定した「型」によって制限される。

たとえば型を「int」にすれば、変数には-2147483648～2147483647の整数値を入れられるが、実数は入れられない。また、型を「byte」にすれば、-128～127の整数値を入れられるが、int型の時のような大きい整数値は入れられない。

このように、変数にどのような値が入れられるのかを決めるのが「型」である。

型そのものにデータを格納することはできない。

たとえば「型 = 値;」のように、型に値を入れることはできない。

型はあくまで変数の「設計図」であり、変数そのものではないからである。

型は、「バケツを作るための金型」だと考えればよい。金型そのものに水は入れられない。金型を元にバケツを作ることで、そのバケツに水を入れることができる。この「バケツ」が「変数」、「水」が「格納する値」、「金型」が「型」である。

型は以下の2種類存在する。

・プリミティブ型

・参照型

プリミティブ型はint型やdouble型、boolean型等のことで、これらの型で宣言された変数は整数値、実数値（浮動小数点）、論理値を格納できる。

参照型は、クラスや配列の「インスタンス」を参照するための型である。インスタンスは参照を通してのみ使用することができ、通常は参照型変数を宣言して参照を入れてから使用する。

詳しくは「型」「プリミティブ型」「参照」「クラス」「インタフェース」「配列」の項目を参照。

変数やリテラル、戻り値は必ず「型」を持っている。

変数は、作られた際の「型」が、その変数の「型」となる。

リテラルは、リテラルによって型が決まる。整数リテラルであればint型、文字列リテラルであればStringクラスの参照型である。詳しくはそれぞれのリテラルの項目を参照。

戻り値は、メソッドの「戻り値の型」がその値の型となる。

変数に格納されている値やリテラル、戻り値を、他の変数にコピーする場合、型が一致している必要がある。

型が異なる場合、その「格納先変数の型」へと変換してからコピーする必要がある。

この変換を「型変換」と言い、その際の操作を「キャスト」と言う。

ただし、コピー元の型とコピー先の型によっては型変換が自動的に行われる場合がある。これを「暗黙的キャスト」という。

またこれらとは別に、プリミティブ型と対応するラッパークラスは「オートボクシング」という機能を使って自動的に変換することができる。

自動的に変換できない場合には、キャストを行ったり指定した型へ変換するメソッドを使用する必要があり、これらを行わないとコンパイルエラーとなる。

このコンパイルエラーを回避するためにも、変数、リテラル、メソッドの戻り値、この3つがどの型なのか、ということを常に意識してプログラムを組むといいだろう。

つまりメソッドの実装（{}で囲まれた箇所）を除いた部分。

メソッドの「宣言」とも言う。

ただし厳密には、シグネチャーはメソッド名と引数のみを指す。

シグネチャーは、メソッドを呼び出すために必要な情報で構成されている。

メソッド名と引数がシグネチャーに書かれているからこそメソッドを呼び出すことができ、戻り値の型が書かれているからこそ戻り値を受け取ることができる。

シグネチャーはメソッドの「名札」といったところである。

「シグネチャー」という用語はオブジェクト指向用語である。

スーパークラスのメソッドをオーバーライドするメソッドは、オーバーライドされるメソッドと同じシグネチャーにしなければならない。

また、インタフェースのメソッドを実装するメソッドは、実装されるメソッドと同じシグネチャーにしなければならない。

このインタフェースのメソッドや、abstractクラスのabstractメソッドは、シグネチャーのみであり、実装を持たないメソッドである。

このように、シグネチャーはオブジェクト指向の、特にポリモーフィズムの部分に深く関わっている。

厳密には、シグネチャーはメソッド名と引数のみが該当する。

つまり、戻り値の型や例外指定等はシグネチャーに含まない。

ただ、オブジェクト指向用語としての「シグネチャー」は定義が曖昧なため、場合によっては戻り値の型を含んだりメソッドの宣言そのものだったりする。それを踏まえて文脈から読み解くこと。

一般には、シグネチャーには「署名」という意味もある。

電子メール文末の署名を「シグネチャー」と言う。

ちなみに英語で「signature」と書くが、このカタカナ語訳には「シグネチャー」「シグネチャ」「シグネイチャー」「シグネイチャ」「シグニチャー」「シグニチャ」などがある。本辞書では、Java言語仕様の日本語訳で「シグネチャ」が使われており、検索で見つけやすいよう「ー」を付けて「シグネチャー」を採用している。

整数値や実数値を入れて、計算に使用したり、計算結果を入れて取っておくことができる。

また、インスタンスへの参照を格納し、メソッドの呼び出し等を行うことができる。

変数を作成することを「変数を宣言する」という。

変数宣言は「型 変数名;」と書く。

たとえば「int i;」という形式で変数宣言を行うことができ、この「i」が変数となる。

変数は、「変数に入れられる値の種類」が決まっており、その種類を「型」と言う。

上記の例では「int」が「変数i」の型である。これにより、変数iにはint型が定める「-2147483648～2147483647の範囲内の整数値」のみ格納できる。

変数に値を入れる時には、=演算子を使用して「初期化」もしくは「代入」を行う。

たとえば「i = 100;」とすれば、変数iに整数値100が入る。これが「代入」である。

また「int i = 100;」とすれば、変数iが作られると同時に整数値100が入る。これが「初期化」である。

変数内の値は、演算子に渡したりメソッドの引数に渡せば自動的に取得できる。

たとえば「int i2 = i;」とすれば、変数iの中に入ってる値を取得し、変数i2に入れることになる。

この時、変数iの中の値はなくならない。変数に入っている値のコピーが作られてそれが使用されると考えるといいだろう。

型は以下の2種類存在する。

・プリミティブ型

・参照型

プリミティブ型はint型やdouble型、boolean型のことで、これらの型で宣言された変数は整数値、実数値（浮動小数点）、論理値を格納できる。

参照型は、クラスや配列の「インスタンス」を参照するための型である。インスタンスは参照を通してのみ使用することができ、通常は参照型変数を宣言して参照を入れてから使用する。

詳しくは「型」「プリミティブ型」「参照」「クラス」「インタフェース」「配列」を参照。

変数は以下の2種類存在する。

・ローカル変数

・フィールド

ローカル変数はメソッドやブロックの中で宣言された変数で、そのメソッドやブロックから出るとなくなる。

フィールドはクラス内で宣言された変数で、インスタンス内に存在する。そのためインスタンスがなくならない限りインスタンス内のフィールドもなくならない。

詳しくは「ローカル変数」「フィールド」を参照のこと。

ローカル変数とフィールドはそれぞれ「寿命」や「スコープ」が異なる。またフィールドはアクセス修飾子によって「スコープ」が変化する。

また、「ローカル変数」「フィールド」以外にも、「引数」及び「catch」でも変数を宣言することが可能。これらはローカル変数とほとんど同じ性質を持つ。

このように、変数は「どのようなシチュエーションで宣言されるか」によって性質が異なる。

変数を使用する際には「その変数がどの型によってどこで宣言されたのか」を意識すると使いやすくなるだろう。

1バイトは8ビットである。

つまりビットが8個並んでいたらそれが1バイトである。

たとえば、int型変数のサイズは32ビット＝4バイトのサイズということになる。

また、16進数1桁は4ビットなので、1バイトは16進数で2桁となり、1バイトを16進数2桁で表現することが多い。

1バイトは2の8乗、つまり256種類の表現が可能である。

プリミティブ型に、この1バイト分のデータを格納できるbyte型が存在する。

byte型の変数はメモリ上に8ビットの領域を確保し、-128～127までの整数値を格納することができる。

つまり文字通り、1バイト分のデータを格納できる。

そのため、バイト単位の操作を行う際にこの型を使用することが多い。

Javaでは、1バイトは8ビットである。

だが、1バイトが8ビットではないプラットフォームも存在する。

バイトは本来「ひとかたまりのビット」という意味である。そしてそのビットの数は、コンピューターやOSによって異なる。最近のものはほとんどが8ビットだが、昔のものは5ビットや7ビットのものもある。

ネットワークを通して他のコンピューターにデータを送信する際に、1バイトが8ビットではないコンピューターやOSに送信すると問題が発生する可能性があるため、珍しいコンピューターやOSの場合には確認した方がいいだろう。

整数値や実数値といった、具体的な「値」を格納するための変数を作るための型が「プリミティブ型」である。

プリミティブ型で宣言した変数には、その型で指定した種類の値を格納することができる。

また、戻り値の型をプリミティブ型にした場合には、その指定した種類の値を返さなければならない。

プリミティブ型は、以下の8つの型である。

・byte

・short

・int

・long

・char

・float

・double

・boolean

byte型、short型、int型、long型の4つの型は整数型である。これらの型で宣言された変数は整数値を格納することができる。

それぞれの型の差は、格納できる整数値のサイズである。たとえばbyte型で宣言された変数は-128～127の範囲の整数値しか格納できないが、long型で宣言された変数は-9223372036854775808～9223372036854775807の範囲の整数値を格納できる。

この差は、型によって変数のサイズが異なるからである。byte型変数はメモリを1バイト使用し、long型変数はメモリを8バイト使用する。この差によって、格納できる整数値に差が生まれる。

ただ、int型に入りきらない値を使用する場合以外は、int型を使用することが多い。とりあえず整数値を入れたい場合には、サイズに関係なくint型の変数を宣言するといいだろう。

char型は、上記4つの型と同じく整数値を格納することができる。

ただし、通常char型の変数には文字を格納する。char型変数1つに1文字を格納できる。

また、上記4つの型と異なり、char型は符号を持たず、0～65535の範囲の整数値を格納する。

1文字を格納する変数を宣言したい場合にchar型を使用するといいだろう。

float型、double型の2つの型は浮動小数点型である。これらの型で宣言された変数は、浮動小数点という形式で実数値（小数点の付いた値）を格納することができる。

float型とdouble型の差は、格納できる実数値の精度の違いである。double型の方がfloat型よりも「小数点以下」の桁数を多く格納できる。特に問題がなければdouble型を使用するといいだろう。

実数値は浮動小数点という形式で格納されるため、値によっては正確に格納することができず、計算を行うと誤差が生まれる可能性が常にある。たとえば物理計算のような「元々に誤差が含まれる値の計算」に使用し、金銭の計算等正確な値を必要とする場合にはBigDecimalクラスを使用するといいだろう。

boolean型は論理型である。この型で宣言された変数は「true」「false」の2種類のboolean リテラルのみを格納することができる。

この2種類の値を用いて論理演算を行うのがboolean型である。

このように、「変数にどのような値が入れられるのか」は、変数の宣言を行う時にどのプリミティブ型を使用するかで決まる。変数に入れたい値から、どのプリミティブ型を使用するのか決めるといいだろう。

また、プログラム上に直接書かれた値である「リテラル」は、リテラルの種類によって型が決まる。たとえば「100」といった整数リテラルはint型であり、「4.5」といった浮動小数点リテラルはdouble型である。リテラルを変数に代入したり変数を初期化する場合には、リテラルの型も注意した方がいいだろう。

あるプリミティブ型の値を他のプリミティブ型へと変換したい場合には、「キャスト」を行う。

詳しくは「キャスト」の項目を参照。

プリミティブ型には、それぞれのクラス版として「ラッパークラス」が存在する。

詳しくは「ラッパー」の項目を参照。

プリミティブ型に対して、クラスや配列のインスタンスを指し示すための変数の型を「参照型」という。

詳しくは「参照」の項目を参照。

整数リテラルの頭に「0x」もしくは「0X」を付けると、その値は16進数と見なされる。

たとえば「int i = 0XA;」と記述した場合、変数iに16進数の「A」、つまり10進数の「10」が格納される。

その他、詳細については「0x」の項目を参照。

整数リテラルの頭に「0x」もしくは「0X」を付けると、その値は16進数と見なされる。

たとえば「int i = 0xA;」と記述した場合、変数iに16進数の「A」、つまり10進数の「10」が格納される。

頭に付ける文字は「0x」「0X」どちらでも構わない。

また、16進数表記内のアルファベットは大文字でも小文字でも構わない。

つまり「0xa」「0xA」「0Xa」「0XA」はすべて同じである。本辞書では見やすさを考えて「0xA」の形式で統一してある。

16進数表記内のアルファベットは、16進数であるため当然「A～F」「a～f」しか使用できない。「G～Z」「g～z」を使用するとコンパイルエラーとなる。また「0x」「0X」のみでもコンパイルエラーとなる。

整数リテラルを16進数で表記したとしても、内部的には2進数の形式で保存されている点に注意。

「int i = 10;」も「int i = 0xA;」も、変数iには「00000000000000000000000000001010」が保存されている。

この値を16進数形式で文字列化する場合は、IntegerクラスのtoHexString()メソッドを使用する。

一般的に使用されている「10進数」では、「10」が次の桁へと増える条件である。39に1を加えると、一番右端の桁は「10」となり、この時この桁は「0」に変わり、代わりに次の桁である「3」に1が加えられ「4」となり、結果40となる。

対して、2進数ではこの次の桁へと増える条件が「2」となる。01に1を加えると、一番右端の桁は「2」となり、この時この右端の桁は「0」に変わり、代わりに左隣の桁である「0」に1が加えられ「1」となり、結果10となる。

つまり2進数では各桁「0」と「1」のどちらかのみで表現されることになる。

現在のコンピューターのCPUやメモリは、「オフ」と「オン」の2種類の状態を持つスイッチのようなものを並べて構成されている。

たとえばint型の変数を宣言すれば、メモリ上にずらっと並ぶスイッチのうち32個を使って、整数値を表現する。

このスイッチひとつひとつを「ビット」と呼ぶ。

このビットの状態を表記する際に、「オフ」「オン」と書くのは面倒なため、通常は2進数で表記する。「0」を「オフ」、「1」を「オン」に割り当て、2進数の値でメモリの状態を表現するわけである。

2進数の値を整数リテラルとしてプログラム中に記述する方法はない。

2進数の値をプログラム中に記述したい場合は、IntegerクラスのparseInt()メソッドに、文字列として渡せばよい。その際、第2引数には2進数であることを示す「2」を渡す。

ただし、通常はこのような方法ではなく、16進数を用いて記述する。

16進数1桁は2進数4桁に該当するため、変換方法さえ憶えてしまえば2進数の代わりに16進数を使用できるし、16進数を使えば2進数の4分の1の文字数で済む。

詳しくは「16進数」の項目を参照。

一般的に使用されている「10進数」では、「10」が次の桁へと増える条件である。39に1を加えると、一番右端の桁は「10」となり、この時この桁は「0」に変わり、代わりに次の桁である「3」に1が加えられ「4」となり、結果40となる。

対して、16進数ではこの次の桁へと増える条件が「16」となる。10進数での「10～15」は「A～F」で記述し、「F」の桁が1増えると「0」になり、ひとつ上の桁が1増える。たとえば「1F」の値に1を加えると「20」となる。

16進数の1桁は、2進数の4桁に該当する。2の4乗が16となるためである。

そのため、16進数は2進数の4桁をまとめて1桁で表記するために使用される。

2進数4桁を16進数1桁に読み替える時には、右端の桁を0桁目とするとき、「0桁目が1なら1」「1桁目が1なら2」「2桁目が1なら4」「3桁目が1なら8」として足し合わせればよい。

16進数表記は2進数表記の「読み替え」であるため、16進数から2進数に頭の中で読み替えられる技術を持つと便利である。たかだか16通りなので、16通りすべて憶えてしまうといいだろう。

int型の整数値を2進数で表記した場合、int型のサイズは32ビットのため、当然32文字が必要となる。たとえば「1000000」を2進数で表記すると「00000000000011110100001001000000」となり、とても長い。

だが、これを16進数で表記した場合、その4分の1の8文字で済む。たとえば「1000000」を16進数で表記すると「000F4240」と、とても短い。

メモリ上のビットの状態を見る場合（たとえば文字化けの原因を調べるため文字列のダンプを取得する場合）には、2進数で出力すると長くなり読みにくくなるため、代わりに16進数で表記することがほとんどである。

また1バイトは8ビット、つまり16進数2つに当たるため、バイト単位での表記もしやすい。

整数リテラルで16進数表記を使用する場合には、頭に0xもしくは0Xを付けて表記する。

整数値を16進数表記の文字列に変換する場合には、IntegerクラスのtoHexString()メソッドを使用する。

いずれにせよ注意しなければならないのは、別に0xを付けてint型変数に格納しても、10進数表記でint型変数に格納しても、内部的には2進数で格納されているのであり、どちらも関係ないという点である。

内部的には2進数で格納されているものを、文字列に変換する際に10進数表記に変換するか16進数表記に変換するか、という違いである。

16進数表記の正しい記法は特に決まっておらず、場面毎に異なる。

多くの場合、頭に0xを付ける。これを付けないと「0x51」が「51」になるなど、16進数であることが分からないためである。

「A～F」は、大文字小文字どちらも使用され、特に違いはない。