运用桥梁模式重构螺旋矩阵算法

最近的文章中，我们详细探讨了‘内部螺旋矩阵算法’的具体实现，并对其面向对象编程中的可扩展性进行了分析。在此基础上，本文通过应用桥梁设计模式，对原有的代码进行了重构，旨在提高代码的灵活性和可维护性。

以下是重构后的代码示例：

package com.helixalgo;
class Coordinate {
	public int x, y;

	public Coordinate(int x, int y) {
		this.x = x;
		this.y = y;
	}

	public int getX() { return x; }
	public void setX(int x) { this.x = x; }
	public int getY() { return y; }
	public void setY(int y) { this.y = y; }
}

interface SpiralDirection {
	Coordinate getNextPosition(Coordinate current);
}

abstract class AbstractSpiral implements SpiralDirection {
	protected Coordinate startPosition;
	protected Coordinate currentPosition;
	protected int size;

	public void setSize(int size) {
		this.size = size;
		resetPosition();
	}

	private void resetPosition() {
		if (startPosition != null && size > 0) {
			currentPosition = new Coordinate(startPosition.getX(), startPosition.getY());
		}
	}

	public void setStartPosition(Coordinate startPosition) {
		this.startPosition = startPosition;
		resetPosition();
	}
}

/**
 * 顺时针螺旋实现
 */
class ClockwiseSpiral extends AbstractSpiral {
	@Override
	public Coordinate getNextPosition(Coordinate current) {
		// 实现逻辑...
		return current;
	}
}

/**
 * 逆时针螺旋实现
 */
class CounterClockwiseSpiral extends AbstractSpiral {
	@Override
	public Coordinate getNextPosition(Coordinate current) {
		// 实现逻辑...
		return current;
	}
}

/**
 * 螺旋起始位置接口
 */
interface StartPoint {
	Coordinate getStart(int size);
}

/**
 * 左上角起始位置实现
 */
class TopLeftPoint implements StartPoint {
	@Override
	public Coordinate getStart(int size) {
		return new Coordinate(0, 0);
	}
}

/**
 * 右上角起始位置实现
 */
class TopRightPoint implements StartPoint {
	@Override
	public Coordinate getStart(int size) {
		return new Coordinate(0, size - 1);
	}
}

/**
 * 左下角起始位置实现
 */
class BottomLeftPoint implements StartPoint {
	@Override
	public Coordinate getStart(int size) {
		return new Coordinate(size - 1, 0);
	}
}

/**
 * 右下角起始位置实现
 */
class BottomRightPoint implements StartPoint {
	@Override
	public Coordinate getStart(int size) {
		return new Coordinate(size - 1, size - 1);
	}
}

public class SpiralMatrix {
	public void display(SpiralDirection direction, int initialValue, int increment) {
		int size = direction.getSize();
		if (size <= 0) {
			System.out.println("请输入大于0的整数！");
			return;
		}
		int[][] matrix = generateMatrix(direction, initialValue, increment);
		for (int[] row : matrix) {
			for (int value : row) {
				System.out.print(value + "\t");
			}
			System.out.println();
		}
	}

	private int[][] generateMatrix(SpiralDirection direction, int initialValue, int increment) {
		int size = direction.getSize();
		int[][] matrix = new int[size][size];
		int value = initialValue;
		for (int i = 0; i 			Coordinate position = direction.getNextPosition(direction.getCurrentPosition());
			matrix[position.getX()][position.getY()] = value;
			value += increment;
		}
		return matrix;
	}

	public static void main(String[] args) {
		SpiralMatrix matrixGenerator = new SpiralMatrix();
		int size = 5;
		SpiralDirection clockwise = new ClockwiseSpiral();
		SpiralDirection counterClockwise = new CounterClockwiseSpiral();

		clockwise.setSize(size);
		counterClockwise.setSize(size);

		System.out.println("\n左上角开始顺时针内旋(长度" + size + ")：");
		clockwise.setStartPosition(new TopLeftPoint().getStart(size));
		matrixGenerator.display(clockwise, 1, 1);

		System.out.println("\n右上角开始顺时针内旋(长度" + size + ")：");
		clockwise.setStartPosition(new TopRightPoint().getStart(size));
		matrixGenerator.display(clockwise, 1, 1);

		System.out.println("\n右下角开始顺时针内旋(长度" + size + ")：");
		clockwise.setStartPosition(new BottomRightPoint().getStart(size));
		matrixGenerator.display(clockwise, 1, 1);

		System.out.println("\n左下角开始顺时针内旋(长度" + size + ")：");
		clockwise.setStartPosition(new BottomLeftPoint().getStart(size));
		matrixGenerator.display(clockwise, 1, 1);

		System.out.println("\n左上角开始逆时针内旋(长度" + size + ")：");
		counterClockwise.setStartPosition(new TopLeftPoint().getStart(size));
		matrixGenerator.display(counterClockwise, 1, 1);

		System.out.println("\n右上角开始逆时针内旋(长度" + size + ")：");
		counterClockwise.setStartPosition(new TopRightPoint().getStart(size));
		matrixGenerator.display(counterClockwise, 1, 1);

		System.out.println("\n右下角开始逆时针内旋(长度" + size + ")：");
		counterClockwise.setStartPosition(new BottomRightPoint().getStart(size));
		matrixGenerator.display(counterClockwise, 1, 1);

		System.out.println("\n左下角开始逆时针内旋(长度" + size + ")：");
		counterClockwise.setStartPosition(new BottomLeftPoint().getStart(size));
		matrixGenerator.display(counterClockwise, 1, 1);

		System.out.println("\n中心点开始顺时针外旋(长度" + size + ")：");
		clockwise.setStartPosition(new TopLeftPoint().getStart(size));
		matrixGenerator.display(clockwise, size * size, -1);

		System.out.println("\n中心点开始逆时针外旋(长度" + size + ")：");
		counterClockwise.setStartPosition(new TopLeftPoint().getStart(size));
		matrixGenerator.display(counterClockwise, size * size, -1);
	}
}

关于螺旋矩阵的解决思路，本文不再赘述。感兴趣的读者可以查阅之前的文章《内螺旋矩阵算法分析》。本文的重点在于阐述为什么选择使用桥梁模式进行代码重构。

螺旋矩阵的主要变量包括：矩阵的阶数（即边长）、起始位置以及螺旋方向（顺时针或逆时针）。其中，起始位置在之前的讨论中已明确，合法的起始位置仅限于矩阵的四个角落，其他位置可能导致算法陷入死循环。

为了提高程序的灵活性，这三个变量应当能够独立变化。矩阵的阶数作为简单的整数值，其变化较为直接；而起始位置和螺旋方向则可以通过不同的接口进行封装，如上述代码中的‘StartPoint’接口和‘AbstractSpiral’抽象类。通过这种方式，可以确保这两个变量能够独立地变化，从而实现了使用桥梁模式的目的——将抽象部分与其实现部分分离，使它们可以独立变化。

以上代码可以直接运行，复制到开发环境中即可测试效果。若有任何疑问或建议，欢迎交流讨论。