在对象之间搬移特性

最新推荐文章于 2022-01-09 21:03:07 发布
最新推荐文章于 2022-01-09 21:03:07 发布
阅读量530 收藏
点赞数
分类专栏： 重构与优化 文章标签： 重构 函数 对象 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011424653/article/details/52713804
版权

把字段或函数放在正确的位置或合适的对象中。

1 搬移函数 （Move Method）

使用场景：一个函数与另一个类有更多的交流，或该函数与另一个类高耦合。

重构步骤：

  1. 确定搬移范围：源函数使用的字段和函数。 如果这些字段与函数只被源函数使用，则将其一起搬移；
    如果还有其他函数使用这些字段或函数，考虑将这些函数也一并搬移。
  2. 如果源类的子类与父类有源函数的其他声明，则不能搬移。
  3. 在目标类声明这个函数，并将源函数代码复制到目标函数中。
    如果目标函数可能有源对象的引用，要决定如何引用源对象（新建字段或参数传递）。
    如果源函数有异常处理，要决定把异常处理放在合适的位置（源类或目标函数）。
  4. 决定源类中如何引用目标对象（新建字段或参数传递）。
  5. 修改源函数使其成为一个委托函数。
  6. 移除源函数，并将源函数的所有引用点替换为对目标函数的调用。

注意：如果源函数比较复杂，可以先使用Extract Method重构源函数，然后把提取的函数进行函数搬移。

例子：
// 重构前代码

public class Company {

    // 公司状态-新增
    public static final String STATUS_NEW = "0";
    // 公司状态-已修改
    public static final String STATUS_REVISED = "1";
    // 公司状态-通过审核
    public static final String STATUS_APPROVED = "3";

    private String name;

    private String status;

    // Company Other Fields

    public String getName() {
        return name;
    }

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

    public String getStatus() {
        return status;
    }

    public void setStatus(String status) {
        this.status = status;
    }

    // other field's get/set method

}

/**
 * 服务类
 * @param company
 */
public class CompanyServiceImpl {

    /**
     * 审核公司信息
     * @param company
     */
    public void checkCompanyInfo(Company company) {
        if (isComNeedCheck(company)) {
            // check company information
        }

        // do other thing...
    }

    // 下面三个方法都依赖的是Company类，将其放到Company类中更为合适

    private boolean isComNeedCheck(Company company) {
        return isComStatusNew(company) || isComRevised(company);
    }

    private boolean isComRevised(Company company) {
        return Company.STATUS_REVISED.equals(company.getStatus());
    }

    private boolean isComStatusNew(Company company) {
        return Company.STATUS_NEW.equals(company.getStatus());
    }

}

显然可以看出服务类中的方法isComNeedCheck、isComRevised、isComStatusNew都只和Company类进行交流，所以将其放在Company类中更为合适。
// 重构后代码

public class Company {

    // 公司状态-新增
    public static final String STATUS_NEW = "0";
    // 公司状态-已修改
    public static final String STATUS_REVISED = "1";
    // 公司状态-通过审核
    public static final String STATUS_APPROVED = "3";

    private String name;

    private String status;

    // Company Other Fields

    public boolean isComNeedCheck() {
        return isComStatusNew() || isComRevised();
    }

    public boolean isComRevised() {
        return Company.STATUS_REVISED.equals(getStatus());
    }

    public boolean isComStatusNew() {
        return Company.STATUS_NEW.equals(getStatus());
    }

    public String getName() {
        return name;
    }

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

    public String getStatus() {
        return status;
    }

    public void setStatus(String status) {
        this.status = status;
    }

    // other field's get/set method

}

public class CompanyServiceImpl {

    /**
     * 审核公司信息
     * @param company
     */
    public void checkCompanyInfo(Company company) {
        if (company.isComNeedCheck()) {
            // check company information
        }

        // do other thing...
    }

}

重构后代码结构更加清晰，便于后期根据模块来进行维护。

2 搬移字段（Move Field）

使用场景：某个字段被另一个类更多的使用。

