This sounds like a very n00b question, but bear with me here:

I'm trying to access the position of my bat (paddle) in my pong game and use it in my ball class. I'm doing this because I want a particle effect to go off at the point of contact where the ball hits the bat.

Each time the ball hits the bat, I receive an error stating that I haven't created an instance of the bat. I understand that I have to (or can use a static class), but I'm not sure of how to do so in this example.

I've included both my Bat and Ball classes.

namespace Pong
{
#region Using Statements
using System;
using System.Collections.Generic;

using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Audio;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
#endregion

public class Ball
{
    #region Fields

    private readonly Random rand;
    private readonly Texture2D texture;
    private readonly SoundEffect warp;
    private double direction;
    private bool isVisible;
    private float moveSpeed;
    private Vector2 position;
    private Vector2 resetPos;
    private Rectangle size;
    private float speed;
    private bool isResetting;
    private bool collided;
    private Vector2 oldPos;
    private ParticleEngine particleEngine;
    private ContentManager contentManager;
    private SpriteBatch spriteBatch;
    private bool hasHitBat;
    private AIBat aiBat;
    private Bat bat;

    #endregion

    #region Constructors and Destructors

    /// <summary>
    /// Constructor for the ball
    /// </summary>
    public Ball(ContentManager contentManager, Vector2 ScreenSize)
    {
        moveSpeed = 15f;
        speed = 0;
        texture = contentManager.Load<Texture2D>(@"gfx/balls/redBall");
        direction = 0;
        size = new Rectangle(0, 0, texture.Width, texture.Height);
        resetPos = new Vector2(ScreenSize.X / 2, ScreenSize.Y / 2);
        position = resetPos;
        rand = new Random();
        isVisible = true;
        hasHitBat = false;

        // Everything to do with particles
        List<Texture2D> textures = new List<Texture2D>();
        textures.Add(contentManager.Load<Texture2D>(@"gfx/particle/circle"));
        textures.Add(contentManager.Load<Texture2D>(@"gfx/particle/star"));
        textures.Add(contentManager.Load<Texture2D>(@"gfx/particle/diamond"));
        particleEngine = new ParticleEngine(textures, new Vector2());
    }

    #endregion

    #region Public Methods and Operators

    /// <summary>
    /// Checks for the collision between the bat and the ball. Sends ball in the appropriate
    /// direction
    /// </summary>
    public void BatHit(int block)
    {
        if (direction > Math.PI * 1.5f || direction < Math.PI * 0.5f)
        {
            hasHitBat = true;
            particleEngine.EmitterLocation = new Vector2(aiBat.Position.X, aiBat.Position.Y);
            switch (block)
            {
                case 1:
                    direction = MathHelper.ToRadians(200);
                    break;
                case 2:
                    direction = MathHelper.ToRadians(195);
                    break;
                case 3:
                    direction = MathHelper.ToRadians(180);  
                    break;
                case 4:
                    direction = MathHelper.ToRadians(180);
                    break;
                case 5:
                    direction = MathHelper.ToRadians(165);
                    break;
            }
        }
        else
        {
            hasHitBat = true;
            particleEngine.EmitterLocation = new Vector2(bat.Position.X, bat.Position.Y);
            switch (block)
            {
                case 1:
                    direction = MathHelper.ToRadians(310);
                    break;
                case 2:
                    direction = MathHelper.ToRadians(345);
                    break;
                case 3:
                    direction = MathHelper.ToRadians(0);
                    break;
                case 4:
                    direction = MathHelper.ToRadians(15);
                    break;
                case 5:
                    direction = MathHelper.ToRadians(50);
                    break;
            }
        }

        if (rand.Next(2) == 0)
        {
            direction += MathHelper.ToRadians(rand.Next(3));
        }
            else
        {
            direction -= MathHelper.ToRadians(rand.Next(3));
        }
        AudioManager.Instance.PlaySoundEffect("hit");
    }

    /// <summary>
    /// JEP - added method to slow down ball after powerup deactivates
    /// </summary>
    public void DecreaseSpeed()
    {
        moveSpeed -= 0.6f;
    }

    /// <summary>
    /// Draws the ball on the screen
    /// </summary>
    public void Draw(SpriteBatch spriteBatch)
    {
        if (isVisible)
        {
            spriteBatch.Begin();
            spriteBatch.Draw(texture, size, Color.White);           
            spriteBatch.End();

            // Draws sprites for particles when contact is made
            particleEngine.Draw(spriteBatch);
        }
    }

