ホームページへ戻る
 

上へ戻る
 

			        Java入門  その3    by    H.Y     3月 20 12:39:51 JST 2002


目次

4。オーバーロード
4ー1。メソッドのオーバーロード
4ー2。コンストラクターのオーバーロード
5。クラスの継承
5ー1。サブクラス
5ー2。サブ・サブクラス
5ー3。継承と変数
5ー4。継承とメソッドとオーバーライド
1)メソッドがオーバーライドされる場合
2)メソッドがオーバーライドされない場合
5ー5。継承とコンストラクタ
1)スーパークラスとサブクラスのコンストラクタの実行
2)スーパークラスのコンストラクタの呼び出し
5ー6。オブジェクトクラス java.lang.Object
1) Object クラスの主なメソッド
2) getClass() の実演
6。インターフェイス
6ー1。インターフェイスの宣言
6ー2。インターフェイスの実装
6ー3。インターフェイスの例 1
6ー4。インターフェイスをメソッドの引数に利用
6ー5。インターフェイスで定数宣言
6ー6。インターフェイスの継承
7。内部クラス
7ー1。内部クラスの作成例
7ー2。匿名クラス
8。修飾子
8ー1。クラスの修飾子
1)abstract
2) final
8ー2。変数の修飾子
1)final
2)static
3)private,protected,public
8ー3。メソッドの修飾子
1)abstract
2)static
3)private,protected,public

========================================================================================

4。オーバーロード
4ー1。メソッドのオーバーロード
Java では、メソッドに対して複数の実装を行うことができる。 クラスの定義では、同じ名前
のメソッドが複数個存在する。これが、「メソッドのオーバロード」である。オーバーロードと
は、同じ名前のメソッドであるのに、引数の数、データ型が異るメソッドが存在すると言うこと
である。この、
(1)引数の型
(2)データ型
のセットを「シグネチャ(siganature)」と呼ぶ。、シグネチャが異ると、オーバロードできる。

------------ over_method.java -------------------------------------
class calculator{
int addem(int data1, int data2){ //引数 2 個
return data1 + data2;
}

int addem(int data1, int data2, int data3){ //引数 3 個
return data1 + data2 + data3;
}
}

public class over_method{
public static void main(String[] args){
calculator calc = new calculator();

System.out.println("\n addem(2, 6) = " + calc.addem(2, 6) );
System.out.println(" addem(4, 7, 9) = " + calc.addem(4,7,9) + "\n");
}
}
-------------------------------------------------------------------

4ー2。コンストラクターのオーバーロード
メソッドと同じ様に、コンストラクターも、同じ名前で複数実装することができる。これが
コンストラクターのオーバロードである。

--------------- over_const.java ----------------------------------
class data{
private String data_string;

data(char[] c){ //コンストラクタ 1 Type1 配列の引数
data_string = new String(c);
}

data(String s){ //コンストラクタ 2 Type2 String型の引数
data_string = s;
}

public String getData(){ //メソッド
return data_string;
}
}

public class over_const{
public static void main(String[] args){
char chararray[] = {'H','e','l','l','o'}; //char型の配列

System.out.println("\n");
System.out.println((new data(chararray)).getData()); //Type 1

System.out.println((new data("Hello from Java !")).getData()); //Type 2
System.out.println("\n");
}
}

5。クラスの継承
ある元のクラス(基本クラスまたはスーパークラス)から、他のクラス(派生クラスまたは
サブクラス)を派生することができる。
別の言いかたをすると、基本クラスを継承してサブクラスを生成する。
クラスの継承は extends キーワードを用いる。

class サブクラス名 extends スーパークラス名 {
.....
}

サブクラスが継承できるのは、1 つのスーパークラスからだけである。 逆に、スーパークラス
は、複数のサブークラスを持てる。
サブクラスはスーパークラスの、インスタンス変数や、メソッドを使うことができる。
即ち、
(1)インスタンス変数
(2)メソッド
は継承される。しかし、
(3)コンストラクタ
は継承されない。
2 つ以上のスーパークラスから、サブクラスを作ることは Java ではゆるされない。そこで
クラスの変わりにインターフェイスを用いる。 詳しくは 6。インターフェイスを参照のこと。