重构方法：在目标类新建一个字段，修改源字段的所有用户，令它们调用新字段。

重构步骤：

  1. 封装要搬移的字段。
  2. 在目标类中新建一个相同的字段，并建立相应的设置取值函数。
  3. 决定在源对象中如何引用目标对象。
  4. 删除源字段，并将对源字段的所有相关调用替换为对目标函数的调用（设置、取值函数）。

例子：
// 重构前代码

public class Account {

    // 利率
    private double intersetRate;

    /**
     * 计算利率
     * @param amount
     * @param days
     * @return
     */
    public double interestForAmountAndDays(double amount, int days) {
        return this.intersetRate * amount * days / 365;
    }

}

public class AccountType {

}

利率与账户并没有什么关系，所有intersetRate放在Account类中并不合适。我们假设利率与账户类型AccountType有关系。
// 重构后代码

public class Account {

    private AccountType type;

    public double interestForAmountAndDays(double amount, int days) {
        return type.getIntersetRate() * amount * days / 365;
    }

}

public class AccountType {

    private double intersetRate;

    public double getIntersetRate() {
        return intersetRate;
    }

    public void setIntersetRate(double intersetRate) {
        this.intersetRate = intersetRate;
    }

}

3 提炼类（Extract Class）

一个类应该是一个清楚的抽象，处理一些明确的责任。

使用场景：随着业务的增加，在某个类中添加了过多的数据与函数，使该类的职责不清晰。

重构方法：建立一个新类，将相关的字段和函数搬移至新类。

重构步骤：

  1. 确定如何分解类的责任。
  2. 建立一个新类，用于表现从源类中分离出来的责任。
  3. 建立从源类访问新类的连接关系。
  4. 把必要的字段与函数搬移至新类。
  5. 每次搬移后，编译测试；
  6. 精简每个类的接口。如果你建立起双向连接，检查是否可以将其改为单向连接。
  7. 决定是否公开新类。如果要公开，决定使其成为引用对象或不可变对象。

例子：
// 重构前代码

public class Person {

    private String name;
    /**
     * 区号
     */
    private String areaCode;
    /**
     * 电话号码
     */
    private String telNumber;

    /**
     * 获取电话号码
     * @return
     */
    public String getTelephoneNumber() {
        return getAreaCode() + "-" + getTelNumber();
    }

    public String getName() {
        return name;
    }

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

    public String getAreaCode() {
        return areaCode;
    }

    public void setAreaCode(String areaCode) {
        this.areaCode = areaCode;
    }

    public String getTelNumber() {
        return telNumber;
    }

    public void setTelNumber(String telNumber) {
        this.telNumber = telNumber;
    }

}

Person类中的字段areaCode、telNumber，方法getTelephoneNumber（）都是与电话相关，可以考虑将其提取到一个新类中，以便把与电话相关的代码都放在一个类中，比如后面又添加了校验电话号码的代码等等，便于以后维护。
// 重构后代码

public class Person {

    private String name;

    private TelephoneNumber telNum;

    public String getTelephoneNumber() {
        return telNum.getTelephoneNumber();
    }

    public String getName() {
        return name;
    }

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

}

/**
 * 抽取的新类
 */
public class TelephoneNumber {

    private String areaCode;

    private String number;

    public String getTelephoneNumber() {
        return getAreaCode() + "-" + getNumber();
    }

    public boolean checkTelephoneNumber() {
        // check ....
        return true;
    }

    public String getAreaCode() {
        return areaCode;
    }

    public void setAreaCode(String areaCode) {
        this.areaCode = areaCode;
    }

    public String getNumber() {
        return number;
    }

    public void setNumber(String number) {
        this.number = number;
    }

}

4 将类内联化（Inline Class）

内联化类是与提炼类相反的重构手法。

使用场景：如果一个类没有做太多事情，或不再承担足够的责任，就将其内联化到另一个类中。

重构方法：将这个类的所有特性搬移到另一个类中，然后删除原类。

