<?xml version="1.0" encoding="utf-8" ?><rss version="2.0"><channel><title><![CDATA[NewReErWen的博客]]></title><description><![CDATA[]]></description><link>https://blog.youkuaiyun.com/NewReErWen</link><language>zh-cn</language><generator>https://blog.youkuaiyun.com/</generator><copyright><![CDATA[Copyright &copy; NewReErWen]]></copyright><item><title><![CDATA[致 永不止步的我们]]></title><link>https://blog.youkuaiyun.com/NewReErWen/article/details/117792876</link><guid>https://blog.youkuaiyun.com/NewReErWen/article/details/117792876</guid><author>NewReErWen</author><pubDate>Fri, 11 Jun 2021 21:42:27 +0800</pubDate><description><![CDATA[致 永不止步的我们
序

2020年注定是不平凡的一年，我们携手同心抗击疫情，谱写了毕业学年不一样的华章。
四载学涯，今有所成；师恩难忘，同窗情长；相逢即又告别，归帆又离岸。愿大家带着母校深深的祝福和殷殷的嘱托，追逐梦想，奋力拼搏，不负韶华，只争朝夕，热情谱写飞扬的青春，执着描绘璀璨的人生。
此去经年，愿所得皆所期；愿岁月安好，归来仍是少年！
2020年6月

去年的六月份发生了一件全球震惊的事情，科学家通过观测计算发现，距太阳系一光年以外的一颗星星爆炸了。今年六月，正好能在夜晚看到那遥远的光。
不归者
距]]></description><category></category></item><item><title><![CDATA[《重构 改善既有代码的设计》 读书笔记（二十三）]]></title><link>https://blog.youkuaiyun.com/NewReErWen/article/details/108425325</link><guid>https://blog.youkuaiyun.com/NewReErWen/article/details/108425325</guid><author>NewReErWen</author><pubDate>Tue, 20 Oct 2020 21:38:04 +0800</pubDate><description><![CDATA[第一步：观察被overdraftCharge()使用的每一项特性，考虑是否值得将它们与overdraftCharge()一起移动。
由于超支天数daysOverdrawn会随着账户不同而不同，所以需要把它留在Account类中。然后，将overdraftCharge()复制到AccountType中，做一些调整。
class AccountType {
	boolean isPremium() {
		return true;
	}
	double overdraftCharge(int daysOverd]]></description><category></category></item><item><title><![CDATA[《重构 改善既有代码的设计》 读书笔记（二十二）]]></title><link>https://blog.youkuaiyun.com/NewReErWen/article/details/108412409</link><guid>https://blog.youkuaiyun.com/NewReErWen/article/details/108412409</guid><author>NewReErWen</author><pubDate>Tue, 20 Oct 2020 21:20:46 +0800</pubDate><description><![CDATA[6.9 替换算法（Substitute Algorithm）
你想要把某个算法替换为另一个更清晰的算法。

将函数本体替换为另一个算法。

String foundPersone(String[] people){
    for (int i = 0; i &lt; people.length; i++){
        if(people[i].equals("Don"))
            return "Don";
        if(people[i].equals("John"))
 ]]></description><category></category></item><item><title><![CDATA[《重构 改善既有代码的设计》 读书笔记（二十一）]]></title><link>https://blog.youkuaiyun.com/NewReErWen/article/details/108394820</link><guid>https://blog.youkuaiyun.com/NewReErWen/article/details/108394820</guid><author>NewReErWen</author><pubDate>Sun, 18 Oct 2020 22:36:29 +0800</pubDate><description><![CDATA[6.6 分解临时变量（Split Temporaray Variable）
你的程序有个临时变量被赋值超过一次，它既不是循环变量，也不被用于收集计算结果。

针对每次赋值，创造一个独立、对应的临时变量。

double temp = 2 * (height + width);
System.out.println(temp);
temp = height * width;
System.out.println(temp);

