演習問題１（ショッピングカート 合計金額）
演習問題１－４ （Bridge）
機能を追加するために、styleNormal クラスを継承して作成した新しい StyleComma クラスでも、すでに存在している通貨記号の付加機能を利用することができています。
Bridgeパターンを適用する目的は、「実装方法と機能を別々に拡張できるようにする」ことです。機能を拡張するためのクラス階層と、実装を拡張するためのクラス階層を分けておくことで、実装階層クラス（SymbolKanjiYen や SymbolYenmark）と機能拡張クラス（StyleComma）を好みの組み合わせで利用することができるようになります。
この例では、StyleNormal クラスと ISymbolCurrency インタフェース（あるいは SymbolCurrency クラス）が機能拡張クラス階層と実装拡張クラス階層を橋渡しする役目を果たします。
実行結果
合計金額は 2560円
合計金額は \2560
合計金額は 2,560円
合計金額は 2560円
合計金額は \2,560
合計金額は \2560
コード
Enshu104.java
public class Enshu104 {
public static void main(String[] args ) {
Cart cart = new Cart ();
cart .add(new Meat ("牛肉", 395, 400));
cart .add(new Vegetable ("じゃがいも", 98, 10));
int price = cart .getTotalPrice();
StyleNormal k1 = new StyleNormal (new SymbolKanjiYen ());
System.out .println("合計金額は " + k1 .display(price )); // 2560円
k1 = new StyleNormal (new SymbolYenmark ());
System.out .println("合計金額は " + k1 .display(price )); // \ 2560
StyleComma k2 = new StyleComma (new SymbolKanjiYen ());
System.out .println("合計金額は " + k2 .displayComma(price )); // 2,560円
System.out .println("合計金額は " + k2 .display(price )); // 2560円
k2 = new StyleComma (new SymbolYenmark ());
System.out .println("合計金額は " + k2 .displayComma(price )); // \ 2,560
System.out .println("合計金額は " + k2 .display(price )); // \ 2560
}
}
ヒント（ISymbolCurrency インターフェース）
通貨記号を金額に付加して返す ISymbolCurrency インタフェースを作成します。後ろに"円"を付ける SymbolKanjiYen クラスと前に "\"を付ける SymbolYenmark クラスは、この ISymbolCurrency インタフェースをインプリメントして作成します。
これらのクラスの display()は、引数として受け取った金額文字列に通貨記号を付加して返す処理を実装します。
ISymbolCurrency インターフェースのコードを見ますか？ はい いいえ
ISymbolCurrency.java
public interface ISymbolCurrency {
public String display(String currency );
}
ヒント（StyleNormal クラス）
カンマ区切りをしない StyleNormal クラスを作成します。このクラスの display() は金額文字列には何もせず、コンストラクタで受け取った ISymbolCurrency インタフェースをインプリメントしたクラスの display() を呼びます。
次に、このクラスを継承して StyleComma クラスを作成します。３桁ごとにカンマ区切りをする displayComma() では、金額文字列をカンマ区切りにし、それを引数にして、コンストラクタで受け取った ISymbolCurrency インタフェースをインプリメントしたクラスの display() を呼びます。カンマ区切りをしない数字の羅列として表示する display() はスーパークラスの StyleNormal クラスのものが実行されます。
StyleNormal クラスのコードを見ますか？ はい いいえ
StyleNormal.java
public class StyleNormal {
private ISymbolCurrency symbol ;
public StyleNormal (ISymbolCurrency symbol ) {
this.symbol = symbol ;
}
public String display(int currency ) {
return symbol .display("" + currency );
}
public String display(String currency ) {
return symbol .display(currency );
}
}
解答
StyleNormal.java
public class StyleNormal {
private ISymbolCurrency symbol ;
public StyleNormal (ISymbolCurrency symbol ) {
this.symbol = symbol ;
}
public String display(int currency ) {
return symbol .display("" + currency );
}
public String display(String currency ) {
return symbol .display(currency );
}
}
StyleComma.java
public class StyleComma extends StyleNormal {
public StyleComma (ISymbolCurrency symbol ) {
super(symbol );
}
public String displayComma(int price ) {
NumberFormat nf = NumberFormat .getNumberInstance (); // カンマ区切り形式
String s = nf .format(price );
return display(s );
}
}
ISymbolCurrency.java
public interface ISymbolCurrency {
public String display(String currency );
}
SymbolKanjiYen.java
public class SymbolKanjiYen implements ISymbolCurrency {
public String display(String currency ) {
return currency + "円";
}
}
SymbolYenmark.java
public class SymbolYenmark implements ISymbolCurrency {
public String display(String currency ) {
return \\ "currency ;
}
}
Enshu104.cpp
#include <iostream>
using namespace std;
#include "Cart.h"
#include "Vegetable.h"
#include "Meat.h"
#include "StyleNormal.h"
#include "SymbolKanjiYen.h"
#include "SymbolYenmark.h"
#include "StyleComma.h"
int main()
{
Cart * cart = new Cart ();
cart ->add(new Meat ("牛肉", 395, 400));
cart ->add(new Vegetable ("じゃがいも", 98, 10));
int price = cart ->getTotalPrice();
symbolKanjiYen s1 ;
styleNormal * k = new styleNormal (&s1 );
cout << "合計金額は " << k ->display(price ) << endl; // 2560円
delete k ;
symbolYenmark s2 ;
k = new styleNormal (&s2 );
cout << "合計金額は " << k ->display(price ) << endl; // \ 2560
delete k ;
k = new StyleComma (&s1 );
cout << "合計金額は " << ((StyleComma *)k )->displayComma(StyleComma ) << endl; // 2,560円
cout << "合計金額は " << k ->display(StyleComma ) << endl; // 2560円
delete k ;
k = new StyleComma (&s2 );
cout << "合計金額は " << ((StyleComma *)k )->displayComma(price ) << endl; // \ 2,560
cout << "合計金額は " << k ->display(price ) << endl; // \ 2560
delete k ;
delete cart ;
return 0;
}
ヒント（SymbolCurrency クラス）
通貨記号を金額に付加して返す SymbolCurrency クラスを作成します。後ろに"円"を付ける SymbolKanjiYen クラスと前に "\"を付ける SymbolYenmark クラスは、この SymbolCurrency クラスを継承して作成します。
これらのクラスの display()は、引数として受け取った金額文字列に通貨記号を付加して返す処理を実装します。
SymbolCurrency クラスのコードを見ますか？ はい いいえ
SymbolCurrency.h
#pragma once
#include <string>
class SymbolCurrency
{
public:
SymbolCurrency();
virtual ~SymbolCurrency(void);
virtual std::string display(std::string ) = 0;
};
SymbolCurrency.cpp
#include "symbolCurrency.h"
SymbolCurrency ::SymbolCurrency(void) {}
SymbolCurrency ::~SymbolCurrency(void) {}
ヒント（StyleNormal クラス）
カンマ区切りをしない StyleNormal クラスを作成します。このクラスの display() は金額文字列には何もせず、コンストラクタで受け取った SymbolCurrency クラスの派生クラスの display() を呼びます。
次に、このクラスを継承して StyleComma クラスを作成します。３桁ごとにカンマ区切りをする displayComma() では、金額文字列をカンマ区切りにし、それを引数にして、コンストラクタで受け取った SymbolCurrency クラスの派生クラスの display() を呼びます。カンマ区切りをしない数字の羅列として表示する display() は基本クラスの StyleNormal クラスのものが実行されます。
StyleNormal クラスのコードを見ますか？ はい いいえ
StyleNormal.h
#pragma once
#include "SymbolCurrency.h"
class StyleNormal
{
private:
SymbolCurrency * currency ;
public:
StyleNormal(void);
StyleNormal(SymbolCurrency *);
virtual ~StyleNormal(void );
std::string display(int);
std::string display(std::string );
};
StyleNormal.cpp
#include "StyleNormal.h"
using namespace std;
StyleNormal ::StyleNormal(void) : currency ((SymbolCurrency *)0) {}
StyleNormal ::StyleNormal(SymbolCurrency * c ) : currency (c ) {}
StyleNormal ::~StyleNormal(void) {}
string StyleNormal ::display(int price )
{
return currency ->display(std::to_string(price );
}
string StyleNormal ::display(string price )
{
return currency ->display(price );
}
解答
StyleNormal.h
#pragma once
#include "SymbolCurrency.h"
class StyleNormal
{
private:
SymbolCurrency * currency ;
public:
StyleNormal(void);
StyleNormal(SymbolCurrency *);
virtual ~StyleNormal(void );
std::string display(int);
std::string display(std::string );
};
StyleNormal.cpp
#include "StyleNormal.h"
using namespace std;
StyleNormal ::StyleNormal(void) : currency ((SymbolCurrency *)0) {}
StyleNormal ::StyleNormal(SymbolCurrency * c ) : currency (c ) {}
StyleNormal ::~StyleNormal(void) {}
string StyleNormal ::display(int price )
{
return currency ->display(std::to_string(price ));
}
string StyleNormal ::display(string price )
{
return currency ->display(price );
}
StyleComma.h
#pragma once
#include <string>
#include "StyleNormal.h"
class StyleComma : public StyleNormal
{
public:
StyleComma(void);
StyleComma(symbolCurrency *);
virtual ~StyleComma(void);
std::string displayComma(int);
};
StyleComma.cpp
#include <sstream>
#include "StyleComma.h"
StyleComma ::StyleComma(void) {}
StyleComma ::StyleComma(SymbolCurrency * c ) : StyleNormal(c ) {}
StyleComma ::~StyleComma(void) {}
string StyleComma ::displayComma(int price )
{
ostringstream ss ;
ss .imbue(locale (""));
ss << fixed << price ;
return display(ss .str());
}
SymbolCurrency.h
#pragma once
#include <string>
class SymbolCurrency
{
public:
SymbolCurrency();
virtual ~SymbolCurrency(void);
virtual std::string display(std::string ) = 0;
};
SymbolCurrency.cpp
#include "SymbolCurrency.h"
SymbolCurrency ::SymbolCurrency(void) {}
SymbolCurrency ::~SymbolCurrency(void) {}
SymbolKanjiYen.h
#pragma once
#include "SymbolCurrency.h"
class SymbolKanjiYen : public SymbolCurrency
{
public:
SymbolKanjiYen();
virtual ~SymbolKanjiYen(void);
virtual std::string display(std::string );
};
SymbolKanjiYen.cpp
#include "SymbolKanjiYen.h"
using namespace std;
SymbolKanjiYen ::SymbolKanjiYen(void) {}
SymbolKanjiYen ::~SymbolKanjiYen(void) {}
string SymbolKanjiYen ::display(string currency )
{
return currency + "円";
}
SymbolYenmark.h
#pragma once
#include "symbolCurrency.h"
class SymbolYenmark : public SymbolCurrency
{
public:
SymbolYenmark();
virtual ~SymbolYenmark(void);
virtual std::string display(std::string );
};
SymbolYenmark.cpp
#include "SymbolYenmark.h"
using namespace std;
SymbolYenmark ::SymbolYenmark(void) {}
SymbolYenmark ::~SymbolYenmark(void) {}
string SymbolYenmark ::display(string currency )
{
return \\ "currency ;
}
Enshu104.cs
class Program
{
static void Main(string[] args )
{
Cart cart = new Cart ();
cart .add(new Meat ("牛肉", 395, 400));
cart .add(new Vegetable ("じゃがいも", 98, 10));
int price = cart .getTotalPrice();
StyleNormal k1 = new StyleNormal (new SymbolKanjiYen ());
Console .WriteLine("合計金額は " + k1 .display(price )); // 2560円
k1 = new StyleNormal (new SymbolYenmark ());
Console .WriteLine("合計金額は " + k1 .display(price )); // \ 2560
StyleComma k2 = new StyleComma (new SymbolKanjiYen ());
Console .WriteLine("合計金額は " + k2 .displayComma(price )); // 2,560円
Console .WriteLine("合計金額は " + k2 .display(price )); // 2560円
k2 = new StyleComma (new SymbolYenmark ());
Console .WriteLine("合計金額は " + k2 .displayComma(price )); // \ 2,560
Console .WriteLine("合計金額は " + k2 .display(price )); // \ 2560
}
}
ヒント（ISymbolCurrency インターフェース）
通貨記号を金額に付加して返す ISymbolCurrency インターフェースを作成します。後ろに"円"を付ける SymbolKanjiYen クラスと前に "\"を付ける SymbolYenmark クラスは、この ISymbolCurrency インターフェースをインプリメントして作成します。
これらのクラスの display()は、引数として受け取った金額文字列に通貨記号を付加して返す処理を実装します。
ISymbolCurrency インターフェースのコードを見ますか？ はい いいえ
ISymbolCurrency.cs
public interface ISymbolCurrency
{
public abstract string display(string currency );
}
ヒント（StyleNormal クラス）
カンマ区切りをしない StyleNormal クラスを作成します。このクラスの display() は金額文字列には何もせず、コンストラクタで受け取った ISymbolCurrency をインプリメントしたクラスの display() を呼びます。
次に、このクラスを継承して StyleComma クラスを作成します。３桁ごとにカンマ区切りをする displayComma() では、金額文字列をカンマ区切りにし、それを引数にして、コンストラクタで受け取った ISymbolCurrency をインプリメントしたクラスの display() を呼びます。カンマ区切りをしない数字の羅列として表示する display() は基本クラスの StyleNormal クラスのものが実行されます。
StyleNormal クラスのコードを見ますか？ はい いいえ
StyleNormal.cs
public class StyleNormal
{
private ISymbolCurrency symbol ;
public StyleNormal(ISymbolCurrency symbol )
{
this.symbol = symbol ;
}
public string display(int price )
{
return symbol .display(price .ToString());
}
public string display(string price )
{
return symbol .display(price );
}
}
解答
StyleNormal.cs
public class StyleNormal
{
private ISymbolCurrency symbol ;
public StyleNormal(ISymbolCurrency symbol )
{
this.symbol = symbol ;
}
public string display(int price )
{
return symbol .display(price .ToString());
}
public string display(string price )
{
return symbol .display(price );
}
}
StyleComma.cs
public class StyleComma : StyleNormal
{
public StyleComma (ISymbolCurrency symbol ) : base(symbol )
{
}
public string displayComma(int price )
{
string s = string.Format("{0:#,0}", price );
return display(s );
}
}
ISymbolCurrency.cs
public interface ISymbolCurrency
{
public string display(string currency );
}
SymbolKanjiYen.cs
public class SymbolKanjiYen : ISymbolCurrency
{
public string display(string currency )
{
return currency + "円";
}
}
SymbolYenmark.cs
public class SymbolYenmark : ISymbolCurrency
{
public string display(string currency )
{
return \\ "currency ;
}
}
Enshu104.vb
Module Enshu104
Sub Main()
Dim cart As Cart = New Cart ()
cart .add(New Meat ("牛肉", 395, 400))
cart .add(New Vegetable ("じゃがいも", 98, 10))
Dim price As Integer = cart .getTotalPrice()
Dim k1 As StyleNormal = New StyleNormal (New SymbolKanjiYen ())
Console .WriteLine("合計金額は " & k1 .display(price )) ' 2560円
k1 = New StyleNormal (New SymbolYenmark ())
Console .WriteLine("合計金額は " & k1 .display(price )) ' \ 2560
Dim k2 As StyleComma = New StyleComma (New SymbolKanjiYen ())
Console .WriteLine("合計金額は " & k2 .displayComma(price )) ' 2,560円
Console .WriteLine("合計金額は " & k2 .display(price )) ' 2560円
k2 = New StyleComma (New SymbolYenmark ())
Console .WriteLine("合計金額は " & k2 .displayComma(price )) ' \ 2,560
Console .WriteLine("合計金額は " & k2 .display(price )) ' \ 2560
End Sub
End Module
ヒント（ISymbolCurrency インターフェース）
通貨記号を金額に付加して返す ISymbolCurrency インターフェースを作成します。後ろに"円"を付ける SymbolKanjiYen クラスと前に "\"を付ける SymbolYenmark クラスは、この ISymbolCurrency インターフェースをインプリメントして作成します。
これらのクラスの display()は、引数として受け取った金額文字列に通貨記号を付加して返す処理を実装します。
ISymbolCurrency インターフェースのコードを見ますか？ はい いいえ
iSymbolCurrency.vb
Public Interface ISymbolCurrency
Public Function display(currency As String) As String
End Class
ヒント（StyleNormal クラス）
カンマ区切りをしない StyleNormal クラスを作成します。このクラスの display() は金額文字列には何もせず、コンストラクタで受け取った ISymbolCurrency をインプリメントしたクラスの display() を呼びます。
次に、このクラスを継承して StyleComma クラスを作成します。３桁ごとにカンマ区切りをする displayComma() では、金額文字列をカンマ区切りにし、それを引数にして、コンストラクタで受け取った ISymbolCurrency をインプリメントしたクラスの display() を呼びます。カンマ区切りをしない数字の羅列として表示する display() は基本クラスの StyleNormal クラスのものが実行されます。
StyleNormal クラスのコードを見ますか？ はい いいえ
StyleNormal.vb
Public Class StyleNormal
Private symbol As ISymbolCurrency
Public Sub New(symbol As ISymbolCurrency )
Me.symbol = symbol
End Sub
Public Function display(print As String) As String
Return symbol .display(print )
End Function
End Class
解答
StyleNormal.vb
Public Class StyleNormal
Private symbol As ISymbolCurrency
Public Sub New(symbol As ISymbolCurrency )
Me.symbol = symbol
End Sub
Public Function display(print As String) As String
Return symbol .display(print )
End Function
End Class
StyleComma.vb
Public Class StyleComma : Inherits StyleNormal
Public Sub New(ByVal symbol As ISymbolCurrency )
MyBase.New(symbol )
End Sub
Public Function displayComma(ByVal price As Integer) As String
Dim s = String.Format("{0:#,0}", price )
Return display(s )
End Function
End Class
iSymbolCurrency.vb
Public Interface ISymbolCurrency
Public Function display(currency As String) As String
End Class
SymbolKanjiYen.vb
Public Class SymbolKanjiYen : Implements ISymbolCurrency
Public Overrides Function display(currency As String) As String Implements ISymbolCurrency .display
Return currency & "円"
End Function
End Class
SymbolYenmark.vb
Public Class SymbolYenmark : Implements ISymbolCurrency
Public Overrides Function display(currency As String) As String Implements ISymbolCurrency .display
Return \ "currency
End Function
End Class
Enshu104.js
const Cart = require("./Cart.js");
const Vegetable = require("./Vegetable.js");
const Meat = require("./Meat.js");
const StyleNormal = require("./StyleNormal.js");
const StyleComma = require("./StyleComma.js");
const SymbolKanjiYen = require("./SymbolKanjiYen.js");
const SymbolYenmark = require("./SymbolYenmark.js");
let cart = new Cart ();
cart .add(new Meat ("牛肉", 395, 400));
cart .add(new Vegetable ("じゃがいも", 98, 10));
let price = cart .getTotalPrice();
let k1 = new StyleNormal (new SymbolKanjiYen ());
process.stdout.write("合計金額は " + k1 .display(curr) + "\n"); // 2560円
k1 = new StyleNormal (new SymbolYenmark ());
process.stdout.write("合計金額は " + k1 .display(curr) + "\n"); // \ 2560
let k2 = new StyleComma (new SymbolKanjiYen ());
process.stdout.write("合計金額は " + k2 .displayComma(curr) + "\n"); // 2,560円
process.stdout.write("合計金額は " + k2 .display(curr) + "\n"); // 2560円
k2 = new StyleComma (new SymbolYenmark ());
process.stdout.write("合計金額は " + k2 .displayComma(curr) + "\n"); // \ 2,560
process.stdout.write("合計金額は " + k2 .display(curr) + "\n"); // \ 2560
ヒント（SymbolCurrency クラス）
通貨記号を金額に付加して返す SymbolCurrency クラスを作成します。後ろに"円"を付ける SymbolKanjiYen クラスと前に "\"を付ける SymbolYenmark クラスは、この SymbolCurrency クラスを継承して作成します。
これらのクラスの display()は、引数として受け取った金額文字列に通貨記号を付加して返す処理を実装します。
SymbolCurrency クラスのコードを見ますか？ はい いいえ
SymbolCurrency.js
module.exports = class SymbolCurrency {
display(currency ) {}
}
ヒント（StyleNormal クラス）
カンマ区切りをしない StyleNormal クラスを作成します。このクラスの display() は金額文字列には何もせず、コンストラクタで受け取った SymbolCurrency クラスの派生クラスの display() を呼びます。
次に、このクラスを継承して StyleComma クラスを作成します。３桁ごとにカンマ区切りをする displayComma() では、金額文字列をカンマ区切りにし、それを引数にして、コンストラクタで受け取った SymbolCurrency クラスの派生クラスの display() を呼びます。カンマ区切りをしない数字の羅列として表示する display() は基本クラスの StyleNormal クラスのものが実行されます。
StyleNormal クラスのコードを見ますか？ はい いいえ
StyleNormal.js
module.exports = class StyleNormal {
constructor(symbol ) {
this.symbol = symbol ;
}
display(currency ) {
return this.symbol .display(currency );
}
}
解答
StyleNormal.js
module.exports = class StyleNormal {
constructor(symbol ) {
this.symbol = symbol ;
}
display(currency ) {
return this.symbol .display(currency );
}
}
StyleComma.js
const StyleNormal = require("./StyleNormal.js");
module.exports = class StyleComma extends StyleNormal {
constructor(symbol ) {
super(symbol );
}
displayComma(currency ) {
let s = Number(currency ).toLocaleString();
return this.display(s );
}
}
SymbolCurrency.js
module.exports = class SymbolCurrency {
display(currency ) {}
}
SymbolKanjiYen.js
const SymbolCurrency = require("./SymbolCurrency.js");
module.exports = class SymbolKanjiYen extends SymbolCurrency {
display(currency ) {
return currency + "円";
}
}
SymbolYenmark.js
const SymbolCurrency = require("./SymbolCurrency.js");
module.exports = class SymbolYenmark extends SymbolCurrency {
display(currency ) {
return \\ "currency ;
}
}
Enshu104.pl
use lib './';
use Cart;
use Vegetable;
use Meat;
use StyleComma;
use SymbolKanjiYen;
use SymbolYenmark;
my $cart = new Cart ();
$cart ->add(new Meat ("牛肉", 395, 400));
$cart ->add(new Vegetable ("じゃがいも", 98, 10));
my $price = $cart ->getTotalPrice();
my $k1 = new StyleNormal (new SymbolKanjiYen ());
print "合計金額は " . $k1 ->display($price ) . "\n"; # 2560円
$k1 = new StyleNormal (new SymbolYenmark ());
print "合計金額は " . $k1 ->display($price ) . "\n"; # \ 2560
my $k2 = new StyleComma (new SymbolKanjiYen ());
print "合計金額は " . $k2 ->displayComma($price ) . "\n"; # 2,560円
print "合計金額は " . $k2 ->display($curr) . "\n"; # 2560円
$k2 = new StyleComma (new SymbolYenmark ());
print "合計金額は " . $k2 ->displayComma($price ) . "\n"; # \ 2,560
print "合計金額は " . $k2 ->display($price ) . "\n"; # \ 2560
ヒント（SymbolCurrency クラス）
通貨記号を金額に付加して返す SymbolCurrency クラスを作成します。後ろに"円"を付ける SymbolKanjiYen クラスと前に "\"を付ける SymbolYenmark クラスは、この SymbolCurrency クラスを継承して作成します。
これらのクラスの display()は、引数として受け取った金額文字列に通貨記号を付加して返す処理を実装します。
SymbolCurrency クラスのコードを見ますか？ はい いいえ
SymbolCurrency.pm
package SymbolCurrency {
sub display {}
}
1;
ヒント（StyleNormal クラス）
カンマ区切りをしない StyleNormal クラスを作成します。このクラスの display() は金額文字列には何もせず、コンストラクタで受け取った SymbolCurrency クラスの派生クラスの display() を呼びます。
次に、このクラスを継承して StyleComma クラスを作成します。３桁ごとにカンマ区切りをする displayComma() では、金額文字列をカンマ区切りにし、それを引数にして、コンストラクタで受け取った SymbolCurrency クラスの派生クラスの display() を呼びます。カンマ区切りをしない数字の羅列として表示する display() は基本クラスの StyleNormal クラスのものが実行されます。
StyleNormal クラスのコードを見ますか？ はい いいえ
StyleNormal.pm
package StyleNormal {
sub new {
my ($class , $symbol ) = @_ ;
my $this = {symbol => $symbol };
return bless $this , $class ;
}
sub display {
my ($this , $currency ) = @_ ;
return $this ->{symbol }->display($currency );
}
}
1;
解答
StyleNormal.pm
package StyleNormal {
sub new {
my ($class , $symbol ) = @_ ;
my $this = {symbol => $symbol };
return bless $this , $class ;
}
sub display {
my ($this , $currency ) = @_ ;
return $this ->{symbol }->display($currency );
}
}
1;
StyleComma.pm
package StyleComma {
use base qw(StyleNormal );
sub new {
my ($class , $symbol ) = @_ ;
my $this = $class ->SUPER::new($symbol );
return bless $this , $class ;
}
sub getPrice {
my ($this , $currency ) = @_ ;
$currency = ~s/(\d{1,3})(?=(?:\d{3})+(?!\d))/$1,/g;
return $this ->display($currency );
}
}
1;
SymbolCurrency.pm
package SymbolCurrency {
sub display {}
}
1;
SymbolKanjiYen.pm
package SymbolKanjiYen {
use base qw(SymbolCurrency );
sub new {
my ($class ) = @_ ;
return bless {}, $class ;
}
sub display {
my ($this , $currency ) = @_ ;
return $currency . "円";
}
}
1;
SymbolYenmark.pm
package SymbolYenmark {
use base qw(SymbolCurrency );
sub new {
my ($class ) = @_ ;
return bless {}, $class ;
}
sub getPrice {
my ($this , $currency ) = @_ ;
return \\ "$currency ;
}
}
1;
Enshu104.rb
require './Cart'
require './Vegetable'
require './Meat'
require './StyleNormal'
require './StyleComma'
require './SymbolKanjiYen'
require './SymbolYenmark'
cart = Cart .new()
cart .add(Meat .new("牛肉", 395, 400))
cart .add(Vegetable .new("じゃがいも", 98, 10))
price = cart .getTotalPrice()
k1 = StyleNormal .new(SymbolKanjiYen .new())
puts "合計金額は " + k1 .display(price ) # 2560円
k1 = StyleNormal .new(SymbolYenmark .new())
puts "合計金額は " + k1 .display(price ) # \ 2560
k2 = StyleComma .new(SymbolKanjiYen .new())
puts "合計金額は " + k2 .displayComma(price ) # 2,560円
puts "合計金額は " + k2 .display(price ) # 2560円
k2 = StyleComma .new(SymbolYenmark .new())
puts "合計金額は " + k2 .displayComma(price ) # \ 2,560
puts "合計金額は " + k2 .display(price ) # \ 2560
ヒント（SymbolCurrency クラス）
通貨記号を金額に付加して返す SymbolCurrency クラスを作成します。後ろに"円"を付ける SymbolKanjiYen クラスと前に "\"を付ける SymbolYenmark クラスは、この SymbolCurrency クラスを継承して作成します。
これらのクラスの display()は、引数として受け取った金額文字列に通貨記号を付加して返す処理を実装します。
SymbolCurrency クラスのコードを見ますか？ はい いいえ
SymbolCurrency.rb
class SymbolCurrency
def display(currency )
end
end
ヒント（StyleNormal クラス）
カンマ区切りをしない StyleNormal クラスを作成します。このクラスの display() は金額文字列には何もせず、コンストラクタで受け取った SymbolCurrency クラスの派生クラスの display() を呼びます。
次に、このクラスを継承して StyleComma クラスを作成します。３桁ごとにカンマ区切りをする displayComma() では、金額文字列をカンマ区切りにし、それを引数にして、コンストラクタで受け取った SymbolCurrency クラスの派生クラスの display() を呼びます。カンマ区切りをしない数字の羅列として表示する display() は基本クラスの StyleNormal クラスのものが実行されます。
StyleNormal クラスのコードを見ますか？ はい いいえ
StyleNormal.rb
class StyleNormal
def initialize(symbol )
@symbol = symbol
end
def display(currency )
return @symbol .display(currency .to_s)
end
end
解答
StyleNormal.rb
class StyleNormal
def initialize(symbol )
@symbol = symbol
end
def display(currency )
return @symbol .display(currency .to_s)
end
end
StyleComma.rb
require './StyleNormal'
class StyleComma < StyleNormal
def initialize(symbol )
super(price )
end
def displayComma(currency )
return @symbol .display(currency .to_s.reverse.gsub(/(\d{3})(?=\d)/ , '\1,' ).reverse)
end
end
SymbolCurrency.rb
class SymbolCurrency
def display(currency )
end
end
SymbolKanjiYen.rb
require './SymbolCurrency'
class SymbolKanjiYen < SymbolCurrency
def display(currency )
return currency + "円"
end
end
SymbolYenmark.rb
require './SymbolCurrency'
class SymbolYenmark < SymbolCurrency
def display(currency )
return "\\ " + currency
end
end
Enshu104.py
from Cart import Cart
from Vegetable import Vegetable
from Meat import Meat
from StyleNormal import StyleNormal
from StyleComma import StyleComma
from SymbolKanjiYen import SymbolKanjiYen
from SymbolYenmark import SymbolYenmark
cart = Cart ()
cart .add(Meat ("牛肉", 395, 400))
cart .add(Vegetable ("じゃがいも", 98, 10))
price = cart .getTotalPrice()
k1 = StyleNormal (SymbolKanjiYen ())
print("合計金額は %s" % k1 .display(price )) # 2560円
k1 = StyleNormal (SymbolYenmark ())
print("合計金額は %s" % k1 .display(price )) # \ 2560
k2 = StyleComma (SymbolKanjiYen ())
print("合計金額は %s" % k2 .displayComma(price )) # 2,560円
print("合計金額は %s" % k2 .display(price )) # 2560円
k2 = StyleComma (SymbolYenmark ())
print("合計金額は %s" % k2 .displayComma(price )) # \ 2,560
print("合計金額は %s" % k2 .display(price )) # \ 2560
ヒント（SymbolCurrency クラス）
通貨記号を金額に付加して返す SymbolCurrency クラスを作成します。後ろに"円"を付ける SymbolKanjiYen クラスと前に "\"を付ける SymbolYenmark クラスは、この SymbolCurrency クラスを継承して作成します。
これらのクラスの display()は、引数として受け取った金額文字列に通貨記号を付加して返す処理を実装します。
SymbolCurrency クラスのコードを見ますか？ はい いいえ
SymbolCurrency.py
class SymbolCurrency :
def display(self , currency ):
pass
ヒント（StyleNormal クラス）
カンマ区切りをしない StyleNormal クラスを作成します。このクラスの display() は金額文字列には何もせず、コンストラクタで受け取った SymbolCurrency クラスの派生クラスの display() を呼びます。
次に、このクラスを継承して StyleComma クラスを作成します。３桁ごとにカンマ区切りをする displayComma() では、金額文字列をカンマ区切りにし、それを引数にして、コンストラクタで受け取った SymbolCurrency クラスの派生クラスの display() を呼びます。カンマ区切りをしない数字の羅列として表示する display() は基本クラスの StyleNormal クラスのものが実行されます。
StyleNormal クラスのコードを見ますか？ はい いいえ
StyleNormal.py
class StyleNormal :
def __init__(self , symbol ):
self .symbol = symbol
def display(self , currency ):
return self .symbol .display(currency )
解答
StyleNormal.py
class StyleNormal :
def __init__(self , symbol ):
self .symbol = symbol
def display(self , currency ):
return self .symbol .display(currency )
StyleComma.py
from StyleNormal import StyleNormal
class StyleComma (StyleNormal ):
def __init__(self , symbol ):
self .symbol = symbol
def displayComma(self , currency ):
s = "{:,}".format(currency )
return self .display(s )
SymbolCurrency.py
class SymbolCurrency :
def display(self , currency ):
pass
SymbolKanjiYen.py
from SymbolCurrency import SymbolCurrency
class SymbolKanjiYen (SymbolCurrency ):
def display(self , currency ):
return str(currency )+ "円"
SymbolYenmark.py
from SymbolCurrency import SymbolCurrency
class SymbolYenmark (SymbolCurrency ):
def getPrice(self , currency ):
return "\\ " + str(currency )
Enshu104.php
<?php
require_once('Cart.php');
require_once('Vegetable.php');
require_once('Meat.php');
require_once('StyleNormal.php');
require_once('StyleComma.php');
require_once('SymbolKanjiYen.php');
require_once('SymbolYenmark.php');
$cart = new Cart ();
$cart ->add(new Meat ("牛肉", 395, 400));
$cart ->add(new Vegetable ("じゃがいも", 98, 10));
$price = $cart ->getTotalPrice();
$k1 = new StyleNormal (new SymbolKanjiYen ());
print "合計金額は " . $k1->display($price) . "\n"; // 2560円
$k1 = new StyleNormal (new SymbolYenmark ());
print "合計金額は " . $k1->display($price) . "\n"; // \ 2560
$k2 = new StyleComma (new SymbolKanjiYen ());
print "合計金額は " . $k2->displayComma($price) . "\n"; // 2,560円
print "合計金額は " . $k2->display($price) . "\n"; // 2560円
$k2 = new StyleComma (new SymbolYenmark ());
print "合計金額は " . $k2->displayComma($price) . "\n"; // \ 2,560
print "合計金額は " . $k2->display($price) . "\n"; // \ 2560
?>
ヒント（ISymbolCurrency インタフェース）
通貨記号を金額に付加して返す ISymbolCurrency インタフェースを作成します。後ろに"円"を付ける SymbolKanjiYen クラスと前に "\"を付ける SymbolYenmark クラスは、この ISymbolCurrency インタフェースをインプリメントして作成します。
これらのクラスの display()は、引数として受け取った金額文字列に通貨記号を付加して返す処理を実装します。
ISymbolCurrency インタフェースのコードを見ますか？ はい いいえ
ISymbolCurrency.php
<?php
interface ISymbolCurrency {
public function display($currency );
}
?>
ヒント（StyleNormal クラス）
カンマ区切りをしない StyleNormal クラスを作成します。このクラスの display() は金額文字列には何もせず、コンストラクタで受け取った SymbolCurrency クラスの派生クラスの display() を呼びます。
次に、このクラスを継承して StyleComma クラスを作成します。３桁ごとにカンマ区切りをする displayComma() では、金額文字列をカンマ区切りにし、それを引数にして、コンストラクタで受け取った SymbolCurrency クラスの派生クラスの display() を呼びます。カンマ区切りをしない数字の羅列として表示する display() は基本クラスの StyleNormal クラスのものが実行されます。
StyleNormal クラスのコードを見ますか？ はい いいえ
StyleNormal.php
<?php
class StyleNormal {
private $symbol ;
public function __construct($symbol ) {
$this->$symbol = $symbol ;
}
public function display($currency ) {
return $this->$symbol ->display($currency );
}
}
?>
解答
StyleNormal.php
<?php
class StyleNormal {
private $symbol ;
public function __construct($symbol ) {
$this->$symbol = $symbol ;
}
public function display($currency ) {
return $this->$symbol ->display($currency );
}
}
?>
StyleComma.php
<?php
require_once('StyleNormal.php');
class StyleComma extends StyleNormal {
public function __construct($symbol ) {
parent::__construct($symbol );
}
public function displayComma($currency ) {
$s = number_format($currency );
return $this->display($s );
}
}
?>
ISymbolCurrency.php
<?php
interface ISymbolCurrency {
public function display($currency );
}
?>
SymbolKanjiYen.py
<?php
require_once('ISymbolCurrency.php');
class SymbolKanjiYen implements ISymbolCurrency {
public function display($currency ) {
return $currency . "円";
}
}
?>
SymbolYenmark.php
<?php
require_once('ISymbolCurrency.php');
class SymbolYenmark implements ISymbolCurrency ) {
public function display($currency ) {
return \\ "$currency ;
}
}
?>
Enshu104.ts
import {Cart} from "./Cart";
import {Vegetable} from "./Vegetable";
import {Meat} from "./Meat";
import {StyleNormal} from "./StyleNormal";
import {StyleComma} from "./StyleComma";
import {SymbolKanjiYen} from "./SymbolKanjiYen";
import {SymbolYenmark} from "./SymbolYenmark";
let cart :Cart = new Cart ();
cart .add(new Meat ("牛肉", 395, 400));
cart .add(new Vegetable ("じゃがいも", 98, 10));
let price :number = cart .getTotalPrice);
let k1 :StyleNormal = new StyleNormal (new SymbolKanjiYen ());
process.stdout.write("合計金額は " + k1 .display(price )); // 2560円
k1 = new StyleNormal (new SymbolYenmark ());
process.stdout.write("合計金額は " + k1 .display(price )); // \ 2560
let k2 :StyleComma = new StyleComma (new SymbolKanjiYen ());
process.stdout.write("合計金額は " + k2 .displayComma(price )); // 2,560円
process.stdout.write("合計金額は " + k2 .display(price )); // 2560円
k2 = new StyleComma (new SymbolYenmark ());
process.stdout.write("合計金額は " + k2 .displayComma(price )); // \ 2,560
process.stdout.write("合計金額は " + k2 .display(price )); // \ 2560
ヒント（ISymbolCurrency インターフェース）
通貨記号を金額に付加して返す ISymbolCurrency インタフェースを作成します。後ろに"円"を付ける SymbolKanjiYen クラスと前に "\"を付ける SymbolYenmark クラスは、この ISymbolCurrency インタフェースをインプリメントして作成します。
これらのクラスの display()は、引数として受け取った金額文字列に通貨記号を付加して返す処理を実装します。
ISymbolCurrency インターフェースのコードを見ますか？ はい いいえ
ISymbolCurrency.ts
export
interface ISymbolCurrency {
public display(currency :string):string;
}
ヒント（StyleNormal クラス）
カンマ区切りをしない StyleNormal クラスを作成します。このクラスの display() は金額文字列には何もせず、コンストラクタで受け取った ISymbolCurrency インタフェースをインプリメントしたクラスの display() を呼びます。
次に、このクラスを継承して StyleComma クラスを作成します。３桁ごとにカンマ区切りをする displayComma() では、金額文字列をカンマ区切りにし、それを引数にして、コンストラクタで受け取った ISymbolCurrency インタフェースをインプリメントしたクラスの display() を呼びます。カンマ区切りをしない数字の羅列として表示する display() はスーパークラスの StyleNormal クラスのものが実行されます。
StyleNormal クラスのコードを見ますか？ はい いいえ
StyleNormal.ts
import {ISymbolCurrency} from "./ISymbolCurrency";
export
class StyleNormal {
private symbol :ISymbolCurrency ;
public constructor(symbol :ISymbolCurrency ) {
this.symbol = symbol ;
}
public display(currency :any):string {
return this.symbol .display("" + currency );
}
}
解答
StyleNormal.ts
import {ISymbolCurrency} from "./ISymbolCurrency";
export
class StyleNormal {
private symbol :ISymbolCurrency ;
public constructor(symbol :ISymbolCurrency ) {
this.symbol = symbol ;
}
public display(currency :any):string {
return this.symbol .display("" + currency );
}
}
StyleComma.ts
import {StyleNormal} from "./StyleNormal";
import {ISymbolCurrency} from "./ISymbolCurrency";
export
class StyleComma extends StyleNormal {
public constructor(symbol :ISymbolCurrency ) {
super(symbol );
}
public displayComma(currency :any):string {
let s :string = Number(currency ).toLocaleString();
return this.display(s );
}
}
ISymbolCurrency.ts
export
interface ISymbolCurrency {
display(currency :string):string;
}
SymbolKanjiYen.ts
import {ISymbolCurrency} from "./ISymbolCurrency";
export
class SymbolKanjiYen implements ISymbolCurrency {
public display(currency :string):string {
return currency + "円";
}
}
SymbolYenmark.ts
import {ISymbolCurrency} from "./ISymbolCurrency";
export
class SymbolYenmark implements ISymbolCurrency {
display(currency :string):string {
return \\ "currency ;
}
}
Enshu104.swift
let cart :Cart = Cart ()
cart .add(Meat ("牛肉", 395, 400))
cart .add(Vegetable ("じゃがいも", 98, 10))
let price :number = cart .getTotalPrice)
let k1 :StyleNormal = StyleNormal (SymbolKanjiYen ())
print("合計金額は \(k1.display(price))") // 2560円
k1 = StyleNormal (SymbolYenmark ())
print("合計金額は \(k1.display(price))") // \ 2560
let k2 :StyleComma = StyleComma (SymbolKanjiYen ())
print("合計金額は \(k2.displayComma(price))") // 2,560円
print("合計金額は \(k2.display(price))") // 2560円
k2 = StyleComma (SymbolYenmark ())
print("合計金額は \(k2.displayComma(price))") // \ 2,560
print("合計金額は \(k2.display(price))") // \ 2560
ヒント（ISymbolCurrency インターフェース）
通貨記号を金額に付加して返す ISymbolCurrency インタフェースを作成します。後ろに"円"を付ける SymbolKanjiYen クラスと前に "\"を付ける SymbolYenmark クラスは、この ISymbolCurrency インタフェースをインプリメントして作成します。
これらのクラスの display()は、引数として受け取った金額文字列に通貨記号を付加して返す処理を実装します。
ISymbolCurrency インターフェースのコードを見ますか？ はい いいえ
ISymbolCurrency.swift
public protocol ISymbolCurrency {
func display(_ currency :String) -> String
}
ヒント（StyleNormal クラス）
カンマ区切りをしない StyleNormal クラスを作成します。このクラスの display() は金額文字列には何もせず、コンストラクタで受け取った ISymbolCurrency インタフェースをインプリメントしたクラスの display() を呼びます。
次に、このクラスを継承して StyleComma クラスを作成します。３桁ごとにカンマ区切りをする displayComma() では、金額文字列をカンマ区切りにし、それを引数にして、コンストラクタで受け取った ISymbolCurrency インタフェースをインプリメントしたクラスの display() を呼びます。カンマ区切りをしない数字の羅列として表示する display() はスーパークラスの StyleNormal クラスのものが実行されます。
StyleNormal クラスのコードを見ますか？ はい いいえ
StyleNormal.swift
public class StyleNormal {
private var symbol :ISymbolCurrency
public init(_ symbol :ISymbolCurrency ) {
self.symbol = symbol
}
public func display(_ price :Int) -> String {
return symbol .display(String(price ))
}
public func display(_ price :String) -> String {
return symbol .display(price )
}
}
解答
StyleNormal.swift
public class StyleNormal {
private var symbol :ISymbolCurrency
public init(_ symbol :ISymbolCurrency ) {
self.symbol = symbol
}
public func display(_ price :Int) -> String {
return symbol .display(String(price ))
}
public func display(_ price :String) -> String {
return symbol .display(price )
}
}
StyleComma.swift
import Foundation
public class StyleComma : StyleNormal {
public override init(_ symbol :ISymbolCurrency ) {
super.init(symbol )
}
public func displayComma(_ price :Int) -> String {
let s :String = String.localizedStringWithFormat("%d", price ) // カンマ区切り形式
return display(s )
}
}
ISymbolCurrency.swift
public protocol ISymbolCurrency {
func display(_ currency :String) -> String
}
SymbolKanjiYen.swift
public class SymbolKanjiYen : ISymbolCurrency {
public func display(_ currency :String) -> String {
return currency + "円"
}
}
SymbolYenmark.swift
public class SymbolYenmark : ISymbolCurrency {
public func display(_ currency :String) -> String {
return \\ "currency ;
}
}
Enshu104.kt
fun main() {
val cart = Cart ()
cart .add(Meat ("牛肉", 395, 400))
cart .add(Vegetable ("じゃがいも", 98, 10))
val price = cart .getTotalPrice()
var k1 = StyleNormal (SymbolKanjiYen ())
println("合計金額は ${k1.display(price)}") // 2560円
k1 = StyleNormal (SymbolYenmark ())
println("合計金額は ${k1.display(price)}") // \ 2560
var k2 :StyleComma = StyleComma (SymbolKanjiYen ())
println("合計金額は ${k2.displayComma(price)}") // 2,560円
println("合計金額は ${k2.display(price)}") // 2560円
k2 = StyleComma (SymbolYenmark ())
println("合計金額は ${k2.displayComma(price)}") // \ 2,560
println("合計金額は ${k2.display(price)}") // \ 2560
}
ヒント（ISymbolCurrency インターフェース）
通貨記号を金額に付加して返す ISymbolCurrency インタフェースを作成します。後ろに"円"を付ける SymbolKanjiYen クラスと前に "\"を付ける SymbolYenmark クラスは、この ISymbolCurrency インタフェースをインプリメントして作成します。
これらのクラスの display()は、引数として受け取った金額文字列に通貨記号を付加して返す処理を実装します。
ISymbolCurrency インターフェースのコードを見ますか？ はい いいえ
ISymbolCurrency.kt
interface ISymbolCurrency {
fun display(currency : String) : String
}
ヒント（StyleNormal クラス）
カンマ区切りをしない StyleNormal クラスを作成します。このクラスの display() は金額文字列には何もせず、コンストラクタで受け取った ISymbolCurrency インタフェースをインプリメントしたクラスの display() を呼びます。
次に、このクラスを継承して StyleComma クラスを作成します。３桁ごとにカンマ区切りをする displayComma() では、金額文字列をカンマ区切りにし、それを引数にして、コンストラクタで受け取った ISymbolCurrency インタフェースをインプリメントしたクラスの display() を呼びます。カンマ区切りをしない数字の羅列として表示する display() はスーパークラスの StyleNormal クラスのものが実行されます。
StyleNormal クラスのコードを見ますか？ はい いいえ
StyleNormal.kt
internal open class StyleNormal (private val symbol : ISymbolCurrency ) {
fun display(currency : Int): String = symbol .display(currency .toString())
fun display(currency : String): String = symbol .display(currency )
}
解答
StyleNormal.kt
internal open class StyleNormal (private val symbol : ISymbolCurrency ) {
fun display(currency : Int): String = symbol .display(currency .toString())
fun display(currency : String): String = symbol .display(currency )
}
StyleComma.kt
import java.text.NumberFormat
internal class StyleComma (symbol : ISymbolCurrency ) : StyleNormal (symbol ) {
fun displayComma(price : Int) : String {
val nf = NumberFormat .getNumberInstance() // カンマ区切り形式
val s = nf .format(price .toLong())
return display(s )
}
}
ISymbolCurrency.kt
interface ISymbolCurrency {
fun display(currency : String) : String
}
SymbolKanjiYen.kt
internal class SymbolKanjiYen : ISymbolCurrency {
override fun display(currency : String) : String = currency + "円"
}
SymbolYenmark.kt
internal class SymbolYenmark : ISymbolCurrency {
override fun display(currency : String) : String = \\ "currency
}
Enshu104.scala
object Main104 {
def main(args : Array [String]) {
val cart = new Cart ()
cart .add(new Meat ("牛肉", 395, 400))
cart .add(new Vegetable ("じゃがいも", 98, 10))
val price : Int = cart .getTotalPrice()
var k1 = new StyleNormal (new SymbolKanjiYen ())
println("合計金額は %s".format(k1.display(price))) // 2560円
k1 = new StyleNormal (new SymbolYenmark ())
println("合計金額は %s".format(k1.display(price))) // \ 2560
var k2 :StyleComma = new StyleComma (new SymbolKanjiYen ())
println("合計金額は %s".format(k2.displayComma(price))) // 2,560円
println("合計金額は %s".format(k2.display(price))) // 2560円
k2 = new StyleComma (new SymbolYenmark ())
println("合計金額は %s".format(k2.displayComma(price))) // \ 2,560
println("合計金額は %s".format(k2.display(price))) // \ 2560
}
}
ヒント（ISymbolCurrency インターフェース）
通貨記号を金額に付加して返す ISymbolCurrency インタフェースを作成します。後ろに"円"を付ける SymbolKanjiYen クラスと前に "\"を付ける SymbolYenmark クラスは、この ISymbolCurrency インタフェースをインプリメントして作成します。
これらのクラスの display()は、引数として受け取った金額文字列に通貨記号を付加して返す処理を実装します。
ISymbolCurrency インターフェースのコードを見ますか？ はい いいえ
ISymbolCurrency.scala
trait ISymbolCurrency {
def display(currency : String) : String
}
ヒント（StyleNormal クラス）
カンマ区切りをしない StyleNormal クラスを作成します。このクラスの display() は金額文字列には何もせず、コンストラクタで受け取った ISymbolCurrency インタフェースをインプリメントしたクラスの display() を呼びます。
次に、このクラスを継承して StyleComma クラスを作成します。３桁ごとにカンマ区切りをする displayComma() では、金額文字列をカンマ区切りにし、それを引数にして、コンストラクタで受け取った ISymbolCurrency インタフェースをインプリメントしたクラスの display() を呼びます。カンマ区切りをしない数字の羅列として表示する display() はスーパークラスの StyleNormal クラスのものが実行されます。
StyleNormal クラスのコードを見ますか？ はい いいえ
StyleNormal.scala
class StyleNormal (var symbol : ISymbolCurrency ) {
def display(currency : Int): String = symbol .display(currency .toString)
def display(currency : String): String = symbol .display(currency )
}
解答
StyleNormal.scala
class StyleNormal (var symbol : ISymbolCurrency ) {
def display(currency : Int): String = symbol .display(currency .toString)
def display(currency : String): String = symbol .display(currency )
}
StyleComma.scala
class StyleComma (symbol : ISymbolCurrency ) extends StyleNormal (symbol ) {
def displayComma(price : Int) : String = display("%,d".format(price ))
}
ISymbolCurrency.scala
trait ISymbolCurrency {
def display(currency : String) : String
}
SymbolKanjiYen.scala
class SymbolKanjiYen extends ISymbolCurrency {
override def display(currency : String) : String = currency + "円"
}
SymbolYenmark.scala
class SymbolYenmark extends ISymbolCurrency {
override def display(currency : String) : String = \\ "currency
}
Enshu104.groovy
class Enshu104 {
static void main(String[] args ) {
Cart cart = new Cart ()
cart .add(new Meat ("牛肉", 395, 400))
cart .add(new Vegetable ("じゃがいも", 98, 10))
int price = cart .getTotalPrice()
StyleNormal k1 = new StyleNormal (new SymbolKanjiYen ())
System.out .println("合計金額は " + k1 .display(price )) // 2560円
k1 = new StyleNormal (new SymbolYenmark ())
System.out .println("合計金額は " + k1 .display(price )) // \ 2560
StyleComma k2 = new StyleComma (new SymbolKanjiYen ())
System.out .println("合計金額は " + k2 .displayComma(price )) // 2,560円
System.out .println("合計金額は " + k2 .display(price )) // 2560円
k2 = new StyleComma (new SymbolYenmark ())
System.out .println("合計金額は " + k2 .displayComma(price )) // \ 2,560
System.out .println("合計金額は " + k2 .display(price )) // \ 2560
}
}
ヒント（ISymbolCurrency インターフェース）
通貨記号を金額に付加して返す ISymbolCurrency インタフェースを作成します。後ろに"円"を付ける SymbolKanjiYen クラスと前に "\"を付ける SymbolYenmark クラスは、この ISymbolCurrency インタフェースをインプリメントして作成します。
これらのクラスの display()は、引数として受け取った金額文字列に通貨記号を付加して返す処理を実装します。
ISymbolCurrency インターフェースのコードを見ますか？ はい いいえ
ISymbolCurrency.groovy
interface ISymbolCurrency {
String display(String currency )
}
ヒント（StyleNormal クラス）
カンマ区切りをしない StyleNormal クラスを作成します。このクラスの display() は金額文字列には何もせず、コンストラクタで受け取った ISymbolCurrency インタフェースをインプリメントしたクラスの display() を呼びます。
次に、このクラスを継承して StyleComma クラスを作成します。３桁ごとにカンマ区切りをする displayComma() では、金額文字列をカンマ区切りにし、それを引数にして、コンストラクタで受け取った ISymbolCurrency インタフェースをインプリメントしたクラスの display() を呼びます。カンマ区切りをしない数字の羅列として表示する display() はスーパークラスの StyleNormal クラスのものが実行されます。
StyleNormal クラスのコードを見ますか？ はい いいえ
StyleNormal.groovy
public class StyleNormal {
ISymbolCurrency symbol
StyleNormal (ISymbolCurrency symbol ) {
this.symbol = symbol
}
String display(int currency ) {
return symbol .display("" + currency )
}
String display(String currency ) {
return symbol .display(currency )
}
}
解答
StyleNormal.groovy
class StyleNormal {
ISymbolCurrency symbol
StyleNormal (ISymbolCurrency symbol ) {
this.symbol = symbol
}
String display(int currency ) {
return symbol .display("" + currency )
}
String display(String currency ) {
return symbol .display(currency )
}
}
StyleComma.groovy
class StyleComma extends StyleNormal {
StyleComma (ISymbolCurrency symbol ) {
super(symbol )
}
String displayComma(int price ) {
NumberFormat nf = NumberFormat .getNumberInstance () // カンマ区切り形式
String s = nf .format(price )
return display(s )
}
}
ISymbolCurrency.groovy
interface ISymbolCurrency {
String display(String currency )
}
SymbolKanjiYen.groovy
class SymbolKanjiYen implements ISymbolCurrency {
String display(String currency ) {
return currency + "円"
}
}
SymbolYenmark.groovy
class SymbolYenmark implements ISymbolCurrency {
String display(String currency ) {
return \\ "currency
}
}
Enshu104.groovy
import "fmt"
func main() {
var cart = NewCart ()
cart .Add(NewMeat ("牛肉", 395, 400))
cart .Add(NewVegetable ("じゃがいも", 98, 10))
var price = cart .GetTotalPrice()
var k1 = NewStyleNormal (NewSymbolKanjiYen ())
fmt.Printf("合計金額は %s\n", k1 .Display (price )) // 2560円
k1 = NewStyleNormal (NewSymbolYenmark ())
fmt.Printf("合計金額は %s\n", k1 .Display (price )) // \ 2560
var k2 = NewStyleComma (NewSymbolKanjiYen ())
fmt.Printf("合計金額は %s\n", k2 .DisplayComma (price )) // 2,560円
fmt.Printf("合計金額は %s\n", k2 .Display (price )) // 2560円
k2 = new StyleComma (NewSymbolYenmark ())
fmt.Printf("合計金額は %s\n", k2 .DisplayComma (price )) // \ 2,560
fmt.Printf("合計金額は %s\n", k2 .Display (price )) // \ 2560
}
ヒント（ISymbolCurrency インターフェース）
通貨記号を金額に付加して返す ISymbolCurrency インタフェースを作成します。後ろに"円"を付ける SymbolKanjiYen クラスと前に "\"を付ける SymbolYenmark クラスは、この ISymbolCurrency インタフェースをインプリメントして作成します。
これらのクラスの display()は、引数として受け取った金額文字列に通貨記号を付加して返す処理を実装します。
ISymbolCurrency インターフェースのコードを見ますか？ はい いいえ
ISymbolCurrency.go
type ISymbolCurrency interface {
Display (currency string) string
}
ヒント（StyleNormal クラス）
カンマ区切りをしない StyleNormal クラスを作成します。このクラスの display() は金額文字列には何もせず、コンストラクタで受け取った ISymbolCurrency インタフェースをインプリメントしたクラスの display() を呼びます。
次に、このクラスを継承して StyleComma クラスを作成します。３桁ごとにカンマ区切りをする displayComma() では、金額文字列をカンマ区切りにし、それを引数にして、コンストラクタで受け取った ISymbolCurrency インタフェースをインプリメントしたクラスの display() を呼びます。カンマ区切りをしない数字の羅列として表示する display() はスーパークラスの StyleNormal クラスのものが実行されます。
StyleNormal クラスのコードを見ますか？ はい いいえ
StyleNormal.go
import (
"reflect"
"strconv"
)
type StyleNormal struct {
symbol ISymbolCurrency
}
func (self *StyleNormal ) Display (currency interface{}) string {
if reflect.TypeOf (currency ).Kind () == reflect.Int {
var s string = strconv.Itoa (currency .(int))
return self.symbol .Display (s )
} else {
return self.symbol .Display (currency .(string))
}
}
func NewStyleNormal (symbol ISymbolCurrency ) *StyleNormal {
return &StyleNormal {
symbol : symbol ,
}
}
解答
StyleNormal.go
import (
"reflect"
"strconv"
)
type StyleNormal struct {
symbol ISymbolCurrency
}
func (self *StyleNormal ) Display (currency interface{}) string {
if reflect.TypeOf (currency ).Kind () == reflect.Int {
var s string = strconv.Itoa (currency .(int))
return self.symbol .Display (s )
} else {
return self.symbol .Display (currency .(string))
}
}
func NewStyleNormal (symbol ISymbolCurrency ) *StyleNormal {
return &StyleNormal {
symbol : symbol ,
}
}
StyleComma.go
import "strconv"
type StyleComma struct {
*StyleNormal
}
func (self *StyleComma ) DisplayComma (price int) string {
return self.Display (comma (price ))
}
func comma (number int) string {
var str = strconv.Itoa(number )
var curr = ""
var l = len(str )
for l < 3 {
curr = "," + str [l -3:] + curr
str = str [0:l -3]
l -= 3
}
return str + curr
}
func NewStyleComma (symbol ISymbolCurrency ) *StyleComma {
return &StyleComma {
StyleNormal : NewStyleNormal (symbol ),
}
}
ISymbolCurrency.go
type ISymbolCurrency interface {
Display (currency string) string
}
SymbolKanjiYen.go
type SymbolKanjiYen struct {
ISymbolCurrency
}
func (self *SymbolKanjiYen ) Display (currency string) string {
return currency + "円"
}
func NewSymbolKanjiYen () ISymbolCurrency {
return &SymbolKanjiYen {}
}
SymbolYenmark.go
type SymbolYenmark struct {
ISymbolCurrency
}
func (self *SymbolYenmark) Display(currency string) string {
return \\ "currency
}
func NewSymbolYenmark () ISymbolCurrency {
return &SymbolYenmark {}
}
enshu104.d
import cart;
import meat;
import vegetable;
import stylenormal;
import stylecomma;
import symbolkanjiyen;
import symbolyenmark;
int main() {
Cart cart = new Cart ();
cart .add(new Meat ("牛肉", 395, 400));
cart .add(new Vegetable ("じゃがいも", 98, 10));
int price = cart .getTotalPrice();
StyleNormal k1 = new StyleNormal (new SymbolKanjiYen ());
printfln("合計金額は %s", k1 .display(price )); // 2560円
k1 = new StyleNormal (new SymbolYenmark ());
printfln("合計金額は %s", k1 .display(price )); // \ 2560
StyleComma k2 = new StyleComma (new SymbolKanjiYen ());
printfln("合計金額は %s", k2 .displayComma(price )); // 2,560円
printfln("合計金額は %s", k2 .display(price )); // 2560円
k2 = new StyleComma (new SymbolYenmark ());
printfln("合計金額は %s", k2 .displayComma(price )); // \ 2,560
printfln("合計金額は %s", k2 .display(price )); // \ 2560
}
return 0;
}
private void printfln(T...)(T args ) { // Shift JIS 出力
import std, std.windows.charset, core.vararg;
std.stdio.writeln(to!(string)(toMBSz(std.format.format(args ))));
}
ヒント（ISymbolCurrency インターフェース）
通貨記号を金額に付加して返す ISymbolCurrency インタフェースを作成します。後ろに"円"を付ける SymbolKanjiYen クラスと前に "\"を付ける SymbolYenmark クラスは、この ISymbolCurrency インタフェースをインプリメントして作成します。
これらのクラスの display()は、引数として受け取った金額文字列に通貨記号を付加して返す処理を実装します。
ISymbolCurrency インターフェースのコードを見ますか？ はい いいえ
isymbolcurrency.d
public interface ISymbolCurrency {
public string display(string currency );
}
ヒント（StyleNormal クラス）
カンマ区切りをしない StyleNormal クラスを作成します。このクラスの display() は金額文字列には何もせず、コンストラクタで受け取った ISymbolCurrency インタフェースをインプリメントしたクラスの display() を呼びます。
次に、このクラスを継承して StyleComma クラスを作成します。３桁ごとにカンマ区切りをする displayComma() では、金額文字列をカンマ区切りにし、それを引数にして、コンストラクタで受け取った ISymbolCurrency インタフェースをインプリメントしたクラスの display() を呼びます。カンマ区切りをしない数字の羅列として表示する display() はスーパークラスの StyleNormal クラスのものが実行されます。
StyleNormal クラスのコードを見ますか？ はい いいえ
stylenormal.d
import std.conv;
import isymbolcurrency;
public class StyleNormal {
private ISymbolCurrency symbol ;
public this(ISymbolCurrency symbol ) {
this.symbol = symbol ;
}
public string display(in int currency ) {
return symbol .display(text(currency ));
}
public string display(in string currency ) {
return symbol .display(currency );
}
}
解答
stylenormal.d
import std.conv;
import isymbolcurrency;
public class StyleNormal {
private ISymbolCurrency symbol ;
public this(ISymbolCurrency symbol ) {
this.symbol = symbol ;
}
public string display(in int currency ) {
return symbol .display(text(currency ));
}
public string display(in string currency ) {
return symbol .display(currency );
}
}
stylecomma.d
import std.format;
import stylenormal;
import isymbolcurrency;
public class StyleComma : StyleNormal {
public StyleComma (ISymbolCurrency symbol ) {
super(symbol );
}
public string displayComma(in int price ) {
string s = format("%,d", price );
// カンマ区切り形式
return display(s );
}
}
isymbolcurrency.d
public interface ISymbolCurrency {
public string display(in string currency );
}
symbolkanjiyen.d
import isymbolcurrency;
public class SymbolKanjiYen : ISymbolCurrency {
public string display(in string currency ) {
return currency ~ "円";
}
}
symbolyenmark.d
import isymbolcurrency;
public class SymbolYenmark : ISymbolCurrency {
public string display(string currency ) {
return \\ "currency ;
}
}
Enshu104.java
program Enshu104;
uses
System.SysUtils,
UnitVegetable,
UnitMeat,
UnitCart,
UnitStyleNormal,
UnitStyleComma,
UnitSymbolKanjiYen,
UnitSymbolYenmark;
var _cart :Cart ;
var price :integer;
var k1 :StyleNormal ;
var k2 :StyleComma ;
begin
_cart := Cart .Create();
_cart .add(Meat .Create('牛肉', 395, 400));
_cart .add(Vegetable .Create('じゃがいも', 98, 10));
price := _cart .getTotalPrice();
k1 := StyleNormal .Create(SymbolKanjiYen .Create());
Writeln('合計金額は ' + k1 .display(price )); // 2560円
k1 := StyleNormal .Create(SymbolYenmark .Create());
Writeln('合計金額は ' + k1 .display(price )); // \ 2560
k2 := StyleComma .Create(SymbolKanjiYen .Create());
Writeln('合計金額は ' + k2 .displayComma(price )); // 2,560円
Writeln('合計金額は ' + k2 .display(price )); // 2560円
k2 := StyleComma .Create(SymbolYenmark .Create());
Writeln('合計金額は ' + k2 .displayComma(price )); // \ 2,560
Writeln('合計金額は ' + k2 .display(price )); // \ 2560
k1 .Free;
k2 .Free;
_cart .Free;
end.
ヒント（ISymbolCurrency インターフェース）
通貨記号を金額に付加して返す ISymbolCurrency インタフェースを作成します。後ろに"円"を付ける SymbolKanjiYen クラスと前に "\"を付ける SymbolYenmark クラスは、この ISymbolCurrency インタフェースをインプリメントして作成します。
これらのクラスの display()は、引数として受け取った金額文字列に通貨記号を付加して返す処理を実装します。
ISymbolCurrency インターフェースのコードを見ますか？ はい いいえ
ISymbolCurrency.pas
unit UnitISymbolCurrency;
interface
type
ISymbolCurrency = interface
function display(currency :string):string;
end;
implementation
end.
ヒント（StyleNormal クラス）
カンマ区切りをしない StyleNormal クラスを作成します。このクラスの display() は金額文字列には何もせず、コンストラクタで受け取った ISymbolCurrency インタフェースをインプリメントしたクラスの display() を呼びます。
次に、このクラスを継承して StyleComma クラスを作成します。３桁ごとにカンマ区切りをする displayComma() では、金額文字列をカンマ区切りにし、それを引数にして、コンストラクタで受け取った ISymbolCurrency インタフェースをインプリメントしたクラスの display() を呼びます。カンマ区切りをしない数字の羅列として表示する display() はスーパークラスの StyleNormal クラスのものが実行されます。
StyleNormal クラスのコードを見ますか？ はい いいえ
StyleNormal.pas
unit UnitStyleNormal;
interface
uses
System.SysUtils,
UnitISymbolCurrency;
type
StyleNormal = class
private
var symbol :ISymbolCurrency ;
public
constructor Create(symbol :ISymbolCurrency );
function display(currency :integer):string; overload;
function display(currency :string):string; overload;
end;
implementation
constructor StyleNormal .Create(symbol :ISymbolCurrency );
begin
self.symbol := symbol ;
end;
function StyleNormal .display(currency :integer):string;
begin
Result := symbol .display(IntToStr(currency ));
end;
function StyleNormal .display(currency :string):string;
begin
Result := symbol .display(currency );
end;
end.
解答
StyleNormal.pas
unit UnitStyleNormal;
interface
uses
System.SysUtils,
UnitISymbolCurrency;
type
StyleNormal = class
private
var symbol :ISymbolCurrency ;
public
constructor Create(symbol :ISymbolCurrency );
function display(currency :integer):string; overload;
function display(currency :string):string; overload;
end;
implementation
constructor StyleNormal .Create(symbol :ISymbolCurrency );
begin
self.symbol := symbol ;
end;
function StyleNormal .display(currency :integer):string;
begin
Result := symbol .display(IntToStr(currency ));
end;
function StyleNormal .display(currency :string):string;
begin
Result := symbol .display(currency );
end;
end.
StyleComma.pas
unit UnitStyleComma;
interface
uses
System.SysUtils,
UnitStyleNormal,
UnitISymbolCurrency;
type
StyleComma = class(StyleNormal )
public
constructor Create(symbol :ISymbolCurrency );
function displayComma(price :integer):string;
end;
implementation
constructor StyleComma .Create(symbol :ISymbolCurrency );
begin
inherited Create(symbol );
end;
function StyleComma .displayComma(price :integer):string;
begin
Result := display(FormatFloat('#,##0', price ));
end;
end.
ISymbolCurrency.pas
unit UnitISymbolCurrency;
interface
type
ISymbolCurrency = interface
function display(currency :string):string;
end;
implementation
end.
SymbolKanjiYen.pas
unit UnitSymbolKanjiYen;
interface
uses
UnitISymbolCurrency;
type
SymbolKanjiYen = class(TInterfacedObject , ISymbolCurrency )
public
function display(currency :string):string;
end;
implementation
function SymbolKanjiYen .display(currency :string):string;
begin
Result := currency + '円';
end;
end.
SymbolYenmark.pas
unit UnitSymbolYenmark;
interface
uses
UnitISymbolCurrency;
type
SymbolYenmark = class(TInterfacedObject , ISymbolCurrency )
public
function display(currency :string):string;
end;
implementation
function SymbolYenmark .display(currency :string):string;
begin
Result := '\ ' + currency ;
end;
end.