常用的代码重构方法

时间：2025-03-12 07:35:15

一.提取子函数

说白了就是一个大函数里，可以根据不同功能分成几个小函数，因为说不定，其他函数也可能会用到其中的函数

二.把大家都要用的方法放到父类中

    所有对象都要执行同一个方法，那就把这个方法放到他们的父类中

三.下移函数到子类

   子类特有的方法就没必要放到父类中，单独实现就可以了

四.封装固定的调用逻辑（有点模板模式的意思）

代码会按照一定的逻辑执行，要完成这个功能，需要执行A,在执行B,最后执行C,这些逻辑通常比较固定，在实现了A,B,C功能之后就要调用它们实现功能，但是每次调用这三个功能函数，必然会造成代码重复

不科学的代码如下：


Car audi = new Audi();
();
();
();

Car bmw = new BMW();
();
();
();

科学的代码如下： 

public abstract  class SmartCar extends Car{
    public final  void autoSpeedup(int speed){
        ();
        ();
        ();
        ("xcqw 加速到 ："+speed);
    }
}

可以看到我们在autoSoeedUp函数中按照顺序调用了关门，启动，加速3个操作，这样在其他地方只需要调用autoSpeedup函数即可。autoSpeedup函数实际上运用了模板方法模式，它封装了3个逻辑流程，并且这个流程不能被修改，但是子类可以重写这三个过程


五.使用泛型去除重复逻辑

/存储Int的集合类
public class IntArrayList{
    private int[] dataSet;
    public  IntArrayList(int size){
        dataSet = new int[size];
    }
    public int get(int position){
        return dataSet[position];
    }

    public void add(int pos ,int data){
        dataSet[pos] =data;
    }
    public int size(){
        return ;
    }
}
//存储String的集合类
public class StringArrayList{
    private String[] dataSet;
    public StringArrayList(int size){
        dataSet = new String[size];
    }
    public String get(int position){
        return dataSet[position];
    }
    public void add(int pos ,String data){
        dataSet[pos] = data;
    }
    public int size(){
        return ;
    }
}


可以看到IntArrayList和StringArrayList都实现了get,add,size三个函数，他们的代码都是一样的，只是具体类型不太一样

所以我们可以抽象集合类SimpleArrayList的实现：

public class SimpleArrayList<T> {
    private T[] dataSet;
    public SimpleArrayList(int size){
        dataSet = (T[]) new Object[size];
    }
    public T get(int position){
        return dataSet[position];
    }
    public void add(int pos ,T data){
        dataSet[pos] = data;
    }
    public int size(){
        return ;
    }
}





//方法一
//使用IntArrayList
IntArrayList intArr = new IntArrayList(2);
(0,3);
(1,55);
((1));
//使用StringArrayList
StringArrayList strArr = new StringArrayList(3);
(0,"hello");
((0));

//方法二  抽出来之后
//使用SimpleArrayList 存储整型
SimpleArrayList<Integer> intArrayList = new SimpleArrayList<>(3);
(0,3);
(1,55);
((1));

//使用SimpleArrayList存储String
SimpleArrayList<String> strArrayList = new SimpleArrayList<>(3);
(0,"hello , SimpleArrayList");
((0));


六.函数避免过多的入参

//复杂版
public void shareToMoment(String title,String content,String thumbUrl,String targetUrl,String creator){
    ("分享到朋友圈：文章标题为："+title+"内容为："+content);
}
//简单版
public static void shareToMoment(ShareData shareData){
    ("分享到朋友圈：文章标题为："++"内容为："+);
}
public class ShareData{
    public String title;
    public String content;
    public String thumbUrl;
    public String targetUrl;
    public String creator;
}
ShareData shareData = new ShareData();
 ="平凡之路";
 = "我曾经失落失望失掉所有方向，直到看见平凡才是唯一的答案";
 = "";
//分享到朋友圈
ShareData(shareData);


七.重构的支柱-----转移函数，说白了就是函数要职责分明

如果一个类中有太多行为（即函数），或一个类与另一个类之间有太多的函数调用，导致高度耦合，我就会考虑转移该函数到更适合的类型中。（说白了就是要函数要职责分明）

/班级类
public class AClass{
    public List<Student> students = new ArrayList<Student>();
    public void add(Student student){
        (student);
    }
}

public class Student{
    public String id;
    public String name;
    public Student(String sId,String sName){
         = sId;
         = sName;
    }
    //很明现在这个其实是遍历Aclass ,所以应该放在AClass中比较好
    public boolean isBelongTo(AClass class1){
        for(Student stu :){
            if(()){
                return true;
            }
        }
        return false;
    }

    @Override
    public String toString() {
        return "Student[ id= "+id+",name="+name+"]";
    }
}

//更改之后Aclass
public class Aclass{
    public List<Student> students = new ArrayList<Student>();
    public void add(Student student){
        (student);
    }
    //放这里就比较好  因为是遍历students
    public boolean contain(Student  student){
        for(Student stu :students){
            if(()){
                return true;
            }
        }
        return false;
    }
}


八.状态模式---参考设计模式中的介绍

状态模式介绍


九.避免对象为null，就写个什么都不做的对象，如果是null就把这个给他

十.把功能拆开

不要把所有功能放在一个函数中




相关文章