5ー1。サブクラスの例
------ SubClassTest1.java ---------------------------
import java.awt.*;
import java.awt.event.*;

class AppFrame extends Frame { //Frame のサブクラス
public void paint(Graphics g) {
b.drawString("こんにちは。Frame クラスです。", 10,100);
}
}
public class SubClassTest1.java {
public static void main(String args[]) {
AppFrame f = new AppFrame();

f.setSize(200,200);

f.addWindowListener(new WondowAdapter() {public void
windowClosing(WindowEvent e ) {System.exit(0); }};

f.shoe();
}
}

5ー2。サブクラスからの継承
------------- SubClassTest2.java ---------------------------------
class SubClassTest2{
public static void main(String args[]){
//サブクラスの生成1
SubClass1 subclass1 = new SubClass1();
System.out.println("-----subclass method -----");
subclass1.i = 10;
System.out.println("i = " + subclass1.i);
subclass1.ShowMsg2();
subclass1.ShowMsg1();

//サブ・サブ・クラス の生成
SubSubClass1 subsubclass1 = new SubSubClass1();
System.out.println("-----subsubclass method -----");
subsubclass1.i = 10;
System.out.println("i = " + subsubclass1.i);
subsubclass1.ShowMsg3();
subsubclass1.ShowMsg2();
subsubclass1.ShowMsg1();
}
}
//-----スーパークラス----
class SuperClass{
int i;
public void ShowMsg1(){
System.out.println("Message from SuperClass");
}
}
//----サブ・クラス--------
class SubClass1 extends SuperClass{
public void ShowMsg2(){
System.out.println("Message from SubClass1");
}
}
//----サブ・サブ・クラス-----
class SubSubClass1 extends SubClass1{
public void ShowMsg3(){
System.out.println("Message from SubSubClass1");
}
}
------------ 実行結果 -----------------------
-----subclass method -----
i = 10
Message from SubClass1
Message from SuperClass
-----subsubclass method -----
i = 10
Message from SubSubClass1
Message from SubClass1
Message from SuperClass


5ー3。継承と変数
継承により、スーパークラスとサブクラスが、同じインスタンス変数を持った場合、
サブクラスの変数が優先する。スーパクラスの、同じ名前のインスタンス変数を参照
する場合は、 super キーワードを用いる。ただし、super で参照できるのは、1 つ
上の階層のスーパークラスまでである。

--------------- SubClassTest4.java --------------------------------
class SubClassTest4{
public static void main(String args[]){
SubClass subclass1 = new SubClass();
subclass1.ShowMsg();
}
}

class SuperClass{
int i = 10; //同じ名前の変数
}

class SubClass extends SuperClass{
int i = 20; //同じ名前の変数

void ShowMsg(){
System.out.println("\n Sub i = " + i);
System.out.println(" Super i = " + super.i + "\n");
}
}
---------- 実行結果 ----------------------------------------------
Sub i = 20
Super i = 10

5ー4。継承とメソッドとオーバーライド
スーパークラスとサブクラスに同じ名前のメソッドが存在する場合、これを「メソッドの
オーバーライド」と言う。
メソッドのオーバーライドはメソッドのシグネチャが同じ場合にのみ、行われる。
シグネチャが一致しないときは、superclass のメソッドはそのまま継承される。
メソッドのオーバーライドはサブクラスが優先する。
1)メソッドがオーバーライドされる場合

-------------------- SubClassTest6.java ------------------------
class SubClassTest6{
public static void main(String args[]){
SuperClass superclass = new SuperClass();
System.out.println("\n SupterClass method......");
superclass.ShowMsg(); // No.1

System.out.println("\n SubClass method........");
SubClass obj = new SubClass();
obj.ShowMsg(); // No.2 メソッドのオーバーライド
obj.ShowMessages(); // No.3 No.4

System.out.println("");
}
}

