Javaは、型付けの強い言語である

プログラミング言語では、そのプログラミングで使うデータに対して、 どんなデータなのかを、分類する定義があります。
そして、「型付けの弱い」言語と「型付けの強い」言語があります。

まずは、強いor弱い という意味を話す前に、 どんなデータを使って、プログラミングをするのかを、学んでいきましょう。



 ・・・ ☕ コーヒータイム ☕ ・・・
Javaのデータタイプには、2つの側面があります。
まずは、
  プリミティブ(primitive)タイプ
  オブジェクト(参照)タイプ
という文法的に重要な側面と、
  文字
  数(かず)
  真偽(正しいor間違い)
  インスタンス(設計図/class を具体化して作られたもの)
    / オブジェクトとも言います.
      / これまたややこしいですが、インスタンスと言えば、意味的に言いたいとき、
      / オブジェクトの場合は、文法的なこと/コードの書き方 が、関係してきます.
        / と考えればいい場合が多いのですが、そのどちらの意味合いで言っているのかは、
        / その場その場で、よく考えて判断してください.
  null(オブジェクトタイプにおいて、参照先がないことを示す)
という、意味的に重要な側面があります。

この2つの側面を意識しておくと、Java言語の理解が深まると思います。

これは、余談ですが、よく、
  Javaは、純粋なオブジェクト指向言語ではない
という言い方をされることがあります。 そして、わたしも、そう思っていましたが、この言い方は、どちらかと言うと、ピント外れではないでしょうか?
この「Javaは、純粋なオブジェクト指向言語ではない」の意味は、 Javaには、プリミティブタイプ が、あるから(すべて参照型ではないから)、純粋ではない と、言っているのですが、これは、言語の物理的なシステムに関することであり、
  カプセル化
  継承
  多態性
という場面においては、まったく意味をなしていません。この言い方が、私を含め多くの人が、
オブジェクト指向は難しい
と思わせている、一因ではないでしょうか?確かに、オブジェクト指向言語では、「参照型/オブジェクト」を使って成り立っていますが、その、オブジェクトの意味と、、オブジェクト指向のオブジェクトの意味は、、同じではないのです。
Javaが、プリミティブタイプ/基本型 を使っている仕様なのは、パフォーマンスの問題のようです。最初からオブジェクトであることは、パフォーマンスを下げることになるようです。☕



データ(値):プリミティブタイプ(基本型)

では、話を元に戻しましょう(コーヒータイムは、さらっと読むだけでOKです)。
Javaのデータは、2種類あります。1つ目は、プリミティブタイプ、もう一つは、オブジェクトタイプ です。
まずは、プリミティブタイプ(primitive types)から、行きましょう。
その他の言い方として、基本型(simple types)とも言います。この言い方もちらっと聞いておくと、理解しやすいと思いましたので紹介しましたが、どちらで覚えてもいいでしょう。
名前から連想できますが、基本型(プリミティブタイプ)とは、classを介して作られるオブジェクトの「原料/材料」と考えてください。
全部で、8種類あります。ざっと書いてみます。
  byte, short, int, long, char, float, double, boolean
私のように、趣味でプログラミングをしている人にとって、重要だと思われるのは、
  int, double, boolean
この3つで、特に、入門時期においては、これだけで十分でしょう。ここで、踏ん張って、全部覚えるのもありかもしれませんが、全体を理解してから、覚えても遅くないでしょう。もし、OJCPなどを狙っているのであれば、その時覚えましょう(もしかしたら、OJCPの対策についても書くかもしれません)。

これを、さらに、意味的に分けてみましょう。まずは、
 整数(Integers):
整数とは、負の数(-の付いた数)、0、正の数(生活で使う数)で、小数は、含めません。
扱えるデータの大きさの違いに応じて、名前も違います。
  byte : -128~0~127(8ビットまで扱えます)
  short : -32,768~0~32,767(16ビット)
  int : -2,147,483,648~0~2,147,483,647(32ビット)
  long :
    -9,223,372,036,854,775,808~0~9,223,372,036,854,775,807
      (64ビット)
整数だけで、こんなに種類があるのですが、たいていの入門書の、サンプルプログラムでは、int ばかりが使われています。それは、普通の小さなサンプルプログラムや今現在の高性能のコンピューターでは、あまり影響がないので、int ばかりを使っているとも考えられます。ただ、byte, short があるのは、パソコンなど/コンピューター の、搭載メモリ(今の標準は、4GB~8GBぐらい?)に応じて考えるのではなく、プログラムの中でどのデータ量が使われるかによって考えるべきだそうです。Javaのためのメモリ領域(スタックorヒープ)は、その定義された、タイプに応じて変化します。なので、たとえ、long を使ったからと言って、極端に搭載メモリが小さくなければ、大きくはパフォーマンスに、影響しないようです。では、どうして、使い分けるのかは、小さなプログラムでは、その パフォーマンス/実行スピード の差はなくとも、大きなプログラムになればなるほど、無駄に大きなデータを定義すると、その積み重ねによって、少しずつ、パフォーマンスが落ちるということでしょう。
また、long を使う例としては、もし「光の速度」で、1000日間、宇宙を飛んだら、どれだけの距離を進むかというプログラムでは、明らかに、intタイプでは、データを保存できないので、そんなときに、あえて、longを使うようです。
ところで、byte, short, long などを知ることは、コンピューターの、ビット や バイト という単位を学習するには、役に立つと思われます。



 ・・・ ☕ コーヒータイム ☕ ・・・