重构步骤：

  1. 在目标类中声明源类的所有public字段和函数，并将其中的所有函数委托至源类。
  2. 把源类的所有引用点替换为对目标类的调用。
  3. 编译测试。
  4. 运用Move Field和Move Method，把源类的所有特性搬移至目标类。
  5. 删除源类。

例子：
假如7.3中重构后的类TelephoneNumber 就是那么的简单，确认没有独立存在的必要的话，可以使用内联化重构手法将TelephoneNumber 的所有字段和方法搬移至Person类中，然后将TelephoneNumber 移除。
// 重构前代码
见7.3中重构后代码。
// 重构后代码
见7.3中重构前代码。

5 隐藏“委托关系”（Hide Delegate）

使用场景：客户先获取服务类中的委托对象，然后再调用委托类的函数，暴露了委托关系。

重构方法：在服务类中建立客户所需的所有函数，用于隐藏委托关系。

重构步骤：

  1. 对于每一个委托关系中的函数，在服务对象中新建一个简单的委托函数。
  2. 调整客户代码，使其只调用服务对象提供的函数。
  3. 每次调整后，编译测试。
  4. 如果没有任何客户调用受托类，移除服务对象中相关的访问函数。
  5. 编译测试。

例子：
// 重构前代码

public class Person {

    private String name;

    private TelephoneNumber telNum;

    public Person(String name, String areaCode, String number) {
        this.name = name;
        telNum = new TelephoneNumber(areaCode, number);
    }

    public String getName() {
        return name;
    }

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

    public TelephoneNumber getTelNum() {
        return telNum;
    }

    public void setTelNum(TelephoneNumber telNum) {
        this.telNum = telNum;
    }

}

public class TelephoneNumber {

    private String areaCode;

    private String number;

    public TelephoneNumber(String areaCode, String number) {
        super();
        this.areaCode = areaCode;
        this.number = number;
    }

    public String getTelephoneNumber() {
        return getAreaCode() + "-" + getNumber();
    }

    public String getAreaCode() {
        return areaCode;
    }

    public void setAreaCode(String areaCode) {
        this.areaCode = areaCode;
    }

    public String getNumber() {
        return number;
    }

    public void setNumber(String number) {
        this.number = number;
    }

}

public class Test {

    public static void main(String[] args) {
        Person person = new Person("liuz", "025", "62526001");
        // 显式调用委托对象的方法
        String telephoneNum = person.getTelNum().getTelephoneNumber();
        System.out.println(telephoneNum);
    }

}

// 重构后代码

public class Person {

    private String name;

    private TelephoneNumber telNum;

    public Person(String name, String areaCode, String number) {
        this.name = name;
        telNum = new TelephoneNumber(areaCode, number);
    }

    public String getTelephoneNumber() {
        return telNum.getTelephoneNumber();
    }

    public String getName() {
        return name;
    }

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

}

public class Test {

    public static void main(String[] args) {
        Person person = new Person("liuz", "025", "62526001");
        // 隐藏委托关系
        String telephoneNum = person.getTelephoneNumber();
        System.out.println(telephoneNum);
    }

}

6 移除中间人（Remove Middle Man）

使用场景：服务类中有过多的委托函数时，可以通过移除简单委托函数来简化服务类代码。

重构方法：让客户直接调用受托类。

重构步骤：

  1. 建立一个新函数，用以获得受托对象。
  2. 删除服务类中的简单委托函数，并将其所有引用点替换为调用受托对象。
  3. 处理每个委托函数后，编译测试。
    注意：可以根据需要，设置获取受托对象函数的可见范围，并保留部分委托函数。

例子：
该重构手法与隐藏委托关系重构手法相反，例子可以把7.5中的例子反过来即可。

7 引入外加函数（Introduce Foreign Method）

使用场景：你需要为服务类新增一个函数，但你却无法修改这个类。

重构方法：在客户类新建一个函数，并把服务类实例以第一参数传入这个新建的函数。

