Redian新闻
>
NSC RD 2/18/2014,还没有收到FP notice
avatar
NSC RD 2/18/2014,还没有收到FP notice# EB23 - 劳工卡
F*e
1
问题是关于decorate pattern(装饰模式),就是给一个人一件一件穿衣服的程序,基
类是人,第一个子继承类是Finery(服饰),Finery下面有3个子继承类分别是:
Tshirt Sneaker Trousers。 程序中用到了装饰模式的思想,和一堆虚函数和覆写函数
,关于这些函数和覆写函数是怎么跑的我看不明白,贴上代码:请牛人观观!
class Program
{
static void Main(string[] args)
{
Person Alice = new Person("Alice");
Console.WriteLine("\n Alice's beautiful dress are:");
Sneakers sneaker = new Sneakers();
BigTrouser trouser = new BigTrouser();
TShirts tshirt = new TShirts();
sneaker.Decorate(Alice); trouser.Decorate(sneaker); 就是这一段看不明白!!!!!
tshirt.Decorate(trouser); 虚函数+覆写函数 咋有递归的感觉
tshirt.Show(); Console.Read();
}
}
class Person //base class
{
private string name;
public Person()
{
}
public Person(string name)
{
this.name = name;
}
public virtual void Show()
{
Console.WriteLine("Decorated person is: {0}", name);
}
}
class Finery : Person
{
protected Person component;
// start decotate
public void Decorate(Person component)
{
this.component = component;
}
public override void Show()
{
if (component != null)
{
component.Show();
}
}
}
class TShirts : Finery
{
public override void Show()
{
Console.Write("Tshirt ");
base.Show();
}
}
class BigTrouser : Finery
{
public override void Show()
{
Console.Write("Trousers ");
base.Show();
}
}
class Sneakers : Finery
{
public override void Show()
{
Console.Write("Sneakers ");
base.Show();
}
}
Alice's beautiful dress are:
Tshirt Trousers Sneakers Decorated person is: Alice

avatar
w*g
2
NSC RD 2/18/2014,还没有收到FP notice.
这正常吗?
avatar
v*a
3
这就是Decorate pattern
tshirt 包含 trouser, trouser 包含 sneaker,...
when you call tshirt.Show();
tshirt 先处理自己的 Write (真正有用的部分), 然后递归调用 trouser.Show()
这也就是关键:
这样 tshirt 就不需要知道 person 到底被多少个Finery decorate,
ANY Finery只需要只要做好自己的工作 和 调用 Base.show() 就可以了,
也就达到了 松耦合:大部分pattern追求的主要目标之一
avatar
y*0
4
NSC要30天左右,2月本身天数就28天,你自己算算啊....太着急了...
avatar
F*e
5


tshirt 调用 base.Show()后,系统是不是先到person类里 看到是virtual后,再到
Finery类里,然后发现是override 于是继续。。一直跑到trouser类里,然后调用
trouser的show(),然后再base.Show()如此循环??
跑到sneaker的show()的时候为什么不再override到trouser了?

【在 v***a 的大作中提到】
: 这就是Decorate pattern
: tshirt 包含 trouser, trouser 包含 sneaker,...
: when you call tshirt.Show();
: tshirt 先处理自己的 Write (真正有用的部分), 然后递归调用 trouser.Show()
: 这也就是关键:
: 这样 tshirt 就不需要知道 person 到底被多少个Finery decorate,
: ANY Finery只需要只要做好自己的工作 和 调用 Base.show() 就可以了,
: 也就达到了 松耦合:大部分pattern追求的主要目标之一

avatar
t*o
6
我的2月12号的还没收到呢
avatar
v*a
7
Finery 类里存了protected Person component;
比如:tshirt 存的 Person 是 trouser;
tshirt 调用 base.Show() 调用的是 Finery 的 show(),然后 Finery 调用的是 他存
的那Person 的 Show(),也就是 Trouser.show(),
然后 recursive
design pattern 的书都有讲的,而且讲得很详细,
说白了就是一个Hook,在调用想要调用的函数之前,先调用你的,然后你再替它调用原
始函数