&gt;&gt;&gt;
final double temp1 = 2 * (he]]></description><category></category></item><item><title><![CDATA[《重构 改善既有代码的设计》 读书笔记（二十）]]></title><link>https://blog.youkuaiyun.com/NewReErWen/article/details/108394812</link><guid>https://blog.youkuaiyun.com/NewReErWen/article/details/108394812</guid><author>NewReErWen</author><pubDate>Wed, 14 Oct 2020 22:52:54 +0800</pubDate><description><![CDATA[做法
简单情况的步骤：

找出只被赋值一次的临时变量。


我们之前说过，如果临时变量被赋值多次，那么意味着它的分割不会有任何影响，我们可以使用分解临时变量（6.6 Split Temporary Variable）来分割。
这样的好处就是，让结构更清晰，更好被提炼。


将只被赋值过一次的变量声明为final。


如果它的确只被赋值过一次，那么这样做不会报错，否则会报错。



编译。


把临时变量被赋值的右侧的表达式提炼成一个独立函数出来。



通常情况，一开始提炼函数时总会将其设置成privat]]></description><category></category></item><item><title><![CDATA[《重构 改善既有代码的设计》 读书笔记（十九）]]></title><link>https://blog.youkuaiyun.com/NewReErWen/article/details/108372465</link><guid>https://blog.youkuaiyun.com/NewReErWen/article/details/108372465</guid><author>NewReErWen</author><pubDate>Tue, 13 Oct 2020 22:50:19 +0800</pubDate><description><![CDATA[6.2 内联函数（Inline Method）
如果一个函数本体和名称一样清楚易懂，就意味着这个函数没有什么作用，此时就可以去除函数调用，替换成函数中的内容。
动机
提炼函数有个度，过度提炼后，会发现小函数无处不在，特别频繁，此时就应该考虑，是不是有些函数可以合并起来呢？
提炼函数从某种意义来讲是一种间接性的体现，它可能带来帮助，但没必要的间接性会适得其反。
除此之外，还有一种需要使用内联函数的情况：当手头上的函数东一头西一头，逻辑很乱时，考虑将它们内联成一个大型函数，然后再分解成条理的小函数。

在进行以]]></description><category></category></item><item><title><![CDATA[《重构 改善既有代码的设计》 读书笔记（十八）]]></title><link>https://blog.youkuaiyun.com/NewReErWen/article/details/108372453</link><guid>https://blog.youkuaiyun.com/NewReErWen/article/details/108372453</guid><author>NewReErWen</author><pubDate>Mon, 12 Oct 2020 22:24:16 +0800</pubDate><description><![CDATA[第六章 重新组织函数
在重构过程中，最常遇到（或者最容易察觉）的坏味道是过长函数（3.2节），其次是重复代码（3.1节）。
为了对付这两种，最有效的就是对其结构进行提取、整理、精练，所以，迎面向我们走来的是提炼函数（6.1 Extract Method）。
当我们多次提炼后，发现有一部分函数体积不大，功能不多，不是很有必要提炼，此时我们就会说，“错了，使用内联函数（6.2 Inline Method）重构，把一些小函数合并到稍大函数中吧。”
在提炼函数过程中，一个困难是处理局部变量。之前我们提到过，处理局部]]></description><category></category></item><item><title><![CDATA[《重构 改善既有代码的设计》 读书笔记（十七）]]></title><link>https://blog.youkuaiyun.com/NewReErWen/article/details/108372446</link><guid>https://blog.youkuaiyun.com/NewReErWen/article/details/108372446</guid><author>NewReErWen</author><pubDate>Sun, 11 Oct 2020 22:14:26 +0800</pubDate><description><![CDATA[5.1 重构的记录形式
这本书介绍重构的标准格式




序号
步骤
内容




1
名称
建造一个重构词汇表，名称很重要，这个名称将会被用在此书任何地方。


2
简短概要
简单介绍这种重构方法的使用场景，以及它所做的事情。这能让你更快地找到所需的重构方法。


3
动机
为什么需要这种重构方法，什么情况应该使用这个，什么时候不应该使用


4
做法
简明扼要地一步一步介绍如何进行此重构


5
范例
一个简单的例子，说明这种重构方法的过程



概要内容：包括三个部分。



