サイトロゴ
この章で行う学習内容
 

クラス
クラスとは?
クラスとはどんなものでしょうか?
会社で使用しているパソコンと自宅のパソコンは違います。 ただし、パソコンは色や形が違っても「パソコン」です。

いきなりですが、デスクトップパソコンを作ってみましょう!

①まずパソコン本体が必要です。 「どんなパソコン本体が必要なんだろう?」 「色は何色がいいかな?」 と考え、パソコン本体の設計図を作ります。

②①で作成した設計図を使い、 パソコン本体(モノ)を作ります。 設計図があるので、パソコン本体 (モノ)はいくつでも作れます。

③次に、パソコンにはマウスが必要です。 「どんなマウスがいいかな?」と考え、マウスの設計図を作ります。

④マウスの設計図を使い、 マウス(モノ)を作ります。 設計図はあるので、何個でもマウスを 作ることができます。

⑤同じようにディスプレイを作り、 パソコン本体・マウスを1つにするため、パソコン自体の設計図を作ります。

このような感じで、パソコンが出来上がります。
ここでいう設計図にあたるものが、Javaプログラミング言語の「クラス」です。

クラスにはオブジェクトのデータ(色やメーカー)などを定義します。 例えば、黒いパソコン、白いパソコンというそれぞれのパソコンによって色が違う点から、 「パソコンには色という要素がある」という定義をする、といった感じです。

設計図があれば「モノ」を作ることができるように、
クラスからオブジェクトを作ることができます。

その上で、「パソコン」クラスを「私のパソコン」オブジェクトという具体的な「モノ」にして、 「黒」という色や「デスクトップ型」という形を与えて使うことにするのです。
このようなクラス(設計図)を利用して
オブジェクト(パソコン)を作成することを、
インスタンスの生成といいます。
パソコン本体、このオブジェクト(モノ)を
「パソコン本体クラスのインスタンス」、
同じようにマウスのこのオブジェクト(モノ)は
「マウスクラスのインスタンス」と言います。

構文
                              フィールド
                              クラス内のどこでも使用できる変数。
                              メソッド
                              処理する部品。引数、戻り値を持つ。
                              コンストラクタ
                              特別なメソッド。
                              今まで作成したもので考えてみると・・・
                              public class Lv0240{   ← 全体「クラス」
                              public static void main(String args[]){
                                          ↑
                                クラスの中にあるものが「メソッド」
                                    //処理
                                 }
                              } 
                          
例文1
                              //クラス
                              public class PersonalComputer{
                                  public Stinrg name;
                                  public int price;
                                  //↑フィールド

                                  public PersonalComputer(){
                                      //↑コンストラクタ
                                      name = “DELL”;
                                      price = 150000;
                                  }

                                  public static void main(String args[]){
                                      //↑メソッド
                                      PersonalComputer myPC = new PersonalComputer();
                                      myPC.show();
                                  }

                                  public void show(){
                                      //↑メソッド
                                      System.out.println(name + “は” + price + “円です。”);
                                  }
                              } 
                          
※フィールドもメソッドも複数定義することができます!
オブジェクトとは?
Javaはオブジェクト指向プログラム言語といわれますが、 オブジェクトとは何でしょうか?オブジェクトとは、 英語で簡単に言うと「もの」という意味になります。 私たちが生きているこの世界のすべてが「モノ」で構成されています。 研修で使っているパソコンを例にしてみます

具体的なパソコン1台1台がオブジェクトになります! 例え、メーカーや形・色が同じだったとしても、 同じパソコン、つまり同じオブジェクトではありません。

このように私たちの世界と同じような考えをプログラミング言語にも応用 しようというのが、「オブジェクト指向言語」です。
 

フィールド
フィールドとは?
フィールドは、クラスが持つ情報を表すものです。 同一クラスのどこからでも参照できます。
構文
                              アクセス修飾子 型 フィールド名 アクセス修飾子
                                ・public     どこからでも参照可能
                                ・private     自クラス内でのみ参照可能
                              メソッド
                              処理する部品。引数、戻り値を持つ。 
                          
例文1
                              //サンプルソース
                              public class PersonalComputer {
                                  private String name;
                                  public int price;
                                  //↑フィールド ・・・ 
                              }
                          
