java设计模式之前

设计原则：(重要)

1.

逻辑代码独立到单独的方法中，注重封装性--易读，易复用。

不要在一个方法中，写下上百行的逻辑代码。把各小逻辑代码独立出来，写于其它方法中，易读其可重复调用。

2.

写类，写方法，写功能时，应考虑其移植性，复用性：防止一次性代码！

是否可以拿到其它同类事物中应该？是否可以拿到其它系统中应该？

3.

熟练运用继承的思想：

找出应用中相同之处，且不容易发生变化的东西，把它们抽取到抽象类中，让子类去继承它们；

继承的思想，也方便将自己的逻辑建立于别人的成果之上。如ImageField extends JTextField；

熟练运用接口的思想：

找出应用中可能需要变化之处，把它们独立出来，不要和那些不需要变化的代码混在一起。

把很简单的东西搞得那么复杂，一次性代码，设计模式优势的实例说明：（策略模式）

说明：

模拟鸭子游戏的应用程序，要求：游戏中会出现各种颜色外形的鸭子，一边游泳戏水，一边呱呱叫。

第一种方法：（一次性代码）

直接编写出各种鸭子的类：MallardDuck//野鸭，RedheadDuck//红头鸭，各类有三个方法：

quack()：叫的方法

swim()：游水的方法

display()：外形的方法

第二种方法：运用继承的特性，将其中共同的部分提升出来，避免重复编程。

即：设计一个鸭子的超类（Superclass）,并让各种鸭子继承这个超类。

public class Duck{

public void quack(){ //呱呱叫

System.out.println("呱呱叫");

}

public void swim(){ //游泳

System.out.println(" 游泳");

}

public abstratact void display(); /*因为外观不一样，让子类自己去决定了。*/

}

对于它的子类只需简单的继承就可以了，并实现自己的display()方法。

//野鸭

public class MallardDuck extends Duck{

public void display(){

System.out.println("野鸭的颜色...");

}

}

//红头鸭

public class RedheadDuck extends Duck{

public void display(){

System.out.println("红头鸭的颜色...");

}

}

不幸的是，现在客户又提出了新的需求，想让鸭子飞起来。这个对于我们OO程序员，在简单不过了，在超类中在加一

个方法就可以了。

public class Duck{

public void quack(){ //呱呱叫

System.out.println("呱呱叫");

}

public void swim(){ //游泳

System.out.println(" 游泳");

}

public abstract void display(); /*因为外观不一样，让子类自己去决定了。*/

public void fly(){

System.out.println("飞吧！鸭子");

}

}

对于不能飞的鸭子，在子类中只需简单的覆盖。

//残废鸭

public class DisabledDuck extends Duck{

public void display(){

System.out.println("残废鸭的颜色...");

}

public void fly(){

//覆盖，变成什么事都不做。

}

}

其它会飞的鸭子不用覆盖。

这样所有的继承这个超类的鸭子都会fly了。但是问题又出来了，客户又提出有的鸭子会飞，有的不能飞。

>>>>>>点评:

对于上面的设计，你可能发现一些弊端，如果超类有新的特性，子类都必须变动，这是我们开发最不喜欢看到的，一个类变让另一个类也跟着变，这有点不符合OO设计了。这样很显然的耦合了一起。利用继承-->耦合度太高了.

第三种方法：

用接口改进.

我们把容易引起变化的部分提取出来并封装之，来应付以后的变法。虽然代码量加大了，但可用性提高了，耦合度也降低了。

我们把Duck中的fly方法和quack提取出来。

public interface Flyable{

public void fly();

}

public interface Quackable{

public void quack();

}

最后Duck的设计成为：

public class Duck{

public void swim(){ //游泳

System.out.println(" 游泳");

}

public abstract void display(); /*因为外观不一样，让子类自 己去决定了。*/

}

而MallardDuck,RedheadDuck,DisabledDuck 就可以写成为：

//野鸭

public class MallardDuck extends Duck implements Flyable,Quackable{

public void display(){

System.out.println("野鸭的颜色...");

}

public void fly(){

//实现该方法

}

public void quack(){

//实现该方法

}

}

//红头鸭

public class RedheadDuck extends Duck implements Flyable,Quackable{

public void display(){

System.out.println("红头鸭的颜色...");

}

public void fly(){

//实现该方法

}

public void quack(){

//实现该方法

}

}

//残废鸭 只实现Quackable（能叫不能飞）

public class DisabledDuck extends Duck implements Quackable{

public void display(){

System.out.println("残废鸭的颜色...");

}

public void quack(){

//实现该方法

}

}

>>>>>>点评:

好处:

这样已设计，我们的程序就降低了它们之间的耦合。

不足:

Flyable和 Quackable接口一开始似乎还挺不错的，解决了问题（只有会飞到鸭子才实现 Flyable），但是Java接口不具有实现代码，所以实现接口无法达到代码的复用。

第四种方法：

对上面各方式的总结:

继承的好处:让共同部分,可以复用.避免重复编程.

继承的不好:耦合性高.一旦超类添加一个新方法,子类都继承,拥有此方法,

若子类相当部分不实现此方法,则要进行大批量修改.

继承时,子类就不可继承其它类了.

接口的好处:解决了继承耦合性高的问题.

且可让实现类,继承或实现其它类或接口.

接口的不好:不能真正实现代码的复用.可用以下的策略模式来解决.