class SuperClass{
void ShowMsg(){
System.out.println(" Message from SuperClass");
}
}

class SubClass extends SuperClass{
void ShowMsg(){
System.out.println(" Message from SubClass");
}
void ShowMessages(){
ShowMsg();
super.ShowMsg(); //super key word
}
}
----------- 実行結果 ----------------------------
SupterClass method......
Message from SuperClass //No.1

SubClass method........
Message from SubClass //No.2
Message from SubClass //No.3
Message from SuperClass //No.4

2)メソッドがオーバーライドされない場合

---------- SubClassTest7.java --------------------------------
class SubClassTest7{
public static void main(String args[]){
SubClass subclass1 = new SubClass();
subclass1.ShowMsg(); //オーバーライドされない
subclass1.ShowMsg(5);
}
}

class SuperClass{
void ShowMsg(){
System.out.println("\n Message from SuperClass");
}
}

class SubClass extends SuperClass{
void ShowMsg(int i){
System.out.println(" Message from SubClass : " + i + "\n");
}
}
------- 実行結果 ----------------------------------------------
Message from SuperClass
Message from SubClass : 5

5ー5。継承とコンストラクタ
コンストラクタは継承されない。 コンストラクタはどちらも実行される。
まず superclass が先に実行される。

1)スーパークラスとサブクラスのコンストラクタの実行
------------ SubClassTest8.java ---------------------------------
class SubClassTest8{
public static void main(String args[]){
SubClass obj = new SubClass();
System.out.println("\n sub i = " + obj.i);
System.out.println(" sub j = " + obj.j + "\n");
}
}

class SuperClass{
int i, j;
SuperClass(){
i = 10;
j = 20;
}
}

class SubClass extends SuperClass{
SubClass(){
j = 200;
}
}
-------- 実行結果 ---------------------------------------------------
sub i = 10 //スーパークラスのコンストラクタで初期化された
sub j = 200 //サブクラスのコンストラクタで初期化された



2)スーパークラスのコンストラクタの呼び出し
super() でよびだす。
----------------- SubClassTest9.java -----------------------

class SubClassTest9{
public static void main(String args[]){
SubClass obj = new SubClass();
System.out.println("\n sub i = " + obj.i);
System.out.println(" sub j = " + obj.j + "\n");
}
}

class SuperClass{
int i, j;
//コンストラクタ - SuperClass 1
SuperClass(){
i = 10;
j = 20;
}
//コンストラクタ - SuperClass 2
SuperClass(int a){
i = a;
j = 20;
}
//コンストラクタ - SuperClass 3
SuperClass(int a, int b){
i = a;
j = b;
}
}

class SubClass extends SuperClass{
//コンストラクタ - SubClass
SubClass(){
super(100); //コンストラクタ SuperClass 3 を呼び出す
}
}
-------- 実行結果 ----------------------------------------------
sub i = 100
sub j = 20

5ー6。オブジェクトクラス java.lang.Object
Java のさまざまなクラスは、継承により階層構造を形成している。そして、この階層の
最上位のクラスは Object クラスである。
プログラマーが作成したクラスはデフォルトで Object クラスを継承している。したがって、
全てのクラスは Object クラスで定義されている、「メンバ変数」 や 「メソッド」 を継承
している。
1) Object クラスの主なメソッド
-----------------------------------------------------------------------------------
返り値 | メソッド | 内容
-----------------------------------------------------------------------------------
boolean | equals(Object obj) | 現在のオブジェクトと同じであれば真を返す
Class | getClass() | 現在のオブジェクトの Class オブジェクトを返す
String | tpString() | 文字列を返す
-----------------------------------------------------------------------------------
2) getClass() の実演

------------------ obj_class.java -------------------------------
class a{
public void print(){
System.out.println(" Here's a....");
}
}

