java重构Java中为什么老是说重构，重构到底是什么意思？

最实用的10个重构小技巧排行榜，您都用过哪些呢？

本次我们抛开JAVA虚拟机源码这些相对底层的东西，LZ来与各位探讨一下几个代码重构的小技巧，这些内容部分来自于书籍当中，部分来自于LZ维护项目当中的一些实践经验。

如果猿友们曾经用过这种手法，也不妨参与到文章的留言当中，将你的小心得、小体会共享与他人，也可以拿来冲击LZ自己定义的排行榜，LZ不甚欢迎。

重构的手法有很多种，相对而言，一篇文章的涵盖量自然是无法提到所有，LZ这里也只能提出一些平时会经常使用的一些手法，像一些比较高端的手法，各位有兴趣的可以去找一些专门的书籍涉猎。

另外还有一点，由于LZ是做JAVA开发的，因此部分重构小技巧可能与JAVA语言，或者说与面向对象的语言息息相关，不过大多数技巧，无论是面向过程的语言，还是面向对象的语言，都是可以相互通用的。

废话不多说，我们来看看实用重构技巧的排行榜吧。

No.1：重复代码的提炼 重复代码是重构收效最大的手法之一，进行这项重构的原因不需要多说。

它有很多很明显的好处，比如总代码量大大减少，维护方便，代码条理更加清晰易读。

它的重点就在于寻找代码当中完成某项子功能的重复代码，找到以后请毫不犹豫将它移动到合适的方法当中，并存放在合适的类当中。

