重构：多态类型的重构

最新推荐文章于 2022-06-13 14:36:42 发布
最新推荐文章于 2022-06-13 14:36:42 发布
阅读量423 收藏 1
点赞数
分类专栏： 重构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010986518/article/details/82873367
版权

一.重构前

1.实用类
public class Item {
    public static final String SULFURAS = "Sulfuras";
    public static final String AGED_BRIE = "Aged Brie";
    public static final String BACKSTAGE_PASSES = "Backstage passes";
    public static final String NORMAL = "Normal";
    private final int sellIn;
    private final int quality;
    private final String name;

    public static Item newInstanceWithNameSellInAndQuality(String name, int sellIn, int quality) {
        if (!name.equals(SULFURAS) && (quality > 50 || quality < 0)) {
            throw new IllegalArgumentException("The quality of the normal item should be between 0 and 50.");
        }
        return new Item(name, sellIn, quality);
    }

    private Item(String name, int sellIn, int quality) {
        this.name = name;
        this.sellIn = sellIn;
        this.quality = quality;
    }

    public int getSellIn() {
        return sellIn;
    }

    public Item updateSellInAndQuality() {
        if (name.equals(SULFURAS)) {
            return new Item(name, sellIn - 1, quality);
        }
        if (name.equals(AGED_BRIE)) {
            return new Item(name, sellIn - 1, notGreaterThanFifty(quality + 1));
        }
        if (name.equals(BACKSTAGE_PASSES)) {
            return new Item(name, sellIn - 1, notGreaterThanFifty(sellIn > 10 ? quality + 1 : (sellIn > 5 ? quality + 2 : (sellIn > 0 ? quality + 3 : 0))));
        }
        return new Item(name, sellIn - 1, notLessThanZero((sellIn <= 0) ? quality - 2 : quality - 1));
    }

    private int notGreaterThanFifty(int quality) {
        return quality > 50 ? 50 : quality;
    }

    private int notLessThanZero(int quality) {
        return quality <= 0 ? 0 : quality;
    }

    public int getQuality() {
        return quality;
    }
}
2.测试类

注意：重构的前提条件是正确的测试类

package org.katas;

import org.junit.Test;

import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;

public class GildedRoseTest {
    @Test
    public void at_the_end_of_each_day_our_system_lowers_sellIn_and_quality_values_by_1_if_sellIn_is_greater_than_0_for_normal_items() {
        Item item = Item.newInstanceWithNameSellInAndQuality(Item.NORMAL, 1, 20);

        Item updatedItem = item.updateSellInAndQuality();

        assertThat(updatedItem.getSellIn(), is(0));
        assertThat(updatedItem.getQuality(), is(19));
    }

    @Test
    public void once_the_sell_by_date_has_passed_quality_of_normal_items_degrades_twice_as_fast() {
        Item item = Item.newInstanceWithNameSellInAndQuality(Item.NORMAL, 0, 20);

        Item updatedItem = item.updateSellInAndQuality();

        assertThat(updatedItem.getSellIn(), is(-1));
        assertThat(updatedItem.getQuality(), is(18));
    }

    @Test
    public void the_quality_of_normal_items_should_be_greater_than_or_equal_to_0() {
        Item item = Item.newInstanceWithNameSellInAndQuality(Item.NORMAL, 0, 0);

        Item updatedItem = item.updateSellInAndQuality();

        assertThat(updatedItem.getSellIn(), is(-1));
        assertThat(updatedItem.getQuality(), is(0));
    }

    @Test(expected = IllegalArgumentException.class)
    public void the_quality_of_normal_items_should_be_no_more_than_50() {
        Item item = Item.newInstanceWithNameSellInAndQuality(Item.NORMAL, 0, 51);
    }

    @Test
    public void the_Aged_Brie_actually_increases_in_Quality_by_1_the_older_it_gets() {
        Item item = Item.newInstanceWithNameSellInAndQuality(Item.AGED_BRIE, 0, 0);

        Item updatedItem = item.updateSellInAndQuality();

        assertThat(updatedItem.getSellIn(), is(-1));
        assertThat(updatedItem.getQuality(), is(1));
    }

    @Test
    public void the_quality_of_Aged_Brie_should_not_exceed_50() {
        Item item = Item.newInstanceWithNameSellInAndQuality(Item.AGED_BRIE, -1, 50);

        Item updatedItem = item.updateSellInAndQuality();

        assertThat(updatedItem.getSellIn(), is(-2));
        assertThat(updatedItem.getQuality(), is(50));
    }