【在 F*****e 的大作中提到】
:
: ,
: tshirt 调用 base.Show()后,系统是不是先到person类里 看到是virtual后,再到
: Finery类里,然后发现是override 于是继续。。一直跑到trouser类里,然后调用
: trouser的show(),然后再base.Show()如此循环??
: 跑到sneaker的show()的时候为什么不再override到trouser了?

avatar
l*l
8
太正常了。再等一到两周
avatar
q*x
9
t-shirt包含trouser?这也太奇怪了。

【在 v***a 的大作中提到】
: 这就是Decorate pattern
: tshirt 包含 trouser, trouser 包含 sneaker,...
: when you call tshirt.Show();
: tshirt 先处理自己的 Write (真正有用的部分), 然后递归调用 trouser.Show()
: 这也就是关键:
: 这样 tshirt 就不需要知道 person 到底被多少个Finery decorate,
: ANY Finery只需要只要做好自己的工作 和 调用 Base.show() 就可以了,
: 也就达到了 松耦合:大部分pattern追求的主要目标之一

avatar
R*d
10
正常

【在 w******g 的大作中提到】
: NSC RD 2/18/2014,还没有收到FP notice.
: 这正常吗?

avatar
F*e
11

说的很清楚,我很明白了,谢谢!!

【在 v***a 的大作中提到】
: Finery 类里存了protected Person component;
: 比如:tshirt 存的 Person 是 trouser;
: tshirt 调用 base.Show() 调用的是 Finery 的 show(),然后 Finery 调用的是 他存
: 的那Person 的 Show(),也就是 Trouser.show(),
: 然后 recursive
: design pattern 的书都有讲的,而且讲得很详细,
: 说白了就是一个Hook,在调用想要调用的函数之前,先调用你的,然后你再替它调用原
: 始函数

avatar
m*k
12
fyi: rd 2/6, fp notice received on 3/7. be patient:-)

【在 w******g 的大作中提到】
: NSC RD 2/18/2014,还没有收到FP notice.
: 这正常吗?

avatar
F*e
13

我想他的意思不是‘包含’,是说tshirt类去装饰被trouser类装饰好的实例,是先后
关系。

【在 q****x 的大作中提到】
: t-shirt包含trouser?这也太奇怪了。
avatar
f*m
14
我也是NSC同一天RD 昨天收到FP 稍微等下哈
avatar
q*x
15
还是别扭。t-shirt和trouser应该是平行单位,trouser应该也可以装饰t-shirt。

【在 F*****e 的大作中提到】
:
: 我想他的意思不是‘包含’,是说tshirt类去装饰被trouser类装饰好的实例,是先后
: 关系。

avatar
w*g
16
still not receive it. I called USCIS and they created Service Request, then
they said it may take another 30 days for them to process the service
request.
This is rediculous.
avatar
v*a
17

当然可以反过来,是平行的概念,这也就是之前说的 decorator pattern的特点,他们
是平行的,松耦合的
只是实现的时候,用了包含,或者说,tshirt 有个指向上级的 pointer, 而 tshirt
不管那个pointer 是谁,也不管tshirt自己本身被谁指向,他只管做完自己的事情之后
,调用 pointer 指向的东西

【在 q****x 的大作中提到】
: 还是别扭。t-shirt和trouser应该是平行单位,trouser应该也可以装饰t-shirt。
avatar
w*g
18
上午还在打电话,结果今天下午就收到了。
看样子还是要耐心点。 FP 约的是两个星期后,在想要不要walk-in.
有在columbus walk in的分享一下

then

【在 w******g 的大作中提到】
: still not receive it. I called USCIS and they created Service Request, then
: they said it may take another 30 days for them to process the service
: request.
: This is rediculous.

avatar
a*u
19
decorate模式目的主要是用对象组合来减少不必要的对象继承关系
avatar
q*x
20
但是组合应该反映has-a吧?应该是人有衣服,而不是衣服有人。

【在 a****u 的大作中提到】
: decorate模式目的主要是用对象组合来减少不必要的对象继承关系
avatar
F*e
21