重构步骤：

  1. 在客户类新建一个函数，用于提供你需要的功能。
    由于这个函数本应该在服务类中，为了以后搬移函数方便，新建的函数不能调用客户类的任何特性。
    如果需要客户类的某个特性的话，就以参数形式传递给该函数。
  2. 以服务类实例作为该函数的第一个参数。
  3. 为了与客户类函数进行区分，将该函数注释为：外加函数，应在服务类实现。

例子：

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;

public class IntroduceForeignMethod {

    public static void main(String[] args) throws ParseException {

        Calendar cal = Calendar.getInstance();
        System.out.println("当前时间：\n" + cal.getTime());

        //
        System.out.println("执行Calendar类的外加函数nextDate");
        IntroduceForeignMethod fm = new IntroduceForeignMethod();
        Date nextDate = fm.nextDate(Calendar.getInstance());
        System.out.println(nextDate);

        //
        System.out.println("执行Calendar类的外加函数truncateDate");
        System.out.println(fm.truncateDate(cal));

        //
        System.out.println("执行Date类的外加函数truncate");
        Date trunDate = fm.truncate(cal.getTime(), "yyyy/MM/dd");
        System.out.println(trunDate);
    }

    /**
     * 获取下一天的日期<br/>
     * 外加函数, 应在Calendar类中
     * @param cal
     * @return
     */
    public Date nextDate(Calendar cal) {
        cal.add(Calendar.DAY_OF_YEAR, 1);
        Date nextDate = cal.getTime();
        return nextDate;
    }

    /**
     * 截取日期，只保留年月日<br/>
     * 外加函数, 应在Calendar类中
     * @param cal
     * @return
     */
    public Date truncateDate(Calendar cal) {
        cal.set(Calendar.HOUR_OF_DAY, 0);
        cal.set(Calendar.MINUTE, 0);
        cal.set(Calendar.SECOND, 0);
        return cal.getTime();
    }

    /**
     * 根据指定格式截取日期<br/>
     * 外加函数, 应在Date类中
     * @param date
     * @param format
     * @return
     */
    public Date truncate(Date date, String format) throws ParseException {
        if (date == null || format == null) {
            return date;
        }
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        return sdf.parse(sdf.format(date));
    }

}

8 引入本地扩展（Introduce Local Extension）

使用场景：你需要为服务类新增一些额外的函数，但你却无法修改这个类。

重构方法：新建一个类，使它包含这些额外函数。让这个新类成为服务类的子类或包装类（统称为本地扩展）。

重构步骤：

  1. 新建一个扩展类，将它作为原始类的子类或包装类。
  2. 在扩展类中加入转型构造函数。
    转型构造函数：接受原对象作为参数的构造函数。
    如果采用子类化方案，转型构造函数应该调用适当的超类构造函数；
    如果采用包装类方案，转型构造函数应该将它得到的传入参数以实例变量的形式保存起来，用作接受委托的原对象。
  3. 在扩展类中加入新特性。
  4. 根据需要，将原对象替换为扩展对象。
  5. 将针对原始类定义的所有外加函数搬移到扩展类中。

例子：

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;

public class ConcreateCalendar extends Calendar {

    private static final long serialVersionUID = -4133479289114370006L;

    private Date today;

    public ConcreateCalendar(String dateStr, String format) {
        super();
        try {
            today = new SimpleDateFormat(format).parse(dateStr);
        } catch (ParseException e) {
            today = new Date();
        }
    }

    public Date getToday() {
        return today;
    }

    public void setToday(Date today) {
        this.today = today;
    }

    protected void computeTime() {
        // TODO Auto-generated method stub

    }

    protected void computeFields() {
        // TODO Auto-generated method stub

    }

    public void add(int field, int amount) {
        // TODO Auto-generated method stub

    }

    public void roll(int field, boolean up) {
        // TODO Auto-generated method stub

    }

    public int getMinimum(int field) {
        // TODO Auto-generated method stub
        return 0;
    }

    public int getMaximum(int field) {
        // TODO Auto-generated method stub
        return 0;
    }