    @Test
    public void the_Sulfuras_is_a_legendary_item_and_as_such_its_Quality_is_80_and_it_never_alters() {
        Item item = Item.newInstanceWithNameSellInAndQuality(Item.SULFURAS, -1, 80);

        Item updatedItem = item.updateSellInAndQuality();

        assertThat(updatedItem.getSellIn(), is(-2));
        assertThat(updatedItem.getQuality(), is(80));
    }

    @Test
    public void the_quality_of_backstage_passes_increases_by_1_when_the_sellIn_are_more_than_10_days() {
        Item item = Item.newInstanceWithNameSellInAndQuality(Item.BACKSTAGE_PASSES, 11, 20);

        Item updatedItem = item.updateSellInAndQuality();

        assertThat(updatedItem.getSellIn(), is(10));
        assertThat(updatedItem.getQuality(), is(21));
    }

    @Test
    public void the_quality_of_backstage_passes_increases_by_2_when_the_sellIn_are_between_5_and_10_days() {
        Item item = Item.newInstanceWithNameSellInAndQuality(Item.BACKSTAGE_PASSES, 10, 20);

        Item updatedItem = item.updateSellInAndQuality();

        assertThat(updatedItem.getSellIn(), is(9));
        assertThat(updatedItem.getQuality(), is(22));
    }

    @Test
    public void the_quality_of_backstage_passes_increases_by_3_when_the_sellIn_are_between_0_and_5_days() {
        Item item = Item.newInstanceWithNameSellInAndQuality(Item.BACKSTAGE_PASSES, 5, 20);

        Item updatedItem = item.updateSellInAndQuality();

        assertThat(updatedItem.getSellIn(), is(4));
        assertThat(updatedItem.getQuality(), is(23));
    }

    @Test
    public void the_quality_of_backstage_passes_drops_to_0_after_the_concert() {
        Item item = Item.newInstanceWithNameSellInAndQuality(Item.BACKSTAGE_PASSES, 0, 20);

        Item updatedItem = item.updateSellInAndQuality();

        assertThat(updatedItem.getSellIn(), is(-1));
        assertThat(updatedItem.getQuality(), is(0));
    }

    @Test
    public void the_quality_of_backstage_passes_is_not_greater_than_50() {
        Item item = Item.newInstanceWithNameSellInAndQuality(Item.BACKSTAGE_PASSES, 1, 50);

        Item updatedItem = item.updateSellInAndQuality();

        assertThat(updatedItem.getSellIn(), is(0));
        assertThat(updatedItem.getQuality(), is(50));
    }
}

二.重构之后

1.实体类
package org.katas;

public class Item {
    public static final String SULFURAS = "Sulfuras";
    public static final String AGED_BRIE = "Aged Brie";
    public static final String BACKSTAGE_PASSES = "Backstage passes";
    public static final String NORMAL = "Normal";
    private final int sellIn;
    private final int quality;
    private static Sell sell;

    public static Item newInstanceWithNameSellInAndQuality(String name, int sellIn, int quality) {
        setSell(name);
        return sell.newInstanceWithNameSellInAndQuality(sellIn, quality);
    }

    public Item(String name, int sellIn, int quality) {
        this.sellIn = sellIn;
        this.quality = quality;
    }

    public int getSellIn() {
        return sellIn;
    }

    public static void setSell(String name) {
        if(name.equals(SULFURAS)) {
            sell = new SulfurasSell();
            return;
        }
        if(name.equals(AGED_BRIE)) {
            sell = new AgedBrieSell();
            return;
        }
        if(name.equals(BACKSTAGE_PASSES)) {
            sell = new BackstagePassesSell();
            return;
        }
        sell = new NormalSell();
    }
    
    public Item updateSellInAndQuality() {
        return sell.updateSellInAndQuality(sellIn, quality);
    }

    public int getQuality() {
        return quality;
    }
}
2.多态类的接口
public interface Sell {
    Item newInstanceWithNameSellInAndQuality(int sellIn, int quality);
    
    Item updateSellInAndQuality(int sellIn, int quality);
}
3.多态类的实现
package org.katas;

public class AgedBrieSell implements Sell {

    public Item newInstanceWithNameSellInAndQuality(int sellIn, int quality) {
        if (quality > 50 || quality < 0) {
            throw new IllegalArgumentException("The quality of the normal item should be between 0 and 50.");
        }
        return new Item("Aged Brie", sellIn, quality);
    }

