So this is going to be the last project for my java class. Any input is appreciated and I'm generally posting it here because someone else might benefit from it.
It is not done yet but when it is I'm going to post the full code.
I made a video about this u can see it here:
https://www.youtube.com/watch?v=wWmsXcuW6FE

The ball class:

``````/*
* This is the Ball class
*/

public class Ball
{
//variables for the x and y position
private int xPos,yPos;
//the direction of the x and y position. Dy is set to -5 because,
//remeber that the applet "grid" has it's (0, 0) orgin at the
//top lefthand corner of the applet window. For the mathimatically
//minded among us, the applet is essentially quadrant IV
public int dx, dy;

public Ball()
{
//sets the initial ball position to near the center of the
//screen
dx = 5;
dy = -5;
setPos(250, 140);
}

public void setPos(int x, int y)
{
this.xPos = x;
this.yPos = y;
}

public int getX(){return xPos;}
public int getY(){return yPos;}

//this is the method used to move the ball
public void move()
{
//it takes the current x and y position, then adds their current
//direction of movement to them, giving us a shift in the ball's
//position in the applet
setPos(this.getX() + dx, this.getY() + dy);
}

//reset method for when the computer scores
public void reset(char winner){
//the same initial setup as before
setPos(250,140);
if(winner == 'R')
dx = -5;
else if (winner == 'L')
dx = 5;
dy = -5;
}
}
``````

Left Paddle:

``````/*
* This is the class for the left paddle
*/

public class PaddleLeft
{
//declaration for variables needed
private int yPos = 0, score;
final int XPOS = 30;

public PaddleLeft()
{
//sets up the paddle to be at a y position of 120
setPos(120);
setScore(0);
}

public void setPos(int pos){
this.yPos = pos;

//if the y position upper left hand corner is
//70 pixels of the bottom of the applet window
if(yPos > 230)
{
//set it back to 70 pixels away
setPos(230);
}

//if the y position upper left hand corner is
//less than zero(outside the applet window)
else if(yPos < 0)
{
//set the y position to 0
setPos(0);
}
}

public int getPos()
{
return yPos;
}

//setters and getters for int score
public void setScore(int score)
{
this.score = score;
}

public int getScore()
{
return this.score;
}

}

/*
* right paddle
*/
public class PaddleRight
{
private int yPos = 0, score;
final int XPOS = 460;

//the constructor takes in an integer( which is, in our case,
//the y position of the ball)
public PaddleRight()
{
//sets the position and sets the score to 0
setPos(120);
setScore(0);
}

public void setPos(int pos){
//same set up as in Paddle left
this.yPos = pos;

if(yPos > 230)
{
setPos(230);
}
else if(yPos < 0)
{
setPos(0);
}
}

public int getPos()
{
return yPos;
}

//setters and getters for int score
public void setScore(int score)
{
this.score = score;
}

public int getScore()
{
return this.score;
}

}
``````

And the main bigboy:

``````/*
* This is the main method of my Pong applet. The game is played by a single
* player who uses the mouse to control the y position of their paddle.
* The computer controlled paddle(the one on the right) uses the y position
* of the ball in play to determine it's paddle position. Essetially, it has
* God-like capabilities that can't be beaten. The object is to see how long
* you can hold out before the computer scores 10 points
*/

import java.applet.*;
import java.awt.event.*;
import java.awt.*;

import javax.swing.*;

