委譲
１ 委譲
委譲とは、あるオブジェクトの操作の一部を他のオブジェクトに処理させることです。クラス継承とほぼ同様の効果を得ることができます。
委譲を行なうオブジェクトは委譲先オブジェクトのアドレスを持ち、必要に応じてそのアドレスを切り替える事によって委譲先を変更し、動作にバリエーションを持たせることもできます。
例えば「消防救急車」を考えて見ましょう。
１１９番に電話しても、あわてていると救急なのか火事なのかをなかなか告げられないということがあるようです。そこで、救急でも消防でもどちらの機能も併せ持ち、どちらにも対応できるように「救急車」と「消防車」が合体した「消防救急車」を作ってしまおうということです。（図1）
オブジェクト指向でいえば、「消防車」と「救急車」の２つのクラスを継承して新しいクラスを作ることになります。これを「多重継承」というのですが、残念ながら C++ 以外では、複数のクラスを継承することはできません。
そこで、仕方がありません。「救急車」クラスだけを継承して新しいクラスを作り、火を消すことは「消防車」にお願いすることにします。「救急車」と「消防車」が合体しているのではなく、「救急車」が「消防車」を牽引していて火事ならば「消防車」が活躍するイメージです。（図2）
「救急車」にはない、消防という機能は「消防車」に委譲するわけです。
それでは FireAmbulance クラスとして作成してみましょう。
FireEngine.java
public class FireEngine extends Car {
public FireEngine() {
super("消防車");
}
public void work() { //(2)
System.out.println("火事を消す。");
}
}
Ambulance.java
public class Ambulance extends Car {
public Ambulance() {
super("救急車");
}
public void siren() { //(3)
System.out.println("ピーポーピーポー");
}
}
FireAmbulance.java
public class FireAmbulance extends Ambulance {
private FireEngine fir = new FireEngine(); //(1)
public void work() { //(2)
fir.work();
}
}
それでは、この FireAmbulance クラスのインスタンスを生成し、siren と run メソッドを呼び出すクラスも作成してみましょう。
Main.java
public class Main {
public static void main(String[] args) {
FireAmbulance fam = new FireAmbulance(); //(1)
fam.work(); //(2)
fam.siren(); //(3)
fam.run(); //(4)
}
}
- 〈宣言/定義〉
- Ambulance を「基底クラス」に持つ「派生クラス」 FireAmbulance を宣言します。
- 生成されたオブジェクトを保持する FireEngine 型の変数を定義します。
- work メソッドを定義し、FireEngine オブジェクトの work を呼ぶようにします。
- 〈処理の流れ〉
- 「派生クラス」 FireAmbulance のオブジェクト変数 fam を宣言、生成します。FireAmbulance のオブジェクトが生成されるとき、FireEngine のオブジェクトも生成され fir に保存されます。
- メソッド work を呼び出します。FireAmbulance の work メソッドが実行されます。そして、fir 内に保持している FireEngine オブジェクトの work メソッドが呼び出されます。
- メソッド siren を呼び出します。「基底クラス」 Ambulance の siren メソッドが実行されます。
- メソッド run を呼び出します。Car の run メソッドが実行されます。
それでは FireAmbulance クラスとして作成してみましょう。
FireEngine.h
#include "Car.h"
class FireEngine : public Car
{
public:
FireEngine();
virtual ~FireEngine();
void work();
};
FireEngine.cpp
#include <iostream>
#include "FireEngine.h"
using namespace std;
FireEngine::FireEngine() : Car("消防車") {}
FireEngine::~FireEngine() {}
void FireEngine::work() { //(2)
cout << "火事を消す。" << endl;
}
Ambulance.h
#include "Car.h"
class Ambulance : public Car
{
public:
Ambulance();
virtual ~Ambulance();
void siren();
};
Ambulance.cpp
#include <iostream>
#include "Ambulance.h"
using namespace std;
Ambulance::Ambulance() : Car("救急車") { }
Ambulance::~Ambulance() {}
void Ambulance::siren() { //(3)
cout << "ピーポーピーポー" << endl;
}
FireAmbulance.h
#include "FireEngine.h"
#include "Ambulance.h"
class FireAmbulance : public Ambulance
{
private:
FireEngine* fir;
public:
FireAmbulance();
virtual ~FireAmbulance();
void work();
};
FireAmbulance.cpp
#include "FireAmbulance.h"
FireAmbulance::FireAmbulance() : fir(new FireEngine()) { } // (1)
FireAmbulance::~FireAmbulance() {
delete fir
}
void FireAmbulance::work() { //(2)
fir->work();
}
work、siren と run メソッドを呼び出すクラスも作成してみましょう。
main.cpp
#include "FireAmbulance.h"
int main() {
FireAmbulance* fam = new FireAmbulance(); //(1)
fam->work(); //(2)
fam->siren(); //(3)
fam->run(); //(4)
delete fam;
}
- 〈宣言/定義〉
- Ambulance を「基底クラス」に持つ「派生クラス」 FireAmbulance を宣言します。
- 生成されたオブジェクトを保持する FireEngine 型の変数を定義します。
- work メソッドを定義し、FireEngine オブジェクトの work を呼ぶようにします。
- 〈処理の流れ〉
- 「派生クラス」 FireAmbulance のオブジェクト変数 fam を宣言、生成します。FireAmbulance のオブジェクトが生成されるとき、FireEngine のオブジェクトも生成され fir に保存されます。
- メソッド work を呼び出します。FireAmbulance の work メソッドが実行されます。そして、fir 内に保持している FireEngine オブジェクトの work メソッドが呼び出されます。
- メソッド siren を呼び出します。「基底クラス」 Ambulance の siren メソッドが実行されます。
- メソッド run を呼び出します。Car の run メソッドが実行されます。
それでは FireAmbulance クラスとして作成してみましょう。
FireEngine.cs
public class FireEngine : Car
{
public FireEngine() : base("消防車") { }
public override void Work() { //(2)
Console.WriteLine("火事を消す。");
}
}
Ambulance.cs
public class Ambulance : Car
{
public Ambulance() : base("救急車") {}
public void Siren() { //(3)
Console.WriteLine("ピーポーピーポー");
}
}
FireAmbulance.cs
public class FireAmbulance : Ambulance
{
private FireEngine fir = new FireEngine(); //(1)
public override string Work() //(2)
{
return fir.Work();
}
}
Ambulance クラスは、新たに siren というメソッドを持っています。それでは、この Ambulance クラスのインスタンスを生成し、siren と run メソッドを呼び出すクラスも作成してみましょう。
main.cs
public class Example
{
public static void main(String[] args) {
FireAmbulance fam = new FireAmbulance(); //(1)
fam.Work(); //(2)
fam.Siren(); //(3)
fam.Run(); //(4)
}
}
- 〈宣言/定義〉
- Ambulance を「基底クラス」に持つ「派生クラス」 FireAmbulance を宣言します。
- 生成されたオブジェクトを保持する FireEngine 型の変数を定義します。
- Work メソッドを定義し、FireEngine オブジェクトの Work を呼ぶようにします。
- 〈処理の流れ〉
- 「派生クラス」 FireAmbulance のオブジェクト変数 fam を宣言、生成します。FireAmbulance のオブジェクトが生成されるとき、FireEngine のオブジェクトも生成され fir に保存されます。
- メソッド Work を呼び出します。FireAmbulance の Work メソッドが実行されます。そして、fir 内に保持している FireEngine オブジェクトの Work メソッドが呼び出されます。
- メソッド Siren を呼び出します。「基底クラス」 Ambulance の Siren メソッドが実行されます。
- メソッド Run を呼び出します。Car の Run メソッドが実行されます。
それでは FireAmbulance クラスとして作成してみましょう。
Car.vb
Public Class FireEngine
Inherits Car
Public Sub New()
MyBase.New("消防車")
End Sub
Public Overrides Function Work() As String ' (2)
Return "火事を消す。"
End Function
End Class
Ambulance.vb
Public Class Ambulance
Inherits Car
Public Ambulance()
MyBase.New("救急車")
End Sub
Public Sub Siren() ' (3)
Console.WriteLine("ピーポーピーポー")
End Sub
End Class
FireAmbulance.vb
Public Class FireAmbulance
Inherits Ambulance
Private fir As FireEngine = New FireEngine() ' (1)
Public Overrides Function Work() As String ' (2)
Return fir.Work()
End Function
End Class
Ambulance クラスは、新たに Siren というメソッドを持っています。それでは、この Ambulance クラスのインスタンスを生成し、Siren と Run メソッドを呼び出すクラスも作成してみましょう。
main.vb
Module Module1
Sub Main()
Dim fam As FireAmbulance = New FireAmbulance() ' (1)
fam.Work(); ' (2)
fam.Siren(); ' (3)
fam.Run(); ' (4)
End Sub
End Class
- 〈宣言/定義〉
- Ambulance を「基底クラス」に持つ「派生クラス」 FireAmbulance を宣言します。
- 生成されたオブジェクトを保持する FireEngine 型の変数を定義します。
- Work メソッドを定義し、FireEngine オブジェクトの Work を呼ぶようにします。
- 〈処理の流れ〉
- 「派生クラス」 FireAmbulance のオブジェクト変数 fam を宣言、生成します。FireAmbulance のオブジェクトが生成されるとき、FireEngine のオブジェクトも生成され fir に保存されます。
- メソッド Work を呼び出します。FireAmbulance の Work メソッドが実行されます。そして、fir 内に保持している FireEngine オブジェクトの Work メソッドが呼び出されます。
- メソッド Siren を呼び出します。「基底クラス」 Ambulance の Siren メソッドが実行されます。
- メソッド Run を呼び出します。Car の Run メソッドが実行されます。
それでは FireAmbulance クラスとして作成してみましょう。
FireEngine.js
const Car = require("./Car.js");
module.exports = class FireEngine extends Car {
constructor() {
super("消防車");
}
work() { //(2)
process.stdout.write("火事を消す。\n");
}
}
Ambulance.js
const Car = require("./Car.js");
module.exports = class Ambulance extends Car {
constructor() {
super("救急車");
}
siren() { //(3)
process.stdout.write("ピーポーピーポー\n");
}
}
FireAmbulance.js
const Ambulance = require("./Ambulance.js");
const FireEngine = require("./FireEngine.js");
module.exports = class FireAmbulance extends Ambulance {
this.fir = new FireEngine(); //(1)
work() { //(2)
this.fir.work();
}
}
それでは、この FireAmbulance クラスのインスタンスを生成し、siren と run メソッドを呼び出してみましょう。
main.js
const FireAmbulance = require("./FireAmbulance.js");
let fam = new FireAmbulance(); //(1)
fam.work(); //(2)
fam.siren(); //(3)
fam.run(); //(4)
- 〈宣言/定義〉
- Ambulance を「基底クラス」に持つ「派生クラス」 FireAmbulance を宣言します。
- 生成されたオブジェクトを保持する FireEngine 型の変数を定義します。
- work メソッドを定義し、FireEngine オブジェクトの work を呼ぶようにします。
- 〈処理の流れ〉
- 「派生クラス」 FireAmbulance のオブジェクト変数 fam を宣言、生成します。FireAmbulance のオブジェクトが生成されるとき、FireEngine のオブジェクトも生成され fir に保存されます。
- メソッド work を呼び出します。FireAmbulance の work メソッドが実行されます。そして、fir 内に保持している FireEngine オブジェクトの work メソッドが呼び出されます。
- メソッド siren を呼び出します。「基底クラス」 Ambulance の siren メソッドが実行されます。
- メソッド run を呼び出します。Car の run メソッドが実行されます。
それでは FireAmbulance クラスとして作成してみましょう。
FireEngine.pm
package FireEngine {
use base qw(Car);
sub new() {
my ($class) = @_;
my $this = $class->SUPER::new("消防車");
return bless $this, $class;
}
work() { #(2)
print "火事を消す。\n";
}
}
1;
Ambulance.pm
package Ambulance {
use base qw(Car);
sub new() {
my ($class) = @_;
my $this = $class->SUPER::new("救急車");
return bless $this, $class;
}
sub siren() { #(3)
print "ピーポーピーポー\n";
}
}
1;
FireAmbulance.pm
package FireAmbulance {
use base qw(Ambulance);
use FireEngine;
sub new() {
my ($class) = @_;
my $this = $class->SUPER::new();
$this->{fir} = new FireEngine(); #(1)
return bless $this, $class;
}
sub work() { #(2)
$this->{fir}->work();
}
}
1;
それでは、この FireAmbulance クラスのインスタンスを生成し、siren と run メソッドを呼び出してみましょう。
main.pl
my $fam = new FireAmbulance(); #(1)
$fam->work(); #(2)
$fam->siren(); #(3)
$fam->run(); #(4)
- 〈宣言/定義〉
- Ambulance を「基底クラス」に持つ「派生クラス」 FireAmbulance を宣言します。
- 生成されたオブジェクトを保持する FireEngine 型の変数を定義します。
- work メソッドを定義し、FireEngine オブジェクトの work を呼ぶようにします。
- 〈処理の流れ〉
- 「派生クラス」 FireAmbulance のオブジェクト変数 $fam を宣言、生成します。FireAmbulance のオブジェクトが生成されるとき、FireEngine のオブジェクトも生成され $fir に保存されます。
- メソッド work を呼び出します。FireAmbulance の work メソッドが実行されます。そして、fir 内に保持している FireEngine オブジェクトの work メソッドが呼び出されます。
- メソッド siren を呼び出します。「基底クラス」 Ambulance の siren メソッドが実行されます。
- メソッド run を呼び出します。Car の run メソッドが実行されます。
それでは FireAmbulance クラスとして作成してみましょう。
FireEngine.rb
class FireEngine < Car
def initialize()
super("消防車")
end
def work() #(2)
puts "火事を消す。"
end
end
Ambulance.rb
class Ambulance < Car
def initialize()
super("救急車")
end
def siren() #(3)
puts "ピーポーピーポー"
end
end
FireAmbulance.rb
class FireAmbulance < Ambulance
def initialize()
super()
@fir = FireEngine.new() #(1)
end
def work() { #(2)
@fir.work()
end
end
それでは、この FireAmbulance クラスのインスタンスを生成し、siren と run メソッドを呼び出してみましょう。
main.rb
fam = FireAmbulance.new() #(1)
fam.work() #(2)
fam.siren() #(3)
fam.run() #(4)
- 〈宣言/定義〉
- Ambulance を「基底クラス」に持つ「派生クラス」 FireAmbulance を宣言します。
- 生成されたオブジェクトを保持する FireEngine 型の変数を定義します。
- work メソッドを定義し、FireEngine オブジェクトの work を呼ぶようにします。
- 〈処理の流れ〉
- 「派生クラス」 FireAmbulance のオブジェクト変数 fam を宣言、生成します。FireAmbulance のオブジェクトが生成されるとき、FireEngine のオブジェクトも生成され @fir に保存されます。
- メソッド work を呼び出します。FireAmbulance の work メソッドが実行されます。そして、@fir 内に保持している FireEngine オブジェクトの work メソッドが呼び出されます。
- メソッド siren を呼び出します。「基底クラス」 Ambulance の siren メソッドが実行されます。
- メソッド run を呼び出します。Car の run メソッドが実行されます。
それでは FireAmbulance クラスとして作成してみましょう。
Car.py
class FireEngine(Car):
def __init__(self):
super().__init__("消防車")
def work(self) #(2)
print("火事を消す。")
Ambulance.py
class Ambulance(Car):
def __init__(self):
super().__init__("救急車")
def siren(self): #(3)
print("ピーポーピーポー")
FireAmbulance.py
class FireAmbulance(Ambulance):
def __init__(self):
super().__init__()
self.fir = FireEngine() #(1)
def work(self): #(2)
self.fir.work()
それでは、この FireAmbulance クラスのインスタンスを生成し、siren と run メソッドを呼び出してみましょう。
main.py
fam = FireAmbulance() #(1)
fam.work() #(2)
fam.siren() #(3)
fam.run() #(4)
- 〈宣言/定義〉
- Ambulance を「基底クラス」に持つ「派生クラス」 FireAmbulance を宣言します。
- 生成されたオブジェクトを保持する FireEngine 型の変数を定義します。
- work メソッドを定義し、FireEngine オブジェクトの work を呼ぶようにします。
- 〈処理の流れ〉
- 「派生クラス」 FireAmbulance のオブジェクト変数 fam を宣言、生成します。FireAmbulance のオブジェクトが生成されるとき、FireEngine のオブジェクトも生成され @fir に保存されます。
- メソッド work を呼び出します。FireAmbulance の work メソッドが実行されます。そして、@fir 内に保持している FireEngine オブジェクトの work メソッドが呼び出されます。
- メソッド siren を呼び出します。「基底クラス」 Ambulance の siren メソッドが実行されます。
- メソッド run を呼び出します。Car の run メソッドが実行されます。
それでは FireAmbulance クラスとして作成してみましょう。
FireEngine.php
<?php
require_once('Car.php');
class FireEngine extends Car {
public function __construct() {
parent::__construct("消防車");
}
public function work() { //(2)
print "火事を消す。\n";
}
}
?>
Ambulance.php
<?php
require_once('Car.php');
class Ambulance extends Car {
public function __construct() {
parent::__construct("救急車");
}
public function siren() { //(3)
print "ピーポーピーポー\n";
}
}
?>
FireAmbulance.php
<?php
require('Ambulance.php');
require('FireEngine.php');
public class FireAmbulance extends Ambulance {
public function __construct() {
parent::__construct();
$this->fir = new FireEngine(); //(1)
}
public function work() { //(2)
$this->fir->work();
}
}
?>
それでは、この FireAmbulance クラスのインスタンスを生成し、siren と run メソッドを呼び出すクラスも作成してみましょう。
Example.php
<?php
require('FireAmbulance.php');
$fam = new FireAmbulance(); //(1)
$fam->work(); //(2)
$fam->siren(); //(3)
$fam->run(); //(4)
?>
- 〈宣言/定義〉
- Ambulance を「基底クラス」に持つ「派生クラス」 FireAmbulance を宣言します。
- work メソッドを定義し、FireEngine オブジェクトの work を呼ぶようにします。
- 〈処理の流れ〉
- 「派生クラス」 FireAmbulance のオブジェクト変数 $fam を宣言、生成します。FireAmbulance のオブジェクトが生成されるとき、FireEngine のオブジェクトも生成され fir に保存されます。
- メソッド work を呼び出します。FireAmbulance の work メソッドが実行されます。そして、fir 内に保持している FireEngine オブジェクトの work メソッドが呼び出されます。
- メソッド siren を呼び出します。「基底クラス」 Ambulance の siren メソッドが実行されます。
- メソッド run を呼び出します。Car の run メソッドが実行されます。
それでは FireAmbulance クラスとして作成してみましょう。
FireEngine.ts
import {Car} from "./Car";
export
class FireEngine extends Car {
public constructor() {
super("消防車");
}
public work():void { //(2)
process.stdout.write("火事を消す。\n");
}
}
Ambulance.ts
import {Car} from "./Car";
export
class Ambulance extends Car {
public constructor() {
super("救急車");
}
public siren():void { //(3)
process.stdout.write("ピーポーピーポー\n");
}
}
FireAmbulance.ts
import {Ambulance} from "./Ambulance";
import {FireEngine} from "./FireEngine";
export
class FireAmbulance extends Ambulance {
private fir:FireEngine = new FireEngine(); //(1)
public work():void { //(2)
fir.work();
}
}
それでは、この FireAmbulance クラスのインスタンスを生成し、siren と run メソッドを呼び出すクラスも作成してみましょう。
Example.ts
import {FireAmbulance} from "./FireAmbulance";
let fam:FireAmbulance = new FireAmbulance(); //(1)
fam.work(); //(2)
fam.siren(); //(3)
fam.run(); //(4)
- 〈宣言/定義〉
- Ambulance を「基底クラス」に持つ「派生クラス」 FireAmbulance を宣言します。
- 生成されたオブジェクトを保持する FireEngine 型の変数を定義します。
- work メソッドを定義し、FireEngine オブジェクトの work を呼ぶようにします。
- 〈処理の流れ〉
- 「派生クラス」 FireAmbulance のオブジェクト変数 fam を宣言、生成します。FireAmbulance のオブジェクトが生成されるとき、FireEngine のオブジェクトも生成され fir に保存されます。
- メソッド work を呼び出します。FireAmbulance の work メソッドが実行されます。そして、fir 内に保持している FireEngine オブジェクトの work メソッドが呼び出されます。
- メソッド siren を呼び出します。「基底クラス」 Ambulance の siren メソッドが実行されます。
- メソッド run を呼び出します。Car の run メソッドが実行されます。
それでは FireAmbulance クラスとして作成してみましょう。
FireEngine.swift
class FireEngine : Car {
public init() {
super.init("消防車")
}
public override func work() { //(2)
print("火事を消す。")
}
}
Ambulance.swift
class Ambulance : Car {
public init() {
super.init("救急車")
}
public func siren() { //(3)
print("ピーポーピーポー")
}
}
FireAmbulance.swift
class FireAmbulance : Ambulance {
private var fir:FireEngine = FireEngine() //(1)
public override func work() { //(2)
fir.work()
}
}
それでは、この FireAmbulance クラスのインスタンスを生成し、siren と run メソッドを呼び出すクラスも作成してみましょう。
Example.swift
let fam:FireAmbulance = FireAmbulance() //(1)
fam.work() //(2)
fam.siren() //(3)
fam.run() //(4)
- 〈宣言/定義〉
- Ambulance を「基底クラス」に持つ「派生クラス」 FireAmbulance を宣言します。
- 生成されたオブジェクトを保持する FireEngine 型の変数を定義します。
- work メソッドを定義し、FireEngine オブジェクトの work を呼ぶようにします。
- 〈処理の流れ〉
- 「派生クラス」 FireAmbulance のオブジェクト変数 fam を宣言、生成します。FireAmbulance のオブジェクトが生成されるとき、FireEngine のオブジェクトも生成され fir に保存されます。
- メソッド work を呼び出します。FireAmbulance の work メソッドが実行されます。そして、fir 内に保持している FireEngine オブジェクトの work メソッドが呼び出されます。
- メソッド siren を呼び出します。「基底クラス」 Ambulance の siren メソッドが実行されます。
- メソッド run を呼び出します。Car の run メソッドが実行されます。
それでは FireAmbulance クラスとして作成してみましょう。
FireEngine.kt
class FireEngine : Car("消防車") {
override fun work() { //(2)
println("火事を消す。")
}
}
Ambulance.kt
open class Ambulance : Car("救急車") {
fun siren() { //(3)
println("ピーポーピーポー")
}
}
FireAmbulance.kt
class FireAmbulance : Ambulance() {
private val fir:FireEngine = FireEngine() //(1)
override fun work() { //(2)
fir.work()
}
}
それでは、この FireAmbulance クラスのインスタンスを生成し、siren と run メソッドを呼び出すクラスも作成してみましょう。
Main.kt
fun main() {
val fam:FireAmbulance = FireAmbulance() //(1)
fam.work() //(2)
fam.siren() //(3)
fam.run() //(4)
}
- 〈宣言/定義〉
- Ambulance を「基底クラス」に持つ「派生クラス」 FireAmbulance を宣言します。
- 生成されたオブジェクトを保持する FireEngine 型の変数を定義します。
- work メソッドを定義し、FireEngine オブジェクトの work を呼ぶようにします。
- 〈処理の流れ〉
- 「派生クラス」 FireAmbulance のオブジェクト変数 fam を宣言、生成します。FireAmbulance のオブジェクトが生成されるとき、FireEngine のオブジェクトも生成され fir に保存されます。
- メソッド work を呼び出します。FireAmbulance の work メソッドが実行されます。そして、fir 内に保持している FireEngine オブジェクトの work メソッドが呼び出されます。
- メソッド siren を呼び出します。「基底クラス」 Ambulance の siren メソッドが実行されます。
- メソッド run を呼び出します。Car の run メソッドが実行されます。
それでは FireAmbulance クラスとして作成してみましょう。
FireEngine.scala
class FireEngine extends Car("消防車") {
override def work() { //(2)
System.out.println("火事を消す。")
}
}
Ambulance.scala
class Ambulance extends Car("救急車") {
def siren() { //(3)
System.out.println("ピーポーピーポー")
}
}
FireAmbulance.scala
class FireAmbulance extends Ambulance() {
private val fir:FireEngine = new FireEngine() //(1)
override fun work() { //(2)
fir.work()
}
}
それでは、この FireAmbulance クラスのインスタンスを生成し、siren と run メソッドを呼び出してみましょう。
Main.scala
object Main {
def main(args: Array[String]) {
val fam:FireAmbulance = new FireAmbulance() //(1)
fam.work() //(2)
fam.siren() //(3)
fam.run() //(4)
}
}
- 〈宣言/定義〉
- Ambulance を「基底クラス」に持つ「派生クラス」 FireAmbulance を宣言します。
- 生成されたオブジェクトを保持する FireEngine 型の変数を定義します。
- work メソッドを定義し、FireEngine オブジェクトの work を呼ぶようにします。
- 〈処理の流れ〉
- 「派生クラス」 FireAmbulance のオブジェクト変数 fam を宣言、生成します。FireAmbulance のオブジェクトが生成されるとき、FireEngine のオブジェクトも生成され fir に保存されます。
- メソッド work を呼び出します。FireAmbulance の work メソッドが実行されます。そして、fir 内に保持している FireEngine オブジェクトの work メソッドが呼び出されます。
- メソッド siren を呼び出します。「基底クラス」 Ambulance の siren メソッドが実行されます。
- メソッド run を呼び出します。Car の run メソッドが実行されます。
それでは FireAmbulance クラスとして作成してみましょう。
FireEngine.groovy
class FireEngine extends Car {
FireEngine() {
super("消防車")
}
void work() { //(2)
System.out.println("火事を消す。")
}
}
Ambulance.groovy
class Ambulance extends Car {
Ambulance() {
super("救急車")
}
void siren() { //(3)
System.out.println("ピーポーピーポー")
}
}
FireAmbulance.groovy
class FireAmbulance extends Ambulance {
FireEngine fir = new FireEngine() //(1)
void work() { //(2)
fir.work()
}
}
それでは、この FireAmbulance クラスのインスタンスを生成し、siren と run メソッドを呼び出すクラスも作成してみましょう。
Main.groovy
class Main {
static void main(String[] args) {
FireAmbulance fam = new FireAmbulance() //(1)
fam.work() //(2)
fam.siren() //(3)
fam.run() //(4)
}
}
- 〈宣言/定義〉
- Ambulance を「基底クラス」に持つ「派生クラス」 FireAmbulance を宣言します。
- 生成されたオブジェクトを保持する FireEngine 型の変数を定義します。
- work メソッドを定義し、FireEngine オブジェクトの work を呼ぶようにします。
- 〈処理の流れ〉
- 「派生クラス」 FireAmbulance のオブジェクト変数 fam を宣言、生成します。FireAmbulance のオブジェクトが生成されるとき、FireEngine のオブジェクトも生成され fir に保存されます。
- メソッド work を呼び出します。FireAmbulance の work メソッドが実行されます。そして、fir 内に保持している FireEngine オブジェクトの work メソッドが呼び出されます。
- メソッド siren を呼び出します。「基底クラス」 Ambulance の siren メソッドが実行されます。
- メソッド run を呼び出します。Car の run メソッドが実行されます。
それでは FireAmbulance クラスとして作成してみましょう。
FireEngine.go
import "fmt"
type FireEngine struct {
*Car
}
func (*FireEngine) Work() { //(4)
fmt.Printf("火事を消す。\n")
}
func NewFireEngine() *FireEngine { //(2)
return &FireEngine {
Car: NewCar("消防車"),
}
}
Ambulance.go
import "fmt"
type Ambulance struct {
*Car
}
func (*Ambulance) Siren() { //(3)
fmt.Printf("ピーポーピーポー")
}
func NewAmbulance() *Ambulance { //(2)
return &Ambulance {
Car: NewCar("救急車")
}
}
FireAmbulance.go
type FireAmbulance struct {
*Ambulance
fir *FireEngine
}
func (fam *FireAmbulance) Work() { //(2)
fam.fir.Work()
}
func NewFireAmbulance() *FireAmbulance {
return &FireAmbulance {
Ambulance: NewAmbulance(),
fir: NewFireEngine(), //(1)
}
}
それでは、この FireAmbulance クラスのインスタンスを生成し、Siren と Run メソッドを呼び出すクラスも作成してみましょう。
Main.go
func main {
var fam = NewFireAmbulance() //(1)
fam.Work() //(2)
fam.Siren() //(3)
fam.Run() //(4)
}
- 〈宣言/定義〉
- Ambulance を「基底クラス」に持つ「派生クラス」 FireAmbulance を宣言します。
- 生成されたオブジェクトを保持する FireEngine 型の変数を定義します。
- Work メソッドを定義し、FireEngine オブジェクトの Work を呼ぶようにします。
- 〈処理の流れ〉
- 「派生クラス」 FireAmbulance のオブジェクト変数 fam を宣言、生成します。FireAmbulance のオブジェクトが生成されるとき、FireEngine のオブジェクトも生成され fir に保存されます。
- メソッド Work を呼び出します。FireAmbulance の Work メソッドが実行されます。そして、fir 内に保持している FireEngine オブジェクトの Work メソッドが呼び出されます。
- メソッド Siren を呼び出します。「基底クラス」 Ambulance の Siren メソッドが実行されます。
- メソッド Run を呼び出します。Car の Run メソッドが実行されます。
それでは FireAmbulance クラスとして作成してみましょう。
fireengine.d
import car;
public class FireEngine : Car {
public this() {
super("消防車");
}
public override void work() { //(2)
printfln("火事を消す。");
}
}
ambulance.d
import car;
public class Ambulance : Car {
public this() {
super("救急車");
}
public void siren() { //(3)
printfln("ピーポーピーポー");
}
}
fireambulance.d
import ambulance;
import fireengine;
public class FireAmbulance : Ambulance {
private FireEngine fir = new FireEngine(); //(1)
public override void work() { //(2)
fir.work();
}
}
それでは、この FireAmbulance クラスのインスタンスを生成し、siren と run メソッドを呼び出すクラスも作成してみましょう。
main.d
import fireambulance;
public int main() {
FireAmbulance fam = new FireAmbulance(); //(1)
fam.work(); //(2)
fam.siren(); //(3)
fam.run(); //(4)
}
- 〈宣言/定義〉
- Ambulance を「基底クラス」に持つ「派生クラス」 FireAmbulance を宣言します。
- 生成されたオブジェクトを保持する FireEngine 型の変数を定義します。
- work メソッドを定義し、FireEngine オブジェクトの work を呼ぶようにします。
- 〈処理の流れ〉
- 「派生クラス」 FireAmbulance のオブジェクト変数 fam を宣言、生成します。FireAmbulance のオブジェクトが生成されるとき、FireEngine のオブジェクトも生成され fir に保存されます。
- メソッド work を呼び出します。FireAmbulance の work メソッドが実行されます。そして、fir 内に保持している FireEngine オブジェクトの work メソッドが呼び出されます。
- メソッド siren を呼び出します。「基底クラス」 Ambulance の siren メソッドが実行されます。
- メソッド run を呼び出します。Car の run メソッドが実行されます。
それでは FireAmbulance クラスとして作成してみましょう。
FireEngine.pas
unit UnitFireEngine;
interface
uses
UnitCar;
type
FireEngine = class(Car)
public
constructor Create();
procedure work(); override;
end;
implementation
constructor FireEngine.Create();
begin
inherited Create('消防車');
end;
procedure FireEngine.work();
begin
Writeln('火事を消す。'); //(2)
end;
end.
Ambulance.pas
unit UnitAmbulance;
interface
uses
UnitCar;
type
Ambulance = class(Car)
public
constructor Create();
procedure siren();
end;
implementation
constructor Ambulance.Create();
begin
inherited Create('救急車');
end;
procedure Ambulance.siren(); //(3)
begin
Writeln('ピーポーピーポー');
end;
end.
FireAmbulance.pas
unit UnitFireAmbulance;
interface
uses
UnitAmbulance,
UnitFireEngine;
type
FireAmbulance = class(Ambulance)
public
constructor Create();
destructor Destroy(); override;
procedure work(); override;
end;
implementation
var fir: FireEngine;
constructor FireAmbulance.Create();
begin
fir := FireEngine.Create(); //(1)
inherited Create();
end;
destructor FireAmbulance.Destroy();
begin
fir.Free;
inherited Destroy();
end;
procedure FireAmbulance.work(); //(2)
begin
fir.work();
end;
end.
それでは、この FireAmbulance クラスのインスタンスを生成し、siren と run メソッドを呼び出すクラスも作成してみましょう。
Main.dpr
program Main;
uses
System.SysUtils,
UnitFireAmbulance;
var fam:FireAmbulance;
begin
fam := FireAmbulance.Create(); //(1)
fam.work(); //(2)
fam.siren(); //(3)
fam.run(); //(4)
fam.Free;
end.
- 〈宣言/定義〉
- Ambulance を「基底クラス」に持つ「派生クラス」 FireAmbulance を宣言します。
- 生成されたオブジェクトを保持する FireEngine 型の変数を定義します。
- work メソッドを定義し、FireEngine オブジェクトの work を呼ぶようにします。
- 〈処理の流れ〉
- 「派生クラス」 FireAmbulance のオブジェクト変数 fam を宣言、生成します。FireAmbulance のオブジェクトが生成されるとき、FireEngine のオブジェクトも生成され fir に保存されます。
- メソッド work を呼び出します。FireAmbulance の work メソッドが実行されます。そして、fir 内に保持している FireEngine オブジェクトの work メソッドが呼び出されます。
- メソッド siren を呼び出します。「基底クラス」 Ambulance の siren メソッドが実行されます。
- メソッド run を呼び出します。Car の run メソッドが実行されます。
実行結果です。
火事を消す。
ピーポーピーポー
救急車が走る。
次に、また別の「救急車」を考えて見ましょう。
災害のときは、道路に障害物があって救急車がなかなか思うように走れないこともあります。そのときは、ブルドーザーの力を借りて障害物をどけることのできる「ブル救急車」も必要です。BullAmbulance クラスとして作成してみましょう。
FireAmbulance クラスと同じように作成するだけです。ただクラス名を BullAmbulance にし、生成するオブジェクトを FireEngine でなく、Bulldozer にすれば出来上がりです。
BullAmbulance.java
public class BullAmbulance extends Ambulance {
private Bulldozer bul = new Bulldozer();
public void work() {
bul.work();
}
}
BullAmbulance.h
#include "Ambulance.h"
class BullAmbulance : public Ambulance
{
private:
Bulldozer* bul;
public:
BullAmbulance();
~BullAmbulance();
void work();
}
BullAmbulance.cpp
#include "BullAmbulance.h"
BullAmbulance::BullAmbulance() : bul(new Bulldozer()) { }
BullAmbulance::~BullAmbulance() {
delete bul;
}
void BullAmbulance::work() {
bul->work();
}
BullAmbulance.cs
public class BullAmbulance : Ambulance
{
private Bulldozer bul = new Bulldozer();
public override void Work() {
bul.Work();
}
}
BullAmbulance.vb
Public Class BullAmbulance
Inherits Ambulance
Private bul As Bulldozer = New Bulldozer()
Public Overrides Sub Work()
bul.Work();
End Sub
End Class
BullAmbulance.js
const Ambulance = require("./Ambulance.js");
const Bulldozer = require("./Bulldozer.js");
module.exports = class BullAmbulance extends Ambulance {
this.bul = new Bulldozer();
work() {
this.bul.work();
}
}
BullAmbulance.pm
package BullAmbulance {
use base qw(Ambulance);
use Bulldozer;
sub new {
my ($class) = @_;
my $this = $class->SUPER::new();
$this->{bul} = new Bulldozer();
return bless $this, $class;
}
sub work {
my ($this) = @_;
$this->{bul}->work();
}
}
BullAmbulance.rb
class BullAmbulance < Ambulance
def initialize()
super()
@bul = Bulldozer.new
end
def work()
@bul.work()
end
end
BullAmbulance.py
class BullAmbulance(Ambulance):
def __init__(self):
super().__init__()
self.bul = Bulldozer()
def work(self):
self.bul.work()
BullAmbulance.php
<?php
require('Ambulance.php');
require('Bulldozer.php');
class BullAmbulance extends Ambulance {
public function __construct() {
parent::__construct();
$this->bul = new Bulldozer();
}
public function work() {
echo $this->bul->work();
}
}
?>
BullAmbulance.ts
import {Ambulance} from "./Ambulance";
import {Bulldozer} from "./Bulldozer";
export
class BullAmbulance extends Ambulance {
private bul:Bulldozer = new Bulldozer();
public work:void() {
this.bul.work();
}
}
BullAmbulance.swift
class BullAmbulance : Ambulance {
private var bul:Bulldozer = Bulldozer()
public override func work() {
bul.work()
}
}
BullAmbulance.kt
class BullAmbulance : Ambulance() {
private val bul:Bulldozer = Bulldozer()
override fun work() {
bul.work()
}
}
BullAmbulance.kt
class BullAmbulance extends Ambulance() {
private val bul:Bulldozer = Bulldozer()
override def work() {
bul.work()
}
}
BullAmbulance.groovy
class BullAmbulance extends Ambulance {
Bulldozer bul = new Bulldozer()
void work() {
bul.work()
}
}
BullAmbulance.go
type BullAmbulance struct {
*Ambulance
bul *Bulldozer
}
func (bam *BullAmbulance) Work() {
bam.bul.Work()
}
func NewBullAmbulance() *BullAmbulance {
return &BullAmbulance {
Ambulance: NewAmbulance(),
bul: NewBulldozer(),
}
}
bullambulance.d
import ambulance;
import bulldozer;
public class BullAmbulance : Ambulance {
private Bulldozer bul = new Bulldozer();
public override void work() {
bul.work();
}
}
BullAmbulance.pas
unit UnitBullAmbulance;
interface
uses
UnitAmbulance,
UnitBulldozer;
type
BullAmbulance = class(Ambulance)
public
constructor Create();
destructor Destroy(); override;
procedure work(); override;
end;
implementation
var bul: Bulldozer;
constructor BullAmbulance.Create();
begin
bul := Bulldozer.Create();
inherited Create();
end;
destructor BullAmbulance.Destroy();
begin
bul.Free;
inherited Destroy();
end;
procedure BullAmbulance.work();
begin
bul.work();
end;
end.
２ ポリモーフィズム
委譲を利用すれば、「消防救急車」や「ブル救急車」など、必要なときに必要な「救急車」をどんどん作って、いろいろな「救急車」を簡単にたくさん作ることができます。しかし、そのうち車庫に収まらなくなったり、点検や保守に手が回らなくなり放置されることになって、一回しか使わなかった「救急車」や、どう使っていいか分からない「救急車」でいっぱいになってしまいます。(図4)
つまり、同じようなのだけれども少しずつ機能の異なるクラスがたくさんできてしまうということです。オブジェクト指向では、新しい機能を持つクラスを簡単に追加できます。しかし、簡単に作れるからと言って、どんどん作っていってしまっては、保守が大変になるばかりです。
それでは、もう一度考えて見ましょう。本来、これらの「救急車」は「消防車」や「ブルドーザー」と合体しているわけではなく牽引しているわけですから、それぞれに「救急車」を用意しなくても、「救急車」は１台だけで、牽引している自動車を換えるだけでよいはずです。
「消防車」を牽引した「消防救急車」も、「ブルドーザー」を牽引した「ブル救急車」も要りません。いろいろなものを牽引できる「スーパー救急車」さえあればよいのです。(図5)
「消防救急車」は「消防車」を、「ブル救急車」「ブルドーザー」を牽引するということが決まっていました。しかし、今度はどんな自動車でも牽引できる「スーパー救急車」を SuperAmbulance クラスとして作成してみましょう。
Car 型の変数には、Car オブジェクトか、Car の「派生クラス」のオブジェクトなら代入できます。SuperAmbulance では、Car 型の変数 car に、その「派生クラス」の FireEngine オブジェクトを代入しています。
こうすることによって、Car の「派生クラス」のオブジェクトなら同じように処理できるわけです。ここでは、Car クラスの持つ work メソッドを呼び出しています。しかし、これによって呼び出されるメソッドは、Car クラスの work メソッドではありません。変数 car に代入されているオブジェクトのクラスである FireEngine の work メソッドです。
ただし、こうした呼び出しで使用できるメソッドは、あくまで Car クラスに存在するものだけです。FireEngine クラスに独自に追加されたメソッドは呼び出すことができません。
基底クラス型に派生クラス型を代入することはオブジェクト指向の重要な特徴です。基本クラスのオブジェクト変数に異なる派生クラスのオブジェクトを代入することで、メソッドの働きが変わることを「ポリモーフィズム（多態性）」と呼びます。
Car.java
public class Car {
protected String kind = "自動車";
public Car() { }
public Car(String kind) {
this.kind = kind;
}
public void run() {
System.out.println(kind + "が走る。");
}
public void work() {
System.out.println("");
}
}
FireEngine.java
public class FireEngine extends Car {
public FireEngine() {
super("消防車");
}
public void work() { //(3)
System.out.println("火事を消す。");
}
}
Ambulance.java
public class Ambulance extends Car {
public Ambulance() {
super("救急車");
}
public void siren() { //(4)
System.out.println("ピーポーピーポー");
}
}
SuperAmbulance.java
public class SuperAmbulance extends Ambulance {
private Car car;
public SuperAmbulance(Car car) {
this.car = car; //(2)
}
public void work() { //(3)
car.work();
}
}
Main.java
public class Main {
public static void main(String[] args) {
SuperAmbulance sam = new SuperAmbulance(new FireEngine()); //(1)
sam.work(); //(3)
sam.siren(); //(4)
sam.run(); //(5)
}
}
- 〈宣言/定義〉
- Ambulance を基底クラスに持つ派生クラス SuperAmbulance を宣言します。
- 生成されたオブジェクトを保持する Car 型の変数を定義します。
- work メソッドを定義し、与えられたオブジェクトの work を呼ぶようにします。
- 〈処理の流れ〉
- 派生クラス SuperAmbulance 型の変数 sam を宣言、FireEngine のインスタンスを引数に SuperAmbulance のインスタンスを生成します。
- SuperAmbulance のオブジェクト生成時、コンストラクタがが呼ばれ、FireEngine のオブジェクトが car に保存されます。
- メソッド work を呼び出します。SuperAmbulance の work が実行されます。そして、car 内に保持している FireEngine オブジェクトの work メソッドが呼び出されます。
- メソッド siren を呼び出します。基底クラス Ambulance の siren が実行されます。
- メソッド run を呼び出します。Car の run が実行されます。
Car 型のポインター変数には、new 演算子によって生成された動的インスタンスである Car または Car の「派生クラス」のオブジェクトを代入できます。SuperAmbulance では、Car 型の変数 car に、その「派生クラス」の FireEngine オブジェクトを代入しています。
こうすることによって、Car の「派生クラス」なら同じように処理できるわけです。ここでは、Car クラスの持つ work メソッドを呼び出しています。しかし、これによって呼び出されるメソッドは、Car クラスの work メソッドではありません。変数 car に代入されているオブジェクトのクラスである FireEngine の work メソッドです。
ただし、こうした呼び出しで使用できるメソッドは、あくまで Car クラスに存在するものだけです。FireEngine クラスに独自に追加されたメソッドは呼び出すことができません。
基底クラス型に派生クラス型を代入することはオブジェクト指向の重要な特徴です。基本クラスのオブジェクト変数に異なる派生クラスのオブジェクトを代入することで、メソッドの働きが変わることを「ポリモーフィズム（多態性）」と呼びます。
また、C++ の場合は基底クラスのメソッド（この例では Car クラスの work）に virtual を記述して「仮想関数」とする必要があります。virtual がないと、派生クラスのメソッドではなく、基底クラスのメソッドが呼ばれてしまいます。
Car.h
#include <string>
class Car {
protected:
std::string kind = "自動車";
public:
Car();
Car(std::string);
virtual ~Car();
void run();
virtual void work(); // virtual がないとポリモーフィズムにならない
};
Car.cpp
#include <iostream>
#include "Car.h"
using namespace std;
Car::Car() {}
Car::Car(string kind) {
this->kind = kind;
}
Car::~Car() {}
void Car::run() { //(5)
cout << kind << "が走る。" << endl;
}
void Car::work() {
cout << "" << endl;
}
FireEngine.h
#include "Car.h"
class FireEngine : Car
{
public:
FireEngine();
virtual ~FireEngine();
void work();
};
FireEngine.cpp
#include <iostream>
#include "FireEngine.h"
using namespace std;
FireEngine::FireEngine() : Car("消防車") {}
FireEngine::~FireEngine() {}
void FireEngine::work() { //(3)
cout << "火事を消す。" << endl;
}
Ambulance.h
class Ambulance : public Car
{
public:
Ambulance();
virtual ~Ambulance();
void siren();
};
Ambulance.cpp
#include "Ambulance.h"
#include <iostream>
using namespace std;
Ambulance::Ambulance() : Car("消防車") {}
Ambulance::~Ambulance() {}
void Ambulance::siren() { //(4)
cout << "ピーポーピーポー" << endl;
}
SuperAmbulance.h
class SuperAmbulance : public Ambulance
{
private:
Car* car;
public:
SuperAmbulance();
SuperAmbulance(Car*);
virtual ~SuperAmbulance();
void work();
};
SuperAmbulance.cpp
#include "SuperAmbulance.h"
SuperAmbulance::SuperAmbulance() {}
SuperAmbulance::SuperAmbulance(Car* car) : car(car) {} //(2)
SuperAmbulance::~SuperAmbulance() {}
void SuperAmbulance::work() { //(3)
car->work();
}
main.cpp
#include "SuperAmbulance.h"
#include "FireEngine.h"
int main() {
FireEngine* fir = new FireEngine();
SuperAmbulance* sam = new SuperAmbulance(fir); //(1)
sam->work(); //(3)
sam->siren(); //(4)
sam->run(); //(5)
delete fir, sam;
}
- 〈宣言/定義〉
- Ambulance を基底クラスに持つ派生クラス SuperAmbulance を宣言します。
- 生成されたオブジェクトを保持する Car 型の変数を定義します。
- work メソッドを定義し、与えられたオブジェクトの work を呼ぶようにします。
- 〈処理の流れ〉
- 派生クラス SuperAmbulance 型の変数 sam を宣言、FireEngine のオブジェクトを引数に SuperAmbulance のオブジェクトを生成します。
- SuperAmbulance のオブジェクト生成時、コンストラクタがが呼ばれ、FireEngine のオブジェクトが car に保存されます。
- メソッド work を呼び出します。SuperAmbulance の work が実行されます。そして、car 内に保持している FireEngine オブジェクトの work メソッドが呼び出されます。
- メソッド siren を呼び出します。基底クラス Ambulance の siren が実行されます。
- メソッド run を呼び出します。Car の run が実行されます。
Car 型の変数には、Car オブジェクトか、Car の「派生クラス」のオブジェクトなら代入できます。SuperAmbulance では、Car 型の変数 car に、その「派生クラス」の FireEngine オブジェクトを代入しています。
こうすることによって、Car の「派生クラス」のオブジェクトなら同じように処理できるわけです。ここでは、Car クラスの持つ Work メソッドを呼び出しています。しかし、これによって呼び出されるメソッドは、Car クラスの Work メソッドではありません。変数 car に代入されているオブジェクトのクラスである FireEngine の Work メソッドです。
ただし、こうした呼び出しで使用できるメソッドは、あくまで Car クラスに存在するものだけです。FireEngine クラスに独自に追加されたメソッドは呼び出すことができません。
基底クラス型に派生クラス型を代入することはオブジェクト指向の重要な特徴です。基本クラスのオブジェクト変数に異なる派生クラスのオブジェクトを代入することで、メソッドの働きが変わることを「ポリモーフィズム（多態性）」と呼びます。
Car.cs
public class Car
{
protected string kind = "自動車";
public Car() { }
public Car(string kind)
{
this.kind = kind;
}
public void Run() //(5)
{
Console.WriteLine(kind + "が走る。");
}
public virtual void Work()
{
Console.WriteLine("");
}
}
FireEngine.cs
public class FireEngine : Car
{
public FireEngine() : base("消防車") { }
public override void Work() //(3)
{
Console.WriteLine("火事を消す。");
}
}
Ambulance.cs
public class Ambulance : Car
{
public Ambulance() : base("救急車") { }
public void Siren() //(4)
{
Console.WriteLine("ピーポーピーポー");
}
}
SuperAmbulance.cs
public class SuperAmbulance : Ambulance
{
private Car car;
public SuperAmbulance() { }
public SuperAmbulance(Car car) {
this.car = car; //(2)
}
public override void Work() //(3)
{
return car.Work();
}
}
main.cs
class Program
{
static void Main(string[] args)
{
SuperAmbulance sam = new SuperAmbulance(new FireEngine()); //(1)
fir.Work(); //(3)
fir.Siren(); //(4)
fir.Run(); //(5)
}
}
- 〈宣言/定義〉
- Ambulance を基底クラスに持つ派生クラス SuperAmbulance を宣言します。
- 生成されたオブジェクトを保持する Car 型の変数を定義します。
- Work メソッドを定義し、与えられたオブジェクトの Work を呼ぶようにします。
- 〈処理の流れ〉
- 派生クラス SuperAmbulance 型の変数 sam を宣言、FireEngine のオブジェクトを引数に SuperAmbulance のオブジェクトを生成します。
- SuperAmbulance のオブジェクト生成時、コンストラクタがが呼ばれ、FireEngine のオブジェクトが car に保存されます。
- メソッド Work を呼び出します。SuperAmbulance の Work が実行されます。そして、car 内に保持している FireEngine オブジェクトの Work メソッドが呼び出されます。
- メソッド Siren を呼び出します。基底クラス Ambulance の Siren が実行されます。
- メソッド Run を呼び出します。Car の Run が実行されます。
Car 型の変数には、Car オブジェクトか、Car の「派生クラス」のオブジェクトなら代入できます。SuperAmbulance では、Car 型の変数 car に、その「派生クラス」の FireEngine オブジェクトを代入しています。
こうすることによって、Car の「派生クラス」のオブジェクトなら同じように処理できるわけです。ここでは、Car クラスの持つ Work メソッドを呼び出しています。しかし、これによって呼び出されるメソッドは、Car クラスの Work メソッドではありません。変数 car に代入されているオブジェクトのクラスである FireEngine の Work メソッドです。
ただし、こうした呼び出しで使用できるメソッドは、あくまで Car クラスに存在するものだけです。FireEngine クラスに独自に追加されたメソッドは呼び出すことができません。
基底クラス型に派生クラス型を代入することはオブジェクト指向の重要な特徴です。基本クラスのオブジェクト変数に異なる派生クラスのオブジェクトを代入することで、メソッドの働きが変わることを「ポリモーフィズム（多態性）」と呼びます。
Car.vb
Public Class Car
Protected kind As String = "自動車"
Public Sub New()
End Sub
Public Sub New(kind As String)
Me.kind = kind
End Sub
Public Sub Run() ' (5)
Console.WriteLine(kind & "が走る。")
End Sub
Public Overridable Sub Work()
Console.WriteLine("")
End Sub
End Class
FireEngine.vb
Public Class FireEngine
Inherits Car
Public Sub New()
MyBase.New("消防車")
End Sub
Public Overrides Function Work() As String ' (3)
Return "火事を消す。"
End Function
End Class
Ambulance.vb
Public Class Ambulance
Inherits Car
Public Ambulance()
MyBase.New("救急車")
End Sub
Public Sub Siren() ' (4)
Console.WriteLine("ピーポーピーポー")
End Sub
End Class
SuperAmbulance.vb
Public Class SuperAmbulance
Inherits Ambulance
Private car As Car
Public Sub New(car As Car) ' (2)
Me.car = car
End Sub
Public Overrides Function Work() As String ' (3)
Return car.Work()
End Function
End Class
main.vb
Module Module1
Sub Main()
Dim sam As SuperAmbulance = New SuperAmbulance(New FireEngine()) ' (1)
sam.Work() ' (3)
sam.Siren() ' (4)
sam.Run() ' (5)
End Sub
End Module
- 〈宣言/定義〉
- Ambulance を基底クラスに持つ派生クラス SuperAmbulance を宣言します。
- 生成されたオブジェクトを保持する Car 型の変数を定義します。
- Work メソッドを定義し、与えられたオブジェクトの Work を呼ぶようにします。
- 〈処理の流れ〉
- 派生クラス SuperAmbulance 型の変数 sam を宣言、FireEngine のオブジェクトを引数に SuperAmbulance のオブジェクトを生成します。
- SuperAmbulance のオブジェクト生成時、コンストラクタがが呼ばれ、FireEngine のオブジェクトが car に保存されます。
- メソッド Work を呼び出します。SuperAmbulance の Work が実行されます。そして、car 内に保持している FireEngine オブジェクトの Work メソッドが呼び出されます。
- メソッド Siren を呼び出します。基底クラス Ambulance の Siren が実行されます。
- メソッド Run を呼び出します。Car の Run が実行されます。
同じクラスを継承した、異なる派生クラスのオブジェクトを変数に代入することで、実際にどのオブジェクトが代入されているかを意識せず、異なる働きをさせることができます。このことを「ポリモーフィズム（多態性）」と呼びます。
しかし、Javascript では、変数に型がありませんので、どのようなオブジェクトであろうが「ポリモーフィズム（多態性）」できてしまいます。
Car.js
module.exports = class Car {
constructor() {
this.kind = arguments.length > 0 ? arguments[0] : "自動車";
}
run() {
process.stdout.write(this.kind + "が走る。\n");
}
work() {
process.stdout.write("\n");
}
}
FireEngine.js
const Car = require("./Car.js");
module.exports = class FireEngine extends Car {
constructor() {
super("消防車");
}
work() { //(3)
process.stdout.write("火事を消す。\n");
}
}
Ambulance.js
const Car = require("./Car.js");
module.exports = class Ambulance extends Car {
constructor() {
super("救急車");
}
siren() { //(4)
process.stdout.write("ピーポーピーポー\n");
}
}
SuperAmbulance.js
const Ambulance = require("./Ambulance.js");
module.exports = class SuperAmbulance extends Ambulance {
constructor(car) {
super();
this.car = car; //(2)
}
work() { //(3)
this.car.work();
}
}
main.js
const FireEngine = require("./FireEngine.js");
const SuperAmbulance = require("./SuperAmbulance.js");
let sam = new SuperAmbulance(new FireEngine()); //(1)
sam.work(); //(3)
sam.siren(); //(4)
sam.run(); //(5)
- 〈宣言/定義〉
- Ambulance を基底クラスに持つ派生クラス SuperAmbulance を宣言します。
- 生成されたオブジェクトを保持する Car 型の変数を定義します。
- work メソッドを定義し、与えられたオブジェクトの work を呼ぶようにします。
- 〈処理の流れ〉
- 派生クラス SuperAmbulance 型の変数 sam を宣言、FireEngine のインスタンスを引数に SuperAmbulance のインスタンスを生成します。
- SuperAmbulance のオブジェクト生成時、コンストラクタがが呼ばれ、FireEngine のオブジェクトが car に保存されます。
- メソッド work を呼び出します。SuperAmbulance の work が実行されます。そして、car 内に保持している FireEngine オブジェクトの work メソッドが呼び出されます。
- メソッド siren を呼び出します。基底クラス Ambulance の siren が実行されます。
- メソッド run を呼び出します。Car の run が実行されます。
同じクラスを継承した、異なる派生クラスのオブジェクトを変数に代入することで、実際にどのオブジェクトが代入されているかを意識せず、異なる働きをさせることができます。このことを「ポリモーフィズム（多態性）」と呼びます。
しかし、Perl では、変数に型がありませんので、どのようなオブジェクトであろうが「ポリモーフィズム（多態性）」できてしまいます。
Car.pm
package Car {
sub new() {
my ($class, $kind) = @_;
$kind = "自動車" if !$kind;
$this = { kind = $kind };
return bless $this, $class;
}
sub run() { #(5)
my ($this) = @_;
print "$this->{kind}が走る。\n";
}
sub work() {
print "";
}
}
1;
FireEngine.pm
package FireEngine {
use base qw(Car);
sub new() {
my ($class) = @_;
my $this = $class->SUPER::new("消防車");
return bless $this, $class;
}
sub work() { #(3)
print "火事を消す。\n";
}
}
1;
Ambulance.pm
package Ambulance {
use base qw(Car);
sub new() {
my ($class) = @_;
my $this = $class->SUPER::new("救急車");
return bless $this, $class;
}
siren() { #(4)
print "ピーポーピーポー\n";
}
}
1;
SuperAmbulance.pm
package SuperAmbulance {
use base qw(Ambulance);
sub new() {
my ($class, $car) = @_;
my $this = $class->SUPER::new();
$this->{car} = $car; #(2)
return bless $this, $class;
}
sub work() { #(3)
my ($this) = @_;
$this->{car}->work();
}
}
1;
main.pl
my $sam = new SuperAmbulance(new FireEngine()); #(1)
$sam->work(); #(3)
$sam->siren(); #(4)
$sam->run(); #(5)
- 〈宣言/定義〉
- Ambulance を基底クラスに持つ派生クラス SuperAmbulance を宣言します。
- work メソッドを定義し、与えられたオブジェクトの work を呼ぶようにします。
- 〈処理の流れ〉
- 派生クラス SuperAmbulance 型の変数 sam を宣言、FireEngine のインスタンスを引数に SuperAmbulance のインスタンスを生成します。
- SuperAmbulance のオブジェクト生成時、コンストラクタがが呼ばれ、FireEngine のオブジェクトが car に保存されます。
- メソッド work を呼び出します。SuperAmbulance の work が実行されます。そして、car 内に保持している FireEngine オブジェクトの work メソッドが呼び出されます。
- メソッド siren を呼び出します。基底クラス Ambulance の siren が実行されます。
- メソッド run を呼び出します。Car の run が実行されます。
同じクラスを継承した、異なる派生クラスのオブジェクトを変数に代入することで、実際にどのオブジェクトが代入されているかを意識せず、異なる働きをさせることができます。このことを「ポリモーフィズム（多態性）」と呼びます。
しかし、Ruby では、変数に型がありませんので、どのようなオブジェクトであろうが「ポリモーフィズム（多態性）」できてしまいます。
Car.rb
class Car
def initialize(kind = "自動車")
@kind = kind
end
def run()
puts @kind + "が走る。"
end
def work()
puts ""
end
end
FireEngine.rb
class FireEngine < Car
def initialize()
super("消防車")
end
def work() #(3)
puts "火事を消す。"
end
end
Ambulance.rb
class Ambulance < Car
def initialize()
super("救急車")
end
def siren() #(4)
puts "ピーポーピーポー"
end
end
SuperAmbulance.rb
class SuperAmbulance < Ambulance
def initialize(car) {
super()
@car = car #(2)
end
def work() #(3)
@car.work()
end
end
main.rb
sam = SuperAmbulance.new(FireEngine.new()) #(1)
sam.work() #(3)
sam.siren() #(4)
sam.run() #(5)
- 〈宣言/定義〉
- Ambulance を基底クラスに持つ派生クラス SuperAmbulance を宣言します。
- 生成されたオブジェクトを保持する Car 型の変数を定義します。
- work メソッドを定義し、与えられたオブジェクトの work を呼ぶようにします。
- 〈処理の流れ〉
- 派生クラス SuperAmbulance 型の変数 sam を宣言、FireEngine のインスタンスを引数に SuperAmbulance のインスタンスを生成します。
- SuperAmbulance のオブジェクト生成時、コンストラクタがが呼ばれ、FireEngine のオブジェクトが @car に保存されます。
- メソッド work を呼び出します。SuperAmbulance の work が実行されます。そして、@car 内に保持している FireEngine オブジェクトの work メソッドが呼び出されます。
- メソッド siren を呼び出します。基底クラス Ambulance の siren が実行されます。
- メソッド run を呼び出します。Car の run が実行されます。
同じクラスを継承した、異なる派生クラスのオブジェクトを変数に代入することで、実際にどのオブジェクトが代入されているかを意識せず、異なる働きをさせることができます。このことを「ポリモーフィズム（多態性）」と呼びます。
しかし、Python では、変数に型がありませんので、どのようなオブジェクトであろうが「ポリモーフィズム（多態性）」できてしまいます。
Car.py
class Car:
def __init__(self, kind = "自動車"):
self.kind = kind
def run(self):
print(f"{self.kind}が走る。")
def work(self):
pass
FireEngine.py
class FireEngine(Car):
def __init__(self):
super().__init__("消防車")
def work(): #(3)
print("火事を消す。")
Ambulance.py
class Ambulance(Car):
def __init__(self):
super().__init__("救急車")
def siren(): #(4)
print("ピーポーピーポー")
SuperAmbulance.py
class SuperAmbulance(Ambulance):
def __init__(self, car):
super().__init__()
self.car = car #(2)
def work(self): #(3)
self.car.work()
main.py
sam = SuperAmbulance(FireEngine()) #(1)
sam.work() #(3)
sam.siren() #(4)
sam.run() #(5)
- 〈宣言/定義〉
- Ambulance を基底クラスに持つ派生クラス SuperAmbulance を宣言します。
- 生成されたオブジェクトを保持する Car 型の変数を定義します。
- work メソッドを定義し、与えられたオブジェクトの work を呼ぶようにします。
- 〈処理の流れ〉
- 派生クラス SuperAmbulance 型の変数 sam を宣言、FireEngine のインスタンスを引数に SuperAmbulance のインスタンスを生成します。
- SuperAmbulance のオブジェクト生成時、コンストラクタがが呼ばれ、FireEngine のオブジェクトが @car に保存されます。
- メソッド work を呼び出します。SuperAmbulance の work が実行されます。そして、@car 内に保持している FireEngine オブジェクトの work メソッドが呼び出されます。
- メソッド siren を呼び出します。基底クラス Ambulance の siren が実行されます。
- メソッド run を呼び出します。Car の run が実行されます。
Car 型の変数には、Car オブジェクトか、Car の「派生クラス」のオブジェクトなら代入できます。SuperAmbulance では、Car 型の変数 car に、その「派生クラス」の FireEngine オブジェクトを代入しています。
こうすることによって、Car の「派生クラス」のオブジェクトなら同じように処理できるわけです。ここでは、Car クラスの持つ work メソッドを呼び出しています。しかし、これによって呼び出されるメソッドは、Car クラスの work メソッドではありません。変数 car に代入されているオブジェクトのクラスである FireEngine の work メソッドです。
ただし、こうした呼び出しで使用できるメソッドは、あくまで Car クラスに存在するものだけです。FireEngine クラスに独自に追加されたメソッドは呼び出すことができません。
基底クラス型に派生クラス型を代入することはオブジェクト指向の重要な特徴です。基本クラスのオブジェクト変数に異なる派生クラスのオブジェクトを代入することで、メソッドの働きが変わることを「ポリモーフィズム（多態性）」と呼びます。
Car.php
<?php
class Car {
public function __construct($kind = "自動車") { //(2)
$this->kind = $kind;
}
public function run() {
print $this->kind . "が走る。\n";
}
public function work() {
print "\n";
}
}
?>
FireEngine.php
<?php
require_once('Car.php');
class FireEngine extends Car {
public function __construct() {
parent::__construct("消防車");
}
public function work() { //(3)
print "火事を消す。\n";
}
}
?>
Ambulance.php
<?php
require_once('Car.php');
class Ambulance extends Car {
public function __construct() {
parent::__construct("救急車");
}
public function siren() { //(4)
print "ピーポーピーポー";
}
}
?>
SuperAmbulance.php
<?php
require_once('Ambulance.php');
class SuperAmbulance extends Ambulance {
public function __construct($car) {
$this->car = $car; //(2)
}
public function work() { //(3)
$this->car->work();
}
}
?>
Example.php
<?php
require('FireEngine.php');
require('SuperAmbulance.php');
$sam = new SuperAmbulance(new FireEngine()); //(1)
$sam->work(); //(3)
$sam->siren(); //(4)
$sam->run(); //(5)
?>
- 〈宣言/定義〉
- Ambulance を基底クラスに持つ派生クラス SuperAmbulance を宣言します。
- work メソッドを定義し、与えられたオブジェクトの work を呼ぶようにします。
- 〈処理の流れ〉
- 派生クラス SuperAmbulance 型の変数 $sam を宣言、FireEngine のインスタンスを引数に SuperAmbulance のインスタンスを生成します。
- SuperAmbulance のオブジェクト生成時、コンストラクタがが呼ばれ、FireEngine のオブジェクトが car に保存されます。
- メソッド work を呼び出します。SuperAmbulance の work が実行されます。そして、car 内に保持している FireEngine オブジェクトの work メソッドが呼び出されます。
- メソッド siren を呼び出します。基底クラス Ambulance の siren が実行されます。
- メソッド run を呼び出します。Car の run が実行されます。
Car 型の変数には、Car オブジェクトか、Car の「派生クラス」のオブジェクトなら代入できます。SuperAmbulance では、Car 型の変数 car に、その「派生クラス」の FireEngine オブジェクトを代入しています。
こうすることによって、Car の「派生クラス」のオブジェクトなら同じように処理できるわけです。ここでは、Car クラスの持つ work メソッドを呼び出しています。しかし、これによって呼び出されるメソッドは、Car クラスの work メソッドではありません。変数 car に代入されているオブジェクトのクラスである FireEngine の work メソッドです。
ただし、こうした呼び出しで使用できるメソッドは、あくまで Car クラスに存在するものだけです。FireEngine クラスに独自に追加されたメソッドは呼び出すことができません。
基底クラス型に派生クラス型を代入することはオブジェクト指向の重要な特徴です。基本クラスのオブジェクト変数に異なる派生クラスのオブジェクトを代入することで、メソッドの働きが変わることを「ポリモーフィズム（多態性）」と呼びます。
Car.ts
export
class Car {
protected kind:string = "自動車";
public constructor(kind:string = "自動車") {
this.kind = kind;
}
public run():void {
process.stdout.write(kind + "が走る。\n");
}
public work():void {
process.stdout.write("\n");
}
}
FireEngine.ts
import {Car} from "./Car";
export
class FireEngine extends Car {
public constructor() {
super("消防車");
}
public work():void { //(3)
process.stdout.write("火事を消す。\n");
}
}
Ambulance.ts
import {Car} from "./Car";
export
class Ambulance extends Car {
public constructor() {
super("救急車");
}
public siren():void { //(4)
process.stdout.write("ピーポーピーポー\n");
}
}
SuperAmbulance.ts
import {Ambulance} from "./Ambulance";
import {Car} from "./Car";
export
class SuperAmbulance extends Ambulance {
private car:Car;
public constructor(car:Car) {
super();
this.car = car; //(2)
}
public work():void { //(3)
this.car.work();
}
}
Example.ts
import {FireEngine} from "./FireEngine";
import {SuperAmbulance} from "./SuperAmbulance";
let sam:SuperAmbulance = new SuperAmbulance(new FireEngine()); //(1)
sam.work(); //(3)
sam.siren(); //(4)
sam.run(); //(5)
- 〈宣言/定義〉
- Ambulance を基底クラスに持つ派生クラス SuperAmbulance を宣言します。
- 生成されたオブジェクトを保持する Car 型の変数を定義します。
- work メソッドを定義し、与えられたオブジェクトの work を呼ぶようにします。
- 〈処理の流れ〉
- 派生クラス SuperAmbulance 型の変数 sam を宣言、FireEngine のインスタンスを引数に SuperAmbulance のインスタンスを生成します。
- SuperAmbulance のオブジェクト生成時、コンストラクタがが呼ばれ、FireEngine のオブジェクトが car に保存されます。
- メソッド work を呼び出します。SuperAmbulance の work が実行されます。そして、car 内に保持している FireEngine オブジェクトの work メソッドが呼び出されます。
- メソッド siren を呼び出します。基底クラス Ambulance の siren が実行されます。
- メソッド run を呼び出します。Car の run が実行されます。
Car 型の変数には、Car オブジェクトか、Car の「派生クラス」のオブジェクトなら代入できます。SuperAmbulance では、Car 型の変数 car に、その「派生クラス」の FireEngine オブジェクトを代入しています。
こうすることによって、Car の「派生クラス」のオブジェクトなら同じように処理できるわけです。ここでは、Car クラスの持つ work メソッドを呼び出しています。しかし、これによって呼び出されるメソッドは、Car クラスの work メソッドではありません。変数 car に代入されているオブジェクトのクラスである FireEngine の work メソッドです。
ただし、こうした呼び出しで使用できるメソッドは、あくまで Car クラスに存在するものだけです。FireEngine クラスに独自に追加されたメソッドは呼び出すことができません。
基底クラス型に派生クラス型を代入することはオブジェクト指向の重要な特徴です。基本クラスのオブジェクト変数に異なる派生クラスのオブジェクトを代入することで、メソッドの働きが変わることを「ポリモーフィズム（多態性）」と呼びます。
Car.swift
class Car {
internal var kind:string = "自動車"
public init(kind:String = "自動車") {
self.kind = kind
}
public func run() {
print("\(kind)が走る。")
}
public func work() {
print()
}
}
FireEngine.swift
class FireEngine : Car {
public init() {
super.init("消防車")
}
public override func work() { //(3)
print("火事を消す。")
}
}
Ambulance.swift
class Ambulance : Car {
public init() {
super.init("救急車")
}
public func siren() { //(4)
print("ピーポーピーポー")
}
}
SuperAmbulance.swift
class SuperAmbulance : Ambulance {
internal var car:Car
public init(car:Car) {
super.init()
self.car = car //(2)
}
public override func work() { //(3)
car.work()
}
}
Example.swift
let sam:SuperAmbulance = SuperAmbulance(FireEngine()) //(1)
sam.work() //(3)
sam.siren() //(4)
sam.run() //(5)
- 〈宣言/定義〉
- Ambulance を基底クラスに持つ派生クラス SuperAmbulance を宣言します。
- 生成されたオブジェクトを保持する Car 型の変数を定義します。
- work メソッドを定義し、与えられたオブジェクトの work を呼ぶようにします。
- 〈処理の流れ〉
- 派生クラス SuperAmbulance 型の変数 sam を宣言、FireEngine のインスタンスを引数に SuperAmbulance のインスタンスを生成します。
- SuperAmbulance のオブジェクト生成時、コンストラクタがが呼ばれ、FireEngine のオブジェクトが car に保存されます。
- メソッド work を呼び出します。SuperAmbulance の work が実行されます。そして、car 内に保持している FireEngine オブジェクトの work メソッドが呼び出されます。
- メソッド siren を呼び出します。基底クラス Ambulance の siren が実行されます。
- メソッド run を呼び出します。Car の run が実行されます。
Car 型の変数には、Car オブジェクトか、Car の「派生クラス」のオブジェクトなら代入できます。SuperAmbulance では、Car 型の変数 car に、その「派生クラス」の FireEngine オブジェクトを代入しています。
こうすることによって、Car の「派生クラス」のオブジェクトなら同じように処理できるわけです。ここでは、Car クラスの持つ work メソッドを呼び出しています。しかし、これによって呼び出されるメソッドは、Car クラスの work メソッドではありません。変数 car に代入されているオブジェクトのクラスである FireEngine の work メソッドです。
ただし、こうした呼び出しで使用できるメソッドは、あくまで Car クラスに存在するものだけです。FireEngine クラスに独自に追加されたメソッドは呼び出すことができません。
基底クラス型に派生クラス型を代入することはオブジェクト指向の重要な特徴です。基本クラスのオブジェクト変数に異なる派生クラスのオブジェクトを代入することで、メソッドの働きが変わることを「ポリモーフィズム（多態性）」と呼びます。
Car.kt
class Car(val kind: String = "自動車") {
fun run() {
println("${kind}が走る。")
}
open fun work() {
println()
}
}
FireEngine.kt
class FireEngine : Car("消防車") {
override fun work() { //(3)
println("火事を消す。")
}
}
Ambulance.kt
open class Ambulance : Car("救急車") {
fun siren() { //(4)
println("ピーポーピーポー")
}
}
SuperAmbulance.kt
class SuperAmbulance(val car:Car) : Ambulance() { //(2)
override fun work() { //(3)
car.work()
}
}
Main.kt
fun main() {
val sam:SuperAmbulance = SuperAmbulance(FireEngine()) //(1)
sam.work() //(3)
sam.siren() //(4)
sam.run() //(5)
}
- 〈宣言/定義〉
- Ambulance を基底クラスに持つ派生クラス SuperAmbulance を宣言します。
- 生成されたオブジェクトを保持する Car 型の変数を定義します。
- work メソッドを定義し、与えられたオブジェクトの work を呼ぶようにします。
- 〈処理の流れ〉
- 派生クラス SuperAmbulance 型の変数 sam を宣言、FireEngine のインスタンスを引数に SuperAmbulance のインスタンスを生成します。
- SuperAmbulance のオブジェクト生成時、コンストラクタがが呼ばれ、FireEngine のオブジェクトが car に保存されます。
- メソッド work を呼び出します。SuperAmbulance の work が実行されます。そして、car 内に保持している FireEngine オブジェクトの work メソッドが呼び出されます。
- メソッド siren を呼び出します。基底クラス Ambulance の siren が実行されます。
- メソッド run を呼び出します。Car の run が実行されます。
Car 型の変数には、Car オブジェクトか、Car の「派生クラス」のオブジェクトなら代入できます。SuperAmbulance では、Car 型の変数 car に、その「派生クラス」の FireEngine オブジェクトを代入しています。
こうすることによって、Car の「派生クラス」のオブジェクトなら同じように処理できるわけです。ここでは、Car クラスの持つ work メソッドを呼び出しています。しかし、これによって呼び出されるメソッドは、Car クラスの work メソッドではありません。変数 car に代入されているオブジェクトのクラスである FireEngine の work メソッドです。
ただし、こうした呼び出しで使用できるメソッドは、あくまで Car クラスに存在するものだけです。FireEngine クラスに独自に追加されたメソッドは呼び出すことができません。
基底クラス型に派生クラス型を代入することはオブジェクト指向の重要な特徴です。基本クラスのオブジェクト変数に異なる派生クラスのオブジェクトを代入することで、メソッドの働きが変わることを「ポリモーフィズム（多態性）」と呼びます。
Car.scala
class Car(val kind: String = "自動車") {
def run() {
System.out.println(this.kind + "が走る。")
}
def work() {
System.out.println()
}
}
FireEngine.scala
class FireEngine extends Car("消防車") {
override def work() { //(3)
System.out.println("火事を消す。")
}
}
Ambulance.scala
class Ambulance extends Car("救急車") {
def siren() { //(4)
System.out.println("ピーポーピーポー")
}
}
SuperAmbulance.scala
class SuperAmbulance(val car:Car) extends Ambulance() { //(2)
override def work() { //(3)
car.work()
}
}
Main.scala
object Main {
def main(args: Array[String]) {
val sam:SuperAmbulance = new SuperAmbulance(new FireEngine()) //(1)
sam.work() //(3)
sam.siren() //(4)
sam.run() //(5)
}
}
- 〈宣言/定義〉
- Ambulance を基底クラスに持つ派生クラス SuperAmbulance を宣言します。
- 生成されたオブジェクトを保持する Car 型の変数を定義します。
- work メソッドを定義し、与えられたオブジェクトの work を呼ぶようにします。
- 〈処理の流れ〉
- 派生クラス SuperAmbulance 型の変数 sam を宣言、FireEngine のインスタンスを引数に SuperAmbulance のインスタンスを生成します。
- SuperAmbulance のオブジェクト生成時、コンストラクタがが呼ばれ、FireEngine のオブジェクトが car に保存されます。
- メソッド work を呼び出します。SuperAmbulance の work が実行されます。そして、car 内に保持している FireEngine オブジェクトの work メソッドが呼び出されます。
- メソッド siren を呼び出します。基底クラス Ambulance の siren が実行されます。
- メソッド run を呼び出します。Car の run が実行されます。
Car 型の変数には、Car オブジェクトか、Car の「派生クラス」のオブジェクトなら代入できます。SuperAmbulance では、Car 型の変数 car に、その「派生クラス」の FireEngine オブジェクトを代入しています。
こうすることによって、Car の「派生クラス」のオブジェクトなら同じように処理できるわけです。ここでは、Car クラスの持つ work メソッドを呼び出しています。しかし、これによって呼び出されるメソッドは、Car クラスの work メソッドではありません。変数 car に代入されているオブジェクトのクラスである FireEngine の work メソッドです。
ただし、こうした呼び出しで使用できるメソッドは、あくまで Car クラスに存在するものだけです。FireEngine クラスに独自に追加されたメソッドは呼び出すことができません。
基底クラス型に派生クラス型を代入することはオブジェクト指向の重要な特徴です。基本クラスのオブジェクト変数に異なる派生クラスのオブジェクトを代入することで、メソッドの働きが変わることを「ポリモーフィズム（多態性）」と呼びます。
Car.groovy
class Car {
String kind = "自動車"
Car() { }
Car(String kind) {
this.kind = kind
}
void run() {
System.out.println(kind + "が走る。")
}
void work() {
System.out.println("")
}
}
FireEngine.groovy
class FireEngine extends Car {
FireEngine() {
super("消防車")
}
void work() { //(3)
System.out.println("火事を消す。")
}
}
Ambulance.groovy
class Ambulance extends Car {
public Ambulance() {
super("救急車")
}
void siren() { //(4)
System.out.println("ピーポーピーポー")
}
}
SuperAmbulance.groovy
class SuperAmbulance extends Ambulance {
Car car
SuperAmbulance(Car car) {
this.car = car //(2)
}
void work() { //(3)
car.work()
}
}
Main.groovy
public class Main {
static void main(String[] args) {
SuperAmbulance sam = new SuperAmbulance(new FireEngine()) //(1)
sam.work() //(3)
sam.siren() //(4)
sam.run() //(5)
}
}
- 〈宣言/定義〉
- Ambulance を基底クラスに持つ派生クラス SuperAmbulance を宣言します。
- 生成されたオブジェクトを保持する Car 型の変数を定義します。
- work メソッドを定義し、与えられたオブジェクトの work を呼ぶようにします。
- 〈処理の流れ〉
- 派生クラス SuperAmbulance 型の変数 sam を宣言、FireEngine のインスタンスを引数に SuperAmbulance のインスタンスを生成します。
- SuperAmbulance のオブジェクト生成時、コンストラクタがが呼ばれ、FireEngine のオブジェクトが car に保存されます。
- メソッド work を呼び出します。SuperAmbulance の work が実行されます。そして、car 内に保持している FireEngine オブジェクトの work メソッドが呼び出されます。
- メソッド siren を呼び出します。基底クラス Ambulance の siren が実行されます。
- メソッド run を呼び出します。Car の run が実行されます。
「派生クラス」のオブジェクトが共通に持つメソッドを定義したインタフェースを作成します。
SuperAmbulance では、ICar インタフェース型の変数 car に、「派生クラス」の FireEngine オブジェクトを代入しています。
こうすることによって、Car の「派生クラス」のオブジェクトなら同じように処理できるわけです。ここでは、Car クラスの持つ Work メソッドを呼び出しています。しかし、これによって呼び出されるメソッドは、Car クラスの Work メソッドではありません。変数 car に代入されているオブジェクトのクラスである FireEngine の Work メソッドです。
ただし、こうした呼び出しで使用できるメソッドは、あくまでインタフェースに存在するものだけです。FireEngine クラスに独自に追加されたメソッドは呼び出すことができません。
インタフェース型に、異なる派生クラスのオブジェクトを代入することで、メソッドの働きが変わることを「ポリモーフィズム（多態性）」と呼びます。
Car.go
import "fmt"
type Car struct {
kind string
}
func (car *Car) Run() {
fmt.Printf("%sが走る。\n", car.kind)
}
func (*Car) Work() {
fmt.Printf("\n")
}
func NewCar(param ...string) *Car { //(2)
var kind string
if param == nil {
kind = "自動車"
} else {
kind = param[0]
}
return &Car{kind}
}
FireEngine.go
import "fmt"
type FireEngine struct {
*Car
}
func (*FireEngine) Work() { //(3)
fmt.Printf("火事を消す。\n")
}
func NewFireEngine() *FireEngine {
return &FireEngine {
Car: NewCar("消防車"),
}
}
Ambulance.go
import "fmt"
type Ambulance struct {
*Car
}
func (*Ambulance) Siren() { //(4)
fmt.Printf("ピーポーピーポー\n")
}
func NewAmbulance() *Ambulance { //(2)
return &Ambulance {
Car: NewCar("救急車")
}
}
SuperAmbulance.go
type ICar interface {
Run()
Work()
}
type SuperAmbulance struct {
car ICar
*Ambulance
}
func (fam *SuperAmbulance) Work() { //(3)
fam.car.Work()
}
func NewSuperAmbulance(car ICar) *SuperAmbulance {
return &SuperAmbulance {
Ambulance: NewAmbulance(),
car: car, //(2)
}
}
Main.go
func main {
var sam = NewSuperAmbulance(NewFireEngine()) //(1)
sam.Work() //(3)
sam.Siren() //(4)
sam.Run() //(5)
}
- 〈宣言/定義〉
- Ambulance を基底クラスに持つ派生クラス SuperAmbulance を宣言します。
- 生成されたオブジェクトを保持する ICar 型の変数を定義します。
- Work メソッドを定義し、与えられたオブジェクトの Work を呼ぶようにします。
- 〈処理の流れ〉
- 派生クラス SuperAmbulance 型の変数 sam を宣言、FireEngine のインスタンスを引数に SuperAmbulance のインスタンスを生成します。
- SuperAmbulance のオブジェクト生成時、コンストラクタがが呼ばれ、FireEngine のオブジェクトが car に保存されます。
- メソッド Work を呼び出します。SuperAmbulance の Work が実行されます。そして、car 内に保持している FireEngine オブジェクトの Work メソッドが呼び出されます。
- メソッド Siren を呼び出します。基底クラス Ambulance の Siren が実行されます。
- メソッド Run を呼び出します。Car の Run が実行されます。
Car 型の変数には、Car オブジェクトか、Car の「派生クラス」のオブジェクトなら代入できます。SuperAmbulance では、Car 型の変数 car に、その「派生クラス」の FireEngine オブジェクトを代入しています。
こうすることによって、Car の「派生クラス」のオブジェクトなら同じように処理できるわけです。ここでは、Car クラスの持つ work メソッドを呼び出しています。しかし、これによって呼び出されるメソッドは、Car クラスの work メソッドではありません。変数 car に代入されているオブジェクトのクラスである FireEngine の work メソッドです。
ただし、こうした呼び出しで使用できるメソッドは、あくまで Car クラスに存在するものだけです。FireEngine クラスに独自に追加されたメソッドは呼び出すことができません。
基底クラス型に派生クラス型を代入することはオブジェクト指向の重要な特徴です。基本クラスのオブジェクト変数に異なる派生クラスのオブジェクトを代入することで、メソッドの働きが変わることを「ポリモーフィズム（多態性）」と呼びます。
car.d
public class Car {
protected string kind = "自動車";
public this() { }
public this(string kind) { //(2)
this.kind = kind;
}
public void run() { //(3)
printfln("%sが走る。", kind);
}
public void work() {
printfln("");
}
protected void printfln(T...)(T args) { // Shift JIS 出力
import std, std.windows.charset, core.vararg;
std.stdio.write(to!(string)(toMBSz(std.format.format(args))) ~ "\n");
}
}
fireengine.d
import car;
public class FireEngine extends Car {
public this() {
super("消防車");
}
public override void work() { //(3)
printfln("火事を消す。");
}
}
ambulance.d
import car;
public class Ambulance : Car {
public this() {
super("救急車");
}
public void siren() { //(4)
printfln("ピーポーピーポー");
}
}
superambulance.d
import car;
import ambulance;
public class SuperAmbulance : Ambulance {
private Car car;
public this(Car car) {
this.car = car; //(2)
}
public override void work() { //(3)
car.work();
}
}
main.d
import superambulance;
import fireengine;
public int main() {
SuperAmbulance sam = new SuperAmbulance(new FireEngine()); //(1)
sam.work(); //(3)
sam.siren(); //(4)
sam.run(); //(5)
}
- 〈宣言/定義〉
- Ambulance を基底クラスに持つ派生クラス SuperAmbulance を宣言します。
- 生成されたオブジェクトを保持する Car 型の変数を定義します。
- work メソッドを定義し、与えられたオブジェクトの work を呼ぶようにします。
- 〈処理の流れ〉
- 派生クラス SuperAmbulance 型の変数 sam を宣言、FireEngine のインスタンスを引数に SuperAmbulance のインスタンスを生成します。
- SuperAmbulance のオブジェクト生成時、コンストラクタがが呼ばれ、FireEngine のオブジェクトが car に保存されます。
- メソッド work を呼び出します。SuperAmbulance の work が実行されます。そして、car 内に保持している FireEngine オブジェクトの work メソッドが呼び出されます。
- メソッド siren を呼び出します。基底クラス Ambulance の siren が実行されます。
- メソッド run を呼び出します。Car の run が実行されます。
Car 型の変数には、Car オブジェクトか、Car の「派生クラス」のオブジェクトなら代入できます。SuperAmbulance では、Car 型の変数 car に、その「派生クラス」の FireEngine オブジェクトを代入しています。
こうすることによって、Car の「派生クラス」のオブジェクトなら同じように処理できるわけです。ここでは、Car クラスの持つ work メソッドを呼び出しています。しかし、これによって呼び出されるメソッドは、Car クラスの work メソッドではありません。変数 car に代入されているオブジェクトのクラスである FireEngine の work メソッドです。
ただし、こうした呼び出しで使用できるメソッドは、あくまで Car クラスに存在するものだけです。FireEngine クラスに独自に追加されたメソッドは呼び出すことができません。
基底クラス型に派生クラス型を代入することはオブジェクト指向の重要な特徴です。基本クラスのオブジェクト変数に異なる派生クラスのオブジェクトを代入することで、メソッドの働きが変わることを「ポリモーフィズム（多態性）」と呼びます。
Car.pas
unit UnitCar;
interface
type
Car = class(TInterfacedObject)
protected
var kind:string;
public
constructor Create(); overload;
constructor Create(kind:string); overload;
procedure run();
procedure work(); virtual;
end;
implementation
constructor Car.Create(); //(2)
begin
kind := '自動車';
end;
constructor Car.Create(kind:string)
begin
self.kind = kind;
end;
procedure Car.run();
begin
Writeln(kind + 'が走る。');
end;
procedure Car.work();
begin
Writeln('');
end;
end.
FireEngine.pas
unit UnitFireEngine;
interface
uses
UnitCar;
type
FireEngine = class(Car)
public
constructor Create();
procedure work(); override;
end;
implementation
constructor FireEngine.Create();
begin
inherited Create('消防車');
end;
procedure FireEngine.work(); //(3)
begin
Writeln('火事を消す。');
end;
end.
Ambulance.pas
unit UnitAmbulance;
interface
uses
UnitCar;
type
Ambulance = class(Car)
public
constructor Create();
procedure siren();
end;
implementation
constructor Ambulance.Create();
begin
inherited Create('救急車');
end;
procedure Ambulance.siren(); //(4)
begin
Writeln('ピーポーピーポー');
end;
end.
SuperAmbulance.pas
unit UnitSuperAmbulance;
interface
uses
UnitCar,
UnitAmbulance;
type
SuperAmbulance = class(Ambulance);
public
constructor Create(car: Car);
procedure work(); override;
end;
implementation
var _car: Car;
constructor SuperAmbulance.Create(car:Car);
begin
_car := car; //(2)
inherited Create();
end;
procedure SuperAmbulance.work(); //(3)
begin
_car.work();
end;
end.
Main.dpr
program Main;
uses
UnitSuperAmbulance,
UnitFireEngine;
var sam:SuperAmbulance;
var fir:FireEngine;
begin
fir := FireEngine.Create();
sam := SuperAmbulance.Create(fir); //(1)
sam.work(); //(3)
sam.siren(); //(4)
sam.run(); //(5)
sam.Free;
fir.Free;
end.
- 〈宣言/定義〉
- Ambulance を基底クラスに持つ派生クラス SuperAmbulance を宣言します。
- 生成されたオブジェクトを保持する Car 型の変数を定義します。
- work メソッドを定義し、与えられたオブジェクトの work を呼ぶようにします。
- 〈処理の流れ〉
- 派生クラス SuperAmbulance 型の変数 sam を宣言、FireEngine のインスタンスを引数に SuperAmbulance のインスタンスを生成します。
- SuperAmbulance のオブジェクト生成時、コンストラクタがが呼ばれ、FireEngine のオブジェクトが _car に保存されます。
- メソッド work を呼び出します。SuperAmbulance の work が実行されます。そして、_car 内に保持している FireEngine オブジェクトの work メソッドが呼び出されます。
- メソッド siren を呼び出します。基底クラス Ambulance の siren が実行されます。
- メソッド run を呼び出します。Car の run が実行されます。
実行結果です。
火事を消す。 ピーポーピーポー 救急車が走る。