    public Item updateSellInAndQuality(int sellIn, int quality) {
        return new Item("Aged Brie", sellIn - 1, notGreaterThanFifty(quality + 1));
    }
    
    private int notGreaterThanFifty(int quality) {
        return quality > 50 ? 50 : quality;
    }
}


package org.katas;

public class BackstagePassesSell implements Sell {
    public Item newInstanceWithNameSellInAndQuality(int sellIn, int quality) {
        if (quality > 50 || quality < 0) {
            throw new IllegalArgumentException("The quality of the normal item should be between 0 and 50.");
        }
        return new Item("Backstage passes", sellIn, quality);
    }

    public Item updateSellInAndQuality(int sellIn, int quality) {
        return new Item("Backstage passes", sellIn - 1, notGreaterThanFifty(sellIn > 10 ? quality + 1 : (sellIn > 5 ? quality + 2 : (sellIn > 0 ? quality + 3 : 0))));
    }
    
    private int notGreaterThanFifty(int quality) {
        return quality > 50 ? 50 : quality;
    }
}


package org.katas;

public class NormalSell implements Sell{

    public Item newInstanceWithNameSellInAndQuality(int sellIn, int quality) {
        if (quality > 50 || quality < 0) {
            throw new IllegalArgumentException("The quality of the normal item should be between 0 and 50.");
        }
        return new Item("Normal", sellIn, quality);
    }

    public Item updateSellInAndQuality(int sellIn, int quality) {
        return new Item("Normal", sellIn - 1, notLessThanZero((sellIn <= 0) ? quality - 2 : quality - 1));
    }

    private int notLessThanZero(int quality) {
        return quality <= 0 ? 0 : quality;
    }
}


package org.katas;

public class SulfurasSell implements Sell {

    public Item newInstanceWithNameSellInAndQuality(int sellIn, int quality) {
        return new Item("Sulfuras", sellIn, quality);
    }

    public Item updateSellInAndQuality(int sellIn, int quality) {
        return new Item("Sulfuras", sellIn - 1, quality);
    }
}

重构完成。

