重构-改善既有代码的设计读书笔记（八）

最新推荐文章于 2021-10-12 10:21:54 发布
最新推荐文章于 2021-10-12 10:21:54 发布
阅读量350 收藏
点赞数
分类专栏： 读书笔记 文章标签： 数据 重构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhangxiaoyang0/article/details/53574258
版权

##重新组织数据

8.1 Self Encapsulate Field （自封装字段）

你直接访问一个字段，但与字段之间的耦合关系逐渐变得笨拙。为这个字段建立取值/设值函数，并且只以这些函数来访问字段。

8.2 Replace Data Value with Object（以对象取代数据值）

你有一个数据项，需要与其他数据和行为一起使用采有意义，将数据项变成对象。
做法：
1. 为待替换数值新建一个类，在其中声明一个final字段，其类型和源类中的待替换数值类型一样。然后在新类中加入这个字段的取值函数，再加上一个接受此字段为参数的构造函数。
2. 将源类中的待替换数值字段的类型改为前面新建的类。
3. 修改源类中该字段的取值函数，令它们调用新类的取值函数。
4. 如果源类构造函数中用到这个待替换字段，我们就修改构造函数，令它改用新类的构造函数来对字段进行赋值动作。
5. 修改源类中待替换字段的设值函数，令它为新类创建一个实例。
6. 现在，你有可能需要对新类使用Change Value to Reference（8.3）。

class Order {   
    public  Order(String customer){
        this.customer = customer;
    }

    public String getCustomer(){
        return customer;
    }

    public void setCustomer(String customer){
        this.customer = customer;
    }

    private String customer;

}

to

class Customer{ 
    public Customer(String name){
        this.name = name;
    }

    public String getName(){
        return name;
    }

    private final String name;
}

class Order {   
    public  Order(String customer){
        this.customer = new Customer(customer);
    }

    public String getCustomer(){
        return customer.getName();
    }

    public void setCustomer(String customer){
        this.customer = new Customer(customer);
    }

    private Customer customer;

}

8.3 Change Value to Reference（将值对象改为引用对象）

你从一个类衍生出许多彼此相等的实例，希望将它们替换为同一个对象。将这个值对象改成引用对象。
做法：
1. 使用Replace Constructor with Factory Method（10.12）。
2. 决定由什么对象负责提供访问新对象的途径。
使用静态字典或一个注册表对象；使用多个对象作为新对象的访问点。
3. 决定这些引用对象应该预先创建好，或是应该动态创建。
4. 修改工厂函数，令它们返回引用对象。

class Customer{ 
    public Customer(String name){
        this.name = name;
    }

    public String getName(){
        return name;
    }

    private final String name;
}

class Order {   
    public  Order(String customer){
        this.customer = new Customer(customer);
    }

    public String getCustomer(){
        return customer.getName();
    }

    public void setCustomer(String customer){
        this.customer = new Customer(customer);
    }

    private Customer customer;

}

to

class Customer{ 
    public static Customer create(String name){
        return (Customer)instance.get(name);
    }

    private Customer(String name){
        this.name = name;
    }

    private static Dictionary instance = new HashTable();

    static void loadCustomer(){
        new Customer("Lemon").store();
        new Customer("Bilston").store();
    }

    private void store(){
        instance.put(this.getName(),this);
    }
}

class Order{    
    public Order(String customer){
        this.customer = Customer.create(customer);
    }
}

8.4 Change Reference to Value（将引用对象改为值对象）

你有一个引用对象，很小且不可变，而且不易管理。将它变成一个值对象。
做法：
1. 检查重构目标是否为不可变对象，或是否可以修改为不可变对象。
如果该对象目前还不是不可变的，就使用Remove Setting Method（10.10），直到它成为不可变的为止。
如果无法将该对象修改为不可变的，就放弃使用本项重构。
2. 建立equals()和hashCode()。
3. 考虑是否可以删除工厂函数，并将构造函数声明为public。

要把一个引用对象变成值对象，关键动作是：检查它是否可变。

8.5 Replace Array with Object（以对象取代数组）

