在软件组件的设计中,如果责任划分的不清晰,使用继承得到的结果往往是随着需求的变化,子类持续膨胀,同时充斥着重复代码,这时候的关键是划清责任。
- Decorator
- Bridgd
手机都有通讯录和游戏功能,M品牌手机和N品牌手机都有通讯录的增删改查功能和游戏功能。可以有两种结构:
一、
父类是手机品牌,下有手机品牌M和手机品牌N,每个子类下各有通讯录和游戏子类。
二、
父类是手机软件,下有通讯录和游戏软件,每个子类下各有手机品牌M和手机品牌N.
在面向对象中有一个很重要的设计原则:
合成、聚合复用原则。即优先使用对象合成、聚合,而不是类继承。
优点:优先使用对象的合成、聚合有利于保持每个类并封装,并集中在单个任务上。这样类和类继承层次会保持较小规模,并且不太可能增长为不可控制的庞然大物。
实际上,上面的例子,需要用对象的职责,而不是结构来考虑问题。
游戏、通讯录这些功能都是软件,让其分离与手机的耦合,就大大减少面对新需求时改动过大的不合理情况。
应该有个手机品牌和手机软件抽象类,让不同的品牌和功能都分别继承他们,这样需要增加新的类或新的功能就不会影响其他的类了。
下面是实现代码:
//手机软件
abstract class HandSetSoft
{
public abstract void Run();
}
abstract class HandSetBrand
{
protected HandSetSoft;//设置手机软件
public void SetHandSetSoft(HandSetSoft soft)
{
this.soft=soft;
}
public abstract void Run();
}
class HandSetBrandM extends HandSetBrand //手机品牌M
{
public void run()
{
System.out.println("M Brand");
soft.Run();
}
class HandSetBrandN extends HandSetBrand //手机品牌N
{
public void run()
{
System.out.println("N Brand");
soft.Run();
}
class HandSetGame extends HandSetSoft
{
public void Run()
{
System.out.println("运行手机游戏");
}
}
class Address extends HandSetSoft
{
public void Run()
{
System.out.println("运行通讯录");
}
}
class HandSetMp3 extends HandSetSoft
{
public void Run()
{
System.out.println("运行手机Mp3");
}
}
public class CellPhonePatten
{
public static void main(String [] args)
{
HandSetBrand ab;
ab=new HandSetBrandN();
ab.SetHandSetSoft( new HandSetGame());
ab.Run();
ab.SetHandSetSoft(new AddressList());
ab.Run();
ab=new HandSetBrandM();
ab.SetHandSetSoft( new HandSetGame());
ab.Run();
ab.SetHandSetSoft(new AddressList());
ab.Run();
ab.SetHandSetSoft(new Mp3());
ab.Run();
}
}
如果现在我们想要增加一个功能,比如拍照功能,在手机软件部分增加手机拍照子类。类的个数增加也只是一个。不影响其他任何类。
同样的想要增加一个品牌,操作类似。
这样的设计符合开放——封闭原则,不会修改原来的代码,而只是扩展类就可以了。
合成/聚合原则,优先使用对象的合成或聚合,而不是类继承。
因为继承很容易造成不必要的麻烦,其本质原因是;
继承是一种强耦合的结构,父类变,子类就必须要交,所以在使用继承时,一定要在是‘is -a’的关系即一对一在考虑使用。
桥接模式
可以看出,这个系统含有两个等级结构:
- 由抽象化角色和提炼抽象化角色组成的抽象化等级结构。
- 由实现化角色和两个具体实现化角色所组成的实现化等级结构。
实现代码:
//Imlementor
abstract class Implementor
{
public abstract void Operation();
}
public class ConcreteImplementorA extends Implementor
{
public void Operation()
{
System.out.println("具体实现A的方式执行");
}
}
public class ConcreteImplementorB extends Implementor
{
public void Operation()
{
System.out.println("具体实现B的方式执行");
}
}
public class Abstraction
{
protected Implementor implementor;
public void SetImplementor(Implementor implementor)
{
this.implementor=implementor;
}
public void Operation()
{
implementor.Operation();
}
}
public class RefinedAbstraction extends Abstraction
{
public void Operation()
{
implementor.Operation();
}
}
public class client
{
public static void main(String []args)
{
Abstraction ab=new RefinedAbstraction();
ab.SetImplementor(new ConcreteImplementorA());
ab.Operation();
ab.SetImplementor(new ConcreteImplementorB());
ab.Operation();
}
}
桥接模式
就是将抽象部分与他的实现部分分离,其实就是实现系统可能有多角度分类,让每一种分类都可能变化,那么就把这种多角度分离出来让他们独立变化,减少他们之间的耦合。
在桥接模式中的桥接是单向的,也就是只能是抽象部分的对象去使用具体实现部分的对象,而不能反过来,也就是单向桥。
使用桥接和原始模式的根本区别在于是通过继承还是通过合成/聚合的方式去实现一个功能需求。因此面向对象分析和设计中有一个原则就是:Favor Composition Over Inheritance
**
本质
就是分离抽象与实现
**