vector2d.java

这是自己设计的一款java泡泡游戏。 这是自己设计的一款java泡泡游戏。这是自己设计的一款java泡泡游戏

package like.graphics;
/**Vectro2D类是一个描述矢量的抽象类，包含两个实现了抽象方法<br>
 *的内置类Double,Integer.该类包含一些矢量的基本操作,有矢量<br>
 *相加,相减,判断是否相等,矢量正规化为单位长,缩放和平移及求<br>
 *大小等.有三中方法创建对象:<br>
 *		Vector2D v;<br>
 *		v = new Vector2D.Double(10.2,20.6);<br>
 *		v = new Vector2D.Integer(10,20);<br>
 *		v = Vector2D.ZERO_VECTORD<br>
 */
 
public abstract class Vector2D
{
	/**创建静态矢量ZERO_VECTOR,x=y=0.0<br>
	 */
	public static final Vector2D.Double ZERO_VECTOR = new Vector2D.Double(0,0);
	
	/**Vector2D的内部类,坐标点用double型表示<br>
	 */
	public static class Double extends Vector2D
	{
		public double x;
		public double y;
		
		public Double()
		{
			this(0.0,0.0);
		}
		
		public Double(double m,double n)
		{
			setX(m);
			setY(n);
		}
		
		private Double(int m,int n)
		{
			setX((double)m);
			setY((double)n);
		}
		
		public final void setX(double m)
		{
			x = m;
		}
		
		public final void setY(double n)
		{
			y = n;
		}
		
		public final double getX()
		{
			return x;
		}
		
		public final double getY()
		{
			return y;
		}
		
		public Vector2D plus(Vector2D v)
		{
			return new Double( getX()+v.getX(),getY()+v.getY());
		}
		
		public Vector2D minus(Vector2D v)
		{
			return new Double( getX()-v.getX(),getY()-v.getY());
		}
			
	}//Double
	
	/**Vector2D的内部类,坐标点用int型表示<br>
	 */
	public static class Integer extends Vector2D
	{
		public int x;
		public int y;
		
		public Integer()
		{
			this(0,0);
		}
		
		public Integer(int m,int n)
		{
			setX(m);
			setY(n);
		}
		
		private Integer(double m,double n)
		{
			setX((int)m);
			setY((int)n);
		}
		
		public final void setX(int m)
		{
			x = m;
		}
				
		public final void setY(int n)
		{
			y = n;
		}
		
		public final void setX(double m)
		{
			x = (int)m;
		}
		
		public final void setY(double n)
		{
			y = (int)n;
		}
		
		public final double getX()
		{
			return (double)x;
		}
		
		public final double getY()
		{
			return (double)y;
		}
		
		public Vector2D plus(Vector2D v)
		{
			return new Integer( getX()+v.getX(),getY()+v.getY());
		}
		
		public Vector2D minus(Vector2D v)
		{
			return new Integer( getX()-v.getX(),getY()-v.getY());
		}
		
	}//Integer
	
	protected Vector2D()
	{
	}
	
	
	public abstract void setX(double n);

	public abstract void setY(double n);

	public abstract double getX();

	public abstract double getY();
	
	/**矢量相加
	 */
	public abstract Vector2D plus(Vector2D v);
	
	/**矢量相减
	 */
	public abstract Vector2D minus(Vector2D v);
	
	/**判断两个矢量是否相等
	 */
	public boolean equals(Vector2D other)
	{
		return (getX() == other.getX()&&getY() == other.getY());
	}
	
	/**矢量正规化
	 */
	public void normalize()
	{
		double len = length();
		if(len == 0)
			return;
		setX(getX()/len);
		setY(getY()/len);
	}
	
	public void scale(double k)
	{
		setX(k*getX());
		setY(k*getY());
	}
	
	/**平移----用给定的double值平移
	 */
	public void translate( double dx,double dy )
	{
		setX(getX() + dx);
		setY(getY() + dy);
	}
	
	/**平移----用给定的Vector2D值平移
	 */
	public void translate(Vector2D v)
	{
		setX(getX() + v.getX());
		setY(getY() + v.getY());
	}
	
	/**矢量点乘
	 */
	public double dot(Vector2D v)
	{
		return getX()*v.getX() + getY()*v.getY();
	}
	
	/**矢量长度
	 */
	public double length()
	{
		return Math.sqrt(this.dot(this));
	}
	
	/**返回矢量信息
	 */
	public String toString()
	{
		return getClass().getName() + " {x=" +getX()+ ",y=" +getY() +"]";
	}
		
}//Vector2D