1バイト(1byte) ⇒ 8ビット(8bit)である:
では、1ビットとは?
1ビットとは、2つの異なるもの を使った、1桁のデータです。
  ◆
  ◇
や、
  
  
や、
  0
  1
などです、コンピューターの世界では、0と1 で表現します。
2つのデータを表現できますね。

ではでは、2ビットとは:
2ビットとは、2つの異なるもの を使った、2桁のデータです。
  00
  01
  10
  11
このように、4つのデータを表現できます。

さらに、3ビット とは?
  000
  001
  010
  011
  100
  101
  110
  111
つまり、8つのデータを表現できるわけです。

こんな風に考えていくと、8ビット(1バイト)では、2の8乗(2)、、つまり、 256個のデータを表現できるようになります。
例えば、1~256 ですね。
これを、Javaのデータタイプの、byte では、
  -128~-1
  0
  1~127
    / 「-128~-1」で、128個、0で1個、1~127で127個、、合わせて、256個
こんな感じに、256の値を、数値に、関連付け/割り当て しているわけです。
これが、ビット・バイト の意味です。☕



では、次は、小数 の扱いについて、考えてみます。
 浮動小数点数(Floating-point numbers):
ただ、この型は、完全な厳密さが無くてもよい場合に、使うそうです。
(例えば、お金を割り算するときには、BigDecimalクラス を、使うそうです.)
  float : 32ビットの大きさ
    / これを使うと、パフォーマンス/実行速度 は、いいが、少し大雑把(おおざっぱ)です.
    / 例えば、金額の「大小だけが」目的の時には、使う価値があります.
  double : 64ビットの大きさ
    / 今時のCPUでは、数学的な計算で、float より、
    / 速くなるように最適化されているようです.
    / 正確さも、float より、いいです.
    / サイン・コサイン・タンジェント を、求めるときに、よく使われます.
      / Java標準ライブラリの、Math.sin(cos/tan)() でも、
      / doubleタイプのデータを、返していました.



 ・・・ ☕ コーヒータイム ☕ ・・・
お金の計算で、doubleを使うとまずい、、
そんなにまずいのか?ちょっと試してみました
これは、101円を3で割って、また3倍したら、101円になるはずなのですが、
そうはならずに、99円になってしまったという例です。
確かに、公式の場で、こうなってしまっては、困りますね。
まあでも、自分のための、支払い計算ぐらいであれば、普通は問題ないと思われますが?☕



次は、
 ブール値(Boolean):
正しいor間違い を、示す値でした。
  boolean
そして、その意味から想像できるように、値は2種類だけです。
  true : 正しい、真
  false : 間違い、偽
この2つだけですが、これは、重要なデータです、、例えば、
こんなプログラムで使えるでしょう。
  もし(さいころの値==3){
    あなたが私に、500円くれる.
  }そうでなかったら{
    私があなたに100円あげる.
  }
こんなプログラムがあったとして さいころの値が3であった ときは、trueになり、「あなたが私に、500円くれる」が実行されますし、falseであれば、「私があなたに100円あげる」が、実行されてしまいます。こんな感じで使うわけです。でも、博打(ばくち)は、いけませんね。

これで、7つ説明しました。残りの一つは、一文字に関するデータです。
  char : ユニコード(Unicode)と同じ、16ビットの大きさ
    / ユニコードと、同じ数値を使って、表現できます.
      / char xUpper = 88;(文字X)
      / char yUpper = 'Y';(文字Y)
        / この意味は、後で説明します.
        / と思いましたが、数字を使う場合を覚えて役立つのは、OJCPぐらい??
    / どんな文字(英語以外)も使えるようにするために、ユニコードが採用された.



データ(値):オブジェクトタイプ(参照型/矢印型)