你有一个数组，其中的元素各自代表不同的东西。以对象替换数组，对于数组中的每个元素，以一个字段来表示。

String[] row = new String[3];
row[0] = "Liverpool";
row[1] = "15";

to

Performance row = new Performance();
row.setName("Liverpool");
row.setWins("15");

8.7 Change Unidirectional Association to Bidirectional（将单向关联改为双向关联）

两个都需要使用对方特性，但其间只有一条单向连接。添加一个反向指针，并使修改函数能够同时更新两条连接。
动机：
在开发过程中，你发现被引用者需要得到其引用者以便进行某些操作。
做法：
1. 在被引用类中增加一个字段，用以保存反向指针。
2. 决定由哪个类-引用端还是被引用端-控制关联关系。
2.1 如果两者都是引用对象，而其间的关联是“一对多”，那么就由“拥有单一引用”的那一方承担“控制者”的角色。
2.2 如果某个对象是组成另一对象的部件，那么就由后者负责控制关联关系。
2.3 如果两者都是引用对象，而其间的关联是“多对多”关系，那么随便其中的哪个对象来控制关联关系都无所谓。
3. 在被控端建立一个辅助函数，其命名应该清楚指出它的有限用途。
4. 如果既有的修改函数在控制端，让它负责更新反向指针。
5. 如果既有的修改函数在被控端，就在控制端建立一个控制函数，并让既有的修改函数调用这个新建的控制函数。

class Order{    
    Customer getCustomer(){
        return customer;
    }

    void setCustomer(Customer arg){
        customer = arg;
    }

    Customer customer;

}

class Customer {    
    private Set orders = new HashSet();
}

to

//一对多的情况
class Customer{     
    //辅助函数
    Set friendOrders(){
        return orders;
    }
    //如果希望在Customer中也能修改连接，就调用控制函数
    void addOrder(Order arg){
        arg.setCustomer(this);
    }
}
class Order{    
    void setCustomer(Customer arg){
        //先让对方删除指向你的指针
        if(customer != null)
            customer.friendOrders().remove(this);
        customer = arg;//再将你的指针指向新对象
        //最后让新对象把它的指针指向你
        if(customer != null)
            customer.friendOrders().add(this);
    }
}
//多对多
class Order{    
    void addCustomer(Customer arg){
        arg.friendOrders().add(this);
        customer.add(arg);
    }

    void removeCustomer(Customer arg){
        arg.friendOrders().remove(this);
        customer.remove(arg);
    }
}

class Customer{ 
    void addOrder(Order arg){
        arg.addCustomer(this);
    }

    void removeOrder(Order arg){
        arg.removeCustomer(this);
    }
}

8.8 Change Bidirectional Association to Unidirectional（将双向关联改为单向关联）

两个类之间有双向关联，但其中一个类如今不再需要另一个类的特性，去除不必要的关联。
做法：
1. 找出保存“你想去除的指针”的字段，检查它的每一个用户，判断是否可以去除该指针。
2. 如果客户使用了取值函数，先运用Self Encapsulate Field（8.1）将待删除字段自我封装起来，然后处理取值函数，使它不再调用该字段。
3. 如果客户未使用取值函数，那就直接修改待删除字段的所有被引用点：改以其他途径获得该字段所保存的对象。
4. 如果已经没有任何函数使用待删除字段，移除所有对该字段的更新逻辑，然后移除该字段。

###这两种手法不太理解

8.11 Encapsulate Collection（封装集合）

