一.提取子函数

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

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

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

三.下移函数到子类

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

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

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

不科学的代码如下：

[java] view plain copy 
 Car audi = new Audi();  
 audi.closeDoor();  
 audi.start();  
 audi.speedup();  
   
 Car bmw = new BMW();  
 bmw.closeDoor();  
 bmw.start();  
 bmw.speedup();  

科学的代码如下：

[java] view plain copy 
 public abstract  class SmartCar extends Car{  
     public final  void autoSpeedup(int speed){  
         this.closeDoor();  
         this.start();  
         this.speedup();  
         System.out.println("xcqw 加速到 ："+speed);  
     }  
 }  

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

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

[java] view plain copy 
 /存储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 dataSet.length;  
     }  
 }  
 //存储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 dataSet.length;  
     }  
 }  

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

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

[java] view plain copy 
 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 dataSet.length;  
     }  
 }  

[java] view plain copy 
 //方法一  
 //使用IntArrayList  
 IntArrayList intArr = new IntArrayList(2);  
 intArr.add(0,3);  
 intArr.add(1,55);  
 System.out.println(intArr.get(1));  
 //使用StringArrayList  
 StringArrayList strArr = new StringArrayList(3);  
 strArr.add(0,"hello");  
 System.out.println(strArr.get(0));  
   
 //方法二  抽出来之后  
 //使用SimpleArrayList 存储整型  
 SimpleArrayList<Integer> intArrayList = new SimpleArrayList<>(3);  
 intArrayList.add(0,3);  
 intArrayList.add(1,55);  
 System.out.println(intArrayList.get(1));  
   
 //使用SimpleArrayList存储String  
 SimpleArrayList<String> strArrayList = new SimpleArrayList<>(3);  
 strArrayList.add(0,"hello , SimpleArrayList");  
 System.out.println(strArrayList.get(0));  

六.函数避免过多的入参

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

七.重构的支柱-----转移函数，函数要职责分明

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

[java] view plain copy 
 /班级类  
 public class AClass{  
     public List<Student> students = new ArrayList<Student>();  
     public void add(Student student){  
         sudent.add(student);  
     }  
 }  
   
 public class Student{  
     public String id;  
     public String name;  
     public Student(String sId,String sName){  
         this.id = sId;  
         this.name = sName;  
     }  
     //很明现在这个其实是遍历Aclass ,所以应该放在AClass中比较好  
     public boolean isBelongTo(AClass class1){  
         for(Student stu :class1.students){  
             if(stu.id.equals(this.id)){  
                 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){  
         sudent.add(student);  
     }  
     //放这里就比较好  因为是遍历students  
     public boolean contain(Student  student){  
         for(Student stu :students){  
             if(stu.id.equals(student.id)){  
                 return true;  
             }  
         }  
         return false;  
     }  
 }  