ShuaiLewis
关注
专栏目录
重构——以多态取代条件表达式（状态模式）
laojiaqi的专栏
08-18 4352
在写代码的时候，经常会遇到switch语句，根据状态码进行不同的操作，该方法简单，快捷，但维护起来较麻烦，也不易扩展。      例如，如下代码 public class Employee { private int mType; static final int salary=500; static final int commission=500;
实践《重构：改善既有代码的设计（第2版）》示例（C++版）（二）
小小笑笑川的博客
07-20 868
《重构：改善既有代码的设计》C++版本，相互讨论，共同学习，不断成长
巧用多态进行方法重构
cld79844的博客
06-12 157
原来写的方法需要调整、修改和优化时，可以利用多态的性质进行重构的工作 参数多加一个废弃的标记，然后由系统的异常处理来控制调用哪个方法，如果重构后的方法长时间运行没有问题，可以去除标记为废弃的方法 ...
多态重构条件语句
anfeng4628的博客
07-06 137
首先，在C#中，多态的体现是什么？虚函数、抽象方法、接口。废话不多说，直接上代码： #region 多态重构switch...case.... public abstract class ShippingCalculation { public abstract decimal Calculate(); } public class A...
Eclipse中的重构类型--学习
shaxianwei的专栏
04-25 160
Eclipse中的重构类型        如果你看一下Eclipse的重构菜单，可以看到四部分。第一部分是撤销和重做。其他的三部分包含Eclipse提供的三种类型的重构。        第一种类型的重构改变代码的物理结构，像Rename和Move。第二种是在类层次上改变代码结构，例如Pull Up和Push Down。第三种是改变类内部的代码，像Extract Method和Encap...
重构的分类
飞翔的大象
08-21 1253
重构的分类：重构的手法中有相当一大部分是双向的、互逆的，也就是说在某种时候是你找我，而在另一些时候是我找你，比如Pull Up Field和Push Down Field，Pull Up Method和Push Down Method等，而另一些则是强调单向的、勇往直前的，比如Encapsulate Field、Remove Control Flag、Remove Parameter、Remove
重构：从方法论到实践
01-27
5. 多条件判断或switch：利用多态简化复杂的条件逻辑。 6. try-catch块中的冗长代码：封装成单独的异常处理函数，提高可读性。 7. 非线性代码流：尽量避免在类内部进行不必要的跳转，保持代码的顺序阅读性。 在实际...
重构：改善既有代码的设计 [重点整理版]
04-10
### 重构：改善既有代码的设计 #### 一、引言 在软件开发过程中，随着项目的不断演进，代码库往往会出现各种各样的问题，这些问题包括但不限于冗余代码、过长的方法、复杂的类结构等。这些问题不仅增加了代码的...
重构：改善既有代码的设计（第2版）1
08-03
再进一步，将相关计算过程按类型重组，引入多态计算器以优化数据处理。这个过程展示了如何逐步、系统地进行重构，而不是一次性大规模修改。 第2章“重构的原则”阐述了重构的核心概念，如理解重构不仅仅是代码的...
重构：改善既有代码的设计.[美]Martin Fowler.epub【文字版手机格式】
04-23
重构，一言以蔽之，就是在不改变外部行为的前提下，有条不紊地改善代码。多年前，正是本书原版的出版，使重构终于从编程高手们的小圈子走出，成为众多普通程序员日常开发工作中不可或缺的一部分。本书也因此成为与...
一次简单易懂的多态重构实践，让你理解条件逻辑
华为云官方博客
04-16 759
复杂的条件逻辑是编程中最难理解的东西之一。
面向对象基础(1)--继承 多态 重构
王帆的专栏
03-14 1459
好久没有写博客了，最近一直忙着复习考研，前几天听了张老师讲的设计模式的这门课，很有感触，就简单地整理一下学的东西。。。 这节课讲的是面向对象的几个基本概念，老师举了个例子把面向对象的很多东西都连接起来了：动物比赛，每个不同动物都有名字，能发出叫声等。。。 一.继承.              第一、子类拥有父类非private的属性和功能；              第二、子类具有
代码重构(二)：类重构规则
weixin_34087301的博客
03-07 198
在上篇博客《代码重构(一)：函数重构规则（Swift版）》中，详细的介绍了函数的重构规则，其中主要包括：Extract Method, Inline Method, Inline Temp, Replace Temp with Query, Introduce Explaining Variable, Split Temporary Variable, Remove Assignments to ...
重构类
Mason的博客
07-08 372
1. 搬移函数每一个方法应该放在它最适合的位置，不能随便乱放，所以很多时候你需要考虑，一个方法在这里是不是最适合的。class Class1 { aMethod(); } class Class2 { } 更改为↓ class Class1 { } class Class2 { aMethod(); } 做法： 检查源类中被原函数所使用的一切特性（字段，函数），考虑是否该被迁
对一个类的重构
niceLaoHu的专栏
05-20 896
项目现在正在原型阶段，很多类的实现都没有进行整理，当增加新功能的时候，为了不修改原有的功能，常常需要进行很多的copy-paste，这就导致了这个类代码的膨胀，以致到了不能维护的边缘。我用了两天时间对这个类进行了重构。做法如下： 分析类的功能； 将重复代码提取为函数； 将独立的职责提取为独立的类； 分析类的特点，提取部分类的公共特性，并将非公共的部分提取
重构 用多态取代条件逻辑
zhjali123的专栏
01-18 1315
示例： Customer类： int num; public int getPrice(){ int result； switch(getFruit.getPriceCode){ case:Fruit.APPLE: result = num * 4； break; case:Fruit.BANANA: result =  num*7; break; } return re
3 类重构
dabusidede的博客
07-21 589
1.以对象取代数据值 如果一个数据值需要和一些行为绑定在一起，那么提炼出一个新类吧 // 重构前 class 房子{ ... int 门的长度; int 门的宽度; int 获取门的面积() { ... } int 获取门的占地面积() { ... } } // 重构后 class 房子{ 门 门; ... } class 门{ int 门的长度; int 门的宽度; int 获取门的面积() { ... } int
重构——使用多态替换switch
fulong0406的博客
06-13 875
java重构 多态替换switch
【重构学习】06 类的重构
ZQ13771472517的博客
01-05 138
好吧，这一章要不要自己写一段示例代码考虑了很久，貌似还是不写的好，因为感觉这一章异常的简单 这一章就是关于类的方法和字段并不合理，所以在搬移方法和字段1、搬移函数 修改点：一个函数与其所在类外的另一个类进行了过多的交流，调用后者或被后者调用 动机：因为出现上述情况，就会出现高度耦合， 做法：在该函数最常引用的类中建立一个有着类似行为的新函数，将旧函数变成一个委托函数，或是移...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值