在软件开发的舞台上，重构是一场不断进化的演变。为了优化、提升代码的质量，我们需要掌握各种重构的细致技法。以下是书中本章详细介绍的重构手法，它们为我们提供了一系列实践的方法，助力代码保持清晰、可读、可维护。
函数组合成类（Form Template Method）： 多个函数具有相似的结构，可以将这些函数组合成一个类的方法，将原函数变为类的实例方法，以提高代码的可读性和维护性。
public class OrderProcessing {
public double calculateTotal(List<Item> items) {
// Calculate total logic
return 0.0;
}
public double applyDiscount(double total) {
// Apply discount logic
return 0.0;
}
}
函数移动（Move Method）： 当一个方法对另一个类的特性更感兴趣时，将该方法移到它所关心的类中，让这个类成为新方法的主体，以增强代码的内聚性。
public class Account {
public double overdraftCharge() {
// Overdraft charge logic
return 0.0;
}
}
public class AccountType {
public double overdraftCharge() {
// Overdraft charge logic moved to AccountType
return 0.0;
}
}
字段移动（Move Field）： 将字段移到其所关联的类中，以确保数据与其行为更为紧密地关联在一起，提高代码的一致性和可理解性。
public class Customer {
private String name;
}
public class Address {
private String city;
private String state;
}
// Move 'city' and 'state' fields from Customer to Address
提炼子类（Extract Subclass）： 当一个类的一部分特性与其他部分不够相关时，可以创建一个新的子类，将相关的特性移入子类，以提高代码的清晰度和可维护性。
public class JobPosition {
private String title;
private double salary;
// Constructors and methods
}
public class ManagerPosition extends JobPosition {
private double bonus;
// Constructors and methods
}
提炼超类（Extract Superclass）： 当两个类有相似的特性时，可以创建一个新的超类，将相似的特性移到超类中，以避免重复的代码，提高代码的重用性。
public class Bird {
private String name;
// Constructors and methods
}
public class Sparrow extends Bird {
// Additional attributes and methods specific to Sparrow
}
以委托取代继承（Replace Inheritance with Delegation）： 当子类仅仅使用父类的一部分功能时，可以使用委托，将子类中的方法调用委托给另一个拥有这部分功能的类，以减少类之间的耦合性。
public class Printer {
public void print(String content) {
// Print content logic
}
}
public class Document {
private Printer printer;
public void printDocument(String content) {
printer.print(content);
}
}
以委托取代子类（Replace Subclass with Delegation）： 类似于上一个手法，但这次是替代整个子类而不是部分功能，通过委托来替代继承关系。
public interface Engine {
void start();
}
public class CarEngine implements Engine {
@Override
public void start() {
// Car engine start logic
}
}
public class BoatEngine implements Engine {
private final CarEngine carEngine;
public BoatEngine(CarEngine carEngine) {
this.carEngine = carEngine;
}
@Override
public void start() {
// Delegating to CarEngine
carEngine.start();
}
}
引入本地扩展（Introduce Local Extension）： 当需要为某个类添加新功能时，可以创建一个新的子类或者使用委托来进行扩展，以避免修改原始类的代码。
public class DateUtils {
public static Date addDaysToDate(Date date, int days) {
// Add days to date logic
return new Date();
}
}
// Client code
Date newDate = DateUtils.addDaysToDate(oldDate, 5);
引入外加函数（Introduce Foreign Method）： 当无法修改某个类的代码时，可以通过创建一个新的类，然后在这个类中添加需要的方法，以实现对原始类的扩展。
public class StringUtils {
public static String reverse(String input) {
// Reverse string logic
return new StringBuilder(input).reverse().toString();
}
}
// Client code
String reversed = StringUtils.reverse("hello");
引入本地代码（Introduce Local Procedure）： 类似于引入本地扩展，但这里是引入本地的一段代码，将一些逻辑局部化，以提高代码的清晰度。
public class Calculator {
public int add(int a, int b) {
// Addition logic
return a + b;
}
}
// Client code
Calculator calculator = new Calculator();
int result = calculator.add(5, 3);
移除设置函数（Remove Setting Method）： 移除一些不必要的设置函数，以确保对象的状态在创建后不可更改，提高代码的可靠性。
public class ImmutablePerson {
private final String name;
public ImmutablePerson(String name) {
this.name = name;
}
// Removed setting method
}
// Client code
ImmutablePerson person = new ImmutablePerson("John");
隐藏委托关系（Hide Delegate）： 当一个类委托给另一个类的时候，通过在调用端隐藏委托关系，以降低类之间的耦合度。
public class Department {
private final Employee supervisor;
public Department(Employee supervisor) {
this.supervisor = supervisor;
}
// Hide delegate
public String getSupervisorName() {
return supervisor.getName();
}
}
public class Employee {
private String name;
public Employee(String name) {
this.name = name;
}
public String getName() {
return name;
}
}
移除中间人（Remove Middle Man）： 当一个类只是委托了另一个类的所有方法时，可以移除中间人，直接调用最终的类的方法，以简化代码结构。
public class Manager {
private final Employee employee;
public Manager(Employee employee) {
this.employee = employee;
}
// Remove middle man
public String getEmployeeName() {
return employee.getName();
}
}
// Client code
Employee employee = new Employee("Alice");
Manager manager = new Manager(employee);
String employeeName = manager.getEmployeeName();
替换算法（Replace Algorithm）： 当一个算法不再适用或者需要替换时，可以通过引入新的算法来替代原有的算法，以提高代码的灵活性。
public interface SortingAlgorithm {
int[] sort(int[] array);
}
public class BubbleSort implements SortingAlgorithm {
@Override
public int[] sort(int[] array) {
// Bubble sort logic
return array;
}
}
// Client code
SortingAlgorithm sortingAlgorithm = new BubbleSort();
int[] sortedArray = sortingAlgorithm.sort(new int[]{3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5});
解除混淆（Decompose Conditional）： 当一个条件表达式过于复杂时，可以将其拆分为多个较简单的条件，以提高代码的可读性和理解性。
public class LoanApproval {
public boolean isLoanApproved(double creditScore, double income) {
// Decompose conditional
return hasGoodCredit(creditScore) && hasSufficientIncome(income);
}
private boolean hasGoodCredit(double creditScore) {
// Check credit score logic
return creditScore > 700;
}
private boolean hasSufficientIncome(double income) {
// Check income logic
return income > 50000;
}
}
合并条件表达式（Consolidate Conditional Expression）： 当多个条件表达式具有相同的结果时，可以将它们合并为一个条件表达式，以简化代码结构。
public class DiscountCalculator {
public double calculateDiscount(double totalAmount, int loyaltyPoints) {
// Consolidate conditional expression
if (totalAmount > 100 && loyaltyPoints > 50) {
return totalAmount * 0.2;
} else {
return 0;
}
}
}
合并重复的条件片段（Consolidate Duplicate Conditional Fragments）： 当代码中存在相同的条件逻辑时，可以将重复的条件逻辑合并为一个条件，以减少重复代码。
public class ReportGenerator {
public void generateReport(boolean isWeekend) {
// Consolidate duplicate conditional fragments
if (isWeekend) {
performWeekendLogic();
} else {
performWeekdayLogic();
}
}
private void performWeekendLogic() {
// Weekend logic
}
private void performWeekdayLogic() {
// Weekday logic
}
}
提炼条件表达式（Extract Conditional Expression）： 将复杂的条件表达式提炼成一个单独的函数或方法，以提高代码的可读性和可维护性。
public class TemperatureChecker {
public String checkTemperature(int temperature) {
// Extract conditional expression
return isHighTemperature(temperature) ? "Too hot" : "Comfortable";
}
private boolean isHighTemperature(int temperature) {
// Check high temperature logic
return temperature > 30;
}
}
合并异常（Consolidate Duplicate Conditional Fragments）： 当多个异常处理块具有相同的代码时，可以将它们合并为一个异常处理块，以减少重复代码。
public class ErrorHandler {
public void handleException(Exception exception) {
// Consolidate duplicate conditional fragments
if (exception instanceof IOException) {
logIOException((IOException) exception);
} else if (exception instanceof SQLException) {
logSQLException((SQLException) exception);
}
}
private void logIOException(IOException ioException) {
// Log IOException
}
private void logSQLException(SQLException sqlException) {
// Log SQLException
}
}
引入断言（Introduce Assertion）： 在代码中引入断言，以确保程序在运行时的某个时刻满足某个条件，有助于提高代码的健壮性。
public class AgeValidator {
public boolean isValidAge(int age) {
// Introduce assertion
assert age >= 0 : "Age should be non-negative";
return age >= 18 && age <= 65;
}
}
分解临时变量（Split Temporary Variable）： 当一个临时变量被赋值多次，可以将其拆分为多个临时变量，每个变量只负责一次赋值。
public class CircleCalculator {
public double calculateCircleArea(double radius) {
// Split temporary variable
double circumference = 2 * Math.PI * radius;
double area = Math.PI * Math.pow(radius, 2);
return area;
}
}
移除对参数的赋值（Remove Assignment to Parameter）： 当参数被函数内部赋值时，可以考虑移除这种赋值，以提高代码的清晰度。
public class ParameterModifier {
public void modifyParameter(int[] numbers) {
// Remove assignment to parameter
for (int i = 0; i < numbers.length; i++) {
numbers[i] = numbers[i] * 2;
}
}
}
以查询取代临时变量（Replace Temp with Query）： 当一个临时变量的值是通过函数调用获取的，可以将其替换为函数调用，以减少临时变量的使用。
public class PriceCalculator {
private double basePrice;
private double discount;
public double calculateFinalPrice() {
// Replace temp with query
return getBasePrice() * (1 - getDiscount());
}
private double getBasePrice() {
// Get base price logic
return basePrice;
}
private double getDiscount() {
// Get discount logic
return discount;
}
}
以函数对象取代函数（Replace Function with Function Pointer）： 当需要在运行时选择不同的函数时，可以引入函数对象，以提高代码的灵活性。
public interface MathOperation {
int operate(int a, int b);
}
public class Addition implements MathOperation {
@Override
public int operate(int a, int b) {
return a + b;
}
}
// Client code
MathOperation addition = new Addition();
int result = addition.operate(5, 3);
拆分循环（Split Loop）： 当一个循环中处理多个逻辑时，可以拆分为多个循环，使每个循环只负责一种逻辑，提高代码的可读性。
public class NumberProcessor {
public void processNumbers(int[] numbers) {
// Split loop
for (int number : numbers) {
processEvenNumber(number);
}
for (int number : numbers) {
processOddNumber(number);
}
}
private void processEvenNumber(int number) {
// Process even number logic
}
private void processOddNumber(int number) {
// Process odd number logic
}
}
以管道取代循环（Replace Loop with Pipeline）： 当循环中的每一步都是独立的时，可以使用管道操作来替代循环，提高代码的简洁性。
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class StringProcessor {
public List<String> processStrings(List<String> strings) {
// Replace loop with pipeline
return strings.stream()
.map(String::toUpperCase)
.collect(Collectors.toList());
}
}
以递归取代循环（Replace Loop with Recursion）： 当循环的逻辑可以通过递归来实现时，可以将循环替换为递归，以简化代码。
public class FactorialCalculator {
public int calculateFactorial(int n) {
// Replace loop with recursion
if (n <= 1) {
return 1;
} else {
return n * calculateFactorial(n - 1);
}
}
}
以迭代器取代循环（Replace Loop with Iterator）： 当循环中涉及到集合的遍历时，可以使用迭代器来替代循环，提高代码的可读性。
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class ListProcessor {
public void processList(List<String> strings) {
// Replace loop with iterator
Iterator<String> iterator = strings.iterator();
while (iterator.hasNext()) {
String current = iterator.next();
processString(current);
}
}
private void processString(String string) {
// Process string logic
}
}
拆分阶段（Split Phase）： 当一个函数负责两个不同阶段的逻辑时，可以拆分为两个函数，每个函数负责一个阶段的逻辑，以提高代码的模块化程度。
public class PaymentProcessor {
public void processPayment(String paymentMethod, double amount) {
// Split phase
if ("CreditCard".equals(paymentMethod)) {
processCreditCardPayment(amount);
} else if ("PayPal".equals(paymentMethod)) {
processPayPalPayment(amount);
}
}
private void processCreditCardPayment(double amount) {
// Process credit card payment logic
}
private void processPayPalPayment(double amount) {
// Process PayPal payment logic
}
}
移除死代码（Remove Dead Code）： 移除不再被调用或者无用的代码，以减少代码库的冗余，提高代码的维护性。
public class DeadCodeRemover {
public void process() {
// Remove dead code
int result = calculateResult(5, 3);
System.out.println(result);
}
private int calculateResult(int a, int b) {
// Dead code
return a * b;
}
}
每个手法都有其特定的应用场景，我们可以根据实际情况选择合适的手法进行应用~~~~~太多了，就当笔记吧，散会