《重构》第一章示例 — 体验重构的魔力 RefactorSample

最新推荐文章于 2019-10-10 22:23:12 发布
最新推荐文章于 2019-10-10 22:23:12 发布
阅读量1.3k 收藏 3
点赞数
分类专栏： JAVA学习扩展 Learn_Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wjw0130/article/details/42969173
版权

     一个月了，没有认真写博客，也没有认真学习，数据库的学习进度一直拖拖拉拉到现在也没有搞定，sad。。。


今天，看了一下《重构》的第一章，深深的被吸引了....


示例 

情景：顾客租电影，电影分三种，儿童票，普通片，新片，儿童片2天以内1.5元，超过两天，每一天加收1.5元，普通片3天以内2元，超过两天，每一天加收2元，新片每天3元，每租一次电影积分加一，如果是新片，且租期超过2天，积分加二。

分析：

以面向对象的思想分析，涉及对象顾客，影片，外加一个租赁类作为顾客和影片的桥接

编写代码

影片类（Movie）：

public class Movie {
    public static final int CHILDRENS = 0;
    public static final int REGULARS = 1;
    public static final int NEW_RELEASE = 2;
    private String name;
    private int movType;

    public Movie(String name, int movType) {
        this.name = name;
        this.movType = movType;
    }

    name:    set 和  get 方法
    movType: set 和get 方法
}

为了节省篇幅，Movie类的name、movType的set和get就不贴了。

租赁类（Rental）：

public class Rental {
    private Movie movie;
    private int rentDays;

    public Rental(Movie movie,int rentDays) {
        this.movie = movie; this.rentDays = rentDays;
    }

    movie 和 rentDays的set和get方法

顾客类（Customer）： 

public class Customer {
    private String name;
    private ArrayList<Rental> rentals = new ArrayList<Rental>();

    public Customer(String name) {
        this.name = name;
    }
    public void addRent(Rental r){
        rentals.add(r);
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String statement() throws Exception {
        String result = "Rental report for " + getName() + "\n";
        double totalAmount = 0;
        int frequent = 0;
        for(Rental r : rentals){
            double thisAmount = 0;
            switch (r.getMovie().getMovType()){
                case Movie.CHILDRENS :
                    thisAmount += (r.getRentDays()>2)?((r.getRentDays()-2)*1.5+1.5):1.5;
                    break;
                case Movie.REGULARS:
                    thisAmount += (r.getRentDays()>3)?((r.getRentDays()-3)*2+2):2;
                    break;
                case Movie.NEW_RELEASE:
                    thisAmount += r.getRentDays() * 3;
                    break;
                default:throw new Exception("类型异常");

            }
            totalAmount += thisAmount;
            frequent += (r.getMovie().getMovType()==Movie.NEW_RELEASE &&
                    r.getRentDays()>2)?2:1;
            result+="\t" + r.getMovie().getName() + "\t" + String.valueOf(thisAmount) + "\n";
        }
        result += "Amount is " + String.valueOf(totalAmount) + "元\n";
        result += "frequent is " + String.valueOf(frequent)+"分";
        return result;
    }
}

编写测试代码： 

public class Test {
    public static void main(String[] args) throws Exception {
        Movie m1 = new Movie("葫芦娃",0);//儿童片
        Movie m2 = new Movie("神雕侠侣",1);//普通片
        Movie m3 = new Movie("何以笙箫默",2);//新片
        Customer c = new Customer("朱小妹");
        c.addRent(new Rental(m1,2));//1.5
        c.addRent(new Rental(m2,2));//2
        c.addRent(new Rental(m3,3));//9
        System.out.println(c.statement());
    }
}

以上代码完成了示例需求，但是代码写的...太烂了，我自己写绝对也是这个样子。。。代码烂，怎么办？重构！

第一步：一劳永逸 —  修改测试代码


为了方便测试，我们将打印结果作为一个字符串保存起来。

public class Test {
    public static void main(String[] args) throws Exception {
        Movie m1 = new Movie("葫芦娃",0);//儿童片
        Movie m2 = new Movie("神雕侠侣",1);//普通片
        Movie m3 = new Movie("何以笙箫默",2);//新片
        Customer c = new Customer("朱小妹");
        c.addRent(new Rental(m1,2));//1.5
        c.addRent(new Rental(m2,2));//2
        c.addRent(new Rental(m3,3));//9
        String result = "Rental report for 朱小妹\n" +
                "\t葫芦娃\t1.5\n" +
                "\t神雕侠侣\t2.0\n" +
                "\t何以笙箫默\t9.0\n" +
                "Amount is 12.5元\n" +
                "frequent is 4分";
        System.out.println(c.statement().equals(result));
    }
}

以后的测试结果，true就是修改正确，false就是修改失败。


第二步：一石二鸟  —  分解customer类statement方法


纵观所有代码，唯独customer类的statement代码最多，最乱，看着烦，看switch更烦，而switch的作用就是一个计算一个临时变量thisAmount的作用，而临时变量越多对一个程序来说就越容易出错，既然容易出错，totalAmount和frement有什么用，还占地方，留它们干嘛，拿走，单独封装。

更改后的customer类：

public class Customer {
    private String name;
    private ArrayList<Rental> rentals = new ArrayList<Rental>();

    public Customer(String name) {
        this.name = name;
    }
    public void addRent(Rental r){
        rentals.add(r);
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String statement() throws Exception {
        String result = "Rental report for " + getName() + "\n";
        for (Rental r : rentals ) {
            result += "\t" + r.getMovie().getName() + "\t" + String.valueOf(amountFor(r)) + "\n";
        }
        result += "Amount is " + String.valueOf(getTotalAmount()) + "元\n";
        result += "frequent is " + String.valueOf(getTotalFrequent())+"分";
        return result;
    }
    private double getTotalAmount() throws Exception {
        double totalAmount = 0;
        for(Rental r : rentals){
            totalAmount += amountFor(r);
        }
        return  totalAmount;
    }
    private int getTotalFrequent(){
        int frequent = 0;
        for(Rental r : rentals){
            frequent += (r.getMovie().getMovType()==Movie.NEW_RELEASE &&
                    r.getRentDays()>2)?2:1;
        }
        return  frequent;
    }
    private double amountFor(Rental r) throws Exception {
        double thisAmount = 0;
        switch (r.getMovie().getMovType()){
            case Movie.CHILDRENS :
                thisAmount += (r.getRentDays()>2)?((r.getRentDays()-2)*1.5+1.5):1.5;
                break;
            case Movie.REGULARS:
                thisAmount += (r.getRentDays()>3)?((r.getRentDays()-3)*2+2):2;
                break;
            case Movie.NEW_RELEASE:
                thisAmount += r.getRentDays() * 3;
                break;
            default:throw new Exception("类型异常");
       }
        return thisAmount;
    }
}


这样statement方法庞大和临时变量多的问题都解决了，进行测试，true，修改正确

第三步：各回各家 — 做自己该干的事


重新审视一下customer类，你会发现它很多它不该干的事，switch计算单次租赁花费和积分这个事，应该电影类干吧，花多钱，得多少分，电影自身最清楚

问题还是存在switch身上，最好不要在另一个对象的属性基础上运用switch，如果非要使用，也应该是在对象自己的数据上使用，而不是在别人的数据上使用。

在rental类中增加getOneMoney方法和getOneFre方法，customer类删除amountFor方法，修改getTotalFrequent方法，switch搬家到Movie类中

更改后的customer类

只变动了getTotalFrequent方法for循环

public class Customer {
    private String name;
    private ArrayList<Rental> rentals = new ArrayList<Rental>();

