情報システム科
Java
目次
入力
Javaのインストール
Javaプログラミング
色々なプログラム(for,while,switch)
クラス(メソッド,コンストラクタ)
オブジェクト指向プログラミング(継承,superとthis,抽象クラス,インターフェース)
便利なクラス(String,Object,Vector,ファイル)
オブジェクトとフィールド・メソッド
例外
スレッド
プログラムを分割(パッケージ,import)
入力
BufferedReader br =
new BufferedReader (new InputStreamReader(System.in));
String str = br.readLine();
import java.io.*; //IOException BufferedReader InputStreamReader
class Hello2
{
public static void main(String[] args) throws IOException
{
System.out.println("名前を入力してください。");
BufferedReader br =
new BufferedReader (new InputStreamReader(System.in));
String str = br.readLine();
System.out.println(str + "さん、こんにちは！");
}
}
Java のインストール
ＳＤＫ
http://java.sun.com/j2se/1.4.1/ja/
j2sdk-1_4_1_02-windows-i586.exe
J2SDK: Java2 Software Development Kit
パス設定
コントロールパネルーーシステムーー詳細設定ーー環境変数
Pathをダブルクリックーー
;c:\j2sdk1.4.1_02\bin
を追加。
JavaTM 2 SDK, Standard Edition ドキュメント
http://java.sun.com/j2se/1.4/ja/docs/ja/
Javaプログラミング
ソースファイル
↓
コンパイル javac コンパイラ
↓
クラスファイル
↓
実行 java インタープリタ
↓
クラスファイルの実行
Java仮想マシン（ＪＶＭ）
class Hello
{
public static void main(String[] args)
{
System.out.println("Hello!");
}
}
コンパイル
javac Hello.java
実行
java Hello
クラスの定義
class クラス名
{
中身
}
mainメソッドの定義
public static void main(String[] args)
{
中身
}
文字列の出力
System.out.println(文字列);
import java.io.*;
class Hello2
{
public static void main(String[] args) throws IOException
{
System.out.println("名前を入力してください。");
BufferedReader br =
new BufferedReader (new InputStreamReader(System.in));
String str = br.readLine();
System.out.println(str + "さん、こんにちは！");
}
}
プログラマ 大山 =
new プログラマ (new Javaを理解する人());
文字列の入力
BufferedReader br =
new BufferedReader (new InputStreamReader(System.in));
String str = br.readLine();
例外
throws IOException
IOException は入出力で発生するかもしれない例外を表す。
throws IOException は、例外が発生しても、投げ出す。
import java.io.*;
java.io.IOException を、簡単にIOException で扱えるようにする。
文字列を整数に変換
x = Integer.parseInt(str);
文字列 + 数
数が文字列に変換されて、前の文字列につながる。
基本データ型
byte １バイト 整数
short ２バイト 整数
int ４バイト 整数
long ８バイト 整数
float ４バイト 小数点数
double ８バイト 少数点数
char ２バイト 単一文字
boolean １バイト 真偽値 true false
コメントの３つのスタイル
//で始まる行
/*と */で囲まれた部分
/**と */で囲まれた部分（ドキュメントを作成するための物）
色々なプログラム
forループ、whileループ
forループ
for(int i=0; i<回数; i++){
中身
break; /*必要なら使うことが出来る ループから抜ける*/
}
whileループ
while(条件){
中身
}
変数を増やす、減らす
x += y; x = x + y;
x -= y; x = x - y;
x++; x = x + 1; インクリメント
x--; x = x - 1; デクリメント
int x=1;
int a;
a=x++; /*aには1が入る */
int x=1;
int a;
a=++x; /*aには2が入る */
class Love
{
public static void main(String[] args)
{
for(int i=0; i<100; i++){
System.out.println(i + "愛してるよー");
}
}
}
class Love2
{
public static void main(String[] args)
{
int i=0;
while (i<100){
System.out.println(i + "愛してる");
i++;
}
}
}
do-whileループ
do{
処理
}while(条件);
if文 （例 Aisatu）
if(条件１){
処理１
}
else if(条件２){
処理２
}
・・・
else{
処理ｚ
}
処理が１行のときは、{}を省略できる。
if(a<0)
b=a;
if(a<0) b=a;
比較
a > b
a >= b
a < b
a <= b
a == b
A != b
switch文（例 Quiz）
switch(x){
case a: /*変数xの値が、aと等しい時 */
処理１
break;
case b;
処理２
break;
・・・
default;
処理ｚ
}
乱数 （例 Uranai Kazuate）
x = (int)(Math.random() * 整数)
xに、0から(整数 -1)の間のでたらめな整数が代入される
break;
ループや switch文の終了
無限ループ（例 Kazuate2）
while(true){
処理
}
for(;;){
処理
}
配列（例 Uranai2 Uranai3）
型名[] 変数 = {データ１,データ２,・・・};
String[] strs = {"大吉","吉","普通"};
strs[0]は大吉。
要素数を指定して配列を作る
型名[] 変数;
変数 = new 型名{要素数};
int[] nums;
nums = new int[3]; /*要素数３の配列オブジェクトを生成 */
int[] nums = new int[3];
最初は0,null
配列の要素数（例 Uranai4）
配列名.length
strs.length
println とprint
print は、改行しない。
クラス
クラスとオブジェクト
クラスの定義
class クラス名
{
フィールド
コンストラクタ
メソッド
・・・・
}
class Dog
{
String name;
int energy;
}
変数とオブジェクトの生成（例 playwithDog）
クラス名 x;
x=new クラス名(外から与えるデータたがあれば、データ);
xは変数で、名前は何でもよい。
Dog x; /* xが Dogを指し示すことが出来る変数 */
x=new Dog();/* Dogの実体を生成し、xがそれを指し示すようにする */
この実体が、インスタンス、又は オブジェクト。
Dog x = new Dog(); でも良い。
playwithDog.java
class Dog /* Dog クラス */
{
String name;
int energy;
}
class playwithDog /* Dog を使うクラス */
{
public static void main(String[] args)
{
Dog x; /* Dog変数 xの定義 */
x=new Dog(); /* Dog オブジェクトの生成 */
x.name="太郎";
x.energy=100;
System.out.println("僕の名前は"+x.name+"だ。わん。");
System.out.println("エネルギーは"+x.energy+"だ。わん。");
}
}
参照型変数
クラス型の変数は「オブジェクトを指し示す」
「オブジェクトを参照する」
Dog d1=new Dog();
Dog d2;
d2=d1;
d1はDogオブジェクトを参照する。
d2=d1;によって、d2も同じオブジェクトを参照する。
メソッド （例 playwithDog3 playwithDog4 playwithDog5）
class クラス名
{
・・・
void メソッド名(){
処理
}
・・・
}
playwithDog4.java
class Dog /* Dog クラス */
{
String name;
int energy;
void bark(){ /* メソッドの定義 */
System.out.println("わん わん！");
energy--;
}
void intro(){ /* メソッドの定義 */
System.out.println("僕の名前は"+name+"だ。わん。");
System.out.println("エネルギーは"+energy+"だ。わん。");
}
}
class playwithDog4 /* Dog を使うクラス */
{
public static void main(String[] args)
{
Dog x; /* Dog変数 xの定義 */
x=new Dog(); /* Dog オブジェクトの生成 */
x.name="太郎";
x.energy=100;
x.intro();
x.bark();
x.intro();
}
}
コンストラクタ（例 playwithDog6 playwithDog7 ）
class クラス名
{
・・・
クラス名(あれば受け取るデータ){
処理
}
・・・
}
playwithDog77.java
class Dog /* Dog クラス */
{
String name;
int energy;
Dog(String n,int e){ /* コンストラクタ */
name=n;
energy=e;
}
void bark(){ /* メソッドの定義 */
System.out.println("わん わん！");
energy--;
}
void intro(){ /* メソッドの定義 */
System.out.println("僕の名前は"+name+"だ。わん。");
System.out.println("エネルギーは"+energy+"だ。わん。");
}
void eat(int e){ /* メソッドの定義 */
energy +=e;
}
}
class playwithDog77 /* Dog を使うクラス */
{
public static void main(String[] args)
{
Dog x=new Dog("太郎",100); /* Dog オブジェクトの生成 */
x.intro();
x.bark();
x.intro();
x.eat(10);
x.intro();
}
}
複数のコンストラクタ（例 playwithDog8 playwithDog9 ）
playwithDog99.java
class Dog /* Dog クラス */
{
String name;
int energy;
Dog(String n,int e){ /* コンストラクタ */
name=n;
energy=e;
}
Dog(){ /* コンストラクタ */
name="未定";
energy=50;
}
void bark(){ /* メソッドの定義 */
System.out.println("わん わん！");
energy--;
}
void intro(){ /* メソッドの定義 */
System.out.println("僕の名前は"+name+"だ。わん。");
System.out.println("エネルギーは"+energy+"だ。わん。");
}
void eat(int e){ /* メソッドの定義 */
energy +=e;
}
void setName(String n){ /* メソッドの定義 */
name=n;
}
}
class playwithDog99 /* Dog を使うクラス */
{
public static void main(String[] args)
{
Dog x=new Dog("太郎",100); /* Dog オブジェクトの生成 */
Dog.y=new Dog(); /* Dog オブジェクトの生成 */
x.intro();
x.bark();
x.intro();
y.setName("次郎");
y.intro();
}
}
private（例 playwithDog10 ）
private：そのクラスの外側からアクセスできない。
アクセス制御
データ隠匿：データをprivate（など）にしてしまう事。
カプセル化：クラスを「privateなメンバを中身とするカプセル」と考える。
private String name;
private int energy;
値を返すメソッド（例 playwithDog11 ）
返り値の型 メソッド名(あれば受け取るデータ){
処理
}
void:値を返さない。
int :intを返す。return と ;の間に、返す物を。
class Dog /* Dog クラス */
{
private String name;
private int energy;
Dog(String n,int e){ /* 引数を取るコンストラクタ */
name=n;
if(e<0) e=0;
energy=e;
}
Dog(){ /* 引数を取らないコンストラクタ */
name="未定";
energy=50;
}
void bark(){ /* 「ほえる」 メソッドの定義 */
if(energy==0){
System.out.println("おなかが減って吼えられないよ。");
return;
}
System.out.println("わん わん！");
energy--;
}
void intro(){ /* 「自己紹介」メソッドの定義 */
System.out.println("僕の名前は"+name+"だ。わん。");
System.out.println("エネルギーは"+energy+"だ。わん。");
}
void eat(int e){ /* 「えさを食べる」メソッドの定義 */
if(e<0){
System.out.println("マイナスは与えられません。");
return;
}
energy +=e;
}
void setName(String n){ /* 「名前を付ける」メソッドの定義 */
name=n;
}
int getEnergy(){ /* 「エネルギーを返す」値を返すメソッドの定義 */
return energy;
}
void setEnergy(int e){ /* 「エネルギーを設定」メソッドの定義 */
if(e<0) e=0;
energy=e;
}
}
class playwithDog111 /* Dog を使うクラス */
{
public static void main(String[] args)
{
Dog x=new Dog("太郎",1); /* Dog オブジェクトの生成 */
Dog y=new Dog(); /* Dog オブジェクトの生成 */
x.intro();
x.bark();
x.bark();
x.eat(-2);
x.eat(1);
x.intro();
y.setName("次郎");
y.setEnergy(2);
y.getEnergy();
y.intro();
}
}
オブジェクト指向プログラミング
クラスの中でクラスを使う（例 PlayWithMao PlayWithMao2 PlayWithMao3 ）
または と かつ
|| または
&& かつ
定義の場所でフィールドを初期化
class x
{
(キーワード) 型 フィールド=初期値;
・・・
}
class Mao{
private int energy = 100;
・・・
}
継承（例 PlayWithFlyingDog ....2 3 4）
既存のクラスから新しいクラスを簡単に作る。
class 新しいクラス extends 元のクラス
{
中身
}
FlyingDogはDogを継承している
スーパークラス：Dog
サブクラス ：FlyingDog
class FlyingDog extends Dog
{
void fly(){
System.out.println("空を飛ぶぞー。びゅーん。");
}
}
PlayWithFlyingDog0.java
class Dog /* Dog クラス */
{
private String name;
private int energy;
Dog(String n,int e){ /* 引数を取るコンストラクタ */
name=n;
if(e<0) e=0;
energy=e;
}
Dog(){ /* 引数を取らないコンストラクタ */
this("未定",50);
}
void bark(){ /* 「ほえる」 メソッドの定義 */
if(energy==0){
System.out.println("おなかが減って吼えられないよ。");
return;
}
System.out.println("わん わん！");
energy--;
}
void intro(){ /* 「自己紹介」メソッドの定義 */
System.out.println("僕の名前は"+name+"だ。わん。");
System.out.println("エネルギーは"+energy+"だ。わん。");
}
void eat(int e){ /* 「えさを食べる」メソッドの定義 */
if(e<0){
System.out.println("マイナスは与えられません。");
return;
}
energy +=e;
}
void setName(String n){ /* 「名前を付ける」メソッドの定義 */
name=n;
}
int getEnergy(){ /* 「エネルギーを返す」値を返すメソッドの定義 */
return energy;
}
void setEnergy(int e){ /* 「エネルギーを設定」メソッドの定義 */
if(e<0) e=0;
energy=e;
}
}
class FlyingDog extends Dog /*Dogを拡張したFlyingDog*/
{
FlyingDog(String n,int e){ /*FlyingDogのコンストラクタ*/
super(n,e); /*スーパークラスDogの引数を取るコンストラクタを呼び出す*/
}
void fly(){
if(getEnergy()<20){
System.out.println("おなかが減って飛べないよ。");
return;
}
System.out.println("空を飛ぶぞー。びゅーん。");
setEnergy(getEnergy()-20);
}
void intro(){ /*オーバーライド*/
super.intro(); /*スーパークラスのintroを使う（使わなくてもよい）*/
System.out.println("僕は空を飛べるぞ。");
}
}
class playwithFlyingDog0
{
public static void main(String[] args)
{
FlyingDog x=new FlyingDog("次郎",100); /* FlyingDog オブジェクトの生成 */
x.intro(); /*自己紹介*/
x.bark();
x.setName("太郎");
x.intro();
x.fly();
}
}
オーバーライド
superとthis
thisは「自分のクラスのこのオブジェクト」を意味する。
(今使っているオブジェクト自身)
Dog(){
name="未定";
energy50;
}
を次のように書くことが出来る。
Dog(){
this("未定".50);
}
コンストラクタを書くときに、その中でスーパークラスのコンストラクタ
(super)や、自分の別のコンストラクタ(this)を使い、
さらに別の処理をしたい場合、
superやthisを初めに書き、他の処理はその後。
サブクラスのコンストラクタの中でsuper等を書かなければ、
自動的に引数を取らないsuper();が(見えなくても)初めに呼び出される。
スーパークラスに引数を取らないコンストラクタがなく、
super();が呼び出されるようなコードを書くとエラーとなる。
thisはメソッドの引数とクラスのフィールドを区別する時にも使用。
Dog(String name,int energy){
this.name=name;
this.energy=energy;
}
this.nameはこのオブジェクトのname
nameはname
オブジェクト指向（例 PlayWithDogs ）
サブクラスとスーパークラスのオブジェクトをスーパークラスの
変数で扱える。
Dog x = new FlyingDog("次郎",100);
x.intro();はFlyingDogintroが呼び出される。
Dog[] dogs = new Dog[5];
dogs[0] = new Dog("太郎",50);
dogs[1] = new FlyingDog("次郎",100);
・・・
Dog[] dogs=
{new Dog("太郎",50),
new FlyingDog("次郎",100),
new Dog("三郎",70),
new Dog("四郎",60),
new FlyingDog("五郎",120) };
class playwithFlyingDog0
{
public static void main(String[] args)
{
Dog[] dogs=new Dog[5];
dogs[0]=new Dog("太郎",50);
dogs[1]=new FlyingDog("次郎",100);
dogs[2]=new Dog("三郎",70);
dogs[3]=new Dog("四郎",60);
dogs[4]=new FlyingDog("五郎",120);
for(int i=0;i < dogs.length;i++){
dogs[i].intro();
System.out.println("-------");
}
}
}
抽象クラス（例 PaymentList PaymentList2）
Employee:一般社員
Manager :管理職
一般社員 + 管理手当て = 管理職
class Employee
{
private String name; //氏名
private int salary; //月給
public Employee(String n,int s){ //コンストラクタ
name=n;
salary=s;
}
public String getName(){
return name;
}
public int getPayment(){
return salary*12;
}
public void raiseSalary(int r){
salary += r; //月給rだけ上げる
}
}
class Manager extends Employee
{
private int extra; //管理職手当て
public Manager(String n,int s,int e){
super(n,s);
extra=e; /*superの後に*/
}
public void setExtra(int e){
extra =e;
}
public int getPayment(){
return super.getPayment() + extra;
}
}
class PaymentList
{
public static void main(String[] args)
{
Employee emps[]=new Employee[4];
emps[0]=new Manager("大山太郎",30,40);
emps[1]=new Manager("猫田次郎",25,40);
emps[2]=new Employee("猿川三郎",20);
emps[3]=new Employee("狸原四郎",15);
System.out.println("一覧");
for(int i=0; i < emps.length ;i++){
System.out.println(emps[i].getName()+"；支払 "+emps[i].getPayment());
}
}
}
AbsEmployee ＜−−抽象クラス、抽象メソッド abstract
↑ ↑
Employee Robot
↑
Manager
抽象メソッドを持つクラス
abstract クラス名
{
・・・
abstract メソッド; /*抽象メソッドは定義を書かない*/
}
abstract class AbsEmployee /*抽象クラス*/
{
abstract public String getName();
abstract public int getPayment();
}
class Employee extends AbsEmployee //一般社員
{
private String name; //氏名
private int salary; //月給
public Employee(String n,int s){ //コンストラクタ
name=n;
salary=s;
}
public String getName(){
return name;
}
public int getPayment(){
return salary*12;
}
public void raiseSalary(int r){
salary += r; //月給rだけ上げる
}
}
class Manager extends Employee //管理職
{
private int extra; //管理職手当て
public Manager(String n,int s,int e){
super(n,s);
extra=e; /*superの後に*/
}
public void setExtra(int e){
extra =e;
}
public int getPayment(){
return super.getPayment() + extra;
}
}
class Robot extends AbsEmployee //ロボットクラス
{
private int num; //識別番号
private int payment; //１年の支払い
public Robot(int n,int p){
num=n;
payment=p;
}
public String getName(){
return "ロボット "+num;
}
public int getPayment(){
return payment;
}
}
class PaymentList2
{
public static void main(String[] args)
{
AbsEmployee[] emps = new AbsEmployee[5];
emps[0]=new Manager("大山太郎",30,40);
emps[1]=new Manager("猫田次郎",25,40);
emps[2]=new Employee("猿川三郎",20);
emps[3]=new Employee("狸原四郎",15);
emps[4]=new Robot(1,200);
System.out.println("一覧");
for(int i=0;i < emps.length ;i++){
System.out.println(emps[i].getName()+"；支払 "+emps[i].
getPayment());
}
}
}
インターフェース implements（例 PaymentList3）
インターフェースは定義のないメソッドの目録。
インターフェイス
interface インターフェース
{
フィールド
メソッド名
}
インターフェースの使い方
class クラス名 implements インターフェース
{
インターフェースのすべてのメソッドの定義を書く
}
interface IfaceEmployee /*インターフェース*/
{
public String getName(); /*自動的に抽象メソッドとなる*/
public int getPayment();
}
class Employee implements IfaceEmployee //一般社員 extendsではない
{
private String name; //氏名
private int salary; //月給
public Employee(String n,int s){ //コンストラクタ
name=n;
salary=s;
}
public String getName(){
return name;
}
public int getPayment(){
return salary*12;
}
public void raiseSalary(int r){
salary += r; //月給rだけ上げる
}
}
class Manager extends Employee //管理職
{
private int extra; //管理職手当て
public Manager(String n,int s,int e){
super(n,s);
extra=e; /*superの後に*/
}
public void setExtra(int e){
extra =e;
}
public int getPayment(){
return super.getPayment() + extra;
}
}
class Robot implements IfaceEmployee //ロボットクラス
{
private int num; //識別番号
private int payment; //１年の支払い
public Robot(int n,int p){
num=n;
payment=p;
}
public String getName(){
return "ロボット "+num;
}
public int getPayment(){
return payment;
}
}
class PaymentList3
{
public static void main(String[] args)
{
IfaceEmployee[] emps = new IfaceEmployee[5];
emps[0]=new Manager("大山太郎",30,40);
emps[1]=new Manager("猫田次郎",25,40);
emps[2]=new Employee("猿川三郎",20);
emps[3]=new Employee("狸原四郎",15);
emps[4]=new Robot(1,200);
System.out.println("一覧");
for(int i=0;i < emps.length ;i++){
System.out.println(emps[i].getName()+"；支払 "+emps[i].getPayment());
}
}
}
インターフェースIfaceEmployeeを使うことで、
Employeeも、Robotも同じように扱えた。
finalーーーもう変更しない
スー朴ラスから派生によってサブクラスを作るときに、
スーパークラスのメソッドをオーバーライドすることができるが、
オーバーライドさせない場合、メソッドの前に final を付ける。
class x
{
・・・
final void method(){
・・・
}
・・・
}
クラスの定義の前にfinalを付けると、
クラスのサブクラスを作ることが出来なくなる。
final calss Y
{
・・・
}
変数の定義の前にfinalを付けると、変更できなくなる。
final int HUNDRED=100;
便利なクラス
String （例 Mojiretuate）
文字列の入れ物を表すクラス
Stringの文字列は変更できないので、「変更不可の文字列クラス」
String x = "Hello";
String x = new String("Hello");
equals 文字列が等しいとTrue
str1,equals(str2)
length 文字列の長さ
str1.length()
Object （例 PlayWithDogString）
継承を使わずに書いたクラスは、Objectというクラスのサブクラスに。
Objectクラスの、toStringメソッド
public String toString(){
・・・(文字列を返す)
}
class Dog
{
・・・
public String toString(){
return "僕の名前は"+name+"だ。わん。";
}
}
とtoStringをオーバーライドすると、
Dog x = new Dog("太郎",100);
System.out.println(x);
で
僕の名前は太郎だ。わん。
と、出力される。
Vector （例 DogList）
配列はあらかじめ要素数を決めないといけないが、
要素数を途中で変えられるクラス。
import java.util.*;
java.util.Vector
Vector v = new Vector();
vをvector、xをあるクラスとするとき
v.addElement(new x) xのオブジェクトをvの最後に追加
v.addElement(new x,i) 第i番目にxのオブジェクトを追加
(x)v.elementAt(i) 第i番の要素を取出し、xのオブジェクトとして扱う
v.removeElementAt(i) 第iバンの要素を削除
v.removeElementAt() すべての要素を削除
v.Size() 要素数を返す
Vector dogs = new Vector(); //Vectorの生成
((Dog)dogs.elementAt(i)).intro(); //(Dog) キャスト
dogs.addElement(new Dog("太郎",100));
ファイルの入出力
出力ファイルの操作 （例 DogList2）
出力ファイルを開く：
PrintWriter 変数 =
new PrintWriter(new BufferedWriter(new FileWriter(ファイル名)));
ファイルに文字列を出力する：変数.println(文字列);
ファイルを閉じる：変数.close();
例外の処理方法必要
mainの横に、throw IOException
例
import java.io.*; //IOExceptionを短い名前で使うため
public static void main(String[] args) throw IOException
PrintWriter output =
new PrintWriter(new BufferedWriter(new FileWriter("dogs.txt")));
output.println(((Dog)dogs.elementAt(i)).getName());
output.close();
入力ファイルの操作 （例 DogList3）
入力ファイルを開く：
BufferedReader 変数 =
new BufferedReader(new FileReader(ファイル名));
ファイルから文字列を入力する：
String temp = 変数.readLine(文字列);
ファイルを閉じる：変数.close();
例外の処理方法必要
mainの横に、throw IOException
例
import java.io.*; //IOExceptionを短い名前で使うため
public static void main(String[] args) throw IOException
BufferedReader input =
new BufferedReader(new FileReader("dogs.txt"));
while((name=input.readLine()) != null)
str = input.readLine();
input.close();
オブジェクトとフィールド・メソッド
クラスとオブジェクトと変数
Dog d = new Dog();
Dogオブジョクトを生成し、dがそれを参照する。
dがDogオブジェクトそのものではない。オブジェクトを参照する変数。
ガーベッジコレクション：使われなくなったオブジェクトを自動的に破棄
Dog d = new Dog("四郎",400);
d = null; //オブジェクトを使わなくなったら
finalize
ガーベッジコレクションでオブジェクトが破棄される前に呼び出されるメソッド
自分自身のオブジェクトの生成 （例 HelloX）
class HelloX
{
void method(){
System.out.println("Hello");
}
public static void main(String[] args){
HelloX h = new HelloX(); //自分自身のオブジェクトを生成
h.method();
}
}
配列 （例 Hairetu Hairetu2）
配列の初期値（デフォルトの初期値）
数値はゼロ、charはnull、booleanはfalse、参照型はnull。
int[] nums;
nums = new int[3];
int[] nums = new int[3];
int[] nums = {10,20,30};
int[] nums1 = {10,20,30};
int[] nums2;
nums2 = nums1;
nums1[0] = 50;
nums2[0]も50になる。
nums2 = nums1;により、同じ配列オブジェクトを参照
クラス型の配列
Dog[] d;
d = new Dog[3];
Dog[] d = new Dog[3];
d[0]=new Dog();
d[1]=new Dog();
d[2]=new Dog();
Dog[] d = {new Dog(),new Dog(),new Dog()};
２次元配列
例えば、３つの１次元配列を要素に持つ、２次元配列の生成。
int [][] mnums = new int[3][];
mnums[0] = new int[1]; //１次元配列の生成
mnums[1] = new int[2];
mnums[2] = new int[3];
mnums[0][0]
mnums[1][0] mnums[1][1]
mnums[2][0] mnums[2][1] mnums[2][2]
int[][] mnums3 = {{10,20},{100},{1,2,3}}
mnums3は３つの１次元配列を要素に持つ配列オブジョクトを指す。
mnum3[0][0]は10 mnum3[0][1]は20
mnum3[1][0]は100
mnum3[2][0]は1 mnum3[2][1]は2 mnum3[2][2]は3
mnum3[0].lengthは2
mnum3[1].lengthは1
mnum3[2].lengthは3
mnum3.lengthは１次元配列の数なので、3
クラス変数 static（例 ManList ManList2 ManList3 ）
staticなメンバ
class x
{
static フィールド; //クラス変数
static メソッド(・・・){・・・} //クラスメソッド
・・・・
}
「x.メンバ名」として使える。（オブジェクトを生成しなくても）
class Man
{
static int num; //クラス変数 フィールド
string name; //インスタンス変数 フィールド
・・・
}
クラス変数は、クラスに付随する物なので、
Man.num = 2;
Man m = new Man("太郎",100);
m.name="次郎";
と、クラス名(ここではMan)を付けて指定することが出来る。
（オブジェクトを付けても指定できる。）
nameはインスタンス変数なので、オブジェクトmを付けて指定。
注意：クラスメソッド内で、staticでないフィールドやメソッド、
自分自身のオブジェクトを表すthisを使えない。
Math.random()
Mathは、J2SDKに定義されている数学クラスで、
randomはそのクラスメソッド
double x = Math.Sqrt(y); //ルート（平方根）
double x = Math.Pow(a,b); // aのb乗
n = Integer.parseInt(str);
IntegerのクラスメソッドであるparseInt
継承の場合の同名のメンバ（例 MethodSample ）
メソッド
スーパークラスとサブクラスに同名のメソッドがあった場合、
「変数.メソッド」は、
インスタンスメソッド（staticの付いていない）は、
そのメソッドを使う変数の型ではなく、実際の”オブジェクトの型”で、
どれが呼び出されるか決められる。
クラスメソッド（staticの付いたもの）は、
クラス名.メソッドで呼び出すが、
「変数.メソッド」と呼び出したときは、
実際のオブジェクトではなく、”変数の型”の物が使われる。
フィールド
スーパークラスとサブクラスに同名のフィールドがあった場合、
「変数.フィールド」は、staticであってもなくても、
実際のオブジェクトではなく、”変数の型”の物が使われる。
メソッドとは、振る舞いが違う。
main（例 ShowArgs ）
public static void main(String[] args)
public：このメソッドは他のクラスでも使える
static：クラスメソッド。オブジェクトを生成することなく使える
void：このメソッドは何も返さない
String[]：String配列を引数にとり
args：変数名がargs。argsは勝手に決めてよいが、たいていこれ。
java XXX this is a pen
args[0]がthis
args[1]がis
args[2]がa
args[3]がpen
例外
例外 （例 Reigai1 Reigai2 Reigai3 ）
try{
例外が発生するかもしれない処理
}caych ( 補足する例外のクラス e){
例外発生時の処理
}finaly{
必ず実行する処理
}
e:例外オブジェクトを参照する変数、別の名前でもかまわない
finaly節はなくてもよい
int[] data = new int[5];
data[5] = 8;
ArrayIndexOutOfBoundsException
String s="Hello";
int x=Integer.parseInt(s);
NumberFormatException
一般に、例外クラスでは、toStringメソッドが
「例外の情報を表す文字列」を返すように定義される。
そしてtoStringメソッドは「文字列＋クラス型の変数」
などというときにも、クラス型の変数に対して呼ばれる
ことになっている。
したがって「文字列＋クラス型の変数」は
「文字列＋toStringの返す文字列」になる。
入出力の例外 （例 Sanbai 2 3 DogList5 ReadDogs 2）
mainの横にthrows IOException
import java.io.*
java.io.IOException
main内部でIOExeptionが発生したとき、
内部では処理せず、外に出すという事。
FileNotFoundExeptionは、IOExeptionの、サブクラスなので、
FileNotFoundExeptionを、IOExeptionにしてもかまわない。
スーパークラスの変数でサブクラスを表すことが出来るるから
FileNotFoundExeptionの例外処理をIOExeptionと別にしたいときは
IOExeptionより前に、FileNotFoundExeptionのcatch節を書く
try{
ファイルを開き、読み込む処理
}catch(FileNotFoundExeption e){
ファイルが見つからなかったときの処理
}catch(IOExeption e){
他のIOExeptionの処理
}finally{
共通の後始末
}
例外（エラー）の分類
Throwable
┏━┻━━┓
Exception Error
┏┻━━━━━━━━┓
RuntimeException ・・・・・
Error：回復不能のエラー
Exception：例外処理によって回復が可能な例外
ErrorとRuntimeExceptionは、コンパイラによってチェックされない例外
ArrayIndexOutOfBoundsExceptin は、RuntimeExceptionのサブクラス
RuntimeException以外のExceptionのサブクラスは、
「コンパイラによってチェックされる例外」IOExeption等
例外クラスの自作 （例 WmanSample）
例外を投げるかもしれないメソッドの定義
返り値の型 メソッド名(あれば引数) throws 例外のクラス名{
・・・
}
例外を投げる
throw 例外を参照する変数;
class WeightException extends Exception //Exceptionから派生
{
public String toString(){ //toStringをオーバーライド
return "例外：マイナスの体重が与えられました";
}
}
public void SetWeight(int w) throws WeightException{
if(w < 0){
WeightEception e=new WeightException();
throw e; //例外を投げる。throwsではない。sがない。
}
}
WMan wm = new WMan("太郎");
try{
wm.setWeight(n);
}catch(WeightException e){
System.out.println(e);
}
-20
例外：マイナスの体重が与えられました
スレッド
独自のスレッドクラス （MythresdSample 2 ）
３つの処理が「同時進行」
スレッドの処理の間には順序付けがないので、雑多に実行される。
class MyThread extends Thread //J2SDKのスレッドクラスThreadから派生
{
private String str;
public MyThread(String s){
str = s;
}
public void run(){ //特別なメソッドで、このスレッドの処理を表す
for(int i = 0; i < 5; i++)
System.out.println(str);
}
}
class MyThreadSample
{
public static void main(String[] args)
{
MyThread t1 = new MyThread("This is t1."); //スレッド作成
MyThread t2 = new MyThread("This is t2.");
//スレッドをスレッドスケジューラに登録し、実行の順番待ちにする。
t1.start();
t2.start();
for(int i = 0; i < 5; i++)
System.out.println("This is main.");
}
}
sleep(500):休止 単位はミリ秒 500で0.5秒
スレッドの別法 Runnable （MyRunClassSample ）
Runnableというインターフェース
class MyRunClass implements Runnable
MyRunClass rc = new MyRunClass("hello");
Thread t = new Tread(rc);
t.start();
プログラムを分割
プログラムの分割
UltraDog.java
PlayWithUltraDog.java
のそれぞれのファイルがあり
javac PlayWithUltraDog.javaで、つぎの２つのファイルが出来、
UltraDog.class
PlayWithUltraDog.class
java PlayWithUltraDogで、実行できる
パッケージ （例 UltraDogX PlaywithUltraDogX）
関係のあるクラスをまとめてグループ分けしたもの
package パッケージ名;
package ultra;
public class UltraDogX
{
・・・
}
別のパッケージからもこのクラスを使えるようにpublicを入れる。
このUltraDogXのコードは、現在のディレクトリの下に、
ultraというディレクトリを作って、その中におく。
ultra.UltraDogX ud = new ultra.UltraDogX();
パッケージの１つのファイルにいくつでもクラスを書けるが、
１つのファイル内でpublicを付けられるクラスは１つだけ。
ファイル名はpublicを付けたクラスと同名にしなければならない。
クラスがpublicでも、メソッドがpublicでなければ、
別のパッケージから使えない。
import
import ultra.*;
で、
ultra.UltraDogXと書かなくても、UltraDogXでよくなる。
import ultra.UltraDogX;でも良い
CLASSPATH
自分の作ったパッケージを任意のディレクトリにおいて使う時に設定
クラス・インターフェイスに付けるアクセス修飾子
指定なし：同じパッケージからのみ使える
public ：別のパッケージからでも使える
フィールド・メソッド・コンストラクタに付けるアクセス修飾子
private ：同じクラスでのみ使える
指定なし ：同じパッケージ内でのみ使える
protected：同じパッケージ内と別のパッケージの
自分のクラスのサブクラスでのみ使える。
public ：すべてのクラスで使える
Ｊ２ＳＤＫのパッケージ
String java.lang.String
java.langは基本パッケージなのでjava.lang.を付けなくてよい
Vector java.util.Vector
java.lang 基本クラス
java.io 入出力関連のクラス
java.util Vectorなど「役に立つクラス」(ユーティリティクラス)
java.awt グラフィックに関する基本クラス
java.swing Swingとよばれるグラフィックに関するクラス
グラフィカルユーザーインターフェース(GUI) イベントドリブン
サンプル集的
目的別高度
ネットワーク関係
データベース関係
デザインパターン：プログラムデザインの基本パターンを集めた物
参考文献
これならわかる Ｊａｖａ
小林健一郎著
講談社発行
2003年1月20日
ホンキで学ぼう！ Ｊａｖａの基本
有賀 妙子 著
秀和システム 発行
2000年9月1日
ホームへ