有个函数返回一个集合，让这个函数返回该集合的一个只读副本，并在这个类中提供添加/移除集合元素的函数。
做法：
1. 加入为集合添加/移除元素的函数。
2. 将保存集合的字段初始化为一个空集合。
3. 找出集合设值函数的所有调用者。你可以修改那个设值函数，让它使用上述新建立的“添加/移除函数”，也可以直接修改调用端，改让它们调用上述新建立的“添加/移除”函数。
4. 找出所有“通过取值函数获得集合并修改其内容的”的函数。逐一修改这些函数，让他们改用“添加/移除”函数。
5. 修改完上述所有的“通过取值函数获得集合并修改集合内容”的函数后，修改取值函数自身，使它返回整个集合的只读副本。
6. 找出取值函数的所有用户，从中找出应该存在于集合所属对象内的代码。运用Extract Method（6.1）和Move Method（7.1）将这些代码移到宿主对象去。
7. 修改现有取值函数的名字，然后添加一个新取值函数，使其返回一个枚举。找出旧取值函数的所有被使用点，将它们都改为使用新取值函数。
8. 如果这一步跨度太大，可以先使用Rename Method修改原取值函数的名称，再建立一个新取值函数用以返回枚举。最后再修改所有调用者，使其调用新取值函数。

class Person{   
    public Set getCourses(){
        return courses;
    }

    public void setCourses(Set arg){
        courses = arg;
    }

    private Set courses;
}

to

class Person{   
    public void addCourse(Course arg){
        courses.add(arg);
    }

    public void removeCourse(Course arg){
        courses.remove(arg);
    }

    private Set courses = new HashSet();
    //可以根据具体情况决定是否使用或移除设值函数。如果使用，设值函数可以调用添加函数初始化集合
    public vodi setCourses(Set arg){
        Iterator it = arg.iterator();
        while(it.hasNext()){
            addCourse((Course)it.next());
        }
    }
    //对于通过取值函数修改集合的情况
    public Set getCourses(){
        return Collections.unmodifiableSet(courses);
    }
}

###实际编码中，从来没见过，也从来没人提过集合的封装这个问题。

8.13 Replace Type Code with Class（以类取代类型码）

类之中有一个数值类型码，但它并不影响类的行为。以一个新的类替换该数值类型码。

class Person{   
    public static final int O = 0;
    public static final int A = 1;
    public static final int B = 2;
    public static final int AB =3;

    private int bloodGroup;

    public Person(int bloodGroup) {
        this.bloodGroup = bloodGroup;
    }

    //set/get方法
}

做法：
1、为类型码建立一个类。
这个类需要一个用以记录类型码的字段，其类型应该和类型码相同，并应该有对应的取值函数。此外还应该用一组静态变量保存运行被创建的实例，并以一个静态函数根据原本的类型码返回合适的实例。

class BloodGroup{   
    public static final BloodGroup O = new BloodGroup(0);
    public static final BloodGroup A = new BloodGroup(1);
    public static final BloodGroup B = new BloodGroup(2);
    public static final BloodGroup AB = new BloodGroup(3);
    public static final BloodGroup[] values = {O,A,B,AB};

    private final int code;

    private BloodGroup(int code){
        this.code = code;
    }

    //get方法

    public static BloodGroup code(int arg){
        return values[arg];
    }
}

2、修改源类实现，让它使用上述新建的类。
维持原先以类型码为基础的函数接口，但改变静态字段，以新建的类产生代码。然后，修改类型码相关函数，让它们也从新建的类中获取类型码。

class Person{   
    public static final int O = BloodGroup.O.getCode();
    public static final int A = BloodGroup.A.getCode();
    public static final int B = BloodGroup.B.getCode();
    public static final int AB =BloodGroup.AB.getCode();

    private BloodGroup bloodGroup;

    public Person(int bloodGroup) {
        this.bloodGroup = BloodGroup.code(bloodGroup);
    }

    public int getBloodGroup(){
        return bloodGroup.getCode();
    }

    pubic void setBloodGroup(int arg){
        this.bloodGroup = BloodGroup.code(arg);
    }
}

3、对于源类中每一个使用类型码的函数，相应建立一个函数，让新函数使用新建的类。
你需要建立“以新类实例为自变量”的函数，用以替换原先“直接以类型码为参数”的函数。你还需要建立一个“返回新类实例”的函数，用以替换原先“直接返回类型码”的函数。建立新函数前，你可以使用Rename Method（10.1）修改原函数名称，明确指出哪些函数仍然使用旧式的类型码。

class Person{   
    public static final int O = BloodGroup.O.getCode();
    public static final int A = BloodGroup.A.getCode();
    public static final int B = BloodGroup.B.getCode();
    public static final int AB =BloodGroup.AB.getCode();