    public int getGreatestMinimum(int field) {
        // TODO Auto-generated method stub
        return 0;
    }

    public int getLeastMaximum(int field) {
        // TODO Auto-generated method stub
        return 0;
    }

}

import java.util.Calendar;
import java.util.Date;
/**
 * 子类化方案
 *
 */
public class LocalExtensionBySubClass extends ConcreateCalendar {

    private static final long serialVersionUID = -3645662145076608166L;

    /**
     * 转型构造函数
     * @param dateStr
     * @param format
     */
    public LocalExtensionBySubClass(String dateStr, String format) {
        super(dateStr, format);
    }

    /**
     * 下一个日期
     * @return
     */
    public Date nextDate() {
        setTime(this.getToday());
        add(Calendar.DAY_OF_YEAR, 1);
        return getTime();
    }

    /**
     * 下一个月份
     * @return
     */
    public Date nextMonth() {
        setTime(this.getToday());
        add(Calendar.MONTH, 1);
        return getTime();
    }

    /**
     * 下一年
     * @return
     */
    public Date nextYear() {
        setTime(this.getToday());
        add(Calendar.YEAR, 1);
        return getTime();
    }

}

import java.util.Calendar;
import java.util.Date;
/**
 * 包装类方案
 *
 */
public class ConcreateCalendarWrap {

    private Calendar cal;

    /**
     * 转型构造函数
     * @param cal
     */
    public ConcreateCalendarWrap(Calendar cal) {
        super();
        this.cal = cal;
    }

    /**
     * 下一个日期
     * @return
     */
    public Date nextDate() {
        cal.add(Calendar.DAY_OF_YEAR, 1);
        return cal.getTime();
    }

    /**
     * 下一个月份
     * @return
     */
    public Date nextMonth() {
        cal.add(Calendar.MONTH, 1);
        return cal.getTime();
    }

    /**
     * 下一年
     * @return
     */
    public Date nextYear() {
        cal.add(Calendar.YEAR, 1);
        return cal.getTime();
    }

    public Date getTime() {
        return cal.getTime();
    }

    public void add(int field, int amount) {
        cal.add(field, amount);
    }

    // ......

}
wxyh_00
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
PHP 杂谈《重构-改善既有代码的设计》之二 对象之间搬移特性
01-20
思维导图 索引： Ø Move Method（搬移函数） Ø Move Field （搬移值域） Ø Extract Class （提炼类） Ø Inline Class （将类内联化，就是把当前的类合并到其他类中） Ø Hide Delegate （隐藏委托关系） Ø Remove Middle Man （ 移除中间人） Ø Introduce Foreign Method （引入外加函数） Ø Introduce Local Extension （引入本地扩展）    介绍    承接上文PHP 杂谈《重构-改善既有代码的设计》之 重新组织你的函数 ，继续说重构方面的内容。    专
重构-改善既有的代码设计（三）
哼哼的博客
09-27 330
1. 在对象之间搬移特性1.1 Move Method（搬移函数）你的程序中，有个函数与其所驻类之外的另一个类进行更多交流，调用后者或者被后者调用。在该函数最常用的类中建立一个有着类似行为的新函数。将旧函数变成一个单纯的委托函数，或者将旧函数完全移除。 动机 如果一个类中有太多行为，或者如果一个类与另一个类有太多合作而形成高度耦合，就应该搬移函数。 做法 - 检查源类中被源函数所使用的一切特
重构——在对象之间搬移特性
zhuzi51的专栏
10-19 785
文章目录楔子7.1 Move Method(搬移函数)动机做法范例7.2 Move Field(搬移字段)动机做法范例：使用Self-Encapsulation7.3 Extract Class 提炼类动机做法7.4 Inline Class(将类内联化)7.5 Hide Delegate(隐藏“委托关系”)动机做法范例7.6 Remove Middle Man(移除中间人)7.7 Introduce Foreign Method(引入外加函数)动机7.8 Introduce Local Extension
《Refactoring》笔记 3：在对象间搬移特性
DAI_JICHEN的博客
01-09 314
1、Move Method（搬移函数） 若一个 method 使用另一个对象的次数比使用当前对象的次数还多，则可以考虑将其移动到另一个对象中。这样可以减少类间的调用关系。 2、Move Field（搬移值域） 若一个 field 被另一个 class 中的函数更多地用到，则应将其移动到经常使用它的类中去。 3、Extract Class（提炼类） 若某个 class 做了两个 classes 应该做的事，则因该新建一个 class，并将相关 field 和 method 搬运到新 clas
搬移特性
gaming & coding
03-23 150
第8章 搬移特性 搬移函数 目的：模块化。将相互关联的软件要素都集中到一块，并确保块与块之间的联系易于查找、直观易懂。 原因 搬移函数最直接的一个动机是，它频繁地引用其他上下文中的元素，对自身上下文中的元素关心甚少。 如果在整理代码时，发现需要频繁调用一个别处的函数，我也会考虑搬移这个函数。内部的辅助函数，若其他地方也需要用到，可以搬移到更通用的地方。 主要使用在嵌套函数的搬移，和类中函数的搬移。原文中Account类中的函数，搬移到 AccountTypel类中。 搬移字段 目的：优化程序中的
重构之路第二篇——在对象之间搬移特性的几种方法
挑水的小和尚的博客
10-22 855
重构之路第二篇——在对象之间搬移特性的几种方法 1 Move Method(搬移函数) 2 Move Field(搬移字段) 3 Extract Class(提炼类) 4 Inline Class(将类内联化) 5 Hide Delegate(隐藏委托关系) 6 Remove Middle Man(移除中间人) 7Introduce Foreign Metho...
3、在对象之间搬移特性
姬世霆的专栏
04-06 930
1、Move Method（搬移函数）       如果一个类有太多行为，或如果一个类与另一个类有太多合作而形成高度耦合，则考虑搬移函数。 这类函数有这种特点：使用另一个对象的次数比使用自己所驻对象的次数还多。     2、Move Field（搬移字段）       和搬移函数类似，某个字段被其所驻之外的另一个类类更多的用到，则考虑将该字段移到那个类中。     3、Ex
重构-改善既有代码的设计
06-10
第7章　在对象之间搬移特性 141 7.1　Move Method（搬移函数） 142 7.2　Move Field（搬移字段） 146 7.3　Extract Class（提炼类） 149 7.4　Inline Class（将类内联化） 154 7.5　Hide Delegate（隐藏“委托...
《重构改善既有代码的设计(2010年版)》（Martin Fowler[美] 著，熊节 译）
01-15
第7章 在对象之间搬移特性141 7.1 MoveMethod（搬移函数）142 7.2 MoveField（搬移字段）146 7.3 ExtractClass（提炼类）149 7.4 InlineClass（将类内联化）154 7.5 HideDelegate（隐藏“委托关系”）157 7.6 ...
重构：改善既有代码的设计.[美]Martin Fowler.epub【文字版手机格式】
04-23
第7章 在对象之间搬移特性 7.1 Move Method(搬移函数) 7.2 Move Field(搬移字段) 7.3 Extract Class(提炼类) 7.4 Inline Class(将类内联化) 7.5 Hide Delegate(隐藏“委托关系”) 7.6 Remove Middle Man(移除...
重构手法列表——在对象之间搬移特性
秋千不会坠的博客
01-26 636
搬移函数（Move Method） 现象：有函数与其所驻类之外的另一个类进行更多交流：调用后者或被后者调用 动机：两个类并无太多合作，但是出现了高度耦合。 做法：在该函数最常引用的类中建立一个有着类似行为的新函数。将旧函数变成一个单纯的委托函数，或是将旧函数完全移除 搬移字段（Move Field） 现象：某个字段被其所驻类之外的另一个类更多地用到 动机：把职责迁移到更适合它的地方去 做法：在目标...
第七章 在对象之间搬移特性
Huaerge的专栏
11-16 628
第七章 在对象之间搬移特性（Moving Features Between Objects）7.1  Move Method(搬移函数)症状：你的程序中，有个函数与其所驻class之外的另一个class进行更多交流；调用后者或被后者调用。解决办法：在该函数最常引用的class中建立一个有着类似行为的新函数。将旧函数变成一个单纯的委托函数，或者是将旧函数完全移除。7.2  Move Field(搬移值域)症状：你的程序中，某个field（值域）被其所驻class之外的另一个class更多地用到。解决办法：在t
在对象之间搬移特性（一）
canlanyangg的博客
08-08 550
1，Move Method (搬移函数)       现象：程序中，有个函数与其所驻类之外的另一个类进行更多交流：调用后者或被后者调用       要点：在该函数最常引用的类中建立一个有着类似行为的新函数。将旧函数变成一个单纯的委托函数，或是将旧函数完全移除。 2，Move Field (搬移字段)       现象：程序中，有个字段被其所驻类之外的另一个类更多的用到       要点：
重构心法修炼第二层：在对象之间搬移特性
大宇的博客，欢迎访问
11-30 279
7.1  搬移函数         当前类中的某个方法，却与其它类配合的更加紧密，那么应该把原类的方法迁移到其它类中。如果用到了当前类中少许字段或者方法，可用方法参数来传递当前字段或者对象。在迁移方法成功后，将当前类的旧函数变成一个单纯的委托函数，或是将旧函数完全删除，即内联函数。         下面的例子中，一种租赁包含一部电影与租期。而计算费用的函数，主要是根据电影的类型，所以才会出现多...
重构——在对象之间搬移特性(1)
No_Game_No_Life_的博客
01-09 530
我们都知道，类往往因为承担过多的责任而变得臃肿不堪。这种情况下，一般会使用"提炼类"这种手法将一部分责任分离出去。如果一个类变得"不负责任"，一般会使用“内联类”这种手法将它融入另一个类。如果一个类使用了另一个类，一般会运用"隐藏委托关系"手法将这种关系隐藏起来通常是有帮助的。有时候隐藏委托关系会导致拥有者的接口经常性地变化，这时就可考虑使用"移除中间人"这种手法了。 Move Method 若发...
重构：二、在对象之间搬移特性
Bonjour
05-26 513
上一篇是对单个方法进行整理，总结出了一些整理时需要用到的方式。现在是在对象之间进行整理。有时候一个类会非常大，可以考虑把这个大类缩小一点。 搬移方法 搬移字段 提炼类 将类内联化 隐藏委托关系 移除中间人 引入外加函数1. 搬移方法如果某个方法大量依赖另一个对象中的方法，可以考虑将这个方法搬移到另一个对象里面。 2. 搬移字段如果当前类的某个字段，在另一个类中多次被使用到，应该将当前类中的这个字段
在对象之间搬移特性（二）
canlanyangg的博客
08-09 502
6，Remove Middle Man       现象：某个类做了过多的简单委托动作       要点：让客户之间调用受托类。 7，Introduce Foreign Method (引入外加函数)       现象：你需要为提供服务的类增加一个函数，但你无法修改这个类       要点：在客户类中建立一个函数，并以第一参数形式传入一个服务类实例。 8，Introduce Local
读书笔记 ------ 重构 -> 在对象之间搬移特性
weijinhua_123的博客
05-23 244
1：“决定把责任放在哪儿” 试用 方法： Move Method ， Move Filed ,如果需要都试用先试用 Move field 再使用 Move Method 。 2：类责任过多 --->Extract class 方法 3：类责任太少---> inline class 4：一个类使用另一个类 ---> Hide Delegate 5：隐藏委托类导致拥有者的接口经常变化--->
matlab矩阵水平搬移
最新发布
01-26
在Matlab中，可以通过矩阵的水平搬移来实现信号的频谱搬移。下面是一个示例代码，演示了如何进行矩阵的水平搬移： ```matlab % 定义频率和时间参数 Fs = 10000; % 采样率 T = 1/Fs; % 采样间隔 L = 1000; % 信号...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值