では、もう一つの種類の、オブジェクトタイプの、データについて、考えてみましょう。
オブジェクトタイプは、classという設計図から出来た実物です。そうはいっても、コンピューターが、本当の実物は作れませんので、今一つ分かりにくいと思いますが、よくある例は、
タイ焼きの鋳型(いがた) が、class で、実物のたい焼き が、オブジェクトという説明です。
こんなイメージでいいと思います。そして、オブジェクトは、プリミティブタイプ のデータを組み合わせて作られます。たい焼き の、具/中身 が、あんこ・カスタードクリーム・しろあん・抹茶・チーズクリーム・チョコレート、、調べたらとてもたくさんあったので、この辺にしときますが、、この違いは、プリミティブタイプのデータを、オブジェクトを作るときに、調整したり、出来あがったたい焼きに、設定していくわけです。
こんな オブジェクト(インスタンス/instance) は、プリミティブタイプとは、変数 という、データを入れる箱に入れるときの方法が、違います。正確に言えば、オブジェクト自体は、箱に入れません。このことは、この後すぐ説明します。
オブジェクトタイプの例としては、Stringオブジェクト が、とても、よく使うオブジェクトの代表と言えます。
ただ、Stringオブジェクト は、特別な存在で、ほかのオブジェクトとは、違った振る舞いをしたりするのですが、とりあえず今日説明する部分では、その違いの部分は、無視して大丈夫なので、この後も、リテラル、変数 とともに、説明していきます。



いろいろなタイプのデータを、変数に、保存しましょう

これから、変数(variable)の意味と、その保存方法について、書いていこうと思います。
まず、変数 とは何なのか?
変数とは、値/データ を入れる 箱 と考えましょう、、というのが、一般的な説明ですが、私もこういう考え方で、覚えました。

その時、リテラル(literal)というものを、よく使います。 ですので、その基本的意味を説明しておきましょう。
リテラルとは、まず、
  変更されない 値/データ
であり、プログラムのソースコードで使われます。
リテラル を、表現するためには、それぞれの、データ型ごとに、
  特定の書式
が、あるので、それに従って書きます。
後で、その例を示しますので、もう一度ここを読んで確かめていただけたらと思います。
また、リテラル とは、変数 の反対語にあたります。
つまり、変数 は、値が、可変/変えられる ということを意味します。

それでは、変数の宣言変数への代入(保存) について、リテラルを使いながら見ていきましょう。

まず、プリミティブタイプから行きます。
整数
  intの場合:
まずは、変数の宣言 の方法です。
    int hen;
    int hen2;
こんな風に宣言します。この意味するところは、
int型の変数 として、hen、hen2 を、定義しました、、ということです。
さて、変数を宣言 したら、次にすべきは、変数に、値/データ を、代入(保存)することです。
これをやらなければ、何のために、変数を宣言したのかわかりませんね。
    hen = 10;
    hen2 = 100000;
こんな感じで、代入していきます。

さてさて、ここで、先ほど話しました、リテラルについて、話していこうと思います。ここでの、リテラル は、1010000です。
一見単に、(半角)数字が書いてあるだけではないか、と思われるかもしれませんが、これこそが、int型リテラル(int型であるリテラル)なのです。
Javaのコードで、こんな風に書いてあれば、これは、int型 で、10、100000 なのだと理解してください。
あともう一つ、実際にコードを書くときに大事なことを説明します。
実は、変数の宣言 と 代入/保存(初期化とも言います)は、一度に書けます。
    int i = 7;
こんな風に書けば、変数 i を宣言したのと同時に、整数7 を、代入したことになります。
実際には、分けて書くより、こうやって一度に書く方が多いです。
あと、覚えなければならないこととして、識別子 の、理解ですね。
この 変数の名前 のことを、識別子 と言います。変数以外にも、後から出てくる メソッド の名前、classの名前 なども、識別子です。その名前は、自分で考えて付けることになります。ただ、その時には、いくつかのルールがあって、してはいけないことがあります。
まず、Java で、必ず出てくる class や、とてもよく出てくる int などは、Javaの 予約語/キーワードと言って、変数の名前などには、使えません。また、true/false/null は、正確には、予約語ではありませんが、識別子に使うことはできません。
早い話、Javaプログラムの中において、特別な意味を持った語 は、使えないということです。
また、識別子 を作るための決まり事もあります。以下に示します。
  1文字目:
    a~z、A~Z、_、$ が、使えます。
  2文字目以降:
    a~z、A~Z、_、$ に加えて、0~9 も使えます。
  気を付けること:
    先ほどいった、Javaプログラムで特別な意味を持った語 は、使えない。
    大文字・小文字は、違う文字である
      / つまり、passwordとpassWord は、
      / w と W が、違うので、違う名前ということになる。
うわっ、こんなの覚えられないわっ!と、思われるかもしれませんが、私にしても、そういえば、そうだったような、、です。でも、大事なのは、以下の通りでしょう。
  ・アルファベットを使う
  ・1文字目で数字を使わない
  ・大文字/小文字に気を付ける と 予約語は使えない
    / しかし、これに関しては、Javaに慣れれば、当たり前のこと.
  (もし、記号が使いたかったら、一応調べる)
実際問題は、この程度で覚えておけば十分だと、思われます。
もし、OJCPを受けるのであれば、何日か前に、しばらく忘れないように、頭に詰め込んでおけばいいと思いますが??
ただ、これを、忘れていました!
日本語や全角文字 は、Stringオブジェクト または、コメント 以外では、使わないで、全て半角文字を使うこと!
これに関しては、パソコンの基礎なので、すぐに調べられますから、分からない人は、調べてください。

今度は、byte変数の宣言と初期化をやってみましょう。
初期化というのは、変数を宣言 して、最初にその変数の値を決定することです。初期化しなくても、デフォルト値 が、与えられるようですが、それは、私のような初心者や、入門者は、まずは、気にしなくて、自分で初期化した方が、いいです。まず、初期化の詳細(デフォルト値)を覚えるのが大変ですし、コードを他人が読むときも、分かりやすいです。また、必ず初期化しなければならない場合もあります。まず、なるべく少なく覚えて、余裕ができてから、考えた方がいいと思います。(OJCPには出る可能性がありますが、あのテストは、基本を覚えてから取り組むべきものです。)ただでさえ、Java言語は、覚えることが、とてもたくさんあります。まだ、学習していませんが、public や、private と同じカテゴリーになる、アクセス修飾子の「protected」のアクションは、とても複雑です。でも、これに関しては、Java言語上達のためには、知っていた方がいい知識だと思われます。

また話が飛んでしましましたが、
  byte b;
  byte improvePerformance = 123;
などのように 宣言 と 初期化 をします。
また、二つ以上の変数を宣言することもできます。
まだ、初期値は決めていないが、とりあえず、3つ必要だなと思ったら、例えば、
  byte one, two, three;
こんな風に、カンマで区切って、最後は、セミコロンです。
セミコロンは、の最後につけるものですが、「文」の定義については「式」と一緒に学ぼうと思います。その方が分かりやすいですから。ここでは、この書き方をまねて覚えてください。 (今すぐ覚えたい方は「ひとつ上をゆくJavaの教科書(岩谷宏)p150,5-1-4:式は文ではない」を読んでいただければ、と思います。この本は難しいですが、少し分かった頃に読むと、とても収穫があります。今だったら(2017/8/13)、アマゾンで安く手に入るでしょう。逆に、¥10,000以上のプレミアが付く気もしますが。)「式」とかの定義は、まあ、大体はわかりそうですが、きっちり理解しておいた方が、オライリーなどの難しめの本を読むとき、クリアに理解できるでしょう。また、「式 文 違い」などで、検索しても、ヒットすると思います。
今度は、リテラルについて、考えてみたいと思います。 先ほど書いた式、、もとい、、文、
  byte improvePerformance = 123;
ですが、さっきの説明から行けば、123 は、int型(32ビット) であり、byte型(8ビット) に、収まらないのではないかと思われる方も、当然いらっしゃると思います。
では、なぜこの 式でなく、、、文は、有効なのでしょうか。それは、整数値リテラル(123など)は、暗黙的に(どこにも、int型とはうたっていないが)、int型 なのですが、これは、自動的に、int からbyte への、型変換(キャスト)が、行われているためです。つまり、これを省略せずに、書くと、
  byte improvePerformance = (byte)123;
    / (byte):byte型へ、キャストしている.
ということです。
ただ、byte型 に収まらない値は、キャストできません。
Eclipse では、こんな風に、警告してくれます。
int から、byte へ、キャストするとは、こんなイメージです。
  00000000000000000000000000000001 ⇒ 00000001
つまり、メモリを確保するための領域を減らしているわけです。
でも、もともと、byte の範囲に収まらないデータは、キャスト出来ません。

次は、short型です。
これも、byte と、考え方は、同じです。
ただ、byte よりも、データの範囲/うつわ が、大きいです。
これも、Eclipse にて、チェックしてもらいました
バッテン/ の処は、エラーです。

では、整数型 の最後です。
long について考えてみましょう。
まず、long型 の場合、int型より大きいので、リテラル を、どう書けばいいのかとお思いでしょう。それには、決まりがあります。
  整数値の後に、L または、l を付けると、long型のリテラル になります。
これに関しても、Eclipse に、いろいろな場合を、チェックしていただきましょう
この場合、変数 lg6 のところで、エラーが起きているのは、12340000000 は、int型の範囲を超えているので、int型リテラル として認められません。かといって、L が、最後についていないので、long型リテラル でも、ないわけです。
これを、解決するには、どうすればいいでしょうか?
12340000000 の後に、L を、付ければ、OKです。
では、今度は、L を付けて、実行してみましょう。
結果は、こうなります。少し画像が大きいので、スクロールして、下の方を見てください。
また、 のマークは、軽い警告で、lg1、lg2、lg3、lg4、lg5 は、宣言して初期化しているだけで、使用していないので、「何のための 変数 なのだ!」と、文句を言っているわけです。こちらとしては、「実験をしているのだ。」と言い返すわけには、いけませんね。これは、コンパイルして、実行することができます。
ただ、この時に、昔(utf-8 という文字コードを使っていなかったころ)には、気づかなかった、エラーを出してしまいました。これは、予想ですが、「~.java」というファイルを、Windows の場合、Shift_JIS だと、想定しているので、コードが、読めないようです。これを解決するには、
コンパイルする際、普通は、
  javac ~.java