    private BloodGroup bloodGroup;

    public Person(int bloodGroup) {
        this.bloodGroup = BloodGroup.code(bloodGroup);
    }

    public int getBloodGroupCode(){
        return bloodGroup.getCode();
    }
    pubic void setBloodGroup(int arg){
        this.bloodGroup = BloodGroup.code(arg);
    }

    public BloodGroup getBloodGroup(){
        return bloodGroup;
    }
    public Person(BloodGroup arg){
        bloodGroup = arg;
    }

    public void setBloodGroup(BloodGroup arg){
        bloodGroup = arg;
    }
}

4、逐一修改源类用户，让它们使用新接口。

Person thePerson = new Person(Person.A);
thePerson.getBloodGroupCode();
thePerson.setBloodGroup(Person.AB);

to

Person thePerson = new Person(BloodGroup.A);
thePerson.getBloodGroup().getCode();
thePerson.setBloodGroup(BloodGroup.AB);

5、删除使用类型码的旧接口，并删除保存旧类型码的静态变量。
删掉与code相关的get/set方法和静态常量。

8.14 Replace Type Code with Subclasses（以子类取代类型码）

你有一个不可变的类型码，它会影响类的行为。以子类取代这个类型码。
不能使用这种方法的情况：

  • 类型码值周对象创建之后发生了改变。

  • 由于某些原因，类型码宿主类已经有了子类。
    上述情况需要使用Replace Type Code with State/Strategy（8.15）。

class Employee {    
    private int type;
    static final int ENGINEER = 0;
    static final int SALESMAN = 1;
    static final int MANAGER = 2;

    Employee(int type) {
        this.type = type;
    }
}

做法：
1、使用Self Encapsulate Field（8.1）将类型码自我封装起来。

int getType() {
    return type;
}

如果类型码被传递给构造函数，就需要将构造函数换成工厂函数。

static Employee create(int type) {      
    return new Employee(type);
}
private Employee(int type) {    
    this.type = type;
}

2、为类型码的 每一个数值建立一个相应的子类。在每个子类中覆写类型码的取值函数，使其返回相应的类型码值。

class Engineer extends Employee{
    int getType(){
        return Employee.ENGINEER;
    }
}

class Employee{
    static Employee create(int type) {
        if(type == ENGINEER) return new Engineer();
        else return new Employee(type);
    }
}

3、从超类中删掉保存类型码的字段，将类型码访问函数声明为抽象函数。

abstract int getType();
static Employee create(int type) {  
    switch(type){
        case ENGINEER:
            return new Engineer();
        case SALESMAN:
            return new Salesman();
        ...
    }
}

这时还可以使用Push Down Method（11.4）和Push Down Field（11.5），将只与特定种类雇员相关的函数和字段推到相关的 子类去。

8.15 Replace Type Code with State/Strategy（以State/Strategy取代类型码）

你有一个类型码，它会影响类的行为，但你无法通过继承手法消除它。以状态对象取代类型码。
如果你打算在完成本重构之后再以Replace Conditional with Polymorphism（9.6）简化一个算法，那么选择Strategy模式比较合适；如果你打算搬移与状态相关的数据，而且你把新建对象视为一种变迁状态，就应该选择使用State模式。

class Employee{
    private int type;
    private final int ENGINEER = 0;
    private final int SALESMAN = 1;
    private final int MANAGER = 2;

    Employee(int type) {
        this.type = type;
    }

    int payAmount(){
        switch(type){
            case ENGINEER:
                return monthlySalary;
            case SALESMAN:
                return monthlySalary+commission;
            case MANAGER:
                return montyleSalary+bonus;
            ...
        }
    }

}

做法：
1、使用Self Encapsulate Field（8.1）将类型码自我封装起来。
加上对象的类型码可变，那么就不能使用继承方式来处理类型码。

Employee (int type) {   
    setType(type);
}
int getType(){
    return type;
}
void setType(int type) {    
    this.type = type;
}
int payAmount(){
        switch(getType()){
            case ENGINEER:
                return monthlySalary;
            case SALESMAN:
                return monthlySalary+commission;
            case MANAGER:
                return montyleSalary+bonus;
            ...
        }
    }

