• オブジェクトとは
• クラスの定義の仕方 more （コンストラクターほか）
• ３次元CG （空間における回転ほか）

　今回はやっと、Java の Java らしい一面である「オブジェクト」という概念について学ぶ。これは、BASIC, FORTRAN, C といった「手続き型」プログラミング言語や、LISP などの「関数型」プログラミング言語、あるいは Prolog などに代表される「論理型」プログラミング言語とは言語設計の思想がまったく異なる、「オブジェクト指向型」と総称されるプログラミング言語を特徴付ける本質的な一面である。
　オブジェクトというものの基本が理解できたら、すでに基本を学んだ「配列」と「文字列」についても、オブジェクトという観点から再度見なおしてみよう。これらはデータ型ではなく、オブジェクトの一種である（これらは、「参照型」という概念で統一される）。

　もっと詳しいことは ここの後半（§1.3） と ここ。

　オブジェクト指向プログラミング（object-oriented programming）では、プログラムが対象としようとしている世界に属す「もの」（＝オブジェクト、object）を中心に据えて、それらの特徴を記述することがプログラミングである。
　例えば、レストランという世界を考えよう。レストランでは個々の客、個々のウェイトレス、個々のコックなどがそれぞれオブジェクトであり、個々の客やウェイトレスやコックは誰も決められた一定の仕事（動作）をする（言い換えれば、それぞれに特徴的な独自の機能＝役割を持っている）。例えば、客は料理の注文をし、ウエイトレスは客からの注文をコックに伝えたり、調理が終った料理を客に出したりし、コックは料理を作る。このような機能（動作）のそれぞれを Java ではメソッド（method）という。
　一方、こういった仕事をするためにはいろいろな種類の道具や材料（コックは鍋や包丁など、ウエイトレスはメニューや注文伝票やＰＤＡなど）が必要であるし、個々のウエイトレスや個々の客や個々のコック（すなわち、個々のオブジェクト）を区別する名前や年齢、性別などの性質・特性（属性、attribute）を持っている。このような属性を保持するもの（変数）を Java ではフィールドという（他のオブジェクト指向言語ではデータメンバーとかメンバー変数とか、単にメンバーとか、スロットともいう）。

　こういったオブジェクトの属性・性質、すなわち、仕事・動作（機能・能力）や道具（情報・データ）をきちんと決めることによって、抽象的概念としての「客」とか「ウエイトレス」とか「コック」といったものを特徴付けることができる。 オブジェクト指向言語では、

• こういった抽象的なものをクラス（class）といい、各クラスに属す個々の「もの」をオブジェクトといい（そのクラスのインスタンス（instance、「具体例」の意）ともいう）、
• 各オブジェクトが行う動作・仕事・機能・操作をメソッド（method）といい、
• 特定のオブジェクトの特定のメソッドを実行して欲しいときにメソッドに渡すデータ・情報をメッセージ（message）という。 オブジェクト指向でないプログラミング言語ではメソッドのことを通常、関数といい、メッセージのことを関数の引数というのが普通である。
• フィールドとメソッドを総称してメンバーという（フィールドもメソッドもクラスを構成するメンバーであるから、そのように呼ばれる）。

　クラスは一種のテンプレート(template、雛形、鋳型)であると考えることもできる。 各クラスの具体的オブジェクトは、その鋳型を使って生成する。このようなことをインスタンス化(instantiation)という。

　Java のデータ型の基本についてはすでに学んだ：

　　基本型
　　　　論理型　　　　　　boolean
　　　　数値型
　　　　　　整数型　　　　byte, short, int, long

　　　　　　文字型　　　　char
　　　　　　浮動小数点型　float, double
　　参照型　　　　　　　　省略（ここを参照のこと）
　　null型　　　　　　　　同上

