2015/11/15~21 時点での本文

1. Object-Oriented Overview
●Learn
Java is an object-oriented programming (OOP) language, 
which means that we can design classes, objects, and 
methods that can perform certain actions. These behaviors 
are important in the construction of larger, more powerful 
Java programs.
	・・・
In this lesson, we will explore some fundamental concepts 
of object-oriented programming to take advantage of the 
power of OOP in Java. 
Java は、
 オブジェクト指向プログラミング(object-oriented programming)
の、言語です。
それはどういうことを意味するのか!
 ・クラス/class(種類・分類) と言う設計図を利用する。
 ・クラスを基にして、データを作る(⇔ プリミティブデータ)。
  それが、オブジェクト(object)。
 ・クラスに結び付けられた関数、すなわち メソッド(method)を持ち、
  クラスを基に作られたデータ/オブジェクト から呼び出す。
そして、関数プログラミングと違うところは、
 クラス/オブジェクト 関係の中で、プログラムが、動く
ことです。 世界が、人間同士の関係で成り立っているように。
前のチャプターで習った、例題プログラムは、
クラス/オブジェクト 同士の、関わりが、全くありませんので、
実は、Javaプログラムではあっても、オブジェクト指向プログラムではなく、
関数型プログラムと言えます。
(しいて言えば、Systemクラス を使っていますが、
 しかし、こういうのは、JavaScriptにもありますし、、
 まあ、オブジェクト指向らしくないと言ったほうがより正確ではありますが)
そして、大きく、複雑でクールなアクションを、 実行するプログラムにおいて、
クラスによって、整理整頓されていることが、
難しくなりがちなプログラムのアクションを、
より明快に、理解することが出来るようにしてくれます。
	・・・
この第3チャプターでは、Javaのオブジェクト指向の恩恵を得られる
ために、その基本を学んでいきます。Instructions
1.
Check out the code in the editor. It incorporates classes, 
objects, and methods. After this lesson, you'll be able to 
read and write Java programs that use the OOP model.
Click Run to run the code.
真ん中の、エディタウィンドウの左下にある、Run をクリックしましょう。
Javaの、クラス/class、オブジェクト、メソッド を、使ったプログラムの
アクションが、実行されます。
* ネズミ目(動物の種類・分類/Rodentia)クラス を、
継承 (extends/受け継ぐこと) して、ネズミクラス を、作っています。
そうすると、動物の分類で、ネズミより大きな分類に入る ネズミ目 
すべてが持つ、特徴を、ネズミクラスも受け継ぐことが出来ます。
そして、ネズミクラスから、ネズミクラスだけが持つ メソッド/アクション を、
実行できるのはもちろんですが、ネズミが持つメソッドも、extendsした
ことによって、そのネズミ目の メソッド/アクション も実行できるように
なっていることを示しているのが、このサンプルプログラムです。




[Next]
2. Classes: Syntax(クラスの作り方:#1)
●Learn
One fundamental concept of object-oriented programming 
in Java is the class.
Javaのオブジェクト指向のベースになっているものは、これです!
 クラスclass)
Javaは、クラスの集まりなのです!

A class is a set of instructions that describe how a data 
structure should behave.
クラス は、データやアクション(オブジェクトに結び付けられた関数) を、
その中に持っています。
それは、オブジェクト(タイプのデータ)の設計図と言えます。

Java provides us with its own set of pre-defined classes, 
but we are also free to create our own custom classes.
Javaプログラム自身は、最初から用意されているクラス を、持っています。
でも、私たちは、ニーズに応じて自ら設計することも出来ます。

Classes in Java are created as follows:
//Create a custom Car class
class Car {
}
The example above creates a class named Car. We will 
define the behavior of the Car data structure in the next 
exercise.
class Car {
}
上のコードは、
 Car
と名付けられた、
class/クラス
(キーワード なので、これからは、class と言う英語も使っていきます。
キーワード は、決められた目的以外では使えません!
つまり、メソッドの名前などに、class は、使えないと言うことです。)
です。
次からの、レッスンでは、Carクラス に、データやアクション(メソッド)を、
追加して、私たち、独自の、Carクラスを作っていきましょう。Instructions
1.
In the code editor, create a Dog class. Use the example 
above to help you. For now, you can ignore the line(s) of 
code at the bottom. We will return to it later in this lesson.
説明文に出てきた、Carクラス の作り方を参考にして、
右の、エディターに書き加えて、
	Dog
という、class を、作ってください。
今は、まだ、
	public static void main(String[] args) {
	}
のところは、ないものと考えてかまいません。
その部分は、あとから学びます。




[Next]
3. Classes: Constructors(コンストラクタ とは?)
●Learn
We're off to a good start! We created a Java class, but it 
currently does not do anything; we need to describe the 
behavior of the class for it to be useful.
よく出来ました、、Javaクラス作成成功です。
でも、この class は、何もしません!
ということで、この class に、何か仕事をしてもらいましょう。

Let's start by creating the starting state of our class. We 
can do this by adding a class constructor to it.
1.
A class constructor will allow us to create Dog instances. 
With a class constructor, we can set some information 
about the Dog.
2.
If we do not create a class constructor, Java provides one 
that does not allow you to set initial information.
まず、この Dogクラス を、設計図として、
データを作った場合(それが オブジェクト)、
最初に設定される値(初期値)を、決める方法を学びましょう。
それには、この Dogクラス の中に、
 コンストラクタ(constructor)