のように書けば、OKですが、もし、それでうまくいかない場合は、
  javac -encoding utf-8 ~.java
のように、タイプしてください。つまり、
    -encoding utf-8
を、上のように、挿入して、タイプするわけです。

これで、整数型のところまで、終わりました。

次は、浮動小数点数(なんでこんな名前かわかりませんが、覚えましょう)、つまり、小数 を、表す型です。
まずは、double型から、考えてみましょう。
まずは、double型 のリテラル表現です。
例えば、
  123.456
のように、書けば、double型のリテラルを意味します。
ここで、気になったのが、
  整数値リテラル(int型)でも、適当に数値を書くと、表現範囲を超えるので、
  小数点が、付く double型のリテラル は、どうなんだろうか?という疑問です。
そこで、いろいろ調べてみましたが、何と、double(64ビット)より、ビット数の小さな、float(32ビット)の方が、long(64ビット)よりも、表現範囲が大きいようです。
表現範囲の大きな順で並べると、以下のようです。
  double(64ビット) > float(32ビット) > long(64ビット) > int(32ビット)
ですので、まあ、極端な小数値を書かなければ、double型のリテラル が、表現範囲を超えることはないと思われます。
ですので、そのことは、考慮せずに考えていきます。
そもそも、浮動小数点数 の理解が深ければ、悩まなくてもいいのでしょうが、いろいろ調べたのですが、難しい!
これに関しては、もし、必要を感じたら、徹底的に、理解することに挑戦してみます。
多分一番有名なSJCPの対策本も、調べたのですが、浮動小数点数 の「しくみ」までは、言及されていませんでした。ネットでは、調べれば、かなり深く、迫っているページはありました。
それで、double型リテラル は、123.456 のように書けばいいことは説明しましたが、
  123.456d または 123.456D
いう書き方もありのようです。
ただ、d/D を付けなくても構いません。
やはり、int型 double型 は、普通に書いて、そのリテラルになるので、
一番よく使う型だと思われます。

では、float型のリテラルは、どう書くかというと、
  123.456f または 123.456F(f/F を、最後に付ける)
一応、私の知識が古いといけないので、ほぼ/多分、最新バージョンの、Eclipse で、チェックしてみましょう
9行目で、float型 より、器(うつわ)の大きな double型リテラル を、代入しようとしています。ですので、Eclipseは「型の不一致である」と言って、を、付けています。
変数の宣言方法は、特に今までと変わりありませんね。

それでは、次は、boolean型についてです。
これについては、値は、
  true
  false
の2つしかないのでした。
それは、まあ、当然で、〇or✖ の、世界ですから。
使い方は、今までと同じで、
  boolean good = true;
  boolean bad = false;
のように書けば、OKです。

使い方の例として、こんなプログラムを書いてみます。
01  class GoodTimesBadTimes{
02    プログラムスタート(){
03      boolean good, bad;
05      int zeroOne = 0か1を返す式;
07      もし( )内がtrueならば( (zeroOne イコール? 0) イコール? true ){
12        good = true;
14        System.out.println(good);
16      }
17      もし(zeroOne イコール 1){
18        bad = false;
20        System.out.println(bad);
22      }
23    }
24  }

この実際のコードは、こうなります
簡単に説明しますと、
3行目で、boolean型変数、good と bad を、宣言しています。
5行目では、int型変数 zeroOne に、0 か 1 を代入しています。これは、ランダムに、0 か 1 になります。確率的に、五分五分ということです。ただし、これは、10回程度では、半々には、なかなかなりません。もし、1000回やれば、多分、約500回ずつで、booleanリテラル の、true false を、プリントすると思われます。 (すいません、、私は数学には詳しくないので、本当に、1000回やれば、五分五分 になるのかは、分かりません。言いたいのは、とてもたくさんの回数をやれば、約50%が、実現されるということです。)
714行目では、もし、zeroOne の値が、0 であれば、boolean型変数good に、booleanリテラル の、true を、代入して、コンソールにプリントするメソッド/~println() に、goodを与えて(~println(good))、good の、値である、true を、コンソールに、プリントするというわけです。
そして、変数zeroOne が、1 であったとき、1720行目で、同様にして、false を、コンソールに、プリントします。
右のPDFの、/*~*/ のコメント部分が、コンソール画面のテキストのコピーです。
この場合、true の回数の方が、多いですが、やる回数が多いほど、ほぼ、同じくらいになります。でも、それは、今回の学習とは、関係ありませんが。