    public Customer(String name) {
        this.name = name;
    }
    public void addRent(Rental r){
        rentals.add(r);
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String statement() throws Exception {
        String result = "Rental report for " + getName() + "\n";
        for (Rental r : rentals ) {
            result += "\t" + r.getMovie().getName() + "\t" + String.valueOf(r.getOne()) + "\n";
        }
        result += "Amount is " + String.valueOf(getTotalAmount()) + "元\n";
        result += "frequent is " + String.valueOf(getTotalFrequent())+"分";
        return result;
    }
    private double getTotalAmount() throws Exception {
        double totalAmount = 0;
        for(Rental r : rentals){
            totalAmount += r.getOne();
        }
        return  totalAmount;
    }
    private int getTotalFrequent(){
        int frequent = 0;
        for(Rental r : rentals){
            frequent += r.getOneFre();
        }
        return  frequent;
    }
}

更改后的rental，起了一个桥梁作用 

public class Rental {
        private Movie movie;
        private int rentDays;
        public Rental(Movie movie,int rentDays) {
            this.movie = movie; this.rentDays = rentDays;
        }
    public int getRentDays() {
        return rentDays;
    }
    public void setRentDays(int rentDays) {
        this.rentDays = rentDays;
    }
    public Movie getMovie() {

        return movie;
    }
    public double getOne() throws Exception {
        return  getMovie().getMoney(rentDays) ;
    }
    public int getOneFre(){
        return  getMovie().getFrequent(rentDays);
    }
    public void setMovie(Movie movie) {
        this.movie = movie;
    }
}

更改后的movie类，终于开始做事了 

/**
 * Created by Kevy on 2015/1/21.
 */
/*编写电影类代码*/
public class Movie {
    public static final int CHILDRENS = 0;
    public static final int REGULARS = 1;
    public static final int NEW_RELEASE = 2;
    private String name;
    private int movType;

    public Movie(String name, int movType) {
        this.name = name;
        this.movType = movType;
    }

    public int getMovType() {
        return movType;
    }
    public void setMovType(int movType) {
        this.movType = movType;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

    public double getMoney(int RentDays) throws Exception {
        double thisAmount = 0;
        switch (getMovType()){
            case Movie.CHILDRENS :
                thisAmount += (RentDays>2)?((RentDays-2)*1.5+1.5):1.5;
                break;
            case Movie.REGULARS:
                thisAmount += (RentDays>3)?((RentDays-3)*2+2):2;
                break;
            case Movie.NEW_RELEASE:
                thisAmount += RentDays * 3;
                break;
            default:throw new Exception("类型异常");
        }
        return  thisAmount ;
    }

    public int getFrequent(int RentDays){
        return (getMovType()==NEW_RELEASE &&
                RentDays>2)?2:1;
    }
}

测试OK，没有问题。


第四步 利用多态

现在所有的类，都在干自己的事，movie类的getMoney方法的代码量看着还是不太好，既然是三种电影只是类型不同而已，那么久完全可以向上抽取使用抽象类。

public interface Type {
    public int getType();
    public double getMovMeony(int days);
}


public class ChildrenMov implements Type {

    public int getType() {
        return 0;
    }

    public double getMovMeony(int days) {
        return (days>2)?((days-2)*1.5+1.5):1.5;
    }
}


public class RegularMov implements Type {

    public int getType() {
        return 1;
    }

    public double getMovMeony(int days) {
        return (days>3)?((days-3)*2+2):2;
    }
}

public class NewMov implements Type {
    public int getType() {
        return 2;
    }

    public double getMovMeony(int days) {
        return days * 3;
    }
}

最终完整代码： 

import java.util.ArrayList;

/**
 * Created by Kevy on 2015/1/21.
 */
public class Customer {
    private String name;
    private ArrayList<Rental> rentals = new ArrayList<Rental>();