を、書くことで、実現できます。
1.
class にある コンストラクタ は、Dogクラス を、設計図とした、
実際の データ/値 を、作ります。
(これを、インスタンス{instance/具体的な例} と言います。
class を基に作られた、実物データのひとつの例 ということです。)
そして、その コンストラクタ に、いくつかデータを与えておくことによって、
実際の データ/情報 を持った、インスタンス(オブジェクト) を、
作ることが出来ます。例えば、そのDogの(具体的な犬の)
毛色 や しっぽの形 などを、特定できるわけです。
2.
もし、コンストラクタのコード を、書かなければ、
Javaは、あなたが設定したい値 と関係なく、
デフォルト値 を、与えて、インスタンス化します。
インスタンス化 を、言い換えると、オブジェクトを作る、
と言うことになります。 
* [参考]
コンストラクタ を書かなかった場合、
Java は、デフォルト値 を与えて、インスタンスを作る
というのは、自分で調べて、説明文に書き加えたのですが、
例えば、intタイプ のデータの場合、初期値を決定していない
場合は、「0」 が、デフォルト値になります。
しかし、初期値を与えていたら、もちろんその値で、
初期化/インスタンス化 されなければ、プログラマーとしては、
ちょっと、こんな仕様では、やってられまへん ということになると
思うので、初期値を与えていたら、そうなるに決まっているとは、
思いましたが、一応、実験してみました。
IDEである「IntelliJ IDEA」で、実験した結果を、
貼り付けると、
	・・・ ここから、コード ・・・
/**
 * Created by alarky on 2015/11/15.
 */
public class ConstructorTest_1 {
    int constructorInt;
        // int のデフォルト値は、0.
    int clearData = 2;
}

class Go {
    public static void main(String[] args) {
        ConstructorTest_1 test1= new ConstructorTest_1();
        System.out.println(test1.constructorInt);
        System.out.println(test1.clearData);
    }
}
	・・・ ここまで ・・・

	・・・ ここから、結果 ・・・
% java Go(IntelliJのコピペは長いので変更)
0
2
Process finished with exit code 0
	・・・ ここまで ・・・
ということで、やはり、class の段階で、初期値を与えておくと、
その値で、インスタンス化 されたわけです。
少し慣れてきたら、こんな風に、実験してみると、
100%の解を得られるわけではありませんが、
なぜなら、素人実験なので、実験自体に問題がある場合も
ありえるからなのですが、まず、90%以上の確信は、得られるでしょう。
この部分は、まだコードを読めない時点では、分からないと思いますが、
なんとなく分かる人もいるでしょう。でもこの程度のコードなら、
Codecademy's Java を、終えるころには、分かるはずです。 

The code below demonstrates how a class constructor is 
created:
class Car {

    //The class constructor for the Car class
    public Car() {

    }
}
In the example above, we created a class constructor for 
the Car class. This constructor will be used when we create 
Car instances later. The public keyword will be explained 
later in this course.
下のコードは、コンストラクタ の書き方を示したものです。
class Car {
    // 下の2行が、コンストラクタ のコード.
    public Car() {
    }
}
この例では、Carクラスの コンストラクタを書く例になっています。
また、この例では、何も設定しないコンストラクタなので、
書かないのと同じでは、ありますが、この中に、
Carクラス のインスタンス を、作るときに、
例えば、車の色、どんな形、燃費、カーナビつき
などを設定して、実例/インスタンス を、作るように出来るわけです。
また、publicキーワード については、
このチャプターで、後からお話します。 Instructions
1.
Add a class constructor called Dog to the class.
右のエディタに、Dogクラス の、コンストラクタ を、書いてください。
	・・・ 以下のコードは、無視してください ・・・
public static void main(String[] args) {
 
	}
	・・・ ここまで ・・・ 
* もし、正解できなかったら、本文のコードの、Car を、Dog に書き換えて、
貼り付けてみましょう。
何を書き忘れているか、分かります。
わたしも、簡単!簡単!と、思って書いたら、書き忘れていました。 




[Next]
4. Classes: Instance Variables(インスタンス変数)
●Learn
When we create a new class, we probably have specific 
details that we want the class to include. We save those 
specific details into instance variables.
私たちが、何か新たに class を作ろうとする時、その中に、
 含めたいこと
が、出てくるでしょう。
例えば、あなたが、Imomushiクラス(いも虫class)を作ろうとした場合、
 足の数
 だけはなんとしても含めたい!
と思うかもしれませんね。
そんなときは、
 int imomushiNoAshi;
というコードを書きます。
そして、この、
 imomushiNoAshi(芋虫の足)
のことを、
 インスタンス変数(instance variable)
と言います。
* いも虫に関しては、ここに書かれていることの具体例があったほうが、
いいかなと思って書き加えたのですが、まあ、後から具体例は出てくるので、
余分だったかもしれません。
上に書いたことをコードにするとこうなります:
class Imomushi{
	int imomushiNoAshi;
}
でも、英語の、instance variable は、
もうその言葉だけで、ニュアンスが伝わってきますが、
日本語に訳された、「インスタンス変数」は、
何じゃらほいって、感じなので、やっぱり、実例があったほうがいいと、
思うのです。 

Here is an instance variable in the Car class that describes 
a detail that we might want to associate with a car:
class Car {

    //Using instance variables to model our Car class after a 
    //real-life car
    int modelYear;

    public Car() {

    }
}
In the example above, we created the instance variable 
named modelYear. Instance variables model real-world car 
attributes, such as the model year of a car. Finally, the 
instance variable is represented by the int data type.
下のコードの例は、私たちが、カーclass を作る時、
含めておくべきだろうなあ、と考えられる、
 インスタンス変数
です。
class Car {

    // 実際の車にちなんで、何年モデルの車なのか?
    // を、インスタンス変数 にする.
    int modelYear;

    public Car() {
    
    }

}
インスタンス変数 が、どれか分かりますか?
 modelYear
が、それに当たります。
そして、このインスタンス変数 に、使うべき、タイプ/型 は、
何でしょう?
そうです、数値をデータにしたいですね。
ですから、今まで習った、int, boolean, char の中では、
 int
が、一番適切でしょう。ということで、
 int modelYear;
と、インスタンス変数 を、宣言 しました。 Instructions
1.
Let's model the Dog class after a real-world dog. Create an 
int instance variable called age.
では、「本物の犬(現実世界の犬)」を、真似た、Dogクラス に、
して見ましょう。
インスタンス変数、
 age(年齢)
を、宣言してください。
変数のタイプは、数値ですね。
つまり、本文のコード、
 int modelYear;
を、真似れば、OKです。




[Next]
5. Classes: Constructor Parameters
(コンストラクタのパラメータ)
●Learn
Perfect! By adding a class constructor and creating 
instance variables, we will soon be able to use the Dog 
class. However, the class constructor Dog is still empty. 
Let's modify this by adding parameters to the Dog 
constructor.
Perfect!、コンストラクタ と インスタンス変数 を、class に加えました。
私たちが、Dogクラス を、使えるようになるのは、もう目の前です。
ですが、右のエディタ のとおり、コンストラクタには、
何も書かれていませんね。
パラメータ(parameter)を、書き加えて、
あなたが、Dogオブジェクト(インスタンス) を、作る時、
年齢、体重、毛色、シッポの形 などを決められるようにしましょう。

You can think of parameters like options at an ice cream 
store. You can choose to order a traditional ice cream cone, 
but other times you may want to specify the size of the 
cone or the flavor of the ice cream.
パラメータ とは、アイスクリームショップ の、オプション のようなものと、
考えてください。
ショップでは、もちろん、まあ、標準的なアイスクリームも選べますが、
もっと大きなコーンにしてみたり、いつもと違った味のものを、
食べたくなるかもしれませんね。

For the Dog class, we can specify the initial dog age by 
adding parameters to the class constructor.
1.
Parameters allow data types to be created with specified 
attributes.
コンストラクタ に、パラメータ を追加することによって、
Dogオブジェクト を作った時、そのDogの、年齢を決めてあげられます。
1.
パラメータ は、いろいろなデータ型に、その 値 を設定することが出来ます。
この場合でしたら、int型 の、変数age に、あなたの好きな、整数値を、
セットすることができるのです。

Let's add parameters to our Car class constructor:
class Car {

    //Use instance variables to model our Car class after a 
    //real-life car
    int modelYear;

    public Car(int year) {

        modelYear = year;
    }
}
In the example above, we add the int parameter year to 
the Car constructor.
	・・・
The value of modelYear will equal the int value that is 
specified when we first use this class constructor.
では、実際に、私たちの Carクラス の コンストラクタ に、
 パラメータ
を、付けてみましょう。
class Car {
    // 本物の車のような感じにするために、
    //私たちの、Carオブジェクトのための、インスタンス変数を宣言します.
    int modelYear;

    public Car(int year) {

        modelYear = year;
    }
}
上のコードでは、
 コンストラクタ
  public Car(){ }
に、
 int 型 の
 パラメータ変数 year
を、追加して、
  public Car(int year) {
    modelYear = year;
  }
と、しました。
	・・・
インスタンス変数modelYear の 値 は、私たちが、この コンストラクタ を、
を使って、オブジェクト を作るときに指定する int型 の、値、、
ということになります。 Instructions
1.
Add an int parameter called dogsAge in between the 
parentheses of the Dog() constructor.
コンストラクタ、
  Dog() { }
の、
 () の中
に、
 int型 の、変数 dogsAge
を、パラメータ として追加してください。 

2.
Inside of the constructor block, set the instance variable 
age equal to the dogsAge parameter
コンストラクタ、
  Dog() { }
の、
 { } の中
で、
 インスタンス変数age
が、
 パラメータdogsAge の 値
に、なるように、セットしましょう。

* やり方は、説明に出てくる
class Car {
  // ここに書かれていること!
}
を、真似るだけです。 




[Next]
6. The main Method(main()メソッドについて)
●Learn
We're almost ready to use our custom Dog class! But first, 
we need to understand how to structure and run our Java 
program.
もう、私たちの特別素敵な?Dogクラスは、
ほとんど使えるところまで、出来ています。
でも、その前に、右のエディタにある コード全体の仕組みについて、
知る必要があります。
それで、あなたは、どうやって、Javaプログラムが、動き始めるのかを、
知ることが出来ます。 

You may have noticed a mysterious looking line of code in 
previous lessons that looks like this:
public static void main(String[] args) {

}
This is Java's built-in main method. We will learn more 
about methods and keywords around the main method 
later on, but first let's understand what the purpose of 
main is.
1.
When Java runs your program, the code inside of the main 
method is executed.
	・・・
For now, you can ignore the keywords in the main method 
that we have not yet covered. You will learn about them 
later in the course.
あなたは、ずっと、こんな怪しげなコード を、見てきたと思います。
public static void main(String[] args) {

}
これは、Javaプログラムが、最初からもっている
 mainメソッド
  // よく、main() のように書きます.
と言うものです。
この メソッド 全体については、後から学ぶことにして、
まず、
 この、main()メソッド の、存在理由は?
何なのでしょう?
1.
Javaプログラムが動くときは、
 まず、つまり、最初に、
 main()メソッドの
 {  } の中
から、実行されます。
	・・・