衣服包装人(给人穿衣服),如果现在程序需要扩展,不仅给人穿衣服,还要给狗狗穿
衣服,
那么衣服之类的类就不用改,直接写一个狗狗的类,用衣服的类直接去包装狗狗的类。
当然人,狗狗的类上面最好继承一个公共的抽象动物类接口,服装的抽象类也继承那个
接口。

【在 q****x 的大作中提到】
: 但是组合应该反映has-a吧?应该是人有衣服,而不是衣服有人。
avatar
r*t
22
tshirt base 是 finary, 这里和 person 没啥事,就是反复调用 component.show(),
最后 sneaker.component 就是 person Alice 了。

【在 F*****e 的大作中提到】
:
: 衣服包装人(给人穿衣服),如果现在程序需要扩展,不仅给人穿衣服,还要给狗狗穿
: 衣服,
: 那么衣服之类的类就不用改,直接写一个狗狗的类,用衣服的类直接去包装狗狗的类。
: 当然人,狗狗的类上面最好继承一个公共的抽象动物类接口,服装的抽象类也继承那个
: 接口。

avatar
r*t
23
为啥这里的衣服一定要是 Person 的 subclass? 我想大家疑问是这个。

【在 F*****e 的大作中提到】
:
: 衣服包装人(给人穿衣服),如果现在程序需要扩展,不仅给人穿衣服,还要给狗狗穿
: 衣服,
: 那么衣服之类的类就不用改,直接写一个狗狗的类,用衣服的类直接去包装狗狗的类。
: 当然人,狗狗的类上面最好继承一个公共的抽象动物类接口,服装的抽象类也继承那个
: 接口。

avatar
q*x
24
可能理解成“穿衣服的人”好一些。
基本上decorator就是个链表。表尾是基类,多一个decoration就多一个元素。

【在 r****t 的大作中提到】
: 为啥这里的衣服一定要是 Person 的 subclass? 我想大家疑问是这个。
avatar
F*e
25

现实中,除了人,还有别的如猫狗,也可以被装扮。人,猫狗都继承一个component类
(比如说),衣服的类也继承component类,那么component就像一个接口,可以用作扩
展,这样就实现了封闭-开放原则和可扩展松耦合的好处。
为了简单起见,我只定义了一个类,就是人person这个类,所以就直接继承了。

【在 r****t 的大作中提到】
: 为啥这里的衣服一定要是 Person 的 subclass? 我想大家疑问是这个。
avatar
r*t
26
这个解释和 code 完全不同,按这个解释,Finary 必须一定不能是 Person 的子类,
算了爱啥啥吧,快学不完了。。。

【在 F*****e 的大作中提到】
:
: 现实中,除了人,还有别的如猫狗,也可以被装扮。人,猫狗都继承一个component类
: (比如说),衣服的类也继承component类,那么component就像一个接口,可以用作扩
: 展,这样就实现了封闭-开放原则和可扩展松耦合的好处。
: 为了简单起见,我只定义了一个类,就是人person这个类,所以就直接继承了。

avatar
q*x
27
类型关系是这样:
item, item with decor1, item with decor1 and decor2, item with decor1, 2,
and 3, etc.

【在 r****t 的大作中提到】
: 这个解释和 code 完全不同,按这个解释,Finary 必须一定不能是 Person 的子类,
: 算了爱啥啥吧,快学不完了。。。

avatar
z*u
28
人可以穿n件衣服,但一件衣服只能穿在一个人身上
所以衣服has-a人,比人has-a衣服更合理吧?

【在 q****x 的大作中提到】
: 但是组合应该反映has-a吧?应该是人有衣服,而不是衣服有人。
相关阅读
logo
联系我们隐私协议©2024 redian.news
Redian新闻
Redian.news刊载任何文章,不代表同意其说法或描述,仅为提供更多信息,也不构成任何建议。文章信息的合法性及真实性由其作者负责,与Redian.news及其运营公司无关。欢迎投稿,如发现稿件侵权,或作者不愿在本网发表文章,请版权拥有者通知本网处理。