小实例 class BadExample { publicvoid someMethod1(){ //code System.out.println("重复代码");/* 重复代码块 *///code } publicvoid someMethod2(){ //code System.out.println("重复代码");/* 重复代码块 *///code } } /* ---------------------分割线---------------------- */class GoodExample { publicvoid someMethod1(){ //code someMethod3(); //code } publicvoid someMethod2(){ //code someMethod3(); //code } publicvoid someMethod3(){ System.out.println("重复代码");/* 重复代码块 */ } } No.2：冗长方法的分割 有关冗长方法的分割，其实有时候与重复代码的提炼是有着不可分割的关系的，往往在我们提炼重复代码的过程中，就不知不觉的完成了对某一个超长方法的分割。

倘若在你提炼了大部分的重复代码之后，某一些冗长方法依然留存，此时就要静下心来专门处理这些冗长方法了。

这其中有一点是值得注意的，由于我们在分割一个大方法时，大部分都是针对其中的一些子功能分割，因此我们需要给每一个子功能起一个恰到好处的方法名，这很重要。

可以说，能否给方法起一个好名字，有时候能体现出一个程序猿的大致水准。

小实例 class BadExample { publicvoid someMethod(){ //function[1] //function[2] //function[3] } } /* ---------------------分割线---------------------- */class GoodExample { publicvoid someMethod(){ function1(); function2(); function3(); } privatevoid function1(){ //function[1] } privatevoid function2(){ //function[2] } privatevoid function3(){ //function[3] } } No.3：嵌套条件分支的优化（1） 大量的嵌套条件分支是很容易让人望而却步的代码，我们应该极力避免这种代码的出现。

尽管结构化原则一直在说一个函数只能有一个出口，但是在这么大量的嵌套条件分支下，让我们忘了这所谓的规则吧。

有一个专业名词叫卫语句，可以治疗这种恐怖的嵌套条件语句。

它的核心思想是，将不满足某些条件的情况放在方法前面，并及时跳出方法，以免对后面的判断造成影响。

经过这项手术的代码看起来会非常的清晰，下面LZ就给各位举一个经典的例子，各位可以自行评判一下这两种方式，哪个让你看起来更清晰一点。

小实例 class BadExample { publicvoid someMethod(Object A,Object B){ if (A != null) { if (B != null) { //code[1] }else { //code[3] } }else { //code[2] } } } /* ---------------------分割线---------------------- */class GoodExample { publicvoid someMethod(Object A,Object B){ if (A == null) { //code[2]return; } if (B == null) { //code[3]return; } //code[1] } } No.4：嵌套条件分支的优化（2） 此处所说的嵌套条件分支与上面的有些许不同，它无法使用卫语句进行优化，而应该是将条件分支合并，以此来达到代码清晰的目的。

由这两条也可以看出，嵌套条件分支在编码当中应当尽量避免，它会大大降低代码的可读性。

下面请尚且不明觉厉的猿友看下面这个典型的小例子。

小实例 class BadExample { publicvoid someMethod(Object A,Object B){ if (A != null) { if (B != null) { //code } } } } /* ---------------------分割线---------------------- */class GoodExample { publicvoid someMethod(Object A,Object B){ if (A != null && B != null) { //code } } } No.5：去掉一次性的临时变量 生活当中我们都经常用一次性筷子，这无疑是对树木的摧残。

然而在程序当中，一次性的临时变量不仅是对性能上小小的摧残，更是对代码可读性的亵渎。

因此我们有必要对一些一次性的临时变量进行手术。

小实例 class BadExample { privateint i; publicint someMethod(){ int temp = getVariable(); return temp * 100; } publicint getVariable(){ return i; } } /* ---------------------分割线---------------------- */class GoodExample { privateint i; publicint someMethod(){ return getVariable() * 100; } publicint getVariable(){ return i; } } No.6：消除过长参数列表 对于一些传递了大批参数的方法，对于追求代码整洁的程序猿来说，是无法接受的。

我们可以尝试将这些参数封装成一个对象传递给方法，从而去除过长的参数列表。

大部分情况下，当你尝试寻找这样一个对象的时候，它往往已经存在了，因此绝大多数情况下，我们并不需要做多余的工作。

小实例 class BadExample { publicvoid someMethod(int i,int j,int k,int l,int m,int n){ //code } } /* ---------------------分割线---------------------- */class GoodExample { publicvoid someMethod(Data data){ //code } } class Data{ privateint i; privateint j; privateint k; privateint l; privateint m; privateint n; //getter&&setter } No.7：提取类或继承体系中的常量 这项重构的目的是为了消除一些魔数或者是字符串常量等等，魔数所带来的弊端自不用说，它会让人对程序的意图产生迷惑。

而对于字符串等类型的常量的消除，更多的好处在于维护时的方便。

因为我们只需要修改一个常量，就可以完成对程序中所有使用该常量的代码的修改。

顺便提一句，与此类情况类似并且最常见的，就是Action基类中，对于INPUT、LIST、SUCCESS等这些常量的提取。

小实例 class BadExample { publicvoid someMethod1(){ send("您的操作已成功！"); } publicvoid someMethod2(){ send("您的操作已成功！"); } publicvoid someMethod3(){ send("您的操作已成功！"); } privatevoid send(String message){ //code } } /* ---------------------分割线---------------------- */class GoodExample { protectedstaticfinal String SUCCESS_MESSAGE = "您的操作已成功！"; publicvoid someMethod1(){ send(SUCCESS_MESSAGE); } publicvoid someMethod2(){ send(SUCCESS_MESSAGE); } publicvoid someMethod3(){ send(SUCCESS_MESSAGE); } privatevoid send(String message){ //code } } No.8：让类提供应该提供的方法 很多时候，我们经常会操作一个类的大部分属性，从而得到一个最终我们想要的结果。

这种时候，我们应该让这个类做它该做的事情，而不应该让我们替它做。

而且大部分时候，这个过程最终会成为重复代码的根源。

小实例 class BadExample { publicint someMethod(Data data){ int i = data.getI(); int j = data.getJ(); int k = data.getK(); return i * j * k; } lass Data{ privateint i; privateint j; privateint k; public Data(int i, int j, int k) { super(); this.i = i; this.j = j; this.k = k; } publicint getI() { return i; } publicint getJ() { return j; } publicint getK() { return k; } } } /* ---------------------分割线---------------------- */class GoodExample { publicint someMethod(Data data){ return data.getResult(); } lass Data{ privateint i; privateint j; privateint k; public Data(int i, int j, int k) { super(); this.i = i; this.j = j; this.k = k; } publicint getI() { return i; } publicint getJ() { return j; } publicint getK() { return k; } publicint getResult(){ return i * j * k; } } } No.9：拆分冗长的类 这项技巧其实也是属于非常实用的一个技巧，只不过由于它的难度相对较高，因此被LZ排在了后面。

针对这个技巧，LZ很难像上面的技巧一样，给出一个即简单又很容易说明问题的小例子，因为它已经不仅仅是小手段了。

大部分时候，我们拆分一个类的关注点应该主要集中在类的属性上面。

拆分出来的两批属性应该在逻辑上是可以分离的，并且在代码当中，这两批属性的使用也都分别集中于某一些方法当中。

如果实在有一些属性同时存在于拆分后的两批方法内部，那么可以通过参数传递的方式解决这种依赖。

类的拆分是一个相对较大的工程，毕竟一个大类往往在程序中已经被很多类所使用着，因此这项重构的难度相当之大，一定要谨慎，并做好足够的测试。

No.10：提取继承体系中重复的属性与方法到父类 这项技巧大部分时候需要足够的判断力，很多时候，这其实是在向模板方法模式迈进的过程。

它的实例LZ这里无法给出，原因是因为它的小实例会毫无意义，无非就是子类有一样的属性或者方法，然后删除子类的重复属性或方法放到父类当中。

往往这一类重构都不会是小工程，因此这一项重构与第九种类似，都需要足够的谨慎与测试。

而且需要在你足够确认，这些提取到父类中的属性或方法，应该是子类的共性的时候，才可以使用这项技巧。

结束语 由于LZ目前的工作就是维护一个相对古老的项目，因此上面这十种手法，LZ几乎都已经一一尝试过了，可喜的是效果都还不错。

限于最后两种与实际情况的联系太过紧密，因此LZ无法给出简单的实例，不过后面两种毕竟不是常用的重构手法，因此也算是可以接受了。

不过不常用不代表不重要，各位猿友还是要知道这一点的。

另外LZ还要说的是，上面的实例只是手法的一种简单展示，实际应用当中，代码的结构可能是千奇百怪，但却万变不离其宗。

因此只要抓住每种手法的核心，就不难从这些乱军丛中安然穿过。

好了，本次的小分享到此结束，希望各位猿友如果觉得有所收获，可以推荐一下鼓励下LZ，顺便也让更多的人看到。

这样的话，或许我们每一个接手的项目代码，都不至于十分的糟糕了，也算是给像LZ这样的项目维护者一条生路吧。

重写重载，重构，加载，覆盖的区别

楼主的问题问得很好，但是我们每一个问题都是想要一个结果的，这个问题涉及java基础方面的，重载/重写（其实就是覆盖）针对的对象都是方法，所以我们具体的来说是方法重载和方法覆盖是怎么一回事，重构。

。

就像楼上说的那样，是针对代码，写得不好自然要重新来写，而对于初学者来说理解方法重载和方法覆盖是一个很重要的课题。

这之前需要楼主先明白什么是方法，方法其实就是函数（java中的称呼不一样而已），顾名思义就是完成一个动作或者功能的代码体（用{}包起来），一个方法必须具备返回类型/方法名/参数这三个基本元素，当然也有例外（比如构造方法是没有返回类型的）。

重载是为了让程序能够具备更好地灵活性而设计的，使用它可以节省很多时间，让代码更加简洁。

下面这个例子很好地说明了这点，楼主可以看下： public class Circle { private int x,y,r; private double pi=3.1415; public Circle(int x,int y) { this.x=x; this.y=y; r=1; this.prt(); } public Circle(int x,int y,int r) { this.x=x; this.y=y; this.r=r; this.prt(); } public void prt() { System.out.println("x="+x+",y="+y+",r="+r); } public static void main(String[] args) { Circle c1=new Circle(10,10); Circle c2=new Circle(20,20,10); } } Circle这个类保存一个圆，它拥有圆心坐标x y，半径长度r，如果在建立的时候不输入r，那么就默认半径r=1,方法重载要求方法名相同，返回类型相同，但是参数的类型或者个数不同，或者参数的顺序不同，在这里我们Circle构造方法的参数个数就不同，所以重载就发生了。

而覆盖是发生在不同类中的事情，通常是子类重写父类的方法，这个在接口中被普遍采用，因为实现接口以后必须重写某些方法，否则程序无法正确编译。

下面这个程序能很好的帮助你来理解覆盖： class PrintFather { int i=1; public void prt() { System.out.println("i="+i); } } public class PrintOverriden extends PrintFather { String name="PrintOverriden"; public void prt() { System.out.println("Name="+name); System.out.println("i="+i); } public static void main(String[] args) { PrintOverriden p=new PrintOverriden(); p.prt(); } } 父类里的prt()方法只打印int i，然后子类需要打印出String name，所以子类重写了prt()这个方法。

至于加载的意思，其实就是让编译器执行某段程序，可以是类可以是包可以是任何编译器能够编译的代码。

java 代码重用 真么体现的？ 重构和重用是一个意识吗？

重构可以说是覆盖,用覆盖一词来讲就比较清楚。

在面向对象的一个特性--继承中就表现出重构的意思。

重构，就是继承于父类方法的子类将子类的方法重写，方法名及参数完全相同. 重用是继承了就可以用父类定义的方法和变量，不用再定义一次。

比如说 class B { public void see(){ System.out.println("this is b"); } } public class A extends B{ public void see() { System.out.println("this is a"); } public static void main(String[] args) { B b=new A(); b.see(); } } 这是重构的意思。

class B { public void see(){ System.out.println("this is b"); } } public class A extends B{ public static void main(String[] args) { B b=new A(); b.see(); } } 这是重用的意思

java中重写和重构二者的定义和区别？

我晕，楼上，重构可不是“重载构造函数”的简写。

软件重构和重写压根不是一个层次上的东西！软件重构是说程序员为了对 已有程序 在尽量不改变接口的前提下 进行如下处理 而做的 重新编写代码的工作1、去除bug2、提高效率3、增加新的功能等等。

而方法重写只是大多数面向对象语言提供的一种机制，目的主要是帮助实现“多态”。

许多时候java代码的重构确实利用了java的方法重写机制，但是你要理解它们根本不是同一层次上的东西。

重构：站在软件整体设计思想的高度，改变软件内部结构达到提高效率，增加功能，去除bug等工作。

方法重写：仅仅是java的一种语言机制，它和继承，超类可以引用子类等机制一同实现“多态”。

Java代码重构的几种模式

Java代码的重构模式主要有三种：重命名方法重构模式、引入解释性变量重构模式、以查询取代临时变量重构模式重命名方法重构模式建议执行如下的步骤来完成：1.建立一个具有新名称的方法2.将旧方法的方法体复制进新方法3.讲旧方法的方法体修改为调用新方法4.将所有引用旧方法的地方修改为引用新方法5.删除旧方法引入解释性变量重构模式步骤相对简单，如下：1.声明一个局部变量，并将其初始化为需要替换的表达式部分2.对于复杂的表达式，用新的局部变量代替其中需要替换的部分3.对于该表达式的其他部分，重复这个过程以查询取代临时变量重构模式的步骤如下：1.找出只赋值了一次的局部变量2.将该局部变量声明为final并重新编译（以确保该变量的确只赋值了一次）3.复制赋值语句的等号右侧的表达式，并将其修改为一个新方法的方法体4.将赋值语句的等号右侧更改为对新方法的调用5.将所有对该局部变量的使用替换为对新方法的调用6.删除赋值语句以及局部变量的声明

Java中为什么老是说重构，重构到底是什么意思？

首先，重构这个概念，不是JAVA所特有的，而是软件工程的一个概念。

主要是指改善现有的程序代码，使其更方便、简单的使用，提高可重用性、可维护性。

在面向对象C++C#JAVA等语言中，重构的概念一般是指对类进行重构，一般在现有类的某些功能方法不能满足扩展需要，或者修复BUG时，就需要重构 重构是一个可迭代的过程，可以对一个功能重复重构，直到其满足软件的需求、维护和可扩展性 重构的方法比较多，一本书也说不完，一些概念性的内容见百科 /view/120901.htm