今のところは、main()メソッド の中にある、
キーワード については、まだ説明していませんので、
気にしないでください。
後で、説明します。 
* アプレットは、main()ではなく、
ブラウザが呼ぶ、コールバックシステム
というもので、
 init()メソッド
から、始まります。
もし、あれっ、と思ったら、こんな例外も
あるということで、納得してください。 
でも、最近は、アプレット人気のことを考えると、
必要ない知識かなあ~?Instructions
1.
Your Dog class already has a main method. It should look 
like the following:
public static void main(String[] args) {

}
Do not include anything inside of the main method yet. 
Click Run to continue.
右の、Dogクラス は、すでに、こんな、main()メソッド を、持っていますね。
public static void main(String[] args) {

}
では、まだ、この、main()メソッドの、{  } の中 には、何も書かないで、
エディタの、左下の、Run を、クリックして、次のレッスンに進みましょう。




[Next]
7. Objects(オブジェクト)
●Learn
Perfect! Now that we have a main method in our class, 
we're ready to start using the Dog class.
Perfect!、さて、私たちの Dogクラス には、main()メソッド が、
ありますから、いつでも、準備OKです。

To use the Dog class, we must create an instance of the 
Dog class. An instance of a class is known as an object in 
Java.
でも、
 Dogクラスを利用するためには
、、
 オブジェクト
を、
 作らなくてはいけないのです。
それは、
 インスタンス
とも言いますが、「実際の例」という意味の言葉です。
すなわち、Dogクラスを、設計図とした、Dogオブジェクト を、
作るわけです。
では、インスタンス と、オブジェクト は、どう違うのですか?と、
聞かれそうですが、それは、同じなのですが、
文章の中で使うとき、Dogインスタンス という言葉には、
Dogクラス を設計図とした... という感じがしますし、
Dogオブジェクト というと、そのデータで、
何かアクションを... という感じがすると思います。

The example below demonstrates how to create a Car 
object:
class Car {

    int modelYear;

    public Car(int year) {

        modelYear = year;

    }

    public static void main(String[] args){

        Car myFastCar = new Car(2007);

    }
}
In the example above, we create a Car object named 
myFastCar. When creating myFastCar, we used the class 
constructor and specified a value for the required int 
parameter year.
	・・・
2007 is the model year of myFastCar. Note that we 
declared the new object inside the main method.
この例は、Carオブジェクト を、作っているコードです。
class Car {

    int modelYear;

    public Car(int year) {

        modelYear = year;

    }

    public static void main(String[] args){

        Car myFastCar = new Car(2007);
          // myFastCar - 私の速い車
    }
}
myFastCar というのが、オブジェクトになります。
そして、
  Car myFastCar = new Car(2007);
というコードを見て分かるように、
コンストラクタ
  public Car(int year) { コード; }
を、使っていますね。
(public は、アクセスを制限するためのもので、
 まだ、気にしないでください。
 一番緩い制限が、public ですが、
 詳細は、覚えていません、、悪しからず.)
そして、int型 の、パラメータ として、
特定の値、すなわち、整数値 を、書いておく必要が、
あります、、ここでは、2007 に、なっています。*1
つまり、myFastCarオブジェクト は、2007年モデル の、
オブジェクトとして、作られるわけです。
特に、ここでのポイントは、
 ・Car myFastCar = new Car(2007);
  // この、構文.
  // クラス名 オブジェクト名 = new クラス名(パラメータ);
   // new クラス名(パラメータ);
   // … コンストラクタの実行を意味しています
 ・main()メソッドの中に、この文がある。
  // つまり、Javaプログラムは、ここから始まるわけです.
*1 以前のレッスンで、
  コンストラクタを作らなかった場合、
  パラメータ無し の、コンストラクタが、
  自動で、実行される.
という話をしましたが、
このように、パラメータ ありの、コンストラクタを書いた場合、
必ず、オブジェクトを、作るときに、パラメータ が、必要になります。
もし、パラメータ が無い、コンストラクタ が必要であれば、
新たに、パラメータ 無し の、コンストラクタ も、書きましょう。 Instructions
1.
Inside of main, use the Dog constructor to create a Dog 
object and assign it to the variable spike. Make sure that 
you specify the required int parameter age.
main()メソッド の中に、Dog()コンストラクタ を、使って、
Dogオブジェクト を作ってください。
そして、Dogオブジェクト型変数 として、spike という名前にして、
その Dogオブジェクト を、保存してください(代入/セット してください)。
* 変数spike は、オブジェクト ということになり、
タイプ/型 としては、Dog型 と言うことになります。
その時、Dogオブジェクト の、インスタンス変数age を、
設定するための、パラメータ として、
 (  )
の中に、int型、パラメータ、dogsAge に、値 を、設定することを、
忘れないでください。
* 正解するためには、本文のコードをよく見て、上手く真似ることです!




