博文梗概：Java对Unity中二维向量类（Vector2）的模仿实现

标题：Java实现二维向量运算

核心内容：Vector2类的设计与功能

• 类结构：定义Vector2类，包含x和y两个公共字段表示二维坐标。

class Vector2
{
    //基本属性
	public double x;
	public double y;
    //......//
	
}

• 构造函数：

  • 有参构造：直接初始化x和y的值。
  • 无参构造：默认初始化为(0, 0)。

class Vector2
{
    //......//
	//构造函数；
	Vector2(double x,double y)//有参：赋值；
	{
		this.x=x;
		this.y=y;
	}
	Vector2()//无参：默认0；
	{
		x=0;
		y=0;
	}
    //......//
}

• 字符串表示：重写toString()方法，输出格式为(x, y)。

class Vector2
{
    //......//
	//输出显示；
	public String toString()
	{
		return "( "+x+" , "+y+" )";
	}
    //......//
}
	

向量基础运算方法

加法运算
Add(Vector2 v)：实现向量逐分量相加，返回修改后的当前对象。

class Vector2
{
	//......//
	//向量加法运算
	public Vector2 Add(Vector2 v)
	{
		x=x+v.x;
		y=y+v.y;
		return this;
	}
	//......
}

减法运算
Sub(Vector2 v)：实现向量逐分量相减，返回修改后的当前对象。

class Vector2
{
	//......//
	//减法运算
	public Vector2 Sub(Vector2 v)
	{
		x=x-v.x;
		y=y-v.y;
		return this;
	}
	//......//
}

倍乘运算
Mux(double n)：向量与标量相乘，实现缩放功能。

class Vector2
{
	//......//
	//倍乘（常数）
	public Vector2 Mux(double n)
	{
		x=x*n;
		y=y*n;
		return this;
	}
	//......//
}

点积运算
Dot(Vector2 v)：计算两个向量的点积（内积），返回标量结果。

class Vector2
{
	//......//
	//点乘（向量）
	public double Dot(Vector2 v)
	{
		return x*v.x+y*v.y;
	}
	//......//
}

向量模长
Lenth()：通过欧几里得公式计算向量长度（模）。

class Vector2
{
	//......//
	//取大小；
	public double Lenth()
	{
		return Math.sqrt(x*x+y*y);
	}
	//......//
}

归一化
Normalize()：返回单位向量（模为1的方向向量），零向量处理为返回(0, 0)。

class Vector2
{
	//.......//
	//取模向量
	public Vector2 Normalize()
	{
		if(Lenth()==0) return new Vector2();
		return new Vector2(x/Lenth(),y/Lenth());
	}
	//......//
}

角度计算功能

• 向量间夹角

         Angel(Vector2 v)：通过点积公式计算两向量夹角（弧度），零向量返回0。

• 与x轴夹角

        Angel()：计算向量与x轴的夹角（弧度），用于方向判断。

class Vector2
{
    //......//
	//有参：对v取夹角
	public double Angel(Vector2 v)
	{
		if(Lenth()==0||v.Lenth()==0) return 0;
		return Math.acos((x*v.x+y*v.y)/(Lenth()*v.Lenth()));
	}
	//无参：对x轴取角度
	public double Angel()
	{
		
		if(Lenth()==0) return 0;
		return Math.acos(x/Lenth());
	}
}

测试内容

• 编写App类测试Vector2功能：