    public Customer(String name) {
        this.name = name;
    }
    public void addRent(Rental r){
        rentals.add(r);
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String statement() throws Exception {
        String result = "Rental report for " + getName() + "\n";
        for (Rental r : rentals ) {
            result += "\t" + r.getMovie().getName() + "\t" + String.valueOf(r.getOne()) + "\n";
        }
        result += "Amount is " + String.valueOf(getTotalAmount()) + "元\n";
        result += "frequent is " + String.valueOf(getTotalFrequent())+"分";
        return result;
    }
    private double getTotalAmount() throws Exception {
        double totalAmount = 0;
        for(Rental r : rentals){
            totalAmount += r.getOne();
        }
        return  totalAmount;
    }
    private int getTotalFrequent(){
        int frequent = 0;
        for(Rental r : rentals){
            frequent += r.getOneFre();
        }
        return  frequent;
    }
}


/**
 * Created by Kevy on 2015/1/21.
 */

public class Rental {
        private Movie movie;
        private int rentDays;
        public Rental(Movie movie,int rentDays) {
            this.movie = movie; this.rentDays = rentDays;
        }
    public int getRentDays() {
        return rentDays;
    }
    public void setRentDays(int rentDays) {
        this.rentDays = rentDays;
    }
    public Movie getMovie() {

        return movie;
    }
    public double getOne() throws Exception {
        return  getMovie().getMoney(rentDays) ;
    }
    public int getOneFre(){
        return  getMovie().getFrequent(rentDays);
    }
    public void setMovie(Movie movie) {
        this.movie = movie;
    }
}


/**
 * Created by Kevy on 2015/1/21.
 */
/*编写电影类代码*/
public class Movie {
    public static final int CHILDRENS = 0;
    public static final int REGULARS = 1;
    public static final int NEW_RELEASE = 2;
    private String name;
   private Type t;

    public Movie(String name, int movType) throws Exception {
        this.name = name;
        setT(movType);
    }

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

    public double getMoney(int RentDays) {
        return t.getMovMeony(RentDays);
    }

    public int getFrequent(int RentDays){
        return (t.getType()==NEW_RELEASE &&
                RentDays>2)?2:1;
    }

