The best way to not burden the memory is to only use as much memory as you need.
If you need a massive array, have one. Make it global, so that all your functions can work on it.
Need to have many massive arrays? Have an array of them!

Processing does allow for object-oriented programming, since you can write your own classes, and they can extend from other classes.

Processing is an API framework on top of some other programming language.

Its standard language is Java. But there are many others,
like Android, JavaScript, CoffeeScript, Ruby, Python, etc.

Thus, any OOP has to come from the language Processing is on top of.

Processing model is in short:

1. global variables
2. setup()
3. draw()
4. input events

So, we use OOP only if we want to. Do as you find better!

It really does make a lot of sense once you start moving into complicated sketches that need many different objects moving about with changing variables. I don't mind a little exercise,so stump up the code.

... but I am worried that it might consume more memory using a bunch or functions and objects.
Am I being irrational?

When we create a class, it's like a template w/ field variables + methods.
When a class is instantiated (that is, an object is created outta it)
an amount of dynamic memory allocation is reserved for each variable present in that class.
But methods don't use any extra memory. So don't worry about them for RAM purposes.

Another thing to consider is the number range we need to store.
An int[1000] would allocate a little more than 1000*4 bytes -> 4 Kbytes.

Each int can store about -2 billions up to 2 billions!
But if you need only from -32768 up to 32767, you can replace int for short data-type!
Doing so you'd use 2 bytes instead of 4.

And for -128 to 127 you can even choose byte! It's just 1 byte.
And if you got no need for negative numbers? Just choose char -> 0 up to 65535.
It's 2 bytes, same as short.

I don't know/think processing supports the use of pointers natively.

Although we don't have directly memory access in Java.
Any non-primitive variables are pointer variables in disguise!

There are 8 primitive data-types in Java:

1. boolean (1 byte)
   
2. byte (1 byte)
3. short (2 bytes)
4. char (2 bytes)
5. int (4 bytes)
6. long (8 bytes)
7. float (4 bytes)
8. double (8 bytes)

Any other data-type is automatic of a reference/pointer type!

So in a code like this:
int[] arr = new int[30];

That variable arr would store the physical memory address of the instantiated int[30] array object.

String str = "Test";

Same thing, str stores the initial memory address of that String object.

When is a bit not a bit? When it's used in java!

Yeah I know in some languages strings are actually arrays.

In Java, String is a special class which has an internal char[] object AFAIK.
And we can use its charAt() method to directly access a char from it, like an index!

I was thinking that a boolean would take up 1 bit of memory...

I wish that would be true too. But for easier storage & access, a byte is much more practical than a bit.
And I believe even in C/C++/D, a bool uses up a whole byte as well!

I remember in C++ something about using pointers when using functions and arrays.

In C/C++, when we need a variable capable of storing memory addresses,
we need to explicitly declare it as pointer of something.

Like I said, in Java and many other modern languages,
non-primitive variables are pointer/reference types implicitly.

I've found a code which measures memory before and after instantiating lotsa fatty classes
w/ lotsa primitive fields.

Seems like both boolean & byte data-types really use 1 byte each 1.
At least for x86 CISC CPU family.

/** 
 * Memory Storage Test (v2.01)
 * by  Jon Skeet (2008/Oct)
 * mod GoToLoop
 * 
 * https://forum.processing.org/topic/when-to-use-functions
 *
 * http://stackoverflow.com/questions/229886/size-of-a-byte-in-memory-java
 * http://stackoverflow.com/questions/383551/what-is-the-size-of-a-boolean-variable-in-java
 */

static final class LotsOfBooleans {  // 96 boolean variables
  boolean a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, aa, ab, ac, ad, ae, af;
  boolean b0, b1, b2, b3, b4, b5, b6, b7, b8, b9, ba, bb, bc, bd, be, bf;
  boolean c0, c1, c2, c3, c4, c5, c6, c7, c8, c9, ca, cb, cc, cd, ce, cf;
  boolean d0, d1, d2, d3, d4, d5, d6, d7, d8, d9, da, db, dc, dd, de, df;
  boolean e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, ea, eb, ec, ed, ee, ef;
  boolean f0, f1, f2, f3, f4, f5, f6, f7, f8, f9, fa, fb, fc, fd, fe, ff;
}

static final class LotsOfBytes {  // 96 byte variables
  byte a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, aa, ab, ac, ad, ae, af;
  byte b0, b1, b2, b3, b4, b5, b6, b7, b8, b9, ba, bb, bc, bd, be, bf;
  byte c0, c1, c2, c3, c4, c5, c6, c7, c8, c9, ca, cb, cc, cd, ce, cf;
  byte d0, d1, d2, d3, d4, d5, d6, d7, d8, d9, da, db, dc, dd, de, df;
  byte e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, ea, eb, ec, ed, ee, ef;
  byte f0, f1, f2, f3, f4, f5, f6, f7, f8, f9, fa, fb, fc, fd, fe, ff;
}

static final class LotsOfInts {  // 96 int variables (96*4 = 384 bytes)
  int a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, aa, ab, ac, ad, ae, af;
  int b0, b1, b2, b3, b4, b5, b6, b7, b8, b9, ba, bb, bc, bd, be, bf;
  int c0, c1, c2, c3, c4, c5, c6, c7, c8, c9, ca, cb, cc, cd, ce, cf;
  int d0, d1, d2, d3, d4, d5, d6, d7, d8, d9, da, db, dc, dd, de, df;
  int e0, e1, e2, e3, e4, e5, e6, e7, e8, e9, ea, eb, ec, ed, ee, ef;
  int f0, f1, f2, f3, f4, f5, f6, f7, f8, f9, fa, fb, fc, fd, fe, ff;
}

static final int SIZE = 1024*1024;
static long startMem, endMem;

final void setup() {        
  final LotsOfBooleans[] first = new LotsOfBooleans[SIZE];
  final LotsOfBytes[] second = new LotsOfBytes[SIZE];
  final LotsOfInts[] third = new LotsOfInts[SIZE];
  /////////////////////////////////////////////////////////////////////////////
  System.gc();
  startMem = getMemory();

  for (int i = 0; i != SIZE; first[i++] = new LotsOfBooleans());

  System.gc();
  endMem = getMemory();

  println("Size for LotsOfBooleans: " + (endMem - startMem));
  println("Average size: " + (endMem - startMem) / SIZE);
  /////////////////////////////////////////////////////////////////////////////
  System.gc();
  startMem = getMemory();

  for (int i = 0; i != SIZE; second[i++] = new LotsOfBytes());

  System.gc();
  endMem = getMemory();

  println("\nSize for LotsOfBytes: " + (endMem - startMem));
  println("Average size: " + (endMem - startMem) / SIZE);
  /////////////////////////////////////////////////////////////////////////////
  System.gc();
  startMem = getMemory();

  for (int i = 0; i != SIZE; third[i++] = new LotsOfInts());

  System.gc();
  endMem = getMemory();

  println("\nSize for LotsOfInts: " + (endMem - startMem));
  println("Average size: " + (endMem - startMem) / SIZE);
  /////////////////////////////////////////////////////////////////////////////
  exit();
}

static final long getMemory() {
  final Runtime rt = Runtime.getRuntime();
  return rt.totalMemory() - rt.freeMemory();
}