//we need the Applet methods and the MouseMotionListener interface
//(used for the human controlled panel
public class pongMain extends JApplet implements MouseMotionListener, ActionListener
{
//we declare an instance of our ball and two paddles
public Ball ball;
public PaddleLeft pLeft;
public PaddleRight pRight;
//a font used to display the score
Font newFont = new Font("sansserif", Font.BOLD, 20);
//The image I am creating is going to be double buffered
//so that there is no flicker when the applet is repainted
Graphics bufferGraphics;
// The image that will contain everything that has been drawn on
// bufferGraphics.
Image offscreen;
// variables used to set the width and height of the applet.
final int WIDTH = 500, HEIGHT = 300;
//variable used to record the time that the game has proceeded to
//because we want to tell the person how long the lasted
long currentTime;
int choice;
String name;
Listener listen;

public void setChoice(int choice)
{
this.choice = choice;
}

public int getChoice()
{
return this.choice;
}

public void init()
{
//sets the applet to be 500 * 300
setSize(500, 300);
//we now instantiate our ball and two paddles
ball = new Ball();
pLeft = new PaddleLeft();
//this paddle is set to the current ball y position
//minus 35 so the ball will be lined up with the center
//of our 70 pixel long paddle
pRight = new PaddleRight();

listen = new Listener();

setBackground(Color.black);

// Create an offscreen image to draw on
offscreen = createImage(WIDTH, HEIGHT);
bufferGraphics = offscreen.getGraphics();

choice = -1;
setFocusable(true);
requestFocusInWindow();
}

public void start()
{
int choicer;
while (getChoice() == -1)
{
String[] options = {"2 Players", "onePlayer", "Score Board"};
choicer = JOptionPane.showOptionDialog(this, "choices", "dialog",
JOptionPane.YES_NO_CANCEL_OPTION,
JOptionPane.QUESTION_MESSAGE,null,options,options);
setChoice(choicer);
}

if (getChoice() == 0)
{
addKeyListener(listen); // Add listener

//this sets the current time in milliseconds
currentTime = System.currentTimeMillis();

//I am going to use a timer to do a certain list of tasks
//every 15 milliseconds, which is about 67 frames a second
//(there are 1000 milliseconds in a second, so we divide that
//by 15 to set up our game's frame rate
Timer time = new Timer(15, this);

//this is the "game loop". It won't end until the
//computer has scored 10 points on the board.
//we begin our time so that the actionPerformed method will be called
//every 15 milliseconds
time.start();
while(pRight.getScore() < 10 && pLeft.getScore() < 10){
//nothing happens in here, but the timer is still running in the
//background, executing our actionPerformed method and making
//the wheels of this program turn
}
//after the game needs to end, we stop the timer and calculate
//how long the user has been playing by subtracting the current
//time from the initial currentTime
time.stop();
currentTime = System.currentTimeMillis() - currentTime;
//we repaint one more time to display how long the player
//lasted in this helpless cause =)
repaint();
}

else if (getChoice() == 1)
{
addMouseMotionListener(this);

//this sets the current time in milliseconds
currentTime = System.currentTimeMillis();

//I am going to use a timer to do a certain list of tasks
//every 15 milliseconds, which is about 67 frames a second
//(there are 1000 milliseconds in a second, so we divide that
//by 15 to set up our game's frame rate
Timer time = new Timer(15, this);

//this is the "game loop". It won't end until the
//computer has scored 10 points on the board.
//we begin our time so that the actionPerformed method will be called
//every 15 milliseconds
time.start();
while(pRight.getScore() < 10 && pLeft.getScore() < 10){
//nothing happens in here, but the timer is still running in the
//background, executing our actionPerformed method and making
//the wheels of this program turn
}

//after the game needs to end, we stop the timer and calculate
//how long the user has been playing by subtracting the current
//time from the initial currentTime
time.stop();
currentTime = System.currentTimeMillis() - currentTime;
//we repaint one more time to display how long the player
//lasted in this helpless cause =)
repaint();
name = JOptionPane.showInputDialog("Enter Your name");
//output the score and name to the outFile
}

else if (getChoice() == 2)
{

}
}

public void stop()
{

}

public void paint(Graphics g)
{
if (getChoice() == 0)
{
//instead of using the typical graphics, we are going to
//use bufferGraphics (which we declared at the beginning
//of the class) to draw onto our off-screen image

//first, we clear off whatever was previously on the image
bufferGraphics.clearRect(0, 0, WIDTH, HEIGHT);

//we now draw our two paddles in blue
bufferGraphics.setColor(Color.white);
//the XPOS is a final int, so it never changes, but the
//yPos does. We make the paddles 10 * 70.
//Left side
bufferGraphics.fillRect(pLeft.XPOS, pLeft.getPos(), 10, 70);
//Right side
bufferGraphics.fillRect(pRight.XPOS, pRight.getPos(), 10, 70);

//this draws our mid-court line and our scores in white
bufferGraphics.setColor(Color.white);
bufferGraphics.setFont(newFont);
//we show our player's hopeless circumstances
bufferGraphics.drawString("" + pLeft.getScore(), 150, 15);
//we get the score from our PaddleRight object
bufferGraphics.drawString(""+ pRight.getScore(),300,15);
//mid-court divider
bufferGraphics.fillRect(240,0,5,300);

//Remeber, we painted one last time after the computer's
//score reached ten
if(pRight.getScore() == 10)
{
//we divide the milliseconds by 1000 to display in seconds how
//long the game lasted
bufferGraphics.drawString("Right Won", 40, 150);
}

if(pLeft.getScore() == 10)
{
//we divide the milliseconds by 1000 to display in seconds how
//long the game lasted
bufferGraphics.drawString("Left Won", 40, 150);
}

//we draw the ball
bufferGraphics.setColor(Color.white);
bufferGraphics.fillOval(ball.getX(),ball.getY(), 10, 10);
//finally, we draw the offscreen image to the applet
g.drawImage(offscreen, 0, 0, this);
//this line makes sure that all the monitors are up to date before
//proceeding
Toolkit.getDefaultToolkit().sync();
}

else if (choice == 1)
{
//instead of using the typical graphics, we are going to
//use bufferGraphics (which we declared at the beginning
//of the class) to draw onto our off-screen image

//first, we clear off whatever was previously on the image
bufferGraphics.clearRect(0, 0, WIDTH, HEIGHT);

//we now draw our two paddles in blue
bufferGraphics.setColor(Color.white);
//the XPOS is a final int, so it never changes, but the
//yPos does. We make the paddles 10 * 70.
//Left side
bufferGraphics.fillRect(pLeft.XPOS, pLeft.getPos(), 10, 70);
//Right side
bufferGraphics.fillRect(pRight.XPOS, pRight.getPos(), 10, 70);

//this draws our mid-court line and our scores in white
bufferGraphics.setColor(Color.white);
bufferGraphics.setFont(newFont);
//we show our player's hopeless circumstances
bufferGraphics.drawString("Futile", 150, 15);
//we get the score from our PaddleRight object
bufferGraphics.drawString(""+ pRight.getScore(),300,15);
//mid-court divider
bufferGraphics.fillRect(240,0,5,300);

//Remeber, we painted one last time after the computer's
//score reached ten
if(pRight.getScore() == 10)
{
//we divide the milliseconds by 1000 to display in seconds how
//long the game lasted
bufferGraphics.drawString("You Lasted: " + (currentTime/ 1000) + "sec.", 40, 150);
}

//we draw the ball
bufferGraphics.setColor(Color.white);
bufferGraphics.fillOval(ball.getX(),ball.getY(), 10, 10);
//finally, we draw the offscreen image to the applet
g.drawImage(offscreen, 0, 0, this);
//this line makes sure that all the monitors are up to date before
//proceeding
Toolkit.getDefaultToolkit().sync();
}
}

//all good double buffers need the update() method. If
// you leave this out, the image will still flicker
public void update(Graphics g)
{
paint(g);
}

public void mouseMoved(MouseEvent evt)
{
pLeft.setPos(evt.getY()- 35);
}

// The necessary methods, though this one is unused, we still
//have to put it here.
public void mouseDragged(MouseEvent evt)
{

}

//this is where the program figures out if the ball has hit
//a paddle, the top or bottom of the applet window, or if the
//computer scored
public void checkCollision()
{
if (choice == 0)
{
//remember, our ball is 10*10 and the x and y positions are the
//top-left corners of the ball. If the top left corner y position
//is 0 or 290, we reverse the y- direction that the ball was
//travelling in by multiplying ball.dy by -1
if(ball.getY() == 0 || ball.getY() == 290)
{
ball.dy = (ball.dy * -1);
}

//if the ball is at the right-hand edge of the human paddle's
//domain and the boolean method hitPaddle() is true, then we
//reverse the dx position of ball by multiplying ball.dx by -1
if ((ball.getX() == 40) && hitLPaddle())
{
ball.dx = (ball.dx * -1);
}

if ((ball.getX() == 460) && hitRPaddle())
{
ball.dx = (ball.dx * -1);
}

//we already know that the computer paddle can't miss, so if
//the ball reaches the left-hand edge of the paddle, we can make the
//dx switch directions without any additional checks
if (ball.getX() == WIDTH)
{
pLeft.setScore(pLeft.getScore()+1);
ball.reset('R');
}

//if the ball is missed by the human paddle and reaches the
//left-hand edge of the applet window, then reset the ball
//and increment the score
if(ball.getX() == 0)
{
pRight.setScore(pRight.getScore() + 1);
ball.reset('L');
}
}
else if (choice == 1)
{
//remember, our ball is 10*10 and the x and y positions are the
//top-left corners of the ball. If the top left corner y position
//is 0 or 290, we reverse the y- direction that the ball was
//travelling in by multiplying ball.dy by -1
if(ball.getY() == 0 || ball.getY() == 290){
ball.dy = (ball.dy * -1);
}

//if the ball is at the right-hand edge of the human paddle's
//domain and the boolean method hitPaddle() is true, then we
//reverse the dx position of ball by multiplying ball.dx by -1
if((ball.getX() == 40) && hitLPaddle()){
ball.dx = (ball.dx * -1);
}

//we already know that the computer paddle can't miss, so if
//the ball reaches the left-hand edge of the paddle, we can make the
//dx switch directions without any additional checks
if(ball.getX() == 460){
ball.dx = (ball.dx * -1);
}

//if the ball is missed by the human paddle and reaches the
//left-hand edge of the applet window, then reset the ball
//and increment the score
if(ball.getX() == 0){
pRight.setScore(pRight.getScore() + 1);
ball.reset('R');
}
}
}

public boolean hitLPaddle()
{
boolean didHit = false;
//this just checks if the ball is lined up between the top and
//bottom right-hand corners of the human paddle
if((pLeft.getPos() - 10) <= ball.getY() && (pLeft.getPos() + 70) > ball.getY())
{
//sets didHit to true
didHit = true;
}

return didHit;
}

public boolean hitRPaddle()
{
boolean didHit = false;
if((pRight.getPos() - 10) <= ball.getY() && (pRight.getPos() + 70) > ball.getY())
{
//sets didHit to true
didHit = true;
}

return didHit;
}

@Override
//every 15 milliseconds, the Timer time triggers the
//actionPerformed method
public void actionPerformed(ActionEvent arg0)
{
//moves the ball
ball.move();
//lines the computer paddle up with the ball

if (choice == 1)
pRight.setPos(ball.getY() - 35);

//checks the ball for a collision
checkCollision();
//repaints the applet
repaint();
}

public class Listener extends KeyAdapter //Inner class to track keys
{
public void keyPressed(KeyEvent e)
{
if (e.getKeyCode() == KeyEvent.VK_UP)
pRight.setPos(pRight.getPos() - 10);
if (e.getKeyCode() == KeyEvent.VK_DOWN)
pRight.setPos(pRight.getPos() + 10);
if (e.getKeyCode() == KeyEvent.VK_W)
pLeft.setPos(pLeft.getPos() - 10);
if (e.getKeyCode() == KeyEvent.VK_S)
pLeft.setPos(pLeft.getPos() + 10);
}
}
}
``````

I hope you benefit from this :>

edit ---> you can view the applet in here: Click Here