class b extends a{
public void print(){
System.out.println(" Here's b....");
}
}

class c extends a{
public void print(){
System.out.println(" Here's c....");
}
}

class d extends a{
public void print(){
System.out.println(" Here's d....");
}
}

public class obj_class{
public static void main(String[] args){
a a1 = new a();
b b1 = new b();
c c1 = new c();
d d1 = new d();

a aref; //a class variable

aref = a1;
System.out.println("\n aref\'s class is now " + aref.getClass());
aref.print();

aref = b1;
System.out.println(" aref\'s class is now " + aref.getClass());
aref.print();

aref = c1;
System.out.println(" aref\'s class is now " + aref.getClass());
aref.print();

aref = d1;
System.out.println(" aref\'s class is now " + aref.getClass());
aref.print();

System.out.println("");
}
}
---- 実行結果 -----------------------------------------------------------------
aref's class is now class a // Object クラスの getClass() メソッドの実行結果
Here's a....
aref's class is now class b
Here's b....
aref's class is now class c
Here's c....
aref's class is now class d
Here's d....
6。インターフェイス
インターフェイスは、実装を持たないクラスと考えられる。別の言い方をすると、クラスの
骨組みをした表したものと言える。
2 つ以上のスーパークラスから、サブクラスを作ること(多重継承)は Java ではゆるされない。
そこでクラスの替わりにインターフェイスを用いる。

6ー1。インターフェイスの宣言
インターフェイス内では、「定数」と「メソッド」を宣言する。
======================================================================
[修飾子] interface インターフェイス名 {
データ型 変数名 = 初期値; //定数の必要あり
.......
戻り値のデータ型 メソッド名(引数リスト); //メソッド
.......
}
======================================================================
修飾子 : (1) 無し : このインターフェイスには同じパッケージ内からアクセスできる。
(2) public : このインターフェイスにはどこからでもアクセスできる。
変数 : final public static が自動的に付加される。したがって、定数である。
メソッド: abstruct public が自動的に付加される。メソッド内部は記述できない。

abstract の意味は抽象型。
final の意味は固定値。

6ー2。インターフェイスの実装
クラスでは、1 つ以上のインターフェイスを実装することができる。インターフェイスの
実装には、 implement キーワードを用いる。
=======================================================================
[修飾子] class クラス名 implement interface1, interface2,....{
.........
}
=======================================================================
このインターフェイスを実装したクラスは、 extends でさらにクラスを継承することができ
る。

6ー3。インターフェイスの例 1
-------------------- InterfaceTest1.java ------------------
class InterfaceTest1{
public static void main(String args[]){
Class1 obj = new Class1();
obj.ShowMsg();
}
}
//インターフェース
interface Interface1{
int i = 10;
void ShowMsg();
}
//インターフェースを実装するクラス
class Class1 implements Interface1{
public void ShowMsg(){
System.out.println("Hello from Class + i = " + i);
}
}

6ー4。インターフェイスをメソッドの引数に利用
------------------- InterfaceTest2.java -------------------
class InterfaceTest2{
public static void main(String args[]){
myClass obj = new myClass();
//引数にインターフェースを実装したクラスへの参照を渡す
Print(obj);
//obj.Show() でも同じ
}
//インターフェースを引数に取るメソッド
static void Print(ShowMsg s){
s.Show();
}
}
//インターフェース
interface ShowMsg{
void Show();
}
//インターフェースを実装しているクラス
class myClass implements ShowMsg{
public void Show(){
System.out.println("Message from Implement");
}
}

6ー5。インターフェイスで定数宣言
インターフェイスで変数を宣言すると、必ず定数になるので、定数をインターフェイスに
まとめて宣言する。
--------------- InterfaceTest3.java ----------------------
class InterfaceTest3{
public static void main(String args[]){
Calc c = new Calc();
c.Total_calc();
}
}
class Calc implements Items{
public void Total_calc(){
int total;
total = Oil * 40 + Wash;
System.out.println("Total = " + total);
}
}
//インターフェース
interface Items{
int Oil = 200;
int Gas = 110;
int Wash = 1500;
}