えっと、次は、char型の、リテラルと、そのchar型変数への、代入 です。
代入 に、関しては、= 代入演算子を、使うのは、どんな型であろうと同じですので、もう慣れてきたと思います。
問題は、リテラル表現ですね。
大体私は、char型 が何のためにあるのかわかりませんが、Codecademy の、Javaコースでも、char型 を、取り上げていたので、まあ、チェックすべきでしょう。
何のためにあるのかわからないというのは、後から出てくる、Stringオブジェクト において、文字を、1文字だけにしたのと、実用的には、どこが違うのかわからないからです。まあ、これに関しては、恥をさらしそうなので、もうこれ以上は言いません。
リテラル表現は、一重引用符/' で、1文字だけを囲んで、
  'A'
  'a'
のように書いて、表現します。
そのほかにも、ユニコード表現 など が、使えたりするのですが、ググっても、その使い方は、あまり意味がないと書かれていたりするので、今の段階では、あまり時間をかける意味はないでしょう。ので、パスです。
ただ、改行文字 や、'自体 を、どう表すのかは重要だと思われますので、説明いたします。
これは、エスケープシーケンス というものですが、これの説明も、次回以降に、回させてください。
簡単に、これら3つだけ紹介します。
  改行:'\n'
  一重引用符:'\''
  二重引用符:'\"'

では、例によって、Eclipseを使って、チェックしてみます
ここで、注意すべきところは、
6~8行目 で、\ は、バックスラッシュ になっているところですね。
私の環境(Windows10英語版)では、どちらになるのかわかりません。お恥ずかしいですが、分からないのです。それに、どちらでも構わないので、原因を追究しようともしていませんが。
Windows日本語版では、\マーク になるのが、普通だと思いますが、まあその辺は、目をつぶってください。
次にチェックすべきの方が、大事ですが、14行目に、注目してください。この実行結果は、
  改行します
  改行します
  改行します
となりますが、どうしてそうなるか、分かりますか?
それは、
  '\n'
が、改行文字 を表しているからです。
改行文字 とは、このように「改行する機能を持った文字」で、改行文字自体には、形はないのです。

さて、やっと終わりに近づいてきました。
今回は、あと、オブジェクトタイプの、Stringオブジェクト に簡単に触れて、終わりにしたいと思います。最後には、確認テストを、用意しました。これは、私が、最近作ったばかりの問題集ですが、ちょっといけてると自分では思っていますが、がっくりされるといけないので、これ以上は、言いません。

では、最後に、オブジェクトタイプにおける、変数の宣言、初期化 について、学んでいきましょう。
オブジェクトタイプの変数 とは、
  オブジェクト(インスタンスともいう)自体
が、
  変数自体
になります。
オブジェクトタイプのリテラルに関しては、私も、まだ今のところ、、よく知らなくて、申し訳ないですが、Stringオブジェクト配列(オブジェクトである) の、リテラルしか、表現方法を知らないのですが、その他のオブジェクトに関しては、もし、リテラルがあるとしても、入門レベルでは、あまり登場しません。私自身おいおい学習しながら、対応していきます。
配列に関しては、その話だけで、長くなりますので、次回以降に回させてください。

では、今回は、Stringオブジェクト に関して、簡単に、紹介します。
実は、Stringオブジェクト も、非常に大事な部分で、これは、これだけで取り上げた方がいいぐらいの内容があります。
今回は、本当に、簡単に、説明します。
普通、オブジェクトを、作るには、ちょっと特別なコードを書くのですが、Stringオブジェクトの生成は、本当に簡単です。
  String strObj = "ストリングオブジェクト";
このように、書くだけです。
Stringリテラルは、
  "ストリングオブジェクト"
のように、二重引用符/" で「0文字以上」を、囲むだけです。また、
(0文字の時:"" は、空文字列 と言います。)
"" の、 の部分には、"日本語もOK"です。
あと、char型リテラル の時と同様に、
  "\n"
  "\'"
  "\""
も、使えますので、覚えておきましょう。

では、Eclipse✔ です。
ここで、注目すべきは、
  "改行します\n2行目です\n3行目です"
の部分でしょうか?
これは、char型リテラル と違って、同じ、Stringリテラルどうし なので、直接、埋め込むことができます。
これは、
  +演算子
を、使わなくてもという意味ですが、これには、まだ、触れていませんでした。
これも、この演算子を使って、Stringオブジェクト と、足し算すると、Stringオブジェクトではない方も、Stringオブジェクトに、暗黙で変わるとか、少し複雑な部分があるので、Stringオブジェクト の時に、改めて学習しましょう。

