public void handleKeyboardInput(int ki){
      if(ki == KeyEvent.VK_SPACE){
         Point2D intersectionPoint = lineIntersectionTest();
         if(intersectionPoint != null){
            System.out.println(intersectionPoint.X + "\n" + intersectionPoint.Y);
            endPoint.X = intersectionPoint.X;
            endPoint.Z = intersectionPoint.Y;
            //Now I have the points of collision on the line
         }
         
      }
   }

   public Point2D lineIntersectionTest(){
      double intersectionX, intersectionY;
      Point2D Line1P1 = ballBehavior;
      Point2D Line1P2 = ballBehavior.movePointForward(10f);
      
      Point2D Line2P1 = new Point2D(wall.X - (wall.Width/2), wall.Z - (wall.Depth/2));
      Point2D Line2P2 = new Point2D(wall.X + (wall.Width/2), wall.Z - (wall.Depth/2));
      
      double denominator, numeratorA, numeratorB, r, s;

      denominator =  ( ( Line2P2.Y - Line2P1.Y ) * ( Line1P2.X - Line1P1.X ) ) -
                  ( ( Line2P2.X - Line2P1.X ) * ( Line1P2.Y - Line1P1.Y ) );
   
      //if(denominator != 0){ //check for parrellel lines
      numeratorA = ( ( Line2P2.X - Line2P1.X) * (Line1P1.Y - Line2P1.Y ) ) -
                ( ( Line2P2.Y - Line2P1.Y) * (Line1P1.X - Line2P1.X ) );

      numeratorB = ( (Line1P2.X - Line1P1.X ) * ( Line1P1.Y - Line2P1.Y) ) -
                ( (Line1P2.Y - Line1P1.Y ) * ( Line1P1.X - Line2P1.X) );

      r = ( numeratorA / denominator ) ;
       s = ( numeratorB / denominator ) ;

       if(r >= 0.0f && r <= 1.0f  &&
          s >= 0.0f && s <= 1.0f){
          intersectionX = r * (Line1P2.X - Line1P1.X) + Line1P1.X;
           intersectionY = r * (Line1P2.Y  - Line1P1.Y) + Line1P1.Y;
           return new Point2D((float) intersectionX, (float) intersectionY);
       }
       
       return new Point2D();
   }

public class Point2D {
   public float X = 0f, Y = 0f;//Point Locations
   public float angle = 0f;//Point Rotations
      
   public Point2D(float x, float y){X = x; Y = y;}
      
   public Point2D(float x, float y, float angleIn)
      {X = x; Y = y; angle = angleIn;}
      
   public Point2D(){};
      
   public Point2D movePointForward(float distance){
      Point2D newPoint = new Point2D();
      double tmpAngle = Math.toRadians(angle);
      newPoint.X = (float)(Math.cos(tmpAngle) * distance) + X;
      newPoint.Y = (float)(Math.sin(tmpAngle) * distance) + Y;
      newPoint.angle = angle;
      return newPoint;
   }
   
   public static float dotProduct(Point2D A, Point2D B) {                       
        return A.X * B.X + A.Y * B.Y;
    }

    public float magnitude() {
        return (float) Math.sqrt(X * X + Y * Y); 
    }

    public void normalize() {
        float M = magnitude();
        if (M > 0f || M < 0f) {
            X /= M;
            Y /= M;
        }
    }
   
   
   public void wrapAngle(){angle = wrapValue(angle, 360.0f);}
   
   public float wrapValue(float in, float max){return in % max;}
}

if(intersectionPoint.X != 0f && intersectionPoint.Y != 0f){//If Lines Intersect
      //Start point of Wall line
      Vector2D collisionV1 = new Vector2D(wall.X - (wall.Width/2), wall.Z - (wall.Depth/2));
      //End point of Wall line
      Vector2D collisionV2 = new Vector2D(wall.X + (wall.Width/2), wall.Z - (wall.Depth/2));
      //Subtract the two wall vectors
      Vector2D surfaceVector = collisionV2.sub(collisionV1);
      //Normalize the two wall vectors
      surfaceVector = surfaceVector.normalize();
            
      //Get the Normal 
      Vector2D normal = new Vector2D( surfaceVector.Y, -surfaceVector.X);
            
      //Start point of intersecting line
      Vector2D velocityVector1 = ballBehavior.toVector2D();
      //End Point of the intersecting line
      Vector2D velocityVector2 = ballBehavior.movePointForward(10f).toVector2D();
            
      float vectorX = surfaceVector.dotProduct(surfaceVector, velocityVector1);
      float vectorY = surfaceVector.dotProduct(normal, velocityVector2);
      //Make the VectorY negative as to "flip" the collision
      vectorY =  -vectorY;
            
      Vector2D bouncedVector = surfaceVector.mul(vectorX).add(normal.mul(vectorY));
            
      //Place on Object on the Point of the reflection
      reflect = new Point2D(bouncedVector.X, bouncedVector.Y);
   }

public class Vector2D {
    public float X = 0.0f, Y = 0.0f;

    public Vector2D() {}
    public Vector2D( float x, float y ) { X = x; Y = y; }
    public Vector2D( Vector2D a ) { X = a.X; Y = a.Y; }
    
    public float length() {
        return (float) Math.sqrt( (X * X) + (Y * Y) );
    }

    public Vector2D normalize(){
        float len = length();
        if (len > 0f || len < 0f) {
            X /= len;
            Y /= len;
        }
        return new Vector2D(X, Y);
    }
    
    public float dotProduct( Vector2D A, Vector2D B) {                       
        return (A.X * B.X) + (A.Y * B.Y);
    }

    public Vector2D add( Vector2D a ) {
        X += a.X;
        Y += a.Y;
        return new Vector2D(X, Y);
    }
    
    public Vector2D sub( Vector2D a ) {
        X -= a.X;
        Y -= a.Y;
        return new Vector2D(X, Y);
    }

    public Vector2D mul( Vector2D a ) {
        X *= a.X;
        Y *= a.Y;
        return new Vector2D(X, Y);
    }

    public Vector2D mul( float scalar ) {
        X *= scalar;
        Y *= scalar;
        return new Vector2D(X, Y);
    }
    
}