　Java をはじめとするオブジェクト指向型言語では、データ型という概念はもっと一般化されてクラスというものになり、個々のデータ型の値を取る '変数' という「もの」もオブジェクトという概念に一般化される。すなわち、オブジェクトは、変数のように単に一定のタイプのデータを保持できるというだけでなく、複数のタイプのデータを同時に持つことができるし、一定の機能（つまり、何らかの処理を実行できる能力）もいくつか併せ持っている。したがって、オブジェクトは単なる「変数」以上に一般的な「もの」であるが、抽象的な概念ではなく、具体的に存在する「もの」である。
例えば、文字列 "abc" や "uvwxyz" はそれぞれオブジェクトである。一方、文字列全体（あるいは別の言い方をすれば、文字列という概念）のことを Java では String クラスと言う。つまり、 "abc" や "uvwxyz" などの個々の文字列はどれも String クラスのオブジェクトである。このように、クラスは、ある一定のタイプのデータを保持できると同時に一定の機能を有したオブジェクト全体を呼ぶ呼称であり、そういったオブジェクトとは何かということを特徴付ける抽象的な概念である。

• 「オブジェクト」は、「変数」などの概念をより一般化したものであり、「クラス」は「データ型」という概念をより一般化したものである。変数などのデータの型を宣言する「データ型宣言」に対応することが、Java等のオブジェクト指向型言語では「オブジェクトの定義と生成」である：

  　　変数など（実体がある）　⇒　オブジェクト
  　　データ型（抽象的概念）　⇒　クラス
  　　データ型の宣言　        ⇒　オブジェクトの定義と生成  

• １つ１つのオブジェクトは固有の属性あるいはデータ格納箱(フィールド)と処理機能（メソッド）を持っており、個々のオブジェクトごとに保有する具体的データや機能の細部が異なり得るが、その枠組みは同一である。すべてのオブジェクトに共通のこの枠組みを規定しているものがクラスである。
• 例えば、レストランにはウェイターＡ、ウェイターＢ、・・・と大勢のウェイターがいるが、それぞれのウェイターは「ウェイターというクラス」のオブジェクトである。
• したがって、機能（注文を取る等のウェイターとしてやるべき仕事＝メソッドにあたる）はどのウェーターも同一であるが、使う道具の現状（記録内容）や名前や年齢など（＝属性）はウェイターごとに異なる。
• ウェーターという概念が、どういう道具を持ち、どういう仕事をやるかを決めることによって定まるのと同様に、Java では、クラスはフィールドとメソッド(いずれも複数あってよい)を定義することによって定められる。
• Javaのプログラムは、そういったクラスの定義の集まりである。

　我々はすでに前回見たように、Java アプリケーションにおける main 関数の引数としてや入出力の際に String クラスを使っている。String クラスは文字列を扱うクラスであり、

    java.lang    

    import java.lang.*;    

�@　String クラスのオブジェクトの宣言の仕方

　String はクラスであり、クラスはデータ型の一般化であるから、int 型の変数 n を

    int n;  

    String s;                 // �@

�A　String クラスのオブジェクトの初期化／生成の仕方

    String s;

    new演算子  

    s = new String("abcd");   // �A

    s = "abcd";               // �A’

�B　String クラスのオブジェクトの宣言と初期化・生成を同時に行なうには

　やはり配列の場合と同様に、宣言�@と初期化・生成�A（または�A’）を一緒にして

    String s = new String("abcd");   // �B

    String s = "abcd";               // �B’

● 文字列についての詳細は、「Javaの基本(9) オブジェクト超入門」 文字列 の項を参照のこと。 を参照のこと。

　これまで何度も述べてきたように、オブジェクト指向言語の観点から言うと、クラスは、なんらかの一定のまとまりのある "もの" がどんなものであるかを抽象化したもの（すなわち、概念を具体化したもの）である。
　一方、クラスは "データ型" の概念を一般化したものでもある。 データには文字（char）、整数（byte, int, long）、実数（float, double）、論理値（boolean）、参照（ポインタ）などのような基本的なものから、それらをもとにして定義される配列（同じ型のデータの集まり）や文字列（String, 文字の並び）のようなものだけに限らず、さらに複雑な構造のものがある。
例えば、型が異なるデータの集まり（一般に、そのようなものをレコード(record)と呼ぶ）は配列という概念を拡張したものであるし、スタック、キュー、リスト、木、グラフ、等々のいわゆるデータ構造(data structure)と呼ばれるものは、レコードという概念をさらに拡張したもの（データ構造＝データの集合＋その上の操作の集まり）であり、こういったものはすべて "データ型" という概念の一般化である（データ型という概念を抽象化したものなので、抽象的データ型(abstract data type)とも言う）。
一般に、レコードを構成する要素のことをフィールド(項目)と呼ぶが、クラスの構成要素の一つであるフィールドという名前（後述する）はここに由来する。