    /// <summary>
    /// Checks for the current direction of the ball
    /// </summary>
    public double GetDirection()
    {
        return direction;
    }

    /// <summary>
    /// Checks for the current position of the ball
    /// </summary>
    public Vector2 GetPosition()
    {
        return position;
    }

    /// <summary>
    /// Checks for the current size of the ball (for the powerups)
    /// </summary>
    public Rectangle GetSize()
    {
        return size;
    }

    /// <summary>
    /// Grows the size of the ball when the GrowBall powerup is used.
    /// </summary>
    public void GrowBall()
    {
        size = new Rectangle(0, 0, texture.Width * 2, texture.Height * 2);
    }

    /// <summary>
    /// Was used to increased the speed of the ball after each point is scored.
    /// No longer used, but am considering implementing again.
    /// </summary>
    public void IncreaseSpeed()
    {
        moveSpeed += 0.6f;
    }

    /// <summary>
    /// Check for the ball to return normal size after the Powerup has expired
    /// </summary>
    public void NormalBallSize()
    {
        size = new Rectangle(0, 0, texture.Width, texture.Height);
    }

    /// <summary>
    /// Check for the ball to return normal speed after the Powerup has expired
    /// </summary>
    public void NormalSpeed()
    {
        moveSpeed += 15f;
    }

    /// <summary>
    /// Checks to see if ball went out of bounds, and triggers warp sfx
    /// </summary>
    public void OutOfBounds()
    { 
        // Checks if the player is still alive or not   
        if (isResetting)
        {
            AudioManager.Instance.PlaySoundEffect("warp");
            {   
                // Used to stop the the issue where the ball hit sfx kept going off when detecting collison
                isResetting = false;
                AudioManager.Instance.Dispose();
            }
        }      
    }

    /// <summary>
    /// Speed for the ball when Speedball powerup is activated
    /// </summary>
    public void PowerupSpeed()
    {
        moveSpeed += 20.0f;
    }

    /// <summary>
    /// Check for where to reset the ball after each point is scored
    /// </summary>
    public void Reset(bool left)
    {
        if (left)
        {
            direction = 0;
        }
        else
        {
            direction = Math.PI;
        }

        // Used to stop the the issue where the ball hit sfx kept going off when detecting collison
        isResetting = true; 
        position = resetPos; // Resets the ball to the center of the screen
        isVisible = true;
        speed = 15f; // Returns the ball back to the default speed, in case the speedBall was active
        if (rand.Next(2) == 0)
        {
            direction += MathHelper.ToRadians(rand.Next(30));
        }
        else
        {
            direction -= MathHelper.ToRadians(rand.Next(30));
        }
    }

    /// <summary>
    /// Shrinks the ball when the ShrinkBall powerup is activated
    /// </summary>
    public void ShrinkBall()
    {
        size = new Rectangle(0, 0, texture.Width / 2, texture.Height / 2);
    }

    /// <summary>
    /// Stops the ball each time it is reset. Ex: Between points / rounds
    /// </summary>
    public void Stop()
    {
        isVisible = true;
        speed = 0;
    }

    /// <summary>
    /// Updates position of the ball
    /// </summary>
    public void UpdatePosition()
    {
        size.X = (int)position.X;
        size.Y = (int)position.Y;
        oldPos.X = position.X;
        oldPos.Y = position.Y;
        position.X += speed * (float)Math.Cos(direction);
        position.Y += speed * (float)Math.Sin(direction);
        bool collided = CheckWallHit();
        particleEngine.Update();

        // Stops the issue where ball was oscillating on the ceiling or floor
        if (collided)
        {
            position.X = oldPos.X + speed * (float)Math.Cos(direction);
            position.Y = oldPos.Y + speed * (float)Math.Sin(direction);
        }
    }
            #endregion

    #region Methods

    /// <summary>
    /// Checks for collision with the ceiling or floor. 2*Math.pi = 360 degrees
    /// </summary>
    private bool CheckWallHit()
    {
        while (direction > 2 * Math.PI)
        {
            direction -= 2 * Math.PI;
            return true;
        }

        while (direction < 0)
        {
            direction += 2 * Math.PI;
            return true;
        }

        if (position.Y <= 0 || (position.Y > resetPos.Y * 2 - size.Height))
        {
            direction = 2 * Math.PI - direction;
            return true;
        }
        return true;
      }

