java如何抽出大量重复代码

在Java中，抽出大量重复代码的方法包括使用方法抽取、类继承、接口、泛型和设计模式。 在这些方法中，方法抽取是最直接的方式。它通过将重复代码块提取到单独的方法中来减少代码重复。接下来，我们将详细讨论方法抽取，并介绍其他几种减少重复代码的方法。

一、方法抽取

方法抽取是最常用的减少代码重复的方法之一。通过将重复的代码块提取到一个公共方法中，可以提高代码的可读性和可维护性。

1、识别重复代码

首先，需要识别代码中重复的部分。例如，在进行数据验证、计算等操作时，通常会发现多个地方存在相同的代码。

public class Calculator {
    public int add(int a, int b) {
        // 重复代码
        if (a < 0 || b < 0) {
            throw new IllegalArgumentException("参数不能为负数");
        }
        return a + b;
    }
    public int subtract(int a, int b) {
        // 重复代码
        if (a < 0 || b < 0) {
            throw new IllegalArgumentException("参数不能为负数");
        }
        return a - b;
    }
}

2、提取公共方法

将重复的代码提取到一个单独的方法中，然后在需要的地方调用该方法。

public class Calculator {
    private void validateInput(int a, int b) {
        if (a < 0 || b < 0) {
            throw new IllegalArgumentException("参数不能为负数");
        }
    }
    public int add(int a, int b) {
        validateInput(a, b);
        return a + b;
    }
    public int subtract(int a, int b) {
        validateInput(a, b);
        return a - b;
    }
}

二、类继承

类继承是面向对象编程的一项重要特性，它允许创建一个新类，该类继承自现有类，并重用现有类的代码。

1、识别公共行为

首先，识别多个类之间的公共行为。例如，多个类可能需要实现相同的日志记录或错误处理功能。

public class Animal {
    public void eat() {
        System.out.println("吃东西");
    }
    public void sleep() {
        System.out.println("睡觉");
    }
}
public class Dog extends Animal {
    public void bark() {
        System.out.println("汪汪叫");
    }
}
public class Cat extends Animal {
    public void meow() {
        System.out.println("喵喵叫");
    }
}

2、提取公共行为

将公共行为提取到一个基类中，然后让其他类继承该基类。

public class Animal {
    public void eat() {
        System.out.println("吃东西");
    }
    public void sleep() {
        System.out.println("睡觉");
    }
}
public class Dog extends Animal {
    public void bark() {
        System.out.println("汪汪叫");
    }
}
public class Cat extends Animal {
    public void meow() {
        System.out.println("喵喵叫");
    }
}

三、接口

接口可以定义一组方法，而不实现它们。通过实现这些接口，不同的类可以提供自己的实现，从而减少代码重复。

1、定义接口

首先，定义一个接口，该接口包含需要实现的方法。

public interface Logger {
    void log(String message);
}

2、实现接口

然后，让不同的类实现这个接口，并提供自己的实现。

public class ConsoleLogger implements Logger {
    @Override
    public void log(String message) {
        System.out.println("控制台日志: " + message);
    }
}
public class FileLogger implements Logger {
    @Override
    public void log(String message) {
        // 将日志写入文件
    }
}

四、泛型

泛型允许在类和方法中使用参数化类型，从而减少代码重复。例如，可以创建一个通用的集合类，而不必为每种类型的集合创建单独的类。

1、定义泛型类

首先，定义一个泛型类，该类使用参数化类型。

public class Box<T> {
    private T value;
    public void set(T value) {
        this.value = value;
    }
    public T get() {
        return value;
    }
}

2、使用泛型类

然后，可以使用不同的类型来实例化这个泛型类。

public class Main {
    public static void main(String[] args) {
        Box<String> stringBox = new Box<>();
        stringBox.set("Hello");
        Box<Integer> intBox = new Box<>();
        intBox.set(123);
    }
}

五、设计模式

设计模式是解决软件设计中常见问题的通用解决方案。通过使用设计模式，可以减少代码重复，提高代码的可维护性和可扩展性。

1、单例模式

单例模式确保一个类只有一个实例，并提供一个全局访问点。例如，日志记录器通常使用单例模式。

public class Singleton {
    private static Singleton instance;
    private Singleton() {}
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

2、工厂模式

工厂模式提供了一种创建对象的接口，而不需要指定具体类。例如，可以使用工厂模式创建不同类型的日志记录器。

public interface Logger {
    void log(String message);
}
public class ConsoleLogger implements Logger {
    @Override
    public void log(String message) {
        System.out.println("控制台日志: " + message);
    }
}
public class FileLogger implements Logger {
    @Override
    public void log(String message) {
        // 将日志写入文件
    }
}
public class LoggerFactory {
    public static Logger getLogger(String type) {
        if (type.equalsIgnoreCase("console")) {
            return new ConsoleLogger();
        } else if (type.equalsIgnoreCase("file")) {
            return new FileLogger();
        }
        return null;
    }
}

通过上述方法，Java开发者可以有效地减少代码重复，提高代码的可读性和可维护性。每种方法都有其适用的场景，选择合适的方法可以更好地解决代码重复问题。