一句话，介绍这个重构能够]]></description><category></category></item><item><title><![CDATA[《重构 改善既有代码的设计》 读书笔记（十六）]]></title><link>https://blog.youkuaiyun.com/NewReErWen/article/details/108352425</link><guid>https://blog.youkuaiyun.com/NewReErWen/article/details/108352425</guid><author>NewReErWen</author><pubDate>Sun, 11 Oct 2020 22:01:27 +0800</pubDate><description><![CDATA[4.2.1 单元测试和功能测试
先讲讲单元测试和功能测试的差异。

单元测试：

目的是为了提高程序员的生产率。
它是高度局部化的东西，每个测试类都隶属于单一包
它能够测试其他包的接口，除此之外它将假设其他包一切正常。



功能测试：

目的是为了保证软件能够正常运作。
从客户的角度保障质量，并不关心程序员的生产力。
它们应该由一个专门的找BUG团队去负责开发，这个团队应该使用重量级工具和技术来帮助开发良好的功能测试。


当功能测试中出现问题时，要除去它至少做两件事。
1、修改代码。
2、编写单元测试，]]></description><category></category></item><item><title><![CDATA[《重构 改善既有代码的设计》 读书笔记（十五）]]></title><link>https://blog.youkuaiyun.com/NewReErWen/article/details/108331259</link><guid>https://blog.youkuaiyun.com/NewReErWen/article/details/108331259</guid><author>NewReErWen</author><pubDate>Fri, 09 Oct 2020 22:23:43 +0800</pubDate><description><![CDATA[第四章 构筑测试体系
如果你是第一次看我这个《重构 改善既有代码的设计》 读书笔记系列，那么我建议你不要一开始看这一节，因为它的确的确很无聊。
可靠的测试是安全重构的前提。
4.1 自测试代码的价值

一套测试就是一个强大的BUG侦测器，能够大大缩短查找BUG所需要的时间。

但我们都很懂，编写测试代码，意味着额外的时间，额外的精力，除非真正地感受到这种方法对编程速度的提升，否则自我测试是没有意义的。（体现不出它的意义）

在通常情况下，我们的测试是手动运行的，如果测试变得自动化，能够自动告诉错误出现在哪里]]></description><category></category></item><item><title><![CDATA[《重构 改善既有代码的设计》 读书笔记（十四）]]></title><link>https://blog.youkuaiyun.com/NewReErWen/article/details/108309722</link><guid>https://blog.youkuaiyun.com/NewReErWen/article/details/108309722</guid><author>NewReErWen</author><pubDate>Thu, 08 Oct 2020 17:26:07 +0800</pubDate><description><![CDATA[3.16 中间人（Middle Man）

委托：一个方法直接写功能逻辑，这是亲历亲行；一个方法调用了别的类中的方法，这就是委托。

在面向对象中，一个惯用的伎俩就是委托，这是随着‘封装’一同产生的。

封装：对外部世界隐藏其内部细节。

委托是个好东西，但不能滥用：某个类有一半的函数都委托给了其他类，这就是过度运用。（此时此地，其实充斥着依恋情结（3.7节）的味道）
在过度运用委托时，就意味着产生了过多的中间人，这时就该使用移除中间人（7.6 Remove Middle Man）。

移除中间人（7.6 ]]></description><category></category></item><item><title><![CDATA[《重构 改善既有代码的设计》 读书笔记（十三）]]></title><link>https://blog.youkuaiyun.com/NewReErWen/article/details/108309716</link><guid>https://blog.youkuaiyun.com/NewReErWen/article/details/108309716</guid><author>NewReErWen</author><pubDate>Sun, 04 Oct 2020 22:14:46 +0800</pubDate><description><![CDATA[3.13 夸夸其谈未来性（Speculative Generality）
关于程序的可扩展性，其实有很多说法，但大多数都是空想——不结合需求的框架不是好框架。
如果说，在编写一个框架时，考虑所有所有的情况，那么这个框架必然是庞大的，有些东西是用户无法用得着的。（虽然可扩展性很好，但是没用到的，也不可能用到的就是废代码）
可扩展性往往体现在抽象类上，如果你发现，在当前需求下，这个抽象类没有太大作用，那么就运用折叠继承体系（11.9 Collapse Hierarchy）将抽象类与子类合二为一。