Stringオブジェクト に関しては、学ぶべきが非常にたくさんありますが、私としましては、GUI(Swingなど)を、少しでも早くやりたいので、深入りし過ぎは、まずは、止めておきます。
かと言って、それ以外の部分でも、Threadクラス などの処も、きっちりやらないと、Swingの活用も限られてしまいますので、まだまだ、道のりは長いですが、頑張って続けようと思っています!

と、よく考えたら、今回のテーマは、
  Javaは、型付けの強い言語 である
ということでした。
もし、JavaScript を少し学習したことのある人なら、もう言うまでもなく、今までの学習で、身にしみて感じていると思いますが、最後に、型付けが強いとどうなのか、本当に簡単に書いておきます。私自身深くは語れませんので。
 ・Javaが、安全で、安心できるのは、型付けが強いから。
 ・すべての変数、全ての式 は、型 を持っており、揺らぎがない。
   / ですから、たとえ、暗黙の変換についても、きっちりしたルールがあります。
   / 勝手に、数値が、文字列 になったりはしません。
 ・たとえメソッドを通して渡される変数であっても、
  コンパイラは、きっちりと、型チェックをします。
まあ、こんなことを、Schildt氏 が、語っておりました。
とは言え、私も分かる部分と、今一つあいまいな部分がありますが、その辺のところも、以後の学習で、きっちりしていきたいと思います。

それでは、最後に、
   Javaは型付けの強い言語である の、復習テスト
を、最後にやりましょう。




今回の学習のあとがき(2017/8/14):
いつもだいたいは、メインに、「Java the complete reference 9th edition(HerBert Schildt)」を読んで、それでもわからないことは、ネットで検索したり、「ひとつ上をゆくJavaの教科書(岩谷宏)」を読んだりして、書いています。ただ、構成は、自分なりに考えて書いていますが、いつも、自分の知識が、浅いことに気づかされます。
今回は、byteなんて、今時いらないデータだろうと、勝手に思い込んでいましたが、例えば、「ネットワークでのストリームやバイナリデータ」において、とても、役に立つ/useful と、書いてありまた。
ただ、私のレベルや、入門者の方には、負担が大きすぎて、一番大事なことを覚えられなくなってしまうので、書きませんでしたが、自分のレベルも、まだまだだなぁ~と思いました。
またこんなことも書いてありました。
int は、もっともよく使われるだけでなく、配列のインデックス や ループのコントロール でも使われるそうです、深く考えなければ、これらは、byte や short で、十分だと思われますが、実は、int で定義しても、最初は、実際には、byte や short が、計算に使われ、後から、int に、戻されるのだそうです。だから、int が、必要な場合に備えて、int を使っているそうです。こんなことは、私や、多くの入門者にとっては、「深すぎる」ので、割愛しました。
昔、SJCPに合格したので、文法なんて思いだすだけだと思っていたのですが、あれは、本当の意味では、入門レベルに合格しただけですね。
今後は、一度頭の中を空にしてから、読んだり、調べたりしていこうと思っています。

あとがき2:
今日、ひとつ上をゆくJavaの教科書 を読んでいて「これは大事だなと思える部分」がありました。
それは、
 1. 式 と 文 の違い
 2. 式は「値」を持っている(例えば「式、3>5」は、false という値を持っています)。
この辺りは、ちょっとした落とし穴と、思われるので、機会を見つけて説明しようと思っています。

あとがき3:
まだまだ直したいところが、あるような気がしてしようがないですが、気が付いたら、地道に直していこうと思っています。
なんだかんだうまくいくだろうとは、思いますが、思ったより、時間がかかると思いますので、真剣に早く、Javaを身に着けようと思っている方は、いろいろなアプローチを試みられることを、強くお勧めします。



・・・ ☕コーヒータイム☕ ・・・
まだ、JavaTheCompleteReference(Java8) のまだ読んでいないとこをを読んでいたら、難しいので、パスしていたところが、書いてありました。
double型リテラル の、指数表記 の方法です。
標準表記 の方は、すでに説明いたしました。
難しかったのですが、やっと分かりました。
こんなことは、常に覚えていなくても、問題ないと思われますが、もし、この知識が必要となった場合、1回でも理解しておくと、後から思い出しやすいので、よければ、読んでみてください。

それで、Eclipseに、チェックされながら、コードを書いて実行したのが、このコードです。
それでは、このコードを見ていきましょう。

まず、4行目の、
  d1 = 0.005;
は、普通の、double型 の、リテラル でしたね。
問題は、変数 d2~d9 は、全て、double型 の、指数表記です。

こんなに、たくさんあるのは、いろいろなパターンを書いて、基本ルールを理解しているか、確かめたかったからです。
まあ、納得いくまで、いろいろ書いて確かめましたので、
  Java での double型 の、指数表記