　クラスは、このように２つの側面（同じものを違う方向から見たもの）をもつ。

　一般に、クラスとはどう書くべきものなのかをここであらためて述べる。クラスの一般的な形は

    クラス修飾子 class クラス名 {
        フィールド宣言
        コンストラクタ宣言
        メソッド宣言
    }               

1. フィールドの宣言、コンストラクタの宣言、メソッドの宣言、の「宣言」は「定義」のことである。
2. フィールドの宣言、コンストラクタの宣言、メソッドの宣言を書く順序は任意である。ただし、この順序で書くことが多い（意味的に、そのようになることが多いため）。
3. フィールドの宣言、コンストラクタの宣言、メソッドの宣言はあってもなくてもよい。例えば、フィールド宣言しかなくてもよいし、どれもなくてもよい。
4. クラス修飾子は public, final, abstract のどれか（詳細は後述）。１つも付けなくてもよい（これまで作ったプログラム例では、修飾子は必ず public とした）。
5. フィールドの宣言の仕方と、メソッドの定義の仕方の基本はすでにやった通り。ただし、これらにも public, private, static, final などの修飾子を付けることがある（これまでは、すべてのメソッドに public を付けてきた）。その違いは以下で述べる。
6. コンストラクタ（constructor）は、その名の通り、このクラスのオブジェクトを生成する（作る＝construct）ためのメソッドである。書き方は以下で述べる。

　すでに学んだように、クラス修飾子は public, abstract, final のいずれか。修飾子は、クラス名の前に付けてクラスの性格の一端を指定するほか、フィールドやメソッドの前にも付けて同様にその性格の一端を指定する。
　修飾子の種類とそのおよその意味を次の表に示す。

　この中では、private, public, static, final だけわかれば十分である。 クラスのアクセス修飾子は public, abstract, final のいずれかだけである。

• アクセス修飾子 public をつけたクラスは、他のいかなるクラスにおいてもそのオブジェクトを生成して使うことができる。
• アクセス修飾子を指定しないクラスは、同一パッケージ内のクラス内でのみ有効である（つまり、それら以外のクラスからはアクセスしてオブジェクトを作ることができない）。同一パッケージに属することが明示的に宣言されていなくても、同じディレクトリに置いてあるクラスファイルは同じパッケージにあると考える。
• final を付けたクラスは、拡張することができない（そのクラスを継承して拡張することができない）。このことは今はわからなくてよい。
• abstract なクラスは中身がまだ定義されていないクラスであり、それを継承して具体化することができる。これについても今はわからなくてよい。

　フィールドの宣言は

      データ型　変数名 ;         (1) 変数の宣言    

      データ型[] 配列名 ;        (2) 配列の宣言    

      クラス名　変数名 ;         (3) クラス型変数の宣言    

      int   n = 123;
      float x = 45.67e-3;    

      double[] a = new double[10];
      int[]    b = int[]{1, 23, 456}; 
      char[]   c = {'a', 'b', 'c', 'd', 'e'};    

　３つ目の宣言

　　　　　　クラス名　変数名；  

　(1)や(3)のような、フィールドの１つとして宣言される変数（例えば x とする）は、オブジェクト（＝インスタンス。例えば Obj とする）を生成するとそのオブジェクトのフィールドとして Obj . x のように使うことができる（ただし、異なるオブジェクト同士では異なる変数である。つまり、Obj1, Obj2 が同じクラスのオブジェクトであっても Obj1.x と Obj2.x は異なるものである）ので、インスタンス変数とも言う（後述のクラス変数と比べよ）。

　上のような宣言の書き方は、変数のデータ型宣言と同じ書き方であることに注意したい（すでに述べたように、クラスはデータ型という概念を拡張した概念である）。

