PVector is a class which deals w/ vectorial math between 2 PVectors for example.
PVector has 3 float fields -> x, y, z; so the simplest use to make outta it
is to have 3 variables to store things! 

ArrayList is like an Array, but more appropriate when the # of items is unknown or anoying to find out! 

Since a regular Array's syntax is simpler and have a slightly better performance,
it should be preffered when the # of items is well defined! 

Accessing ArrayLists or a class can be unusual at first. If you wanted to get the x position of the first Dot you would write this:

As GoToLoop pointed out, this is a case where using an array would make more sense assuming the number of Dots will not change.

You can access the fields of a class directly, the same way you'd call a method from it:

  for (Dot dotDraw: dots) {
    dotDraw.render();
    println(dotDraw.dotX + "\t " + dotDraw.dotY);
  }

Thanks for the replies.

When using a for loop, it is typical to use a variable named i to do the looping. The variable j is also typical, it just is alphabetically next after i.

Thanks for the help. I really appreciate it!

I had no idea I could use get() to access the class.

Method get() has nothing to do w/ class access per se. It can access anything from a List!
Actually, it is a method which belongs to class List. Its purpose is to have a random access to a List.

In your program, you have an ArrayList of instances from class Dot.
Let's say you wanna a direct access to the 10th instance of a Dot which is stored in List dots.
You just issue something like the following -> Dot d = dots.get(9);

Of course, if you still don't have at least 10 elements stored there, you'd get an exception (error)! 
So, if you wanna know 1st how many elements are stored in a List, use method -> size():

int sizeOfDots = dots.size();      // gets current size of ArrayList dots!
Dot d = dots.get(sizeOfDots - 1);  // gets last element of ArrayList dots!

It's not that hard, but still lotsa things to get around.
Like I told you, if you can, use a regular Array. It's much easier!!! 

... since PVector still seems too complex for me.

Well, if you just need to have 2 or 3 float type variables (x, y, z), you can use a PVector just for that! 
You can even make a class of yours extends PVector, and you get those 3 variables
automatically w/o creating them just for fun!

It's a waste of resources, but just to make a point, here's your class Dot w/ a built-in PVector:

class Dot extends PVector { 

  Dot(float dotX, float dotY, float dotDiam) {
    super(dotX, dotY, dotDiam);  // initializes PVector w/ 3 values... 
  }

  void render() {
    ellipse(x, y, z, z);         // x, y & z come from PVector!
  }
}

In my code, would it be best to name i, and j to more descriptive variables?

Variable i is traditionally used as a loop iterator for all programming languages for decades!
And when there's a need to an inner loop, since j comes after i, it is also traditionally used as iterator too!

Of course, if your loop has a theme, like iterate a list of students, you can use something like:

for (int student = 0; student != numStudents;)  println( myStudents[student++] );

But a simple i is understandable to all programmers!
For Array index iteration, I also like to use idx instead of i.  

Should new variables always be made from existing variables if they are used multiple times?

As asimes has already mentioned, if you can pre-calc something which is gonna be used many times ahead,
a temporary local variable helps performance and readability a lot!  

I made some progress on my program (I'm trying to remake a connect the dots game I use to play on Windows XP).

When the dots are placed, are they placed at (0,0), (1, 1), (2, 2), or would they be placed at (1, 0), (2, 0), (3, 0)? Having a for loop within another for loop is very confusing for me.

Well, it depends on the order you put i & j as parameters for your class Dot constructor call!

Generally, programmers prefer the outer loop as the row and inner one as the column.
That is, for each row, the inner loop iterates putting elements from left to right. Then, next row begins! 

I did some refactoring on your code, just to be easy for me to understand it.
But I believe you need to drastically change your algorithm for it to be able to work on any screen size!  

Dot dots[];

final static color GREY = 0300, BG = -1;
final static byte  dotSpacing = 25, halfSpacing = dotSpacing >> 1;

void setup() {
  size(500, 500);
  smooth();
  frameRate(30);
  strokeWeight(5);

  ArrayList points = new ArrayList();

  for (int row = dotSpacing; row <= height - halfSpacing; row += dotSpacing)
    for (int col = dotSpacing; col <= width - halfSpacing; col += dotSpacing)
      points.add( new Dot(col, row) );

  dots = new Dot[points.size()];
  points.toArray(dots);
}

void draw() {
  background(BG);
  stroke(GREY);

  final int mx  = mouseX, my = mouseY;
  final int len = dots.length;

  //Lines on x-axis
  for (int i = 1; i < len; i++) {
    Dot d1 = dots[i];
    Dot d2 = dots[i-1];

    //Mouse has to be between, but not touching dots
    if (mx > d2.dotX + Dot.halfDiam & mx < d1.dotX - Dot.halfDiam &&
      my > d2.dotY - Dot.halfDiam & my < d1.dotY + Dot.halfDiam)

      line(d1.dotX, d1.dotY, d2.dotX, d2.dotY);
  }

  //Lines on y-axis
  for (int i = round( sqrt(len) ); i < len; i++) {
    Dot d1 = dots[i];
    Dot d2 = dots[i - round( sqrt(len) )];

    if (mx > d2.dotX - Dot.halfDiam & mx < d1.dotX + Dot.halfDiam &&
      my > d2.dotY + Dot.halfDiam & my < d1.dotY - Dot.halfDiam)

      line(d1.dotX, d1.dotY, d2.dotX, d2.dotY);
  }

  noStroke();
  fill(Dot.dotColor);

  for (Dot dotDraw: dots)    dotDraw.render();
}

final class Dot {
  final short dotX, dotY;
  final static byte  dotDiam  = 6, halfDiam = dotDiam >> 1;
  final static color dotColor = 0;

  Dot(int initDotX, int initDotY) {
    dotX = (short) initDotX;
    dotY = (short) initDotY;
  }

  void render() {
    ellipse(dotX, dotY, dotDiam, dotDiam);
  }
}

Maybe this helps? If not, try printing i from one for loop then checking this again: