Idea中重构从精通到陌生
Idea中重构从精通到陌生
为什么要重构，因为我们总是不可能在一开始就写出简洁的代码
为了类更小，函数更小，越小，意味着它所承担的少，求求你了，给代码减负吧！！（甘哥你在看吗？）
如何借助 idea来实现快速重构
函数
提炼函数
一个函数几百行,需要依靠注释才能看懂,这种时候我们就要用 大名鼎鼎的提炼函数,在代码整洁之道这样说：阅读一段好的代码就像看看报一样！
例子
鼠标选中,右键
public class ExtractMethodExampleOriginal {
private String _name;
private Hashtable orders;
void printOwing() {
Enumeration e = orders.elements();
double outstanding = 0.0;
//打印横幅
System.out.println("************************************");
System.out.println("***********Customer Owes***********");
System.out.println("************************************");
//计算未完成
while (e.hasMoreElements()) {
Order each = (Order) e.nextElement();
outstanding += each.getAmount();
}
//打印详细信息
System.out.println("name:" + _name);
System.out.println("amount" + outstanding);
}
}
idea技巧
重构后
public class ExtractMethodExampleOriginal2 {
private String _name;
private Hashtable orders;
void printOwing() {
printBanner();
double outstanding = calculateOutstanding();
printDetails(outstanding);
}
private void printDetails(double outstanding) {
System.out.println("name:" + _name);
System.out.println("amount" + outstanding);
}
private double calculateOutstanding() {
double outstanding = 0.0;
while (true) {
Enumeration elements = orders.elements();
if (!elements.hasMoreElements()) break;
Order each = (Order) elements.nextElement();
outstanding += each.getAmount();
}
return outstanding;
}
private static void printBanner() {
System.out.println("************************************");
System.out.println("***********Customer Owes***********");
System.out.println("************************************");
}
}
内联函数&内联变量
当函数代码和名称一样好懂时，需要内联，一个临时变量被简单的赋值了一次，需要内联，,刚刚把代码提出去，现在又放回去了=。=
例子：
isCurrentOutstandingBiggerThanZero方法的内容是 getCurrentOutstanding() > 0 ；我一看就知道是大于0啊，反复套娃是吧！这时候就要内联函数
public class InlineMethodAndTempExampleOriginal {
double calcPreviousOutstanding() {
return isCurrentOutstandingBiggerThanZero() ? 2 : 1;
}
double calcAfterOutstanding() {
return isCurrentOutstandingBiggerThanZero() ? 20 : 10;
}
boolean isCurrentOutstandingBiggerThanZero() {
return getCurrentOutstanding() > 0;
}
double getCurrentOutstanding() {
return 10;
}
}
idea操作
选中方法，右键重构，选择
内联操作(Ctrl+Alt+N) 内联方法和内联变量的快捷键都是Ctrl+Alt+N
重构后
double calcPreviousOutstanding() {
return getCurrentOutstanding() > 0 ? 2 : 1;
}
double calcAfterOutstanding() {
return getCurrentOutstanding() > 0 ? 20 : 10;
}
double getCurrentOutstanding() {
return 10;
}
已查询取代临时变量
就是将一个临时变量的计算过程，放到一个函数中。然后变量去引用函数。
这样提有什么好处？
1.是扩大了范围，本来临时变量是只在函数内可见。
2.更容易提方法
上链接(例子)
public class ReplaceTempWithQueryExampleOriginal {
private int quantity;
private int itemPrice;
public double calcPrice() {
int basePrice = quantity * itemPrice;
double discountFactor;
if (basePrice > 1000) {
discountFactor = 0.95;
} else {
discountFactor = 0.98;
}
return basePrice * discountFactor;
}
}
步骤
1.首先将 quantity * itemPrice 提取函数
2. 选中 提取函数
double discountFactor;
if (basePrice > 1000) {
discountFactor = 0.95;
} else {
discountFactor = 0.98;
}
3.这时候 是不是 发现discountFactor 只被用了一次，一看到这种情况，DNA就触动了，TM直接将 discountFactor 内联变量，
public double calcPrice() {
int basePrice = getBasePrice();
double discountFactor = getDiscountFactor(basePrice);
return basePrice * discountFactor;
}
private static double getDiscountFactor(int basePrice) {
double discountFactor;
if (basePrice > 1000) {
discountFactor = 0.95;
} else {
discountFactor = 0.98;
}
return discountFactor;
}
重构后
public class ReplaceTempWithQueryExample2 {
private int quantity;
private int itemPrice;
public double calcPrice() {
int basePrice = getBasePrice();
return basePrice * getDiscountFactor(basePrice);
}
private static double getDiscountFactor(int basePrice) {
double discountFactor;
if (basePrice > 1000) {
discountFactor = 0.95;
} else {
discountFactor = 0.98;
}
return discountFactor;
}
private int getBasePrice() {
return quantity * itemPrice;
}
}
引入解释性变量
当你有一个复杂的表达式时,将它的结果或者其中一部分的结果放进一个临时变量
例子
private void introduceVariableConditionalMethod() {
if (platform.toUpperCase().indexOf("MAC") > -1 &&
browser.toUpperCase().indexOf("IE") > -1 && isInitialized() && resize > 0) {
//do something
}
}
private double calcPrice() {
return quantity * itemPrice - Math.max(0, quantity - 500) * itemPrice * 0.05 + Math.min(quantity * itemPrice * 0.1, 100.0);
}
private boolean isInitialized() {
return false;
}
技巧
上面introduceVariableConditionalMethod函数中的if中有 大量的一眼看过去不知道意思的，这时候就要将一个个表达式的结果用 临时变量保存，专业术语叫 引入解释性变量(Ctrl+Alt+V),干就完事了，兄弟们！！
1.我们先对introduceVariableConditionalMethod函数下手
private void introduceVariableConditionalMethod() {
boolean isMacos = platform.toUpperCase().indexOf("MAC") > -1;
boolean isIe = browser.toUpperCase().indexOf("IE") > -1;
boolean wasResized = resize > 0;
if (isMacos && isIe && isInitialized() && wasResized) {
//do something
}
}
2.calcPrice函数，我k这么长，这谁写的代码！我写的，那没事了，哈哈哈哈！！
private double calcPrice() {
return quantity * itemPrice - Math.max(0, quantity - 500) * itemPrice * 0.05 + Math.min(quantity * itemPrice * 0.1, 100.0);
}
先引入解释性变量 这样有助于我们理解，下面代码是不是一目了然
private double calcPrice() {
int totalPrice = quantity * itemPrice;
double discount = Math.max(0, quantity - 500) * itemPrice * 0.05;
double shippingCost = Math.min(quantity * itemPrice * 0.1, 100.0);
return totalPrice - discount + shippingCost;
}
其实到这已经可以了，不过还记得上面我们说了啥吗？
难道是以查询来取代临时变量，没错，不过我就不写，就是懒。
使用引入解释性变量 还有助于提取函数（以查询来取代临时变量本质上就是提取函数，不要说你没看出来）
重构后
private void introduceVariableConditionalMethod() {
if (platform.toUpperCase().indexOf("MAC") > -1 &&
browser.toUpperCase().indexOf("IE") > -1 && isInitialized() && resize > 0) {
//do something
}
}
private double calcPrice() {
int basePrice = quantity * itemPrice;
double discount = Math.max(0, quantity - 500) * itemPrice * 0.05;
double shippingCost = Math.min(quantity * itemPrice * 0.1, 100.0);
return basePrice - discount + shippingCost;
}
private boolean isInitialized() {
return false;
}
分解临时变量
当有一个临时变量，被多次赋值（一个变量被承担了多个责任），但它既不是循环变量，也不是计算结果。我从业这么多年还未见到，有人这样写！
例子
double calcDistanceTravelled(int time) {
double result;
// 加速度 /力除以质量
double acc = primaryForce / mass;
int primaryTime = Math.min(time, initPrimaryTime);
result = 0.5 * acc * primaryTime * primaryTime;
int secondaryTime = time - initPrimaryTime;
if (secondaryTime > 0) {
double primaryVel = acc * initPrimaryTime;
acc = (primaryForce + secondaryForce) / mass;
result += primaryVel * secondaryTime + 0.5 * acc * secondaryTime * secondaryTime;
}
return result;
}
技巧
例子中可以看出acc(加速度)被赋值多次，
1.先将acc第二次 赋值改为二次加速度
2.然后将第一次acc 使用 shift+F6 可以快速将acc 全部重命名。
当然这份代码还能优化~
重构后
double calcDistanceTravelled(int time) {
double result;
// 加速度 /力除以质量
double primaryAcc = primaryForce / mass;
int primaryTime = Math.min(time, initPrimaryTime);
result = 0.5 * primaryAcc * primaryTime * primaryTime;
int secondaryTime = time - initPrimaryTime;
if (secondaryTime > 0) {
double primaryVel = primaryAcc * initPrimaryTime;
double secondaryAcc = (primaryForce + secondaryForce) / mass;
result += primaryVel * secondaryTime + 0.5 * secondaryAcc * secondaryTime * secondaryTime;
}
return result;
}
移除对参数的赋值
代码中对入参赋值
例子
public int changeSimpleTypeParameterValueAndReturn(int inputVal) {
if (inputVal < 50) {
inputVal = inputVal * 2;
}
if (inputVal > 60) {
inputVal = inputVal + 1;
}
return inputVal;
}
技巧
用一个临时变量取代该参数
注意java 中是按值传递，对参数赋值是无意义的
那没有意义,那我直接复用这个变量不行吗？
我看你之前说说的都忘了，分解临时变量，一个变量被多次赋值，一个人承担多个责任不累吗？
重构后
public int changeSimpleTypeParameterValueAndReturn(int inputVal) {
int result=inputVal;
if (inputVal < 50) {
result = inputVal * 2;
}
if (inputVal > 60) {
result = inputVal + 1;
}
return result;
}
以函数对象取代函数
当你有一个大型函数,局部变量很多，提取函数变得很困难, 就是将函数放到一个对象中，其中的局部变量变为对象的字段,这样就更容易的将大型函数拆成多个 小的
例子
还没看到合适的
替换算法
将原本不容易理解的算法替换成成一个更清晰的算法
例子
public String findPerson(String[] people) {
for (int i = 0; i < people.length; i++) {
if (people[i].equals("Tom")) {
return "Tom";
}
if (people[i].equals("Sam")) {
return "Sam";
}
if (people[i].equals("Tim")) {
return "Tim";
}
}
return "";
}
技巧
啊这，没啥说的
重构后
public String findPerson(String[] people) {
List candidates = List.of("Tom", "Sam", "Tim");
for (String person : people) {
if (candidates.contains(person)) {
return person;
}
}
return "";
}
对象间搬移特性
搬移函数(Move Method)
当一个类中的函数与另一个的的关系更强，这时候通常将该函数提取到此类中
例子
public class Account {
private AccountType type;
private int daysOverdrawn;
public Account(AccountType type, int daysOverdrawn) {
this.type = type;
this.daysOverdrawn = daysOverdrawn;
}
public double calcOverdraftCharge() {
if (type.isPremium()) {
double result = 10;
if (daysOverdrawn > 7) {
result += (daysOverdrawn - 7) * 0.85;
}
return result;
} else {
return daysOverdrawn * 1.75;
}
}
public double calcBankCharge() {
double result = 4.5;
if (daysOverdrawn > 0) {
result += calcOverdraftCharge();
}
return result;
}
}
public class AccountType {
public static final int ACCOUNT_TYPE_PREMIUM = 1;
public static final int ACCOUNT_TYPE_SENIOR = 2;
private int accountType;
public AccountType(int accountType) {
this.accountType = accountType;
}
public boolean isPremium() {
return ACCOUNT_TYPE_PREMIUM == accountType;
}
}
重构技巧
我们可以看见 calcOverdraftCharge这个函数用来计算透支费用,它会根据不同的AccountType(账号类型) 来进行计算，可以感觉到这个函数和AccountType类的关系更强。
不管是重构代码还是使用设计模式，都需要对业务有一定的了解，不然就是纸上谈兵
开始对calcOverdraftCharge重构
1. 将 daysOverdrawn变为形参，选中daysOverdrawn变量 使用引入形参(CTRL+ALT+P) 然后代理方法(ALT+SHIFT+O)
有的时候因为快捷键冲突可能和导致失效，使用右键重构(CTRL+ALT+SHIFT+T)
因为后面我们要搬移函数，但是它依赖daysOverdrawn这个变量
public double calcOverdraftCharge() {
return calcOverdraftCharge(daysOverdrawn);
}
public double calcOverdraftCharge(int daysOverdrawn) {
if (type.isPremium()) {
double result = 10;
if (daysOverdrawn > 7) {
result += (daysOverdrawn - 7) * 0.85;
}
return result;
} else {
return daysOverdrawn * 1.75;
}
}
- 搬移函数(F6)
重构后
public class Account {
private AccountType type;
private int daysOverdrawn;
public Account(AccountType type, int daysOverdrawn) {
this.type = type;
this.daysOverdrawn = daysOverdrawn;
}
public double calcOverdraftCharge() {
return type.calcOverdraftCharge(daysOverdrawn);
}
public double calcBankCharge() {
double result = 4.5;
if (daysOverdrawn > 0) {
result += calcOverdraftCharge();
}
return result;
}
}
public class AccountType {
public static final int ACCOUNT_TYPE_PREMIUM = 1;
public static final int ACCOUNT_TYPE_SENIOR = 2;
private int accountType;
public AccountType(int accountType) {
this.accountType = accountType;
}
public boolean isPremium() {
return ACCOUNT_TYPE_PREMIUM == accountType;
}
public double calcOverdraftCharge(int daysOverdrawn) {
if (isPremium()) {
double result = 10;
if (daysOverdrawn > 7) {
result += (daysOverdrawn - 7) * 0.85;
}
return result;
} else {
return daysOverdrawn * 1.75;
}
}
}
搬移字段（Move Field）
类中字段被其它类用的更多,这就像自己的老婆老往别人家跑，你说这你能受的了吗？这不让她搬出去？
技巧
和上面搬移方法一样 F6(只适用于静态字段)
沉默是今夜的康桥！
提炼类(EXtract Class)
一个类承担的过多不属于它的职责
技巧
重构后
public class Person {
private final TelephoneNumber telephoneNumber = new TelephoneNumber();
private String name;
public Person(String name, String officeAreaCode, String officeNumber) {
this.name = name;
this.telephoneNumber.officeAreaCode = officeAreaCode;
this.telephoneNumber.officeNumber = officeNumber;
}
public String getTelephoneNumber() {
return telephoneNumber.getTelephoneNumber();
}
public class TelephoneNumber {
String officeAreaCode;
String officeNumber;
public TelephoneNumber() {
}
public String getTelephoneNumber() {
return "(" + officeAreaCode + ")" + officeNumber;
}
}
}
内联类(Inline Class)
当类的职责过少时,就将改类内联到和它联系紧密的类
技巧
首先查看调用点(Alt+F7),然后重构
隐藏委托关系(Hide Delegate)
客户通过委托类来调用另一个对象,应该在服务类上直接返回客户想要的.这样的好处就是频闭了内部的实现，日后做变动时用户是无感知的
移除中间人(Remove Middle Man)
类中做了大量简单的委托，这时候应该让客户直接调用
重新组织数据
自封装字段
关于字段的访问要么直接访问，要么通过函数来间接访问.
间接访问的好处:
- 可以延迟初始化
- 子类可以动态的改变获取数据的途径
以对象取代数组
在我们公司中算法端的业务中存在大量的 return 数组，通过不同的下标来表明其含义
其实应该 用对象来取代数组
以字面常量取代魔法值
在阿里巴巴开发手册中明确要求不能出现魔法值，如果一个常量具有特殊意义那就应该创建一个常量并为其命名
以字段取代子类
你的各个子类中唯一差别只是在返回常量数据的函数上
例子
public interface Client {
PtyOsType getTtyOsType();
}
public class CmdClient implements Client{
@Override
public PtyOsType getTtyOsType() {
return PtyOsType.CMD;
}
}
public class LinuxBashClient implements Client {
@Override
public PtyOsType getTtyOsType() {
return PtyOsType.LINUX_BASH;
}
}
重够后
public abstract class Client {
public final PtyOsType PtyOsType ;
public Client(com.example.core.client.PtyOsType ptyOsType) {
PtyOsType = ptyOsType;
}
public PtyOsType getTtyOsType(){
return PtyOsType;
}
}
public class ClientFactory {
public Client getClient(PtyOsType ptyOsType) {
switch (ptyOsType) {
case CMD -> {
return SingletonClient.CMD_CLIENT.getInstance();
}
case LINUX_BASH -> {
return SingletonClient.BASH_CLIENT.getInstance();
}
default -> throw new IllegalStateException("没有该客户端");
}
}
public Client getClient(Integer id) {
return getClient(PtyOsType.getById(id));
}
public enum SingletonClient {
CMD_CLIENT(new CmdClient(PtyOsType.CMD)),BASH_CLIENT(new LinuxBashClient(PtyOsType.LINUX_BASH));
private final Client instance;
SingletonClient(Client client){
instance = client;
}
public Client getInstance(){
return instance;
}
}
}
参考
重构:改善即有代码的设计