　オブジェクトを指す変数を宣言しても、その変数は具体的な（＝実体のある）オブジェクトを指しているわけではない。具体的なオブジェクトを生成することによって、その変数は初めて実体をもつ。

　オブジェクト（＝インスタンス）の生成の仕方

　オブジェクトの生成はインスタンス化ともいい、次のように書く：

　　　　変数名　＝　ｎｅｗ クラス名 (); 

• どのフィールドも同じクラス内のメソッドから自由にアクセスできる（値を参照したり、値を変更したりできる）のは当然であるが、
• public を付けたフィールドは、クラス修飾子の public と同様に、他のいかなるクラスからもアクセスできる。
• private を付けたフィールドはそのクラス内でのみ有効である（他のクラスからはアクセスできない）。
• public も private も付けないフィールド同じパッケージ内だけで有効である。
• final は変数、メソッド、あるいはクラスを修飾することができ、簡単に言うと、それらの「修正を禁止」する。フィールドの場合、final を付けると値を変更することができない。すなわち、定数として扱いたいときに final を付ける。ただし、初期値を与えておくことが必要（そうしないと、値が定まらないままになってしまう）。
• 修飾子は複数つけることもある。例えば、public で final な場合、

        public final int PI = 3.141592;  

  のように書く。

　メソッドの一般的な形は

      修飾子 結果型 メソッド名 ( 型 仮引数 , ... , 型 仮引数 )　ブロック	  

• 「修飾子」としては public, private, protected, abstract, static, final, synchronized, native のうちのいくつかを 0 個以上書く。
• 同じクラス内では、どのメソッドも互いに他を呼び出す（アクセスする）ことができるのは当然であるが、
• public なメソッドは他のクラスからも呼び出すことができる（ただし、呼び出すときには、クラス名を　クラス名 ．メソッド名　という形で指定しなければならない。そういうことをしない限りは、同じメソッド名を違うクラス内で使ってもよい）。
• private を付けたメソッドはそのクラス内でのみ有効である（他のクラスからはアクセスできない）。
• public も private も付けないメソッドは同じパッケージ内だけで有効である。同一パッケージに属することが明示的に宣言されていなくても、同じディレクトリに置いてあるクラスファイルは同じパッケージにあると考える。
• static が付いているかいないかでメソッドの使い方が異なる。
  static が付いたメソッド（クラスメソッド）は

        クラス名 ．メソッド名(実引数) 

  のように使う（同一クラス内のメソッドの場合には「クラス名 ．」の部分は省略してもよい、というか普通は書かない）が、
  static でないメソッド（インスタンスメソッド）は

        オブジェクト名 ．メソッド名(実引数) 

  のように、オブジェクトを生成してから、そのオブジェクトのメソッドとして使わなければならない。このことは後述する。
• 「結果型」には、メソッドが値として返すデータの型を書く。値を返さないメソッドの場合には void と書く。
• 仮引数（かりひきすう、formal argument）：メソッドを定義する際には、パラメータとして外部（そのメソッドを呼び出したもの）から渡されるデータを受け取るために変数や配列などを用意しておく（0 個以上）。メソッドを呼び出すときに具体的な値（実引数という）をこれらのパラメータに与えると、それらが仮引数にコピーされる。ブロック内では仮引数を使って処理を記述する。
  各引数ごとに、そのデータ型を宣言しておく必要がある。
• 「ブロック」（複合文）は ｛ で始まり ｝ で終わる中に、ステートメント（文）を書く。

(1)
    public static int sum ( int[] a, int first, int last ) {
        int s = 0;	
	for (int i=first; i<last; i++) {
            s += a[i];
        }
        return s;
    } 

(2)
    public static void nothing() { }  // 何もしない

(3) 
    private static int floor(double x) { 

    // double 型の変数（の値）を int 型 へ変換(整数化)するメソッド
       return (int)x;
    } 

(4) 
    static double power(double x, int n) { 
    // xn を計算して返すメソッド
        double p = 1.0;
        for (int i=0; i<n; i++)
            p *= x;
        return p;
    } 