※フィールドnameはprivateなので自クラスのみ参照可能です。priceはpublicなので他クラスからも参照可能です。
メソッド
メソッドとは?
クラスの部品、動作、機能を表すものです。 このクラスができること(振る舞い)です。
構文
                              アクセス修飾子 戻り値の型 メソッド名(型 引数名1, ・・・, 型 引数名n){
                                  処理
                              }
                              アクセス修飾子
                                ・public     どこからでも参照可能
                                ・private     自クラス内でのみ参照可能
                              戻り値の型
                              ・このメソッドが処理した結果を返す値の型になります
                                        戻り値で値を何も返さない場合、
                                  つまり戻り値がない場合は「void」を指定します。
                              メソッド名
                                 ・任意につけることができます
                                 ・メソッドの処理に適した名前を付けます
                              引数
                              ・メソッドが処理する時に、必要な値(もらう値)になります
                                        引数は1つだけでなく、
                                    カンマ区切りで複数指定することができます。

                          
例文1
                              public class MyPC{
                                  //戻り値なし、引数なしのメソッド
                                  public void show1() {
                                      String name = “DELL”;
                                      int price = 150000;
                                      System.out.println( name + “は” + price + “円です。” );
                                  }
                                  //戻り値String、引数なしのメソッド
                                  public String show2() {
                                      String name = “HP”;
                                      int price = 60000;
                                      String message = name + “は” + price + “円です。”;
                                      return message;
                                  }
                                  //戻り値void、引数String型1つ
                                  public void show3( String name ) {
                                      int price = 75000;
                                      System.out.println( name + “は” + price + “円です。” );
                                  }
                                  //戻り値String、引数String型1つ、int型1つ
                                  public String show4( String name , int price) {
                                      String message = name + “は” + price + “円です。”;
                                      return message;
                                  }
                              }
                          
注意点
戻り値を返さない場合は、戻り値の型をvoidにします。
これで、戻り値なしという意味になります。
この場合returnする必要はありません!
returnは、メソッドの処理が終わるということです。
returnの後に処理はできません。
例)  return a;
× System.out.println(a);
mainは特別なメソッドです。
このメソッドはJava実行時に最初に呼ばれます。

例)C:\sample>java Sample
これは、「Sampleクラスのmainメソッドを実行」という意味になります。
※フィールドnameはprivateなので自クラスのみ参照可能です。priceはpublicなので他クラスからも参照可能です。
コンストラクタ
コンストラクタとは?
インスタンスを生成する時に呼ばれるメソッド。 インスタンスを生成時に初期化を行います。
構文
                              アクセス修飾子 クラス名(型 引数名1,・・・,型 引数名n){
                                  初期化処理
                              }
                              アクセス修飾子
                                ・public     どこからでも参照可能
                                ・private     自クラス内でのみ参照可能
                              引数
                              ・このコンストラクタが処理する時に、必要な値(もらう値)になります 初期化処理とは?
                              例えば、自転車インスタンスを生成した時、この自転車は何色でしょうか?
                              自転車は売りに出された時には、色がついています。
                              つまり、インスタンス生成完了時には色がついていなければなりません。

                              インスタンスに対してデフォルト設定をしたり、最後の仕上げをするのが、
                              初期化処理になります。

                          
例文1
                              public class Bicycle{
                                  //タイヤの数
                                  public int tireCnt;
                                  //自転車の色
                                  public String color;

                                  public Bicycle( int tireCnt , String color ){
                                      this.tireCnt = tireCnt;
                                      this.color = color;
                                  }
                              } 
                          
【自クラスのフィールドの呼び出し方】
this.フィールド名

this
this.は「自クラスの」という意味になります。
コンストラクタの中で、引数の名前とフィールドの名前が同じになっています。
引数なのかフィールドなのかを指定する為、thisを使います。
※自クラスのメソッド・コンストラクタの呼び出し時にもthisを使用する事で呼び出せます。
注意点
コンストラクタの定義をしない場合は?
定義上は、コンストラクタの存在しないクラスになっていますが、実は、 デフォルトコンストラクタが存在することになります。
例文
                              public class Sample{
                                  public Sample(){}//が省略されています 
                                  public void method() {
                                      System.out.println(“メソッド処理”);
                                  }
                              }
                          
例文
                              public class Sample{
                                  public Sample(){
                                  }
                                  public void method() {
                                      System.out.println(“メソッド処理”);
                                  }
                              }
                              引数があるコンストラクタ、またはコンストラクタに処理を定義する時は、
                              デフォルトコンストラクタはなくなってしまいます。
                              public class ConstructorSample {
                                  int num;
                                  public ConstructorSample(){}
                                  //↑はなくなる
                                  public ConstructorSample( int num ) {
                                  int型引数があるコンストラクタの定義
                                      this.num = num;
                                  }
                                  public void method() {
                                      System.out.println(“メソッド処理”);
                                  }
                              }
                          
 

インスタンス
インスタンスとは?
クラスは設計図のようなものでした。
この設計図を元に実体化したものをインスタンスと言います。

例えば、自転車の設計図があります。
これで自転車に乗ることができるでしょうか?
答えはNoです。あくまでも設計図であり、自転車ではないので乗ることはできません。
自転車に乗るには、自転車の実体(インスタンス)が必要になります。
1つの設計図から複数のオブジェクト(実体)を生成できる。
インスタンスの使用方法

構文
                              ①フィールドアクセス
                                インスタンス名.フィールド名
                              ②メソッド呼び出し
                                インスタンス名.メソッド名( 引数 )

                                  ※インスタンス名とは、インスタンスを格納している変数名のことです。
                                  フィールド使用方法
                          
例文1 フィールドの呼び出し
                              public class Field_01{
                                  private String str;
                                  public int num;
                                  public Field_01() {
                                      str = “フィールド”;
                                      num = 1;
                                  }
                              }
                          
                              public class FieldSample_01 {
                                  public static void main( String args[] ) {
                                      Field_01 sample = new Field_01();
                                      sample.str;
                                      //↑ここでエラーが発生
                                      sample.num;
                                  }
                              }
                          
例文2 メソッドの呼び出し(引数、戻り値がない場合)
                              public class Instance_02 {
                                  public void show() {
                                  public int num;
                                      System.out.println(“★”);
                                  }
                              }
                          
                              public class InstanceSample_02{
                                  public static void main( String args[] ){
                                      Instance_02 sample1 = new Instance_02();
                                      sample1.show();
                                  }
                              }
                          
例文3 メソッドの呼び出し(引数、戻り値がある場合)
                              public class Instance_03{
                                  public int plus( int a , int b ){
                                      int c = a + b;
                                      return c;
                                  }
                              }
                          
                              public class InstanceSample_03{
                                  public static void main( String args[] ){
                                      Field_01 sample = new Field_01();
                                      Instance_03 sample2 = new Instance_03();
                                      int sum = sample2.plus( 10 , 5 );
                                      //↑int型の戻り値を返すので、受け取る 
                                      System.out.println( sum );
                                  }
                              }
                          
クラスの用途
メインクラス
mainメソッドを持っていて、プログラムの最初に呼ばれるクラス。
Javaはメインメソッドを読み込んで実行します。
例文
                              //Main1はmainメソッドを持っています。ですから、「メインクラス」ということになります。
                              public class Main1 {
                                  public static void main( String[] args ) {
                                      Sample1 sample = new Sample1();
                                      sample.show();
                                  }
                              }
                          
                          /*
                          Sample1クラスはmainメソッドを持っていない、
                          ★を表示するshowメソッドを持ったクラスです。
                          ですから、「処理クラス」ということになります。
                          */
                          public class Sample1 {
                              public void show() {
                                  System.out.println( "★" );
                              }
                          
フィールド、メソッドの呼び出し方法

構文
                          自クラスのフィールドの呼び出し方法
                          this.フィールド名 ;
                          自クラスのメソッドの呼び出し方法
                          ■戻り値が無い場合
                          this.メソッド( 引数 ) ;
                          ■戻り値がある場合
                          戻り値の型 変数名 = this.メソッド( 引数 ) ;
                          他クラスのフィールドの呼び出し方法(アクセス修飾子がprivate以外)
                          インスタンス名.フィールド名 ;
                          他クラスのメソッドの呼び出し方法(アクセス修飾子がprivate以外)
                          ■戻り値が無い場合
                          インスタンス名.メソッド( 引数 ) ;
                          ■戻り値がある場合
                          戻り値の型 変数名 = インスタンス名.メソッド( 引数 ) ; 

                      
 

コマンドライン引数
コマンドライン引数とは?
この引数は、実行したクラスのメインメソッドの引数argsに渡ります。
argsはStringの配列です。
渡された値は、左から順に配列に格納されます。
今回の場合は、
“引数1” ⇒ args[0]
“引数2” ⇒ args[1]
となります。
例文
                              public class Sample {
                                  public static void main( String[] args ) {
                                      System.out.println(args[0]);
                                  }
                              }
                          
出力結果
引数1  
                          
要素数の取得方法
コマンドライン引数を使うことで、実行時に値を決められ、
再コンパイルなしに、いろいろなパターンを試すことができます。
ただ、その都度値の数も変わります。

mainメソッド実装時には、引数argsに何個の値が渡されるのかわかりません。
そこで、何個の値がわたってきているのか取得する方法があります。
配列の箱の数を「要素数」といいます。
構文
                              配列名.length 
                          
例文
例) int size = args.length;

これでargsの箱の数がint型で取得できます。
これはどの配列に対しても有効です。
int size = 配列変数.length;
で箱の数が取得できます。
                              public class Sample {
                                  public static void main( String[] args ) {
                                      // argsの中身を全て表示
                                      int size = args.length;
                                      for ( int i = 0; i < size; i++ ) {
                                          System.out.println( args[i] );
                                      }
                                  }
                              }
                          
String型の数字をint型の数字に変換する方法
コマンドライン引数に数字を渡して、足し算などの計算をさせたい場合、
通常のままだとコマンドライン引数はString型なので、計算をさせることが出来ません。
構文
                              int i = Integer.parseInt(String型) ; 
                          
例文
                              String numStr = args[0];
                              int i = Integer.parseInt(numStr); 
                          
 

メンバ変数とローカル変数
メンバ変数とは?
メンバ変数とは、クラスに直接宣言された変数のことです。つまりフィールドのことです。
例文
                              public class Human {
                                  /* 名前 */
                                  public String name;
                                  /* 年齢 */
                                  public int age;
                                  //↑この場合、メンバ変数はクラスに直接宣言されている「name」と「age」になります。
                                  public Human( String name , int age ) {
                                      this.name = name;
                                      this.age = age;
                                  }
                              }
                          
他のクラスからの変数の呼び出し

構文
                              インスタンス名.メンバ変数名 
                          
例文
                              ・Humanクラスから「name」に入っている値を取得する
                              public class MemberSample {
                                  public static void main( String[] args ) {
                                      // Humanクラスのインスタンス生成
                                      Human man = new Human("山田", 23);
                                      // メンバ変数nameを取得
                                      String name = man.name;
                                      System.out.println(name);
                                  }
                              }
                          
出力結果
山田  
                          
ローカル変数とは?

例文
                              public class Human {
                                  public Human( String name , int age ) {
                                      /* 名前 */
                                      String name;
                                      /* 年齢 */
                                      int age;
                                      //↑ここでのローカル変数は、コンストラクタ内に定義されている「name」と「age」になります。
                                      name = "名前";
                                      ge = 10;
                                  }
                              }
                                  ローカル変数はそのコンストラクタ、またはメソッド内でしか使用できません。
                          
 

命名規約
名前の付け方
クラス名、メソッド名
以前、変数名の命名規約で、
変数名をつける際には、名前に意味を持たせるようにしましょう!
と学びました。
クラス・メソッド名も同じように命名規約を用いるようにしましょう。

名前を見ただけで、「どんなクラスなのか?」「どんな処理をしているメソッドなのか?」
がわかるような名前をつけましょう。
例文(悪い例)
                              public class A{
                                  private String str1;
                                  private String str2;
                                  public void setStr1( String str ) {
                                      this.str1 = str ;
                                  }
                              }
                          
例文(良い例)
                              public class Car{
                                  private String name;
                                  private String color;
                                  public void setName( String name ) {
                                      this.name = name ;
                                  }
                              }
                          
良い例では、クラス名に「Car」という名前を付けているので、
車のクラスだというのが分かりやすくなっています。
一方、悪い例では全く同じ処理が記述してあるクラスではありますが,
クラス名が「A」となっており、何をするクラスなのか全く分かりません。
クラスを使用する時にとても不適切です。

メソッド名も同じです。良い例ではメソッド名を「setName()」としています。
それぞれ「車」に名前を設定し、色を設定する処理が記述されているのが、
とても分かりやすいですよね。

悪い例を見てみましょう。
「setStr1()」 
このメソッド名を見て、このメソッドは何を処理するメソッドなのかは分かりませんよね。
何かを設定するメソッドなのかな・・とは思えても何を設定するのか見当もつきません。

このように、クラス名メソッド名を判りやすく付けることにより、
自分でソースを読む時にも、誰かがこのクラス・メソッドを使う時にも
理解しやすくすることが可能になります!
クラス名
クラス名を付ける時は、最初の文字を大文字にするのが一般的なルールです。
                              public class Main {
                                  public static void main ( String[ ] args ) {
                                      System.out.println( "HelloJava" ) ;
                                  }
                              }
                          
                              //複数の単語をつなげる時は、単語の区切り文字も大文字にします。
                              public class ItemBean {
                                  private int id ;
                                  public void setId ( int id ) {
                                      this.id = id;
                                  }
                                  public int getId ( ){
                                      return this.id;
                                  }
                              }
                          
メソッド名
メソッド名を付ける時は、最初の文字を小文字にするのが一般的なルールです。また、メソッドは振る舞いを表すので動詞を使用します。
                              public class Car {
                                  private String name ;
                                  public void run( ) {
                                      System.out.println( this.name + "が走り出しました。" );
                                  }
                              }
                          
                              //複数の単語をつなげる時は、単語の区切り文字も大文字にします。
                              public class ItemBean {
                                  private String name ;
                                  private int id ;
                                  public void setId( int id ) {
                                      this.id = id ;
                                  }
                              }