の書き方を、紹介しようと思います。
(ただし、私が分かったのは、指数表記を、10進数(私たちがいつも使っている数)に、戻す方法が、分かったというだけで、
指数表記をする理由(長くなりすぎるのを避けるため?)や、指数表記とは何者なのか? ということは、全くわかりませんし、
もうそのことは、忘れましょうという感じです。
もし、将来、物理学と積分を学習しているときに、分かったらいいなぐらいに思っています。
まあ、数学を覚えようというのは、半分は本気です。)

基本ルールは、
  [数値リテラル][Eまたはe や Pまたp][正および負の指数]
という書き方です。
そして、これがどのように計算されているかというと、
  数値リテラル × (基数指数)
なんですが、これでは、説明不足ですね。
  基数 は、指数 に対する数、、何乗かするべき数
(数学用語を知らないので、あまりうまく説明できなくて申し訳ない)
そして、基数 が、10 の時は、E か e を、使います。
また、基数 が、2 の時は、P か p を使います。

で、一番難しいところは、指数が、マイナス/- の時です。
数学を理解している人は、なんてことないでしょうが、私は、今日初めて知りましたが、
例えば、
  10-3 の意味は、103分の1、、つまり、1000分の1
になるのです。
こんな感じで、10-2 は、100分の1 です。

です!ので、変数d2~d9 までは、このルールに従って、確かめていってください。

また、d10, d11 は、数値は、16進数のリテラル、、基数が2、、指数は10進数、、というわけが分からない計算で成り立っています。
  / 16進数リテラルは、頭に、0x または 0X を、付けたものです。
ここで、もう一つ気を付けるべきは、
  16進数リテラルの小数部 は、10進数にするとどうなるか?
なんですが、
10進数の場合、例えば、123.45は、、
  102×1 + 101×2 + 100×3 + 10-1×4 + 10-2×5
    / あらゆる数の0乗 は 1 になる.
ですので、
  100x1 + 10×2 + 1×3 + 0.1×4 + 0.01×5
ということになります。

16進数も、同じように考えて、例えば、35行目の、
  0x12.2(16進数リテラルで、12.2)
は、
  161×1 + 160×2 + 16-1×2
ということになり、まず、この部分は、
  16×1 + 2 + [16分の2]
となり、
  16×1 + 2 + [8分の1]
となり、
  18 + [8分の1]
で、結局、
  8分の145 ( 8分の (8×18+1) )
になります。

これで、16進数の、小数部も、解決しました。
ついでに、全部をやると、これに、22 を掛けるわけです。
  [8分の145] × 4
ということは、
  (145×4)÷8 ですね。
答えは、
  72.5
です。。

だんだん自分でも、何を書いているのかわからなくなってきましたが、一応説明できたでしょうか?
こんなことは、普通必要か分かりませんし、もし、必要だとしても、一度、理解しておくだけで、いいのではないでしょか?

これで、終わります。☕



あとがき4:
以後、少しでも早く(それでも遅いでしょうが)、Swing(欲を言えば、FXも)をストレスなく、学習できるレベルに到達したいので、 それに合わせた、学習内容を検討することにしました。
あまりたくさん省略することなく、GUI(Swingなど)を、学ぶ方法は、
 Java A Beginner's Guide, 6th Edition のインデックス が、ポイントだと思われます。
なぜなら、この本の一番最後に、Java Swing と、Java FX が、書かれているからです。
また、Schildt氏の本は、beginner's と言っておきながら、深めの内容だと思われます。
例えば、いま読んだ、「エキスパートに聞く」というコラムで、書いてあったことなんですが、
Q:Why does Java have different data types for integers and floating-point values? That is, why aren’t all numeric values just the same type?
 どうして、Javaの、整数型と浮動小数点(型)には、いろいろな型があるのですか?
 言い換えると、ひとつのタイプではいけないのですか?
A:... Finally, some algorithms require (or at least benefit from) the use of a specific type of data. ...
 つまり、特定のタイプのデータを選ぶことが、プログラムによっては必要であり、
 そうでなくても、少なくとも、例えば、データ量の小さなタイプを使うことは、
 実行速度向上につながりますし、
 ある種の計算では、doubleを使います。パフォーマンスを落とすことになるかもしれませんが、
 floatは、doubleよりも計算誤差が大きいのです。
と、書いてありました。
 (かなり、思い込みの強い訳だと思われる方もいると思いますが、
 英単語自体のニュアンスをつかめない日本人には、
 このぐらいの方が、私はいいと思います。Finally, 無難な訳では、
 意味がぼやけてしまうような気がするからです。
 たしかに、誤訳をしてしまうリスクもあるとは思いますが。)
たいていの入門書には、整数値型は、byte, short, int, long があります。そして、byte型は、...
という具合で、何のための、byte型なのかには、気づかないふり?をしています。
何が言いたいのかというと、Swingを学ぶために、Java A beginner's Guide は、適している
(Schilt氏の本は、信頼に値する)
ということが言いたいわけです。というか、そのことを書こうとしていたのでした、そもそもは。
頑張って続きを書いていきます。