14.  timing[0] = new Timeline();

17.5.  Timeline(){}

In Processing, all classes you create are inner/nested classes of the sketch itself by default.
And inner classes can't hide their fields & methods from its top class; and vice-versa!
So, private keyword declaration is kinda useless there.

If you don't want a class of yours this way, you have to create a separate tab w/ the same name of that class,
plus it gotta have a .java suffix in its tab name as well.

I did some wild experiments w/ your sample there. Take a look:

Main Tab:

---

LedChannel lc = new LedChannel(10);

void setup() {
  println(lc.getPin());

  lc.timing.get(lc.counter).setTime(20, true);
  println(lc.timing.get(lc.counter).getTime());

  exit();
}

---

LedChannel.java Tab:

---

import java.util.List;
import java.util.ArrayList;

class LedChannel {
  static byte counter = -1; // shared by all instances.
  private byte pin;
  final List<TimeLine> timing = new ArrayList();

  LedChannel(int pin) {
    setPin(pin);
    timing.add( new TimeLine() );
    ++counter;
  }

  void setPin(int pin) {
    this.pin = (byte) pin;
  }

  byte getPin() {
    return pin;
  }

  class TimeLine {
    private int currTime;
    private boolean ledStatus;

    void setTime(int time, boolean status) {
      currTime = time;
      ledStatus = status;
    }

    int getTime() {
      return currTime;
    }
  }
}

---

On line 13 you give the type when assigning a field called timing. Remove Timeline[] from that line since you already declared a field named timing of type Timeline[] otherwise it creates a new timing field scoped to the constructor I believe and doesn't assign the class one.

Thank you for the help, everyone.  This was obviously a newbie question :) This is my first time trying to learn java (and OOP in general.)  I was able to tweak it to get it to work with your examples. Then my next hour was far more productive than the previous 3.

Processing isn't a recommended battleground to gain experience w/ OOP best practices!

Processing is a framework API layer over Java and also to other languages
like JavaScript, CoffeeScript, Ruby, Python, etc.

Processing is setup in a way to facilitate non-programmer folks like artists to dive in it as fast as possible.
Although I'm a programmer, I've never coded in "real" Java yet! 

As mentioned before, 1 of those strategies is to make all classes an inner/nested class of the main sketch itself.
To avoid that, you have to create a separate tab w/ same name as the class to put there, plus w/ extension .java.
But there are many other tricks which Processing's framework relies on too! 

I believe you're trying to have some static field variables in your class,
so their content is shared among all instances of it.

Problem is, inner/nested classes can either be 100% static or 0%!
Sole exceptions are for static final primitive or String fields w/ known values at compile time.
Otherwise, only top classes can have mixed static & non-static resources!

I did an example to illustrate the whole situation better. Check it out:

LedChannel lc1 = new LedChannel(10);
LedChannel lc2 = new LedChannel(20);

void setup() {
  noLoop();

  // pin is a non-static field. Each object has its own copy of it.
  println(lc1.pin);
  println(lc2.pin + "\n");

  // Both currTime & ledStatus are static fields.
  // Any modification of either reflects to all object instances.
  lc1.setTime(300, true);

  println(lc2.getTime());
  println(lc2.ledStatus + "\n");

  // Both setTime() & getTime() are static methods.
  // No need to instantiate their class to use it.
  TimeLine.setTime(500, false);
  println(TimeLine.getTime());

  // And since setTime() modifies both currTime & ledStatus static fields, 
  // those modifications reflect on both lc1 & lc2 objects as well.
  println(lc1.ledStatus);

  textAlign(CENTER, CENTER);
  textSize(32);
  lc2.displayTime();
}

// Static classes can't access most of Processing's API!
static class TimeLine {         // 100% static inner/nested class
  private static int currTime;  // private & static field
  static boolean ledStatus;     // static field

  static void setTime(int time, boolean status) {  // static method
    currTime = time;
    ledStatus = status;
  }