(4)
    public static void printArray(int[] a) { 
    // 引数は配列、値を返さない
        for (int i=0; i<a.length; i++) {
            System.out.print(a[i] + " ");
        }
    } 

　コンストラクタはオブジェクトを初期化するための特別なメソッドである。

• コンストラクタは１つのクラスの中に複数あってもよい（オーバーロードという。後述）。
• オブジェクトを生成する際に、どのコンストラクタを呼び出すか（それは、コンストラクタの引数の個数や型で判別できる）によって、生成されるオブジェクトの初期化の仕方を変えることができる。
• クラスの中にコンストラクタが１つも宣言されていないと、引数なしのコンストラクタがデフォールトで用意される。このようなプログラム例は、これまでにいくつも示した。
• コンストラクタは必ずクラス名と同じ名前とし、戻り値の宣言はしない。この点だけが他のメソッドの宣言と異なる。
• new 演算子によってオブジェクトが生成される際、コンストラクタが呼び出され、オブジェクトのフィールドに初期値が代入される。

　　　クラスメソッド (class method)
　　　インスタンスメソッド (instance method)  

1. クラスメソッドは、修飾子 static を付けて定義されるメソッドのことである。
2. このタイプのメソッドはクラス定義だけに直接関係付けられ（クラスから生成されるオブジェクトには反映されない）、クラス名を指定するだけで呼び出して使うことができる（同一のクラス内であれば、クラス名の指定はいらない）。
3. それに対し、インスタンスメソッドは、修飾子 static を付けずに定義されるメソッドであり、
4. このタイプのメソッドは、クラスのインスタンス（すなわち、オブジェクト）を生成することによって、そのインスタンスの中のメソッドとして初めて実体が存在するようになり、そのインスタンスを介してだけ使うことができる。
5. クラスメソッドがインスタンスメソッドを参照することはできない（非 static なメソッドはその時点ではまだ存在していないから）。

クラス型変数の宣言：

　　クラス名　変数名；  

オブジェクトの生成：

　　クラス名　変数名　＝　ｎｅｗ クラス名 (コンストラクタへの実引数); 

（例）　メソッドのタイプ別利用法

(1) 同じクラス内のクラスメソッドを呼び出す例

    public class ex1 {
        // クラス ex1 内のクラスメソッド main
        public static void main(String[] args) {
            int n = 123;
            int sum = add(n, 45);  // クラスメソッド add の呼び出し
            // add と main は同じクラス内なので、クラス名を付けなくてもよい

            System.out.println(n + "+45 = " + sum);
        }

        // クラス ex1 内のクラスメソッド add
        public static int add(int x, int y) {
            return x+y;
        }
    }

(2) 他のクラスのクラスメソッド(String クラスのメソッド valueOf)を呼び出す例

    import java.lang.*;  // String クラスの定義はこのパッケージ内にある
    //（ただし、この import は不要）
    public class ex2 {
        public static void main(String[] args) {
            String str;
            str = String.valueOf(123);
            System.out.println(str); 
        }
    } 

(3) 他のクラスのインスタンスメソッド(String クラスのメソッド toUpperCase)を呼び出す例

    public class ex3 {
        public static void main(String[] args) {
            String str, STR;
            // String クラスのオブジェクト str と STR を生成する

            str = new String("komoji"); 	
            // まとめて、String str = new String("komoji"); でもよい
            // String str = "komoji"; でもよい
            STR = str.toUpperCase();
            System.out.println(STR);  // KOMOJI と出力される 
        }
    }

(4) クラスメソッド・インスタンスメソッドを定義して使う例

    public class EX4_1 {
        EX4_1 { }  // これは、このクラスのコンストラクタであるが
                   // この例のように「何も定義しない」コンストラクタは
                   // 書かずに省略してもよい

        public int DOUBLE(int x) {         // インスタンスメソッド
            return 2*x;
        }

        public static int TRIPLE(int x) {  // クラスメソッド
            return 3*x;
        }
    }

    public class EX4_2 {
        public static void main(String[] args) {
            EX4_1 xx; 
            xx = new EX4_1();						
            EX4_1 xxx = new EX4_1();  // オブジェクト xxx の生成

            int n = xx.DOUBLE(123);   // オブジェクト xx のメソッドDOUBLE
            int m= xxx.DOUBLE(321);   
            System.out.println(EX4_1.TRIPLE(n)); 
               // クラス EX4_1 のクラスメソッド TRIPLE を呼び出している
        }
    }