class App {
	public static void main(String[] args) {
		System.out.println("=== Vector2 类功能测试 ===\n");

		// 测试构造函数和toString方法
		System.out.println("1. 测试构造函数和toString方法:");
		Vector2 v1 = new Vector2();
		Vector2 v2 = new Vector2(3.0, 4.0);
		Vector2 v3 = new Vector2(-2.5, 7.1);
		
		System.out.println("无参构造函数: " + v1.toString());
		System.out.println("有参构造函数(3,4): " + v2.toString());
		System.out.println("有参构造函数(-2.5,7.1): " + v3.toString());
		
		// 测试向量加法
		System.out.println("\n2. 测试向量加法:");
		Vector2 v4 = new Vector2(2.0, 3.0);
		Vector2 v5 = new Vector2(1.5, -2.0);
		Vector2 addResult = new Vector2(v4.x, v4.y).Add(v5);
		System.out.println(v4 + " + " + v5 + " = " + addResult);
		
		// 测试向量减法
		System.out.println("\n3. 测试向量减法:");
		Vector2 v6 = new Vector2(5.0, 8.0);
		Vector2 v7 = new Vector2(2.0, 3.0);
		Vector2 subResult = new Vector2(v6.x, v6.y).Sub(v7);
		System.out.println(v6 + " - " + v7 + " = " + subResult);
		
		// 测试向量倍乘
		System.out.println("\n4. 测试向量倍乘:");
		Vector2 v8 = new Vector2(2.0, -3.0);
		double scalar = 2.5;
		Vector2 muxResult = new Vector2(v8.x, v8.y).Mux(scalar);
		System.out.println(v8 + " * " + scalar + " = " + muxResult);
		
		// 测试点乘运算
		System.out.println("\n5. 测试点乘运算:");
		Vector2 v9 = new Vector2(2.0, 3.0);
		Vector2 v10 = new Vector2(4.0, 1.0);
		double dotResult = v9.Dot(v10);
		System.out.println(v9 + " · " + v10 + " = " + dotResult);
		
		// 测试向量长度计算
		System.out.println("\n6. 测试向量长度计算:");
		Vector2 v11 = new Vector2(3.0, 4.0);
		Vector2 v12 = new Vector2(1.0, 1.0);
		System.out.println("向量 " + v11 + " 的长度 = " + v11.Lenth());
		System.out.println("向量 " + v12 + " 的长度 = " + v12.Lenth());
		
		// 测试向量归一化
		System.out.println("\n7. 测试向量归一化:");
		Vector2 v13 = new Vector2(3.0, 4.0);
		Vector2 v14 = new Vector2(1.0, 2.0);
		System.out.println("向量 " + v13 + " 的归一化 = " + v13.Normalize());
		System.out.println("向量 " + v14 + " 的归一化 = " + v14.Normalize());
		
		// 测试向量夹角计算
		System.out.println("\n8. 测试向量夹角计算:");
		Vector2 v15 = new Vector2(1.0, 0.0);
		Vector2 v16 = new Vector2(0.0, 1.0);
		Vector2 v17 = new Vector2(1.0, 1.0);
		System.out.println("向量 " + v15 + " 和 " + v16 + " 的夹角 = " + Math.toDegrees(v15.Angel(v16)) + " 度");
		System.out.println("向量 " + v15 + " 和 " + v17 + " 的夹角 = " + Math.toDegrees(v15.Angel(v17)) + " 度");
		
		// 测试与X轴夹角计算
		System.out.println("\n9. 测试与X轴夹角计算:");
		Vector2 v18 = new Vector2(1.0, 0.0);
		Vector2 v19 = new Vector2(0.0, 1.0);
		Vector2 v20 = new Vector2(1.0, 1.0);
		System.out.println("向量 " + v18 + " 与X轴的夹角 = " + Math.toDegrees(v18.Angel()) + " 度");
		System.out.println("向量 " + v19 + " 与X轴的夹角 = " + Math.toDegrees(v19.Angel()) + " 度");
		System.out.println("向量 " + v20 + " 与X轴的夹角 = " + Math.toDegrees(v20.Angel()) + " 度");
		
		System.out.println("\n=== 测试完成 ===");
	}
}

测试结果：

>java App

=== Vector2 类功能测试 ===

1. 测试构造函数和toString方法:
无参构造函数: ( 0.0 , 0.0 )
有参构造函数(3,4): ( 3.0 , 4.0 )
有参构造函数(-2.5,7.1): ( -2.5 , 7.1 )

2. 测试向量加法:
( 2.0 , 3.0 ) + ( 1.5 , -2.0 ) = ( 3.5 , 1.0 )

3. 测试向量减法:
( 5.0 , 8.0 ) - ( 2.0 , 3.0 ) = ( 3.0 , 5.0 )

4. 测试向量倍乘:
( 2.0 , -3.0 ) * 2.5 = ( 5.0 , -7.5 )

5. 测试点乘运算:
( 2.0 , 3.0 ) · ( 4.0 , 1.0 ) = 11.0

6. 测试向量长度计算:
向量 ( 3.0 , 4.0 ) 的长度 = 5.0
向量 ( 1.0 , 1.0 ) 的长度 = 1.4142135623730951

7. 测试向量归一化:
向量 ( 3.0 , 4.0 ) 的归一化 = ( 0.6 , 0.8 )
向量 ( 1.0 , 2.0 ) 的归一化 = ( 0.4472135954999579 , 0.8944271909999159 )

8. 测试向量夹角计算:
向量 ( 1.0 , 0.0 ) 和 ( 0.0 , 1.0 ) 的夹角 = 90.0 度
向量 ( 1.0 , 0.0 ) 和 ( 1.0 , 1.0 ) 的夹角 = 45.00000000000001 度

9. 测试与X轴夹角计算:
向量 ( 1.0 , 0.0 ) 与X轴的夹角 = 0.0 度
向量 ( 0.0 , 1.0 ) 与X轴的夹角 = 90.0 度
向量 ( 1.0 , 1.0 ) 与X轴的夹角 = 45.00000000000001 度

=== 测试完成 ===