  static int getTime() {  // static method
    return currTime;
  }
}

class LedChannel extends TimeLine { // inherits static inner class
  byte pin;

  LedChannel(int pin) {
    this.pin = (byte) pin;
  }

  // Only a non-static method can access Processing's API:
  void displayTime() {
    // text(), width & height belong to Processing's API:
    text(getTime(), width>>1, height>>1);
  }
}

P.S.: Just found out that an inner/nested static class can effectively hide information
using private keyword declaration!
Then, to get access to currTime private field, getTime() method is obligatory! 

Just remember that LedChannel, since it's a regular inner class, can't prohibit access
to its own implemented resources to be accessed from its top-class; that is, the main sketch.
Thus, trying to protect them w/ private there is 99% moot!

Here's the same example as above, but w/o class LedChannel directly inheriting from static class TimeLine.
Rather, by instantiating TimeLine inside LedChannel and storing its reference pointer in the field timing.

However unfortunately, private keyword stops working using this latter method!
So, currTime private field can be directly accessed. No need for getTime() method now! 

LedChannel lc1 = new LedChannel(10);
LedChannel lc2 = new LedChannel(20);

void setup() {
  noLoop();

  // pin is a non-static field. Each object has its own copy of it.
  println(lc1.pin);
  println(lc2.pin + "\n");

  // Both currTime & ledStatus are static fields.
  // Any modification of either reflects to all object instances.
  lc1.timing.setTime(300, true);

  println(lc2.timing.currTime);
  println(lc2.timing.ledStatus + "\n");

  // Both setTime() & getTime() are static methods.
  // No need to instantiate their class to use it.
  TimeLine.setTime(500, false);
  println(TimeLine.currTime);

  // And since setTime() modifies both currTime & ledStatus static fields, 
  // those modifications reflect on both lc1 & lc2 objects as well.
  println(lc1.timing.ledStatus);

  textAlign(CENTER, CENTER);
  textSize(32);
  lc2.displayTime();
}

// Static classes can't access most of Processing's API!
static class TimeLine {         // 100% static inner/nested class
  private static int currTime;  // private & static field (not working now!)
  static boolean ledStatus;     // static field

  static void setTime(int time, boolean status) {  // static method
    currTime = time;
    ledStatus = status;
  }

  static int getTime() {  // static method
    return currTime;
  }
}

class LedChannel {
  byte pin;
  final TimeLine timing = new TimeLine();

  LedChannel(int pin) {
    this.pin = (byte) pin;
  }

  // Only a non-static method can access Processing's API:
  void displayTime() {
    // text(), width & height belong to Processing's API:
    text(timing.currTime, width>>1, height>>1);
  }
}

I would set it up like the following which doesn't require .java files.

class Handler {
  ArrayList<LedChannel> channels;
  ArrayList<Timeline> timing;
  ...
  class Timeline {
    ...
  }

  class LedChannel {
    //these can access timing and anything else from the enclosing Handler class
    ...
  }
}

Is there a possible way to do this where my "timing" array would be treated like it was static?

What I'd be looking for would be to add a "int pin" variable to Timeline, and then allow each instance of my LedChannel class to write to the same timing ArrayList.

I'm not sure exactly what he's asking for yet; but I believe he wants a regular class for LedChannel.
However, TimeLine should be static; as for all instances of LedChannel
would access the same unique instance of TimeLine!

Since TimeLine is 100% static, there's no real need to neither instantiate it nor inherit it anyways:
However any methods which would use Processing's API should go to another non- static class.
Even though it should stay w/ it by OOP's logic! 

final static int NUM = 10;
final LedChannel[] lc = new LedChannel[NUM];