[Next]
8. Methods: I(メソッド #1)
●Learn
Great work! We created a Dog object inside of the main 
method, but...nothing happened.
	・・・
Although we created an object inside of main method, we 
did not print out anything about the spike object itself, nor 
did we instruct the class to perform any actions. Let's learn 
about how methods in Java are used to define actions.
Great ワーク!、前回では、main()メソッド の中に、
Dogオブジェクト を、作りました。
でも、何が変わったと言うのですか?
	・・・
私たちは、main()メソッド の中に、Dogオブジェクトを作ったのですが、
ですが、コンソールウィンドウ(右のウィンドウ)に、
Dogオブジェクトspike について、
プリントアウトする指示も、何かのアクションの指示もしていなかったのでした。
ということで、これから、
 Javaでは、アクションを定義するために、どのように、
 メソッド(method) が、書かれるのか!
を、見ていきましょう。

A method is a pre-defined set of instructions. Methods are 
declared within a class. Java provides some pre-defined 
methods available to all classes, but we can create our own 
as well.
メソッド とは、class の中に、定義しておく/書いておく、
 アクションのセット
です。
(実は、class を、作ると、すべての、class は、Objectクラス を、
継承しているので、たとえ、書かれていなくても、最初から、
いくつかの メソッド を、持っているのですが、今のところ、ここは、
さらっと流していただいて)、
私たち、独自のメソッド を、書いてみましょう。

Let's create a new method:
class Car {

    int modelYear;

    public Car(int year) {

        modelYear = year;

    }

    //Our new method to help us get "started"
    public void startEngine() {

        System.out.println("Vroom!");

    }

    public static void main(String[] args){

        Car myFastCar = new Car(2007);

    }
}
In the example above, we added a method called 
startEngine. When the method is used, it will print out 
Vroom!. The void keyword will be explained later in this 
course.
	・・・
Note that the startEngine method is created outside of the 
main method, like the constructor was.
では、さっそく、メソッド を、書き込んでみましょう!:
class Car {
    int modelYear;

    public Car(int year) {
        modelYear = year;
    }

    //このメソッドは、車のスタートを助けます!	
    	// そうは思えない、、ジョーク です.		
    public void startEngine() {		
        System.out.println("ぶるるん!");	
    }							

    public static void main(String[] args){
        Car myFastCar = new Car(2007);
    }
}
この例で、
 startEngine()
という、メソッド を、追加しました。
このメソッドを実行すると、
 ぶるるん!
と、エンジンがうなるわけでなく、単に、そのように、
コンソールウィンドウにプリントアウトされます。
voidキーワード については、
後で説明いたします。
	・・・
ここで、注目し、覚えておいてほしいのは、
 startEngine()メソッド は、	
 main()メソッド の 外		
に、書かれていることです!
コンストラクタ、
 public Car(int year){ ... }
のように。 Instructions
1.
In between the constructor and the main method, add a 
method called bark to the Dog class by typing:
public void bark() {

}
では、エディタの、Dogクラスに、
 bark()メソッド
を、下記のように、タイプしてください。
public void bark() {

}
ただし、
 コンストラクタ と、main()メソッド の、間
に書くこと!

2.
Inside the bark method, type:
System.out.println("Woof!");
bark()メソッド の中に、以下のコードを、書いてください。
どんな風に書くのかは、本文のコードを、よく見てください。
System.out.println("Woof!");
* Woof! - う"~!(犬のうなり声)




[Next]
9. Using Methods: I(メソッドを使う #1)
●Learn
Great! Now the bark method is available to use on the spike 
object. We can do this by calling the method on spike.
Great!、これで、
 Dog型オブジェクトspike
が、使える メソッド として、
 bark()メソッド
を、作ることが出来ました。
そうです、spike を使って、この メソッド を、呼ぶ(call)ことが出来るのです。

Here is an example of calling a method on an object using 
the Car class:
class Car {

    int modelYear;

    public Car(int year) {

        modelYear = year;

    }

    public void startEngine() {

        System.out.println("Vroom!");

    }

    public static void main(String[] args){

        Car myFastCar = new Car(2007);
        myFastCar.startEngine();
    }
}
In the example above, we call the startEngine method on 
the myFastCar object. Again, this occurs inside of the main 
method. Running the program results in printing Vroom! to 
the console.
これは、オブジェクト のための メソッド を、呼び出している例で、
Carクラス に書かれた、インスタンスメソッド(オブジェクトのためのメソッド)を、
呼び出して、実行しています。
* Javaのメソッドには、インスタンスメソッド 以外にも、「クラスメソッド」が、
あります、が、、メソッドの書き方が、違うので、
間違えることはありません。
ただ本文で、「on an object / オブジェクトを利用して」 とあったので、
次に、クラスメソッドの話が来ると思って、わざわざ、インスタンスメソッド
と、書いたのですが、要らぬ心配でした。
クラスメソッドは、別に難しいことはなく、ここまでの知識がしっかりしていれば、
普通に覚えられます。
ただ、その時、
 class を、現実世界 の 再現
と言う考え方は、捨てたほうがいいでしょう。
そもそも、いも虫の足の数 を、インスタンス変数 にしたい、
変な奴がそんなにいると思いますか?あっ、私がいました。
それは、ともかく、class を、現実に当てはめるのは、
 class の使い方 の、one of them
  やり方のひとつに過ぎない
ということです。
クラスメソッドを、覚える機会があったら、思い出してほしいです。
あまり、言われたり、書かれては、いませんが、
私としては、class は、プログラミングにおける整理整頓の技術
だと、思っています。
えっと、話が外れてしまいますが、私は詳細は、
よく知らないのですが、JavaScript の、「プロトタイプ」も、
素晴らしいやり方なのかもしれません。
class Car {
    int modelYear;

    public Car(int year) {
        modelYear = year;
    }

    public void startEngine() {          	
        System.out.println("ブルルン!");	
    } 

    public static void main(String[] args){
        Car myFastCar = new Car(2007);
        myFastCar.startEngine(); 
    }
}
もっと具体的に言うと、
 Carオブジェクト である、
  myFastCarオブジェクト が、startEngine()メソッド を、実行している 
ということになります。
そして、前回説明した、大事なポイントの一つを思い出してください。
 Javaプログラムが動くときは、
 最初に、main()メソッド の {  } の中から、実行されます!
ということですね。
つまり、プログラムを実行すると、 
 * プログラムの実行は、main()メソッドの入っている 「classファイル」
 を、コンソール画面(Windowsならコマンドプロンプト)から、
 java Dog
 (Dogは、class名ですね)
 のようにして実行します(IDEを使わない場合)。
 そして、その中にある、main()が、実行されると言うことです。
コンソールウィンドウ に、
 ブルルン!(Vroom!)
と、プリントアウトされるわけです。 Instructions
1.
Inside of the main method of the Dog class, call the bark 
method on the spike object.
右のエディタの、main()メソッド の中で、
 spike オブジェクト から、bark()メソッド を、
呼び出してください。(メソッドを実行してください、と言うこと)
* 呼び出し方は、本文のコードを、よ~く見て真似ましょう!




[Next]
10. Methods: II(メソッド #2)
●Learn
Fantastic! Similar to constructors, you can customize 
methods to accept parameters.
class Car {

    int modelYear;

    public Car(int year) {

        modelYear = year;

    }

    public void startEngine() {
        System.out.println("Vroom!");
    }

    public void drive(int distanceInMiles) {

        System.out.println("Miles driven: " + distanceInMiles);

    }

    public static void main(String[] args){

        Car myFastCar = new Car(2007);
        myFastCar.startEngine();
        myFastCar.drive(1628);

    }
}
In the example above, we create a drive method that 
accepts an int parameter called distanceInMiles. In the 
main method, we call the drive method on the myFastCar 
object and provide an int parameter of 1628.
	・・・
Calling the drive method on myFastCar will result in 
printing Miles driven: 1628 to the console.
Fantastic!、ところで、コンストラクタ のように、メソッド も、
 パラメータ を使う
ことが出来ます。
class Car {
    int modelYear;

    public Car(int year) {
        modelYear = year;
    }

    public void startEngine() {
        System.out.println("Vroom!");
    }

    public void drive(int distanceInMiles) {				
        System.out.println("Miles driven: " + distanceInMiles);	
        	// Miles driven - 走行マイル				
        	// "文字列" + int型数値 = "新しい文字列"			
        		// 詳しくは、調べてほしい!				
    }											

    public static void main(String[] args){
        Car myFastCar = new Car(2007);
        myFastCar.startEngine();
        myFastCar.drive(1628); 
    }
}
この例で、私たちは、
 drive(int distanceInMiles)メソッド
 (distanceInMiles - マイルに換算した距離)
を、作って、パラメータを付けました。
そして、				
 main()メソッドの中		
で、					
 int型 の パラメータ 1628	
を、含めて、				
 myFastCarオブジェクト		
を使って、呼び出しています。	
	・・・
その結果は、コンソールウィンドウ に、
 Miles driven: 1628
を、プリントアウトすることは、分かりますね。 Instructions
1.
In between the bark and main methods, add a method 
called run to the Dog class by typing:
public void run() {

}
bark()メソッド と、main()メソッド の間に、
 run()メソッド
を、書いてください:
public void run() {

} 

2.
Modify the run method so that it accepts an int parameter 
called feet.
run()メソッド を、書き換えて、
 int型 パラーメタ feet
  // (int feet) に、するということ.
を、追加しましょう。

3.
Inside of the run method, type:
System.out.println("Your dog ran " + feet + " feet!");
run()メソッドの中に、
System.out.println("Your dog ran " + feet + " feet!");
を、書いてください。
(この書き方に慣れていなかったら、
 まあ、コピペして、正解しておきましょう。
 そして、調べて理解すれば、ベストです。)

4.
Inside of the main method, call the run method on the 
spike object. You can pass in an int parameter of your 
choice.
main()メソッド の中 で、
 spikeオブジェクト から、run() メソッド の、コール(呼ぶこと)
を、してください。
その時、
 int型パラメータ に、何か数値を、渡してください。 
* 本文のコードを、みて、どんな風に渡しているのか、確認しましょう。
また、feet は、
 あなたの犬は、○○フィート の距離を走りました。
という文の、○○に、渡す数値 です。
ということで、そんな気分になって、数値を決めたほうがいいです。
フィートって、何センチですか?、、
まあ、なんとなくでいいのでは?




[Next]
11. Using Methods: II
●Learn
Let's explore one of the keywords used in declaring a 
method. In past exercises, when creating new methods, 
we used the keyword void.
	・・・
The void keyword indicates that no value should be 
returned by the method after it executes all the logic in the 
method. If we do want the method to return a value after it 
finishes running, we can specify the return type.
1.
The void keyword (which means "completely empty") 
indicates to the method that no value is returned after 
calling that method.
2.
Alternatively, we can use data type keywords (such as int, 
char, etc.) to specify that a method should return a value 
of that type. 
ここでは、メソッド を、宣言する/定義する/書く 時、その前 に、書いてある、
 キーワード(keyword)
について考えて見ましょう。
今までのレッスンでは、
  void メソッド名( ) { コード; }
    // public は、「ここでは」、気にしなくてOK.
こんなコードを書いたり、見てきましたが、
 void(キーワード)
とは、いったい何なのでしょうか?
	・・・
それは、こんな メソッド 、
void あるメソッド(){
	コード;
	コード;
}
の、
 { の中 }
を、実行し終わった後、
 確かに、コードは実行されましたが、
 その後、返し値/戻り値 が、ない!
と言うことを意味しています。
逆に、戻り値(返し値) を、メソッドは、設定できる!
そして、その 値 を、変数 に代入することも出来る。 
方法がある、、と言ったほうが、分かり易いかもしれませんね。
では、
 この2つの場合
を、考えてみましょう。

1. voidキーワード
このキーワードが設定されている場合は、
メソッドの中のコードが実行された後、
何の 値 も、返さない メソッド を作ります。
では、値 を返すとは?

2. int, char, boolean など を、戻り値タイプ にする
値を返すメソッド にするには、
 void の代わりに、
 今まで習った、データタイプ を、書けばOK
  // int, char, boolean など.
です。
具体的な使い方の例としては、
 返された 値 を、
 変数で、キャッチできます。
これが、値 を、返すと言う意味です。
イメージとしては、
 int kotae = jijou(3);
  // int 答え = 自乗(3);
  // kotae の値は、9 になる.
こんな風に、値 9 を、返して、
int型変数kotae に、9 を、代入したりするわけです。
この、jijou()メソッドは、きっとこんなでしょう。
int jijou(int number){
	return number*number;
}
return キーワードは、すぐに説明します。 
* 戻り値 という言い方は、イメージがやや狂うので、
私は、返し値 と、どちらかと言えば、いいたいのですが...
確か、Javaの本をいくつか書いている、岩谷宏さんは、
「返し値」と、書いていました。
メソッドの「戻り値」と言うものは、そのメソッドを書いた人が、
ある目的のために「返している」のであって、
ブーメランのように、勝手に戻ってくるものではありません。
意味的には、間違っていないのでしょうが、
プログラミングを書くに当たっては、ピントはずれな感じがします。
誰であれ、「戻り値」は、「返そう」として書いているのですから。
ので、私は、以後、「返し値」と書かせていただきます。

An example of indicating a return value for a method is 
below:
class Car {

    int modelYear;

    public Car(int year) {

        modelYear = year;

    }

    public void startEngine() {

        System.out.println("Vroom!");

    }

    public void drive(int distanceInMiles) {

        System.out.println("Your car drove " + 
        distanceInMiles + " miles!");

    }

    public int numberOfTires() {

        return 4;

    }

    public static void main(String[] args){

        Car myFastCar = new Car(2007);
        myFastCar.startEngine();
        myFastCar.drive(1628);

        int tires = myFastCar.numberOfTires();
        System.out.println(tires);

    }
}
In the example above, we created the numberOfTires 
method. This method specifies that it will return an int data 
type. Inside of the method, we used the return keyword to 
return the value of 4 which is an int type.
	・・・
Within main, we called the numberOfTires method on 
myFastCar. Since the method returns an int value of 4, we 
store the value within an int variable called tires. We then 
print the value of tires to the console.
これは、ある タイプ/型 の、値 を、返す メソッド の例です:
class Car {
    int modelYear;

    public Car(int year) {
        modelYear = year;
    }

    public void startEngine() {
        System.out.println("Vroom!");
    }

    public void drive(int distanceInMiles) {
        System.out.println("Your car drove " + 
        distanceInMiles + " miles!");
    }

    public int numberOfTires() {
        return 4;
    }

    public static void main(String[] args){
        Car myFastCar = new Car(2007);
        myFastCar.startEngine();
        myFastCar.drive(1628);
        int tires = myFastCar.numberOfTires();
        System.out.println(tires);
    }
}
上のコードの中で、
  numberOfTires()メソッド
があります。
そして、この メソッド は、int型の値 を、返すように、書かれています。
では、どのようにして返しているのか?
値を返すには、returnキーワード を、使います。
ここでは、4 を、返すコードになっています。
	・・・
そして、main()メソッドの中で、
  int tires = myFastCar.numberOfTires();
と言うコードを実行していますが、これの意味するところは、
Car型オブジェクトmyFastCar を使って、
numberOfTires()メソッド を、呼んでいます。
すると、
  return 4;
というコードがあるので、int型 の 値 4 を、返すわけです。
そして、それを、int型変数 tire で、キャッチしているわけです。
キャッチしていると言う意味は、値4 を、tire に、代入している、
ということです。
さらに、次のコード、、
  System.out.println(tires);
によって、コンソールウィンドウに、4 が、プリントアウトされます。 


1.
In between the run and main methods, add a method 
called getAge that returns age by typing:
public int getAge() {
    return age;
}
run()メソッド と、main()メソッド の間に、下に示してある
 getAge()メソッド
を、書いてください:
public int getAge() {
    return age;
} 

2.
Inside of main, set an int variable spikeAge to the value 
returned by spike.getAge();
main()メソッドの中に、
 int 型の変数 spikeAge に、
 spike.getAge(); というコードによって、
 返される値 を、キャッチできる(代入できる)コード
を、書いてください。
本文のサンプルコードのように書けばいいのです。

3.
On the next line, print out the age by typing:
System.out.println(spikeAge);
次の行に、spikeオブジェクトの age の 値 が、
プリントアウトされるように、
System.out.println(spikeAge);
このコードを書いてください。




[Next]
12. Inheritance(親クラスのメソッドは、子供クラスにもあります)
●Learn
You've created a fully functional Dog class. Congratulations!
	・・・
One of the object-oriented programming concepts that 
allows us to reuse and maintain code more efficiently is 
called inheritance. It is used to share or inherit behavior 
from another class. Let's look at an example:
class Car extends Vehicle {

    int modelYear;

    public Car(int year) {

        modelYear = year;

    }

    //Other methods omitted for brevity...

    public static void main(String[] args){

        Car myFastCar = new Car(2007)
        myFastCar.checkBatteryStatus();

    }
}

class Vehicle {

    public void checkBatteryStatus() {

        System.out.println("The battery is fully charged and 
        ready to go!");

    }
}
In the example above, the extends keyword is used to 
indicate that the Car class inherits the behavior defined in 
the Vehicle class. This makes sense, since a car is a type of 
vehicle.
	・・・
Within the main method of Car, we call the 
checkBatteryStatus method on myFastCar. Since Car 
inherits from Vehicle, we can use methods defined in 
Vehicle on Car objects.
これで、このレッスンでの、Dogクラスは完成しました。 
* main()メソッドの部分は、
 class を、使う部分
ですので、この部分は、プログラムが大きければ、
別class を作ってその中で、実行するので、
Dogクラス 自体 とは、別物と考えましょう。
	・・・
オブジェクト指向プログラミングの目的のひとつは、
 コードを、再利用すること、メンテナンスを簡単にすること
です。
そのための方法が、
 継承(inheritance)
です。
そうすることで、ある別のclass の アクション を、受け継ぐことができます。
では、実際のコードを、見てみましょう。
class Car extends Vehicle {
    int modelYear;

    public Car(int year) {
        modelYear = year;
    }

    public static void main(String[] args){
        Car myFastCar = new Car(2007)
        myFastCar.checkBatteryStatus();
          // Vehicleクラスのメソッドは書かなくても使えます.
    }
}

class Vehicle {
    // バッテリーの状態をチェック.
    public void checkBatteryStatus() {
        System.out.println("バッテリーフル充電、準備OK!");
    }
}
このコードに書かれている
	Car extends Vehicle
の部分に注目してください。
これの意味するところは、
 Vehicleクラス(乗り物クラス)の、アクションは、
 Carクラス が、受け継ぎました. 
* 例外的なことは、Javaにもしはまったら、自分で習得しましょう.
ということです。
また、Carクラスのオブジェクト myFastCar は、
 Car 型の変数 であり
 Vehicle 型の変数 でもある
と、両方が言えます。
Car型って?、、これは、int型、char型、boolean型 の、変数
という言い方と同じで、
class/オブジェクト の種類である Car の 型/タイプ である ということです。
	・・・
Carクラス の、main()メソッドの中で、
Carクラスのオブジェクト myFastCar を使って、
 checkBatteryStatus()メソッド を、呼んでいるのは、
Carクラス が、Vehicleクラス を、extends/継承 しているからです。
つまり、Vehicle/親 クラス に、定義してある メソッドは、
継承/子供 クラス である、Carクラス に、
引き継がれている/遺伝している わけです。Instructions
1.
Note that there are now two files in the code editor. Within 
the Dog class, use the extends keyword to inherit from the 
Animal class.
右のエディタを、よく注意してみてください!
 Dog.java の、右側に、
 Animal.java の、タブ がある
のに気づくと思います。
extendsキーワード を使って、
 Dogクラス を、
 Animalクラス を、継承/extends したクラス
に、してください。 

2.
Within the main method of the Dog class, call the 
checkStatus method on the spike object.
Dogクラス の、main()メソッド の中で、
親クラスである、Animalクラスのメソッド、、
 checkStatus()メソッド
  // 動物に、How are you? と、聞く感じなメソッド.
を、Dogオブジェクト spike を、使って呼び出してください。
Dogクラスに定義されていなくても、extends しているので使えます。




[Next]
13. Generalizations(まとめ)
●Learn
Great work! Let's review everything that we've learned 
about object-oriented programming in Java so far.
	・・・
Class: a blueprint for how a data structure should function
Constructor: instructs the class to set up the initial state of 
an object
Object: instance of a class that stores the state of a class
Method: set of instructions that can be called on an object
Parameter: values that can be specified when creating an 
object or calling a method
Return value: specifies the data type that a method will 
return after it runs
Inheritance: allows one class to use functionality defined in 
another class
では、ここまでで、学習したこと、、Javaのオブジェクト指向プログラミング、、
についてまとめてみます:
	・・・
- class
とは、データ/変数/値 に、
どんなアクションをさせるかの、設計図です。
(もっと簡単に言えば、オブジェクトの設計図)

- コンストラクタ(constructor)
を使って、オブジェクトを作ったときの状態 を、設定出来ます。

- オブジェクト(object)
class を、値化した/データにした、ひとつの例です。

- メソッド(method)
オブジェクトから呼び出せる、アクションのセットです。

- パラメータ(parameter)
コンストラクタ や メソッド を、実行するときに渡すことが出来る、
特定の 値 です。

- 返し値(return value)
メソッド実行後、変数などに、キャッチさせる、特定の 型/タイプ の 値。

- 継承(inheritance)
あるclass が、他のある class の、アクション(データも) を、
使えるようにすることです。
extendsキーワード を、使って実現します。Instructions
1.
Inside of the main method, create a new Coffee object 
called myOrder.
Coffeeクラス にある、main()メソッド の中で、
Coffeeオブジェクト myOrder を、作ってください。
 // myOrder - 私の注文

2.
On the next line, call the addSugar method on myOrder 
and specify 2 as the parameter.
次の行で、
 addSugar()メソッド を、
  // 砂糖をいくつ入れるか決めるメソッド.
 myOrderオブジェクトを使って、
呼び出してください。
パラメータ は、2 とします。

3.
Modify the Coffee class so that it inherits from the Beverage 
class.
Coffeeクラス が、Beverageクラス を、継承/extends するように、
コードを、手直ししてください/ 書き加えてください。
 // beverage - 飲み物

4.
Inside of main, call the isFull method on the myOrder 
object.
Coffeeクラス にある、main()メソッド の中で、
myOrderオブジェクトを使って、
 isFull()メソッド
  // エディタの右タブ、Beverage.java に、書かれています。
  // 「Your order is full!」、意味が分かりません!、、悪しからず.
   // 直訳すると、「あなたの注文はいっぱいです!」
    // 1.品切れなのか聞いている?
    // 2.もう注文するの物がないか、Javaプログラムに聞いている?
を、呼び出してください。


[the End of this HTML]