    public void setT(int d) throws Exception {
       switch (d){
           case CHILDRENS :t = new ChildrenMov();
               break;
           case REGULARS:t = new RegularMov();
               break;
           case NEW_RELEASE:t = new NewMov();
               break;
           default:throw new Exception("类型错误");
       }
    }
}


import sun.plugin2.message.ModalityChangeMessage;

/**
 * Created by Kevy on 2015/1/21.
 */

/* 编写测试代码 */
public class Test {
    public static void main(String[] args) throws Exception {
        Movie m1 = new Movie("葫芦娃",0);//儿童片
        Movie m2 = new Movie("神雕侠侣",1);//普通片
        Movie m3 = new Movie("何以笙箫默",2);//新片
        Customer c = new Customer("朱小妹");
        c.addRent(new Rental(m1,2));//1.5
        c.addRent(new Rental(m2,2));//2
        c.addRent(new Rental(m3,3));//9
        String result = "Rental report for 朱小妹\n" +
                "\t葫芦娃\t1.5\n" +
                "\t神雕侠侣\t2.0\n" +
                "\t何以笙箫默\t9.0\n" +
                "Amount is 12.5元\n" +
                "frequent is 4分";
        System.out.println(c.statement().equals(result));

    }
}

至此，一个简单的代码重构示例，重构完毕

重构最大的启发就是：测试、小改、测试、小改....


u013497151
关注
专栏目录
1.1重构-第一章
Harry的博客
02-06 355
重构是在不改变软件可观察行为的前提下改善其内部结构。 设计模式为重构提供了目标 1.1 起点 这是一个影片出租店用的程序，计算每一个顾客的消费金额并打印详单。操作者告诉程序：租客租了哪些影片、租期多长，程序便根据租赁时间和影片类型算出费用。影片分为三类：普通片、儿童片、新片。除了计算费用，还要为常客计算积分，积分会根据租片种类是否为新片而有不同。 Movie（影片）- movie只
代码重构源码（包含重构前后代码）
06-09
面向对象——代码重构源码（包含重构前后代码），是对《重构——改善既有代码的设计》一书中第一章节实例的模拟实现，实例是为影片出租店所用的租赁程序。
《重构》读书笔记（二）——第一章 第一个重构案例
e5Max的专栏
07-13 1702
第1章 重构，第一个案例          作者在第一章通过一个影片出租的例子，试图阐述重构的基本过程和步骤。看得出来，作者对这个案例给予厚望，花了很大的篇幅。正因如此，我没有理由不好好学习这一章。          影片出租的例子本身不难，但我足足花了一整个下午学习了这个例子。我先是老老实实的把代码用C++重抄了一遍，然后跟着作者的步伐，一步步重构，以期体验“重构改善设计”的完美过程。
《重构》第一章 笔记
幸福在路上
06-14 1049
《重构》第一章：Refactoring, a First Example书中描述的我比较认同的观点： 1.如果你发现自己需要为程序添加一个特性，而代码结构使你无法很方便地那么做，那就先重构那个程序，使特性的添加比较容易进行，然后再添加特性。2.每当我要进行重构的时候，第一个步骤永远相同：我得为即将修改的代码建立一组可靠的测试环境。3.提炼一个函数时，我必须知道可能出什么错。4.段代码里头找出函数内
第一章代码重构
weixin_34037173的博客
10-18 97
代码重构方便之后扩展（主要是循环生成Radiobuttion那里） # -*- coding: utf-8 -*- # import import tkinter as tk # 1 imports from tkinter import ttk from tkinter import scrolledtext as st w...
重构第一章
weixin_43504067的博客
07-18 110
提炼函数：如果一个方法中实现了很多功能，则需要将计算某功能的语句提取出来成为一个独立的函数。 内联变量：若某个方法的返回值被赋值给一个临时变量，之后不再被修改，则将后面使用该临时变量的地方直接替换为方法的调用 搬移函数：提炼出的函数与当前类无关，则搬移该函数到相关的类中 以多态取代条件表达式：以子类取代不同的分支计算。如果一个方法中根据不同的类别计算最终的结果，那么应该引入子类，分别实现各自的计算...
重构学习笔记2（第一章）
jiqikewang的专栏
12-16 459
对于重构的学习，其实也是对于面向对象思想的提升锻炼，并且应该找到设计类的时候到底怎么样才能提升扩展性。 第一章，重构的小例子。 第一步：首先是找到代码泥团，也就是一个函数实现了多个功能，比较复杂的地方，抽取方法。 第二步：找到泥团代码的局部变量以及参数；一般来说，不会被修改的变量可以作为函数参数传进来，然后会被修改到，如果只有一个就当作返回值。 第三步：修改抽出来的函数的变量名等，使更加容
《重构改善既有代码的设计第2版》第1章 重构，第一个示例重构过程
最新发布
03-26
本章聚焦于重构的第一个实例，通过实际的代码示例，详细展示了重构的整个流程，并利用Git进行版本控制，确保每一步改动都有迹可循。 首先，重构的核心是识别代码中的坏味道（code smell），即那些暗示设计问题的不...
重构Javascript代码示例(重构前后对比)
10-27
在软件工程领域，代码重构是一项重要的维护活动，旨在改善现有代码的内部结构而不影响其外部行为。重构的目标通常是提高代码的可读性、可维护性和性能。JavaScript作为一种广泛使用的脚本语言，在前端开发中扮演着...
book-refactoring2-code:《重构 改善既有代码的设计第二版》中示例代码
05-21
存储 《重构: 改善既有代码的设计第二版》的一些示例代码 单元测试 使用 作为我们单元测试套件 运行所有单元测试: npm run test 运行某个单元测试: npx mocha ./src/chapter1/*.test.js 变化 提炼函数 amountFor ...
example_bins:重构的第一个示例代码
06-26
【标题】"example_bins:重构的第一个示例代码"是一个关于软件开发中的重构实践的项目，主要涉及的是Java编程语言。重构是一种改善代码结构而不改变其外在行为的技术，旨在提高代码的可读性、可维护性和整体质量。在...
【重构练习】 大二作业 第1部分
Max_Loop的博客
11-17 1406
要重构的对象是一个实现了大整数类型的数据结构。类的定义和实现在"BigAmount.h"和"BigAmount.cpp"中 但BigAmount这个名字不太好，决定将其改成MyBigNum。 由于类的代码本身写的不好，所以先把文件名改一下，等重构完类之后再修改类名。
侃侃重构(refactor)一
一日三餐
08-19 182
话说距离上次发文章已经是时隔将近一个半月了，期间忙着项目所以对于文章或者说知识的总结就给忽略了！ 这次我们来说说重构，说之前要感谢带领我入门的那些大哥(我曾经的同事，我喊他锋哥，还有经理 包大哥)，那个时候虽然大家都在讨论但是我作为一个菜鸟级的人物，听得不太懂不过现在做android 这一块我发现代码真是乱，所以就想到了这个东西，于是乎就做了一把refactor! 个人理解重构的概念 ...
java 代码重构-第一章(类自己该做自己的事)
HK学习
12-30 174
  重构小提示:重构技术系以微小的步伐修改程序。如果你犯下错误，很容易便可发现它。   上一篇文章:java 代码重构-第一章(分解并重组statement()) 下一篇文章:java 代码重构-第一章(提炼代码)   上次重构了statement(),类看起来,感觉舒服了很多是吧?那下面我们再一步步的做下去...     现在，我已经把原本的函数分为两块，可以分别处理它们。我不...
重构第一章 重构的第一个案例
Huaerge的专栏
10-24 743
这一章通过讲解租碟的案例来初步解释了重构的意义，有些问题何老师已经讲过了，比如说变量命名，分割代码等等1.1 起点  如果你发现自己需要为程序添加一个特性，而代码结构使你无法很方便地那么做，那就先重构那个程序，使特性的添加比较容易进行，然后再添加特性。1.2 重构的第一步（测试）  每当我要进行重构的时候，第一个步骤永远相同：我得为即将修改的代码简历一组可靠的测试环境。  重构之前，首先检查自己是否有一套可靠的测试机制。这些测试必须有自我检验(self-checking)的能力。  什么是自我检验（self
重构初体验——影片出租店例子
代码要像诗
10-10 2257
任何一个傻瓜都能写出计算机可以理解的代码。唯有写出人类容易理解的代码，才是优秀的程序员。 好代码是不断重构出来的，让我们先来看一个案例。 需求： 这是一个影片出租店用的程序，计算每一位顾客的消费金额并打印详单。操作者告诉程序：顾客租了哪些影片、租期多长，程序便根据租赁时间和影片类型计算出费用。影片分为三类：普通片、儿童片和新片。除了计算费用，还要为常客计算积分，具体的租赁用户积分规则为： ...
Delphi 的单元测试工具DUnit
l799623787的专栏
09-09 1919
http://blog.log4d.com/2010/01/delphi-unit-testing-tool-dunit/ DUnit是XUnit家族中的一员，是Extreme Programming测试实现Xtreme Testing的一种工具。 DUnit的用法和JUnit很类似，如果有相关经验很容易上手。这里是DUnit的官方地址：http://dunit.sourceforge.net
重构:第一个案例
zhangweia的专栏
06-07 1160
       在写重构的学习笔记之前，首先我们需要向伟大的软件设计师Martin Fowler致敬，是他带给了我们重构的思想，敏捷的思想。       重构--改善既有代码的设计。意味着对现有运行中的代码进行新的修改、设计。这对很多项目经理来说是不可思议的，因为他们一直奉行的是软件业的一句经典“如果代码可以运行，就不要去修改它”在这条“真理”的引导下，当出现新的功能，新的BUG的时候，后续的程
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值