void setup() {
  noLoop();

  for ( int i = 0; i != NUM; lc[i] = new LedChannel(++i*15) );

  for (LedChannel leds: lc)  println(leds.pin);

  println();

  TimeLine.setTime(300, true);
  println(TimeLine.currTime);
  println(TimeLine.ledStatus + "\n");

  TimeLine.setTime(500, false);
  println(TimeLine.currTime);
  println(TimeLine.ledStatus);

  textAlign(CENTER, CENTER);
  textSize(32);
  lc[NUM/2].displayTime(); // any instance index would get same result.
}

static class TimeLine {
  private static int currTime;
  static boolean ledStatus;

  static void setTime(int time, boolean status) {
    currTime = time;
    ledStatus = status;
  }

  static int getTime() {
    return currTime;
  }
}

class LedChannel {
  byte pin;

  LedChannel(int pin) {
    this.pin = (byte) pin;
  }

  // this method can't be inside TimeLine since it uses Processing's APIs: 
  void displayTime() {  
    text(TimeLine.currTime, width>>1, height>>1);
  }
}

On 2nd thought, rbrauer's solution to encapsulate both classes makes sense!
Number of instances can be fine-controlled anyways.
And for the one supposed to be static, it's enough to keep 1 instance of it.
Only tiny drawback is the need to use the external class' label to reach the internal ones.
Like h.channels[3] or h.timing.

final Handler h = new Handler();

void setup() {
  noLoop();

  for (Handler.LedChannel leds: h.channels)  println(leds.pin);

  println();

  h.channels[Handler.NUM / 2].pin = -100;
  println(Handler.NUM/2 + ": " + h.channels[Handler.NUM / 2].pin + "\n");

  h.timing.setTime(500, false);
  println(h.timing.currTime);
  println(h.timing.ledStatus);

  textAlign(CENTER, CENTER);
  textSize(32);
  h.timing.displayTime();
}

class Handler {
  final static int NUM = 10, STEP = 12;
  final LedChannel[] channels = new LedChannel[NUM];

  final TimeLine timing = new TimeLine();

  {
    for ( int i = 0; i != NUM; channels[i] = new LedChannel(++i*STEP) );
  }

  class LedChannel {
    byte pin;

    LedChannel(int pin) {
      this.pin = (byte) pin;
    }
  }

  class TimeLine {
    int currTime;
    boolean ledStatus;

    void setTime(int time, boolean status) {
      currTime = time;
      ledStatus = status;
    }

    int getTime() {
      return currTime;
    }

    void displayTime() {  
      text(currTime, width>>1, height>>1);
    }
  }
}

1 more example!  This time w/ some replacements:
h.channels became -> lc[]
h.timing became -> tl

This way there's no more need to specify the external class to reach the internal 1s! 

final Handler h = new Handler();

final Handler.LedChannel[] lc = h.channels;
final Handler.TimeLine tl = h.timing;

void setup() {
  noLoop();

  for (Handler.LedChannel leds: lc)  println(leds.pin);

  println();

  lc[Handler.NUM / 2].pin = -100;
  println(Handler.NUM/2 + ": " + lc[Handler.NUM / 2].pin + "\n");

  tl.setTime(500, false);
  println(tl.currTime);
  println(tl.ledStatus);

  textAlign(CENTER, CENTER);
  textSize(32);
  tl.displayTime();
}

class Handler {
  final static int NUM = 10, STEP = 12;
  final LedChannel[] channels = new LedChannel[NUM];

  final TimeLine timing = new TimeLine();

  {
    for ( int i = 0; i != NUM; channels[i] = new LedChannel(++i*STEP) );
  }

  class LedChannel {
    byte pin;

    LedChannel(int pin) {
      this.pin = (byte) pin;
    }
  }

  class TimeLine {
    int currTime;
    boolean ledStatus;

    void setTime(int time, boolean status) {
      currTime = time;
      ledStatus = status;
    }

    int getTime() {
      return currTime;
    }

    void displayTime() {  
      text(currTime, width>>1, height>>1);
    }
  }
}