6ー6。インターフェイスの継承
インターフェイスの継承は、複数のスーパーインタフェイスを持つことができる。即ち、
インターフェイスは多重継承ができる。
===============================================================================
interface インターフェイス名 extends interface1, interface2,..... {
定数;
メソッド;
}
===============================================================================
スーパーインターフェイス間の内容の制限
(1)変数名が同じものは持てない
(2)戻り値が異れば、同じ名前のメソッドを持てる。
--------------- InterfaceTest4.java -----------------------------------------
class InterfaceTest4{
public static void main(String args[]){
myClass obj = new myClass();
obj.ShowMsg();
obj.SayHello();
obj.ComeOn();
System.out.println("i = " + obj.i + ", j = " + obj.j);
}
}
//スーパーインターフェース1
interface SuperInt1{
int i = 10;
void ShowMsg();
}
//スーパーインターフェース2
interface SuperInt2{
int j = 20;
void SayHello();
}
//インターフェース
interface SubInt extends SuperInt1, SuperInt2{
void ComeOn();
}

//インターフェースを実装するクラス
class myClass implements SubInt{
public void ShowMsg(){
System.out.println("Message from SuperInt1 via myClass");
}
public void SayHello(){
System.out.println("Hello Again from SuperInt2 via myClass");
}
public void ComeOn(){
System.out.println("Come On! from SubInt via my Class");
}
}

7。内部クラス

クラスの内部に、クラスを作成することが出来る。このクラスを内部クラス(inner class)と
言う。これに対して、外側のクラスは外部クラス(outer class,enclosing class)と言う。
内部クラス名は、外部クラスと同じあってはならない。
静的な内部クラスと、非静的な内部クラスがある。
1)静的内部クラス
内部クラスの外部クラスの、メンバ変数やメソッドに直接アクセスできない。
さらに、インスタンス化してからでないと、使えないので、あまり使われない。
2)非静的内部クラス。
外部クラスの、メンバ変数やメソッドに直接アクセスできる。
static なメンバは定義出来ない。非静的内部クラスは、GUIのイベント処理に便利な、
アダプタークラスを定義するために、良く用いられる。

7ー1。内部クラスの作成例
------------- InnerClassTest1.java -----------------------------------
class InnerClassTest1{
public static void main(String args[]){
OuterClass objOuter = new OuterClass();
objOuter.CallInnerClass();
}
}

//外部クラス
class OuterClass{
void CallInnerClass(){
InnerClass objInner = new InnerClass();
objInner.ShowMsg();
}
//内部クラス
class InnerClass{
public void ShowMsg(){
System.out.println("Message from Inner Class");
}
}
}
外部クラスのインスタンスが作成され、次に内部クラスのインスタンスが作成される。

7ー2。匿名クラス (anonymouse class)
内部クラスの1つの形態で、名前を持たないクラスである。 この匿名クラスは、GUIぶひんの
イベント処理のためのクラスを定義するためによく用いられる。
====================================================
new スーパークラス名(コンストラクタ引数リスト) {
変数やメソッド;
}
====================================================
class AnonymousTest1{
public static void main(String args[]){
OuterClass objOuter = new OuterClass();
objOuter.CallClass();
}
}

//外部クラス
class OuterClass{
void CallClass(){
//匿名クラス
(new SuperClass(){
public void ShowMsg(){ //匿名クラスのメソッド
System.out.println("Message from Anonymous Class");
}
}).ShowMsg(); //匿名クラスのメソッドを呼び出す
}
}

class SuperClass{
}
外部クラス OuterClass をインスタンス化すると、匿名クラス(名無し)もインスタンス化
されて、ShowMsg() が実行される。

