实践代码体验:1~3版(使用设计模式让代码更加容易扩展,降低耦合,抽象出模板)
**
* @author xiaokai
*
* 1. 鸭子的游戏:基类 quack-叫 swim-游泳 display-外观
* 2. 现在要让鸭子能飞 Duck加个fly 但是橡皮鸭(RubberDuck)不会飞 使用将fly方法覆盖,根quack一样
* 现在又出现一个 (WoodDuck)木头鸭 不会叫 不会飞
*
* 利用继承提供的Duck(鸭子)的行为会导致哪些缺点?
*
* (1)代码在多个子类中重复
*
* (2)很难知道所有鸭子的全部行为
*
* (3)运行时的行为不容易改变
*
* (4)改变会牵一发动全身,造成其他鸭子的不想要的改变
*
* 3. 现在该如何设计,鸭子的行为在子类不停的变化?
*
* 现在把fly的行为 和 叫的行为 定义成接口,从 duck中提取出来,有需要的鸭子实现它,没有的不实现?
*
* (1) Java接口不具备实现,因此你要修改某个行为,你需要追踪到每个子类去修改代码,达不到复用代码的作用
* (2) 鸭子不应该与变化的东西是继承关系,接口是一种特殊继承,应该是有一个
*
* 【设计原则】
*
* 分开变化和不变化的部分
*
* 针对接口编程,而不是针对实现编程
*
* 4.根据设计原则,推出第二版鸭子?
*/
public abstract class Duck {
public void quack(){
System.out.println("瓜瓜叫");
}
public void swim(){
System.out.println("游泳");
}
//每种鸭子的外观不同
public abstract void display();
public void fly(){
System.out.println("飞翔");
}
}
/**
* @author xiaokai
*/
public class GreenDuck extends Duck {
@Override
public void display() {
System.out.println("我是绿头鸭");
}
}
package com.xiaokai.one_part_1.extendClass;
import com.xiaokai.one_part_1.superClass.Duck;
/**
* @author xiaokai
*/
public class RedDuck extends Duck {
@Override
public void display() {
System.out.println("我是红头鸭");
}
}
/**
* @author xiaokai
* 橡皮鸭(新需求,不会叫,吱吱叫,使用继承必须强迫你去检查新的需求,父类是否满足,不满足,需要覆盖实现,这样很烦)
*/
public class RubberDuck extends Duck {
@Override
public void display() {
System.out.println("我是橡皮鸭,我不会飞");
}
@Override
public void quack() {
System.out.println("吱吱叫");
}
@Override
public void fly() {
System.out.println("我不会叫");
}
}
第三版:
package com.xiaokai.one_part_2.superClass;
import com.xiaokai.one_part_2.Behavior.FlyBehavior;
import com.xiaokai.one_part_2.Behavior.QuackBehavior;
/**
* @author xiaokai
* 1.鸭子不会负责实现行为接口,以前是通过继承和覆盖或者是鸭子实现接口,将代码在子类实现,绑定的死死的。
* (委托)现在是具体实现交由 FlyBehavior 和 QuackBehavior,这样有新鸭子来,鸭子代码是不变的,只要扩展新的接口,实现子类就可以,完美
*
* 2.第三版:给委托加set方法,将子类的面对具体实现去掉,动态的改变鸭子的飞行行为
*
* 分清:有一个 是一个 实现
*
* 【设计原则】
*
* 多用组合(有一个),少用继承(是一个 实现)
*
* 3.组合的优点:在运行时动态的改变行为,组合对像符合标准的接口即可
*
* 4.第一个设计模式:策略模式(定义了算法族,分别封装起来 flyBehavior quackBehavior)
* 使用策略模式实现鸭子的行为,鸭子的行为被封装到一组类中,鸭子的行为能为轻易的扩展与改变
*/
public abstract class Duck {
FlyBehavior flyBehavior;
QuackBehavior quackBehavior;
public void swim(){
System.out.println("游泳");
}
//每种鸭子的外观不同
public abstract void display();
public void performFly(){
flyBehavior.fly();//将飞的行为委托出去了
}
public void performQuack(){
quackBehavior.quack();
}
//将子类中的具体实现代码改变
public void setFlyBehavior(FlyBehavior flyBehavior) {
this.flyBehavior = flyBehavior;
}
public void setQuackBehavior(QuackBehavior quackBehavior) {
this.quackBehavior = quackBehavior;
}
}
//飞的接口
public interface FlyBehavior {
void fly();
}
public class CanFly implements FlyBehavior{
@Override
public void fly() {
System.out.println("我会飞");
}
}
public class NoFly implements FlyBehavior {
@Override
public void fly() {
System.out.println("我不会飞");
}
}
//叫的接口
public interface QuackBehavior {
void quack();
}
public class NoQuack implements QuackBehavior{
@Override
public void quack() {
System.out.println("不会叫");
}
}
又来了一个木头鸭子,不会飞,也不会叫,使用第三版体验策略模式的方便之处?
public class WoodDuck extends Duck {
@Override
public void display() {
System.out.println("我是木头鸭子");
}
}
public static void main( String[] args )
{
//第二版
//Duck greenDuck = new GreenDuck();
//greenDuck.performFly();
Duck rubberDuck = new RubberDuck();
rubberDuck.setFlyBehavior(new NoFly());
rubberDuck.performFly();
//第三版 运行时动态绑定(JVM) 木头鸭
Duck woodDuck = new WoodDuck();
woodDuck.setFlyBehavior(new NoFly());
woodDuck.setQuackBehavior(new NoQuack());
woodDuck.performFly();
woodDuck.performQuack();
}
自我总结:抽象出一套模板(Duck)不变的东西,模板里面留有规范的插槽(FlyBehavior QuackBehavior),运行时将符合插槽的具体实现组装进去,实现功能不同的产品
大白话:CPU主板上面有很多插槽,想要不同规格的CPU主板,对应的插槽中插入不同的部件(内存条1G 2G …)