2、新建一个类，根据类型码的用途为它命名。这就是一个状态对象。

3、为这个新类添加子类，每个子类对应一种类型码。

4、在超类中建立一个抽象的查询函数，用以返回类型码。在每个子类中覆写该函数，返回确切的类型码。

abstract class EmployeeType{
    abstract int getTypeCode();
}

class Engineer extends EmployeeType{
    int getTypeCode(){
        return Employee.ENGINEER;
    }
}
//Manager类和Salesman类
...

5、在源类中建立一个字段，用以保存新建的状态对象。

6、调整源类中负责查询类型码的函数，将查询动作转发给状态对象。

7、调整源类中为类型码设值的函数，将一个恰当的状态对象子类赋值给“保存状态对象”的那个字段。

class Employee{ 
    private EmployeeType type;

    int getType(){
        return type.getTypeCode();
    }

    void setType(int arg){
        switch(arg) {
            case ENGINEER:
                type = new Engineer();
                break;
            case SALESMAN:
                type = new Salesman();
                break;
            case MANAGER:
                type = new Manager();
                break;
            ...
        }
    }
}

之后可以运用Replace Constructor with Factory Method（10.12）针对不同的case子句建立相应的工厂函数。还可以再立刻使用Replace Conditional with Polymorphism（9.6），从而将其他的case消除掉。
可以将所有关于类型码和子类的知识都移到新类。

class Employee{
    void setType(int arg){
        type = EmployeeType.newType(arg);
    }
}

class EmployeeType{
    static EmployeeType newType(int code){
        switch(code){
            case ENGINEER:
                return new Engineer();
            case SALESMAN:
                return new Salesman();
            case MANAGER:
                return new Manager();
            ...
        }
    }

    static final int ENGINEER = 0;
    static final int SALESMAN = 1;
    static final int MANAGER = 2;
}

删掉原始类中的类型码定义，添加一个对新类的引用。

class Employee{ 
    int payAmount(){
        switch(getType()){
            case EmployeeType.ENGINEER:
                return monthlySalary;
            case EmployeeType.SALESMAN:
                return monthlySalary+commission;
            ...
        }
    }
}

最后，可以使用Replace Conditional with Polymorphism（9.6）处理payAmount()函数。