8。修飾子
8ー1。クラスの修飾子
========================================================
abstract | インスタンス化出来ないクラス(抽象クラス)
final | 継承出来ないクラス
public | 全てのクラスから参照できるクラス
public 無| 同じパッケージ内からのみ、アクセスできる。
========================================================
1)abstract
実装を持たないクラスである。抽象クラスは、メンバ変数やメソッドの定義のみを行う。
この抽象クラスを継承したサブクラスで実装を行う。このクラスのインスタンスは、同じ
変数名はメソッド名を持つことができる。
---------------- AbstractTest1.java ----------------------------------------
class AbstractTest1{
public static void main(String args[]){
SubShowMsg1 objShow1 = new SubShowMsg1();
objShow1.show();
SubShowMsg2 objShow2 = new SubShowMsg2();
objShow2.show();
SubShowMsg3 objShow3 = new SubShowMsg3();
objShow3.show();
}
}
//抽象クラス
abstract class ShowMsg{
void show(){
}
}
class SubShowMsg1 extends ShowMsg{
void show(){
System.out.println("Hello from SubShowMsg1");
}
}
class SubShowMsg2 extends ShowMsg{
void show(){
System.out.println("Hello from SubShowMsg2");
}
}
class SubShowMsg3 extends ShowMsg{
void show(){
System.out.println("Hello from SubShowMsg3");
}
}
----------実行結果----------
Hello from SubShowMsg1
Hello from SubShoオwMsg2
Hello from SubShowMsg3
2)final
final はこれ以上継承されたくない場合に使う。
final のクラスを継承しようとすると、コンパイルエラーがでる。

8ー2。変数の修飾子
-----------------------------------------------------------------------------
final | 1度しか代入出来ない変数。定数として用いる
private | 同じクラスからしかアクセス出来ない変数
protected | 同じパッケージ、またはサブクラスからしかアクセスできない変数
public | どこからでもアクセス出来る変数
static | 静的変数。クラス変数とも言う。
-------------------------------------------------------------------------
1)final
final 指定の変数は、一度しか値を代入できない。変数をオーバーライドドすることは出来る。
------------------- FinalTest1.java --------------------
class FinalTest1{
public static void main(String args[]){
SubClass obj = new SubClass();
System.out.println("i = " + obj.i);
System.out.println("j = " + obj.j);
}
}
class SuperClass{
final int i = 10;
final int j = 10;
}
class SubClass extends SuperClass{
int j = 100;
}
------- 実行結果 ---------
i = 10
j = 100
2)static
静的変数(クラス変数)を意味する。
3ー11。 1)静的メンバを 参照。
3)private,protected,public
アクセス指定子である。
3ー7。1)クラスメンバのアクセス指定子 を参照。

8ー3。メソッドの修飾子
-------------------------------------------------------------------------------
abstract | 抽象メソッド
final | オーバーライド出来ないメソッド
private | 同じクラス内からのみ、アクセスできるメソッド
protected | 同じパッケージ、またはサブクラスからアクセスできるメソッド
public | どこからでもアクセスできるメソッド
static | 静的メソッド(クラスメソッド)
syncronized | 同期を取るメソッド
-------------------------------------------------------------------------------
1)abstract
抽象メソッドは、抽象クラスの内部で用いられる。逆に言うと、抽象メソッドのある
クラスは抽象クラスでなければならない。
---------------------------- AbstractTest2.java -------------------
class AbstractTest2{
public static void main(String args[]){
SubClass obj = new SubClass(); //インスタンス化
obj.ShowMsg();
}
}
//抽象クラス
abstract class SuperClass{ //抽象クラス
abstract void ShowMsg(); //抽象メソッド
}
class SubClass extends SuperClass{ //抽象クラスを継承する
void ShowMsg(){
System.out.println("Message from SubClass");
}
}
2)static
静的変数(クラス変数)を意味する。
3ー11。 1)静的メンバを 参照。
3)private,protected,public
アクセス指定子である。
3ー7。1)クラスメンバのアクセス指定子 を参照。