折叠继承体系]]></description><category></category></item><item><title><![CDATA[《重构 改善既有代码的设计》 读书笔记（十二）]]></title><link>https://blog.youkuaiyun.com/NewReErWen/article/details/108309707</link><guid>https://blog.youkuaiyun.com/NewReErWen/article/details/108309707</guid><author>NewReErWen</author><pubDate>Sat, 03 Oct 2020 22:35:08 +0800</pubDate><description><![CDATA[3.8 数据泥团（Data Clumps）
在‘3.2 过长函数’中，我们第一次提到‘数据泥团’这个东西。

数据泥团：总是绑在一起出现的数据，就好像一家人一般。

当数据泥团出现时，我们就要考虑，是否应该把它们组合成一个类，这样是否合适，如果确定要组合，那么要参考以下方法：


提炼类（7.3 Extract Class）：相关字段放到一个新类中。


引入参数对象（10.9 Introduce Parameter Object）：用对象代替多个参数。


保持对象完整（10.7 Preserve Who]]></description><category></category></item><item><title><![CDATA[《重构 改善既有代码的设计》 读书笔记（十一）]]></title><link>https://blog.youkuaiyun.com/NewReErWen/article/details/108309696</link><guid>https://blog.youkuaiyun.com/NewReErWen/article/details/108309696</guid><author>NewReErWen</author><pubDate>Fri, 02 Oct 2020 23:04:31 +0800</pubDate><description><![CDATA[3.4 过长的参数列（Long Parameter List）
将方法中所需的所有东西都以参数的形式传递进去，这很好理解，因为那些参数都是方法中必要的部分，但正因如此，才会有‘过长的参数列’这种坏味道。
面向对象解决了一部分问题——方法所需的东西不一定要以参数形式传递，在方法的内部可以通过一个对象来自己调用获取这些参数。

太长的参数列难以理解，太多参数容易造成前后不一致，不易使用，也不易修改。

在‘3.2 过长函数’中，我们已经提及过这种坏味道以及对应重构的方法，在这里重新介绍一下。
每一次回顾都是有必]]></description><category></category></item><item><title><![CDATA[《重构 改善既有代码的设计》 读书笔记（十）]]></title><link>https://blog.youkuaiyun.com/NewReErWen/article/details/108299778</link><guid>https://blog.youkuaiyun.com/NewReErWen/article/details/108299778</guid><author>NewReErWen</author><pubDate>Wed, 30 Sep 2020 22:54:24 +0800</pubDate><description><![CDATA[3.2 过长函数（Long Method）
想想看第一章中的例子，那个又臭又长的statement()方法。很明显，里面的内容虽然有用，但是过于死板，充满着坏味道。
没有接触过面向对象技术，或者初学的人，往往会觉得，面向对象的程序拥有无穷无尽的委托，全然不如面向过程的好。只有在程序变得庞大，业务变得复杂时，才会知道，这种技术有着多大的价值。

拥有短函数的对象会活得比较好，因为这些‘小零件’起到了‘间接层’的作用。
让我们回顾一下间接层是什么：间接层首次亮相于‘2.4 怎么对经理说’。
我们回顾一下它的优点]]></description><category></category></item><item><title><![CDATA[《重构 改善既有代码的设计》 读书笔记（九）]]></title><link>https://blog.youkuaiyun.com/NewReErWen/article/details/108299772</link><guid>https://blog.youkuaiyun.com/NewReErWen/article/details/108299772</guid><author>NewReErWen</author><pubDate>Tue, 29 Sep 2020 22:37:37 +0800</pubDate><description><![CDATA[第三章 代码的坏味道
优秀的程序员，就像一名猎人，穿梭在茂密的丛林中，寻找着一闪而过的猎物。精准、高效、灵敏，这是生存的法则，我们，作为猎人，绝不能被困住，我们要解决它们。

没有任何量度规矩比得上一个见识广博者的直觉。我们只会告诉你一些迹象，它会指出“这里有一个可以用重构解决的问题”。你必须培养出自己的判断力，学会判断一个类内有多少实例变量算是太大、一个函数内有多少行代码才算太长。