(5) オブジェクトを生成して使う例（ソーティング）

  ソーティングを行なうアルゴリズムを３つ定義したクラス SORTER を考えよう（ソースコードは ここ）。
  この例では、コンストラクタは無い（コンストラクタのある例は次回考える）。

課題１３でやること

１．課題１３のためのディレクトリ

    ~/public_html/infomath6/

２．今回やること

　前回、チューリップを描いたときに、後ろに位置するチューリップをそれより手前に位置するチューリップよりも後で描くと（それらが重なる場合には後ろのチューリップが手前のチューリップを上書きするという変なことが生じる（この例 では、花の間隔が大きいので、そのようなことは最初の１個所でしか起こっていない）。これをなくすためには、チューリップの根の位置の y 座標をソートして、y 座標が大きいものを先に描くようにするとよい。上記の SORTER クラスのソーティングメソッドを使ってこれを行なってみよう (「回転なし」の ソースコード１ または ソースコード２ を使うとよい)。
　完成した Java のソースファイルを task13.java とし、それを表示する html ファイルを task13.html とし、ディレクトリ ~/public_html/infomath6/ に置くこと。

３．プラスα

　今回のプラスαは、３次元ＣＧに関することのうち、３次元空間内における回転についてである。
　次の左側のたんぽぽの花は正面を向いているものであるが、多くの場合、右側のたんぽぽのように上向きになっているであろう。この右側のようなたんぽぽを描くためには、x 軸の周りに回転させることが必要になる。

　x 軸の周り（あるいは、y 軸の周り）に theta ラジアン回転させたときの座標変換は次の式で与えられる（x, y, z は旧座標。theta は回転角度（単位はラジアン））。

    3次元CGで x 軸の回りに theta ラジアン回転させたとき

    新 x 座標
       x

    新 y 座標
       y*Math.cos(theta)+z*Math.sin(theta)

    新 z 座標
       -y*Math.sin(theta)+z*Math.cos(theta)

    3次元CGで y 軸の回りに theta ラジアン回転させたとき

    新 x 座標
       x*Math.cos(theta)-z*Math.sin(theta)

    新 y 座標
       y

    新 z 座標
       x*Math.sin(theta)+z*Math.cos(theta)

    3次元CGで z 軸の回りに theta ラジアン回転させたとき

    新 x 座標
       x*Math.cos(theta)+y*Math.sin(theta)

    新 y 座標
       -x*Math.sin(theta)+y*Math.cos(theta)

    新 z 座標
       z

で与えられる。
　もっと一般の場合（任意の直線周りの回転）は、平行移動と２次元の回転の組合わせで表現できる。 　たんぽぽの花 の ソースコード を与えるので、これを基にして x 軸の周りに回転させたもの を描いてみよ。
上記の回転のための座標変換を与えるメソッドは graphics クラスに組み込んでおいたので、~moriya/graphics.java をコンパイルして使うこと。メソッド名と引数は以下の通り（x, y, z は旧座標。theta は回転角度（単位はラジアンではなく「度」））：

    x 軸の回りに theta 度回転
        新 x 座標： Rotate3X_x(double x, double y, double z, double theta)
        新 y 座標： Rotate3X_y(double x, double y, double z, double theta)
        新 z 座標： Rotate3X_z(double x, double y, double z, double theta)

    y 軸の回りに theta 度回転
        新 x 座標： Rotate3Y_x(double x, double y, double z, double theta)
        新 y 座標： Rotate3Y_y(double x, double y, double z, double theta)
        新 z 座標： Rotate3Y_z(double x, double y, double z, double theta)

    z 軸の回りに theta 度回転
        新 x 座標： Rotate3Z_x(double x, double y, double z, double theta)
        新 y 座標： Rotate3Z_y(double x, double y, double z, double theta)
        新 z 座標： Rotate3Z_z(double x, double y, double z, double theta)