     #endregion


     }
 }

    namespace Pong
{
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.Graphics;
using System;

public class Bat
{
    public Vector2 Position;
    public float moveSpeed;
    public Rectangle size;
    private int points;
    private int yHeight;
    private Texture2D leftBat;
    public float turbo;
    public float recharge;
    public float interval;
    public bool isTurbo;

    /// <summary>
    /// Constructor for the bat
    /// </summary>
    public Bat(ContentManager contentManager, Vector2 screenSize, bool side)
    {
        moveSpeed = 7f;
        turbo = 15f;
        recharge = 100f;
        points = 0;
        interval = 5f;
        leftBat = contentManager.Load<Texture2D>(@"gfx/bats/batGrey");
        size = new Rectangle(0, 0, leftBat.Width, leftBat.Height);

        // True means left bat, false means right bat. 
        if (side) Position = new Vector2(30, screenSize.Y / 2 - size.Height / 2);
        else Position = new Vector2(screenSize.X - 30, screenSize.Y / 2 - size.Height / 2);
        yHeight = (int)screenSize.Y;
    }

    public void IncreaseSpeed()
    {
        moveSpeed += .5f;      
    }

    /// <summary>
    /// The speed of the bat when Turbo is activated
    /// </summary>
    public void Turbo()
    {
        moveSpeed += 8.0f;
    }

    /// <summary>
    /// Returns the speed of the bat back to normal after Turbo is deactivated
    /// </summary>
    public void DisableTurbo()
    {
        moveSpeed = 7.0f;
        isTurbo = false;
    }

    /// <summary>
    /// Returns the bat to the nrmal size after the Grow/Shrink powerup has expired
    /// </summary>
    public void NormalSize()
    {
        size = new Rectangle(0, 0, leftBat.Width, leftBat.Height);
    }

    /// <summary>
    /// Checks for the size of the bat
    /// </summary>
    public Rectangle GetSize()
    {
        return size;
    }

    /// <summary>
    /// Adds point to the player or the AI after scoring. Currently Disabled.
    /// </summary>
    public void IncrementPoints()
    {
        points++;
    }

    /// <summary>
    /// Checks for the number of points at the moment
    /// </summary>
    public int GetPoints()
    {
        return points;
    }

    /// <summary>
    /// Sets thedefault starting position for the bats
    /// </summary>
    /// <param name="position"></param>
    public void SetPosition(Vector2 position)
    {
        if (position.Y < 0)
        {
            position.Y = 0;
        }
        if (position.Y > yHeight - size.Height)
        {
            position.Y = yHeight - size.Height;
        }
        this.Position = position;
    }


    /// <summary>
    /// Checks for the current position of the bat
    /// </summary>
    public Vector2 GetPosition()
    {
        return Position;
    }

    /// <summary>
    /// Controls the bat moving up the screen
    /// </summary>
    public void MoveUp()
    {
        SetPosition(Position + new Vector2(0, -moveSpeed));
    }

    /// <summary>
    /// Controls the bat moving down the screen
    /// </summary>
    public void MoveDown()
    {
        SetPosition(Position + new Vector2(0, moveSpeed));
    }

    /// <summary>
    /// Updates the position of the AI bat, in order to track the ball
    /// </summary>
    /// <param name="ball"></param>
    public virtual void UpdatePosition(Ball ball)
    {
        size.X = (int)Position.X;
        size.Y = (int)Position.Y;
    }

    /// <summary>
    /// Resets the bat to the center location after a new game starts
    /// </summary>
    public void ResetPosition()
    {
        SetPosition(new Vector2(GetPosition().X, yHeight / 2 - size.Height));
    }

   /// <summary>
   /// Used for the Growbat powerup
   /// </summary>
    public void GrowBat()
    {
        // Doubles the size of the bat collision
        size = new Rectangle(0, 0, leftBat.Width * 2, leftBat.Height * 2);      
    }

    /// <summary>
    /// Used for the Shrinkbat powerup
    /// </summary>
    public void ShrinkBat()
    {
        // 1/2 the size of the bat collision
        size = new Rectangle(0, 0, leftBat.Width / 2, leftBat.Height / 2);
    }

    /// <summary>
    /// Draws the bats
    /// </summary>
    public virtual void Draw(SpriteBatch batch)
    {
        batch.Draw(leftBat, size, Color.White);
    }


    }
}