每天进步一点_点
关注
专栏目录
《重构：改善既有代码的设计》读书笔记(上)
行走
07-02 1191
重构：改善既有代码的设计
《重构-改善既有代码的设计》读书笔记
最新发布
小秋的博客
07-30 170
重构：对软件内部结构的一种调整，目的是在不改变软件可观察行为的前提下，提高其可理解性，降低其修改成本。
重构 改善既有代码的设计 — 读后感(思维导向图)
09-07
重构 改善既有代码的设计 — 读后感(思维导向图)
《重构：改善代码的既有设计》读书笔记
Sheh伟伟的博客
03-03 5567
本文已同步发表在博客园：http://www.cnblogs.com/davidsheh/p/5239745.html 第1章 重构，第一个案例 代码块俞小，代码的功能就俞容易管理，代码的处理和移动也就俞轻松。（功能也就越单一） 任何不会被修改的变量都可以被当成参数传入新的函数，至于会被修改的变量需要慎重。如果只有一个变量会被修改，可以把它当做返回值。 绝大多数情况下，函数应该放在它所使用的数据的所
《重构-改善既有代码的设计》读后总结
liuxiangke0210的专栏
12-02 438
原文链接：http://www.jianshu.com/p/d6ff54d72afb 最近刚刚毕业入职，刚来团队不是很忙，身边同事正好有一本经典书籍《重构-改善既有代码的设计》，这本书在我实习的时候团队周会上曾经大力推荐过。正好这次趁机借来阅读一遍。 强烈推荐大家阅读这本书，为什么呢？因为书皮上面写着“普通程序员进阶到编程高手必须修炼的秘籍”，这让我仿佛看到了我的“升值加薪，赢取白富
《重构-改善既有代码的设计》读后感
linhao19891124的博客
04-16 487
何时重构： 1，需要为程序添加一个特性，而代码结构使你无法很方便地达成目的，那就先重构那个程序，使特性添加比较容易进行。 如何重构： 1，找到函数内的局部变量和参数。分成可变和不可变。 任何不可变的变量都可以当成参数传入新的函数， 如果只有一个变量会被修改，那么可以把它当成返回值。 2，绝大多数情况下，函数应该放在它所使用的数据的所属对象内，这样可以减少传参。
《重构--改善既有代码的设计》读后感
rancongwei的博客
10-12 229
1. 结构严谨科学 整体结构是1到5章介绍重构的概念、原则以及什么时候重构，6到11章讲一些具体的重构手法，12章讲大型重构，13章总结性的论述重构、复用， 最后一章是整体的总结。 2. 内容完整详尽 内容上不管是最简单的Rename Method（273）还是Move Field（142）都非常详细的论述了该重构手法的概要、动机和详细步骤方法，同时附有代码案例。并且只要出现的重构手法，不管出现多少次，都括号里标有该重构手法的页码。 3. 层次上由浅入深 先是从重构概念原则介绍重构，再从函
《重构_改善既有代码设计》观后感PPT
12-24
【美】马丁福勒 著 是国际著名的面向对象分析设计、UML、模式等方面的专家，敏捷开发方法的创始人之一 重构_改善既有代码设计 软件工程领域的超级经典巨著，与另一巨著《设计模式》并称"软工双雄
重构：改善既有代码的设计 读书笔记
ontheway12138的博客
08-13 281
基本定义：重构（名词）是在不改变软件外在行为的前提下改善其内部结构。提高可理解性，降低修改成本。重构（动词）是使用一系列重构手法，在不改变软件外在行为的前提下，调整其结构。 第一章 如果你需要为程序添加一个新功能，而现有的代码结构使你无法很方便地达成目的，那就需要先重构现有的代码结构。 重构之前，首先检查自己是否有一套可靠的测试机制。这些测试必须有自我检验能力。 重构技术就是以微小的步伐修改程序。如果你放下错误，很容易便可以发现它。 第二章 重构的时机： ..
[读书笔记] 重构改善既有代码的设计（2）
beyongwang的博客
02-26 578
整理第三章的内容，关于代码的坏味道，这些往往也是可以进行重构的信号。 1. 重复代码。这个是非常常见的代码结构问题，这样的代码问题也很明显：难以维护，重复代码意味着当一份代码改动时，另一份也必须做出相应的改动，否则就会出现不一致的问题。这种情况应该提取共同代码。 2. 过长函数。函数过长意味着函数很复杂，处理了好多内容，违背单一职责，同时，程序愈长愈时难以理解，也很难为其起一个合适的可以表其意的
《重构-改善既有代码的设计》感悟
timothytt的博客
07-29 271
前言   “如果为完成今天的任务不择手段，导致不可能在明天完成明天的任务，那么最终还是会失败。” 何为重构?  重构是对软件结构的一种调整，不改变软件可观察行为的前提下： 提高其可理解性 降低修改成本 为什么重构?  代码结构的流失是累积性的，没有重构，程序会逐渐腐败变质  设计不良的程序往往需要更多的代码，因为他们在在不同的地方使用完全相同的语句做同样的事情  重构的一个重要方向是消除重复代码 重构的好处 1. 使软件更容易理解   让别人读懂你的代码，才是最重要的（仅让计算
重构-改善既有代码的设计 读书笔记
wangwenwen的专栏
10-13 2864
一、为什么重构？     重构技术的给我们代来的第一个好处就是他是我们的代码条理清晰，简明易读。于此同时，重构技术借用OO原则，将强代码的扩展性和灵活性，使得日后添加新功能更加轻松容易。     在软件开发过程中，我们每天应该关注两件事情，“今天应该做什么”和“明天应该做什么”。大多数时候，无论是修改BUG还是添加新功能，我们都是关注今天应该完成的事情，忽略了今天已经做的事情对明天应该做的事情
读《重构，改善既有的代码设计》记录有感
小学长的博客
12-14 241
以下将以6次重构的操作来实现一个简单的案例。 例子：这是一个影片出租店用的程序，计算每一个顾客的消费金额并打印详单。操作者告诉程序：顾客租了哪些影片，租期多长，程序便根据租赁时间和影片的类型算出费用。影片分为三类：普通片，儿童片和新片。除了计算费用，还要为常客计算积分，积分会根据租片的种类是否为新片而有所不同。 首先提个问题：什么时候重构？ 看代码实现上面案例如下： Movie.java（影...
《重构——改善既有代码的设计》读书笔记
xiaoxiaoyusheng2012的专栏
03-21 716
一、重构原则 1、重构的两个定义       重构（名词）：对软件内部结构的一种调整，目的是在不改变软件可观察行为的前提下，提高其可理解性，降低其修改成本。       重构（动词）：使用一系列重构手法，在不改变软件可观察行为的前提下，调整其结构。 2、重构与设计        重构与设计彼此互补，重构带来更简单的设计，同时又不损失灵活性，这也降低了设计过程的难度，减轻了设计压力。我们并
《重构 改善既有代码的设计》读书笔记一
不务正业的野猴子
10-01 860
重构原则
重构——重新组织数据
mashaokang1314的博客
10-26 1140
Self Encapsulate Field（自封装字段） 简介访问变量的好处：子类可以通过覆写一个函数而改变获取数据的途径；还支持更灵活的数据管理方式，如延迟初始化。 直接访问变量的好处：代码比较容易阅读； 如果你想访问超类中的一个字段，却又想在子类中将对这个变量的访问改为一个计算后的值，这时候就应该进行“字段自我封装”。 值对象和引用对象之间的相互转换 值对象和引用对象 如果引用对象开始变得难以使用，也许就应该将它改为值对象，引用对象必须被某种方式控制，你总是必须向其控制者请求适当的引用对象。它们
重构-改善既有代码的设计 读后总结
name_javahadoop的博客
07-21 3039
重构-改善既有代码的设计，这本书是很多公司要求JAVA程序员必读的三本书之一（另外两本书是《Java编程思想》和《Effective Java》） 前言 看到别人的代码时感觉就像屎一样，有一种强烈的想重写的冲动，但一定要压制住这种冲动，你完全重写，可能比原来的好一点，但浪费时间不说，还有可能引入原来不存在的Bug，而且，你不一定比原来设计得好，也许原来的设计考虑到了一些你没考虑到的
《重构：改善既有代码的设计》读书笔记
热门推荐
骆昊的技术专栏
04-10 1万+
如果一个人没有听说过《重构》这本书，那么他一定不敢说自己是程序员；如果一个人没有阅读过《重构》这本书，那么很难想象他会是一名优秀的程序员。这本书是很多公司要求Java程序员必读的三本书之一（另外两本书是《Java编程思想》和《Effective Java》），其实无关编程语言，是程序员就能够从这本书中受益。
《重构:改善既有代码的设计》读书笔记（持续更新中）
yytoo2的博客
02-26 2316
背景（我也不知道这个算不算读书笔记，书本知识点整理和个人理解内容可跳至下面正文）： 最近过年加找工作一直没想起来整理学习内容， 时间都很零碎。回想一下， 的确一直以来都是为了完成项目去看知识点。 除了刚开始想转行做IT的时候跟着慕课网的两条前后端路线系统地学习了一下， 但是终究囫囵吞枣。 前几天刚好有被问到《重构》这本书的内容。这两天临时抱佛脚看一下。 有了一定量的代码量积累的现在， 带着些许...
重构：改善既有代码设计再版 PDF 清晰版
"重构_改善既有代码的设计再版（中文）PDF" 本书《重构：改善既有代码的设计再版》是IT领域的一本经典之作，由知名软件工程师Martin Fowler撰写。重构是指在不改变软件外部行为的前提下，对代码进行修改，以改进其...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

每天进步一点_点

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值