3.1 重复代码（Duplicated Code）

重复代码的表现形式：

同一个类中两个方法含有相同的表达式。
两个互]]></description><category></category></item><item><title><![CDATA[《重构 改善既有代码的设计》 读书笔记（八）]]></title><link>https://blog.youkuaiyun.com/NewReErWen/article/details/108287894</link><guid>https://blog.youkuaiyun.com/NewReErWen/article/details/108287894</guid><author>NewReErWen</author><pubDate>Mon, 28 Sep 2020 22:15:42 +0800</pubDate><description><![CDATA[2.4 怎么对经理说
怎么向别人解释，重构不影响效率：客观来讲，重构会影响近期的开发效率，但是就长远看来，重构是一种高效的开发形态。

计算机科学是这样一门科学：它相信所有问题都可以通过增加一个间接层来解决。

间接层的价值：


允许逻辑共享。比如函数可用于不同的地方；超类中的方法被所有子类共享。


分开解释意图和实现。如果类和方法内部以很小单元的意图来编写，那么每一个方法都可以用很简洁的话来表述。


隔离变化。如果只有一个类，那么我有可能会在两个不同地点使用这么一个类对象，此时，当我想要更改一个地点]]></description><category></category></item><item><title><![CDATA[《重构 改善既有代码的设计》 读书笔记（七）]]></title><link>https://blog.youkuaiyun.com/NewReErWen/article/details/108270409</link><guid>https://blog.youkuaiyun.com/NewReErWen/article/details/108270409</guid><author>NewReErWen</author><pubDate>Mon, 28 Sep 2020 22:02:57 +0800</pubDate><description><![CDATA[1.5 结语
以上就是本次例子的全部内容了，让我们回忆一下用到的重构方法吧。只说名字，你能想起来吗？




名称
英文
简介




提炼函数
6.1 Extract Method
一个方法过长时，就要考虑提炼成一个个小方法


搬移函数
7.1 Move Method
当你感觉这个方法不应该属于这个类时，就考虑搬移到更合适的地方吧


以查询取代临时变量
6.4 Replace Temp with Query
这会降低性能，但这是为了让程序更具有结构性


自封装字段
8.1 Self Encapsul]]></description><category></category></item><item><title><![CDATA[《重构 改善既有代码的设计》 读书笔记（六）]]></title><link>https://blog.youkuaiyun.com/NewReErWen/article/details/108249729</link><guid>https://blog.youkuaiyun.com/NewReErWen/article/details/108249729</guid><author>NewReErWen</author><pubDate>Sun, 27 Sep 2020 22:33:17 +0800</pubDate><description><![CDATA[1. 状态/策略取代类型码（8.15 Replace Type Code with State/Strategy）
要转换成状态模式（或策略模式）前，需要确保任何时候都能通过取值函数和设值函数来访问对象变量，这叫做自封装字段（8.1 Self Encapsulate Field）。
所以我们要把Movie中直接引用字段的地方改为通过getter和setter方法调用：
//在这里仅在构造方法中直接使用变量
public Movie(String title, int priceCode) {
	super(]]></description><category></category></item><item><title><![CDATA[《重构 改善既有代码的设计》 读书笔记（五）]]></title><link>https://blog.youkuaiyun.com/NewReErWen/article/details/108230547</link><guid>https://blog.youkuaiyun.com/NewReErWen/article/details/108230547</guid><author>NewReErWen</author><pubDate>Sat, 26 Sep 2020 21:48:12 +0800</pubDate><description><![CDATA[1.4 运用多态取代与价格相关的条件逻辑
1.4.1 getCharge()的再加工
早在1.3.2搬移函数的时候就说过，getCharge()方法还有改进的余地，只不过当时书里没有提，我也没个准确的答案，所以就暂时放下了，而现在，要开始对它开刀了。
回顾一下这个方法：
//Rental类中
/**
 * 获取收费的金额
 * 
 * @author newre
 * @return
 */
public double getCharge() {
	double result = 0;
	switch (t]]></description><category></category></item></channel></rss>