1. class Thing {
     int value;
   }
   Thing thing = new Thing();
   // "thing" is (effectively) global
   // "thing.value" is (effectively) public
   // so you can do this (effectively) anywhere...
   thing.value = 1;

You're getting mixed up. Either you have three values that are global, or you have a thing that has three values, and each thing you make has its own three values.

I think what you want is this:


Thing t1, t2, t3;


void mouseClicked(){
  println( "t1.val1: " + t1.val1 ); // Notice that you can access these directly anyway!
  println( "t1.val2: " + t1.val2 ); // This is because class's data is Processing is public anyway.
  println( "t1.val3: " + t1.val3 ); // This is poor OO programming, yes,
  println( "t2.val1: " + t2.val1 ); // And you could write getVal1(), getVal2(), getVal3()
  println( "t2.val2: " + t2.val2 ); // member functions if you liked!
  println( "t2.val3: " + t2.val3 ); // That would be the best way.
  println( "t3.val1: " + t3.val1 );
  println( "t3.val2: " + t3.val2 );
  println( "t3.val3: " + t3.val3 );
}

Traditionally, you wouldn't be able to change the data contained within a class from outside the class.
You would have to write a function in that class and then call it to change the class's data.
This is how it works in regular Java, C++, and most other programming languages.

In Processing, however, you actually can directly access (and manipulate, if you so desire) a class's private data.
This is because of the way that Processing is written - it's actually a bug. You shouldn't really be able to do it, but you can.
Doing so is not good programming practice, however. Just because you can do it, doesn't mean you should!

I'd add these functions to your class:

float getVal1(){ return val1; }
float getVal2(){ return val2; }
float getVal3(){ return val3; }
void setVal1(float newVal){ val1 = newVal; }
void setVal2(float newVal){ val2 = newVal; }
void setVal3(float newVal){ val3 = newVal; }

Using those functions, you are able to get and set the data in your classes anywhere you like via calls to the classes functions.

Thing t1, t2, t3;

void setup(){
  size(400,400);
  t1 = new Thing(1,2,3);
  t2 = new Thing(4,5,6);
  t3 = new Thing(7,8,9);
  t1.setVal1(3);
  t1.setVal2(3);
  println( "" + t2.getVal2() ); // Prints "5".
  println( "" + t1.getVal1() + " " t1.getVal2() + " " t1.getVal3() ); // prints "3 3 3".
}

In Processing, however, you actually can directly access (and manipulate, if you so desire) a class's private data.
This is because of the way that Processing is written - it's actually a bug. You shouldn't really be able to do it, but you can.
Doing so is not good programming practice, however. Just because you can do it, doesn't mean you should!

It is not a bug, it is normal Java scope rules. It can be surprising because actually classes in Processing are inner classes, so the scoping rules are a bit odd there, but that's to allow looser rules: the classes are quite intimate, close physically, so there is lesser risk to break something.

That's probably why in most Processing sketches (outside libraries), we just don't use 'private' or 'protected' keywords (or rarely). The rules are relaxed, as the Java syntax is a bit relaxed in Processing. Stricter rules can be learned later, and must be applied in industrial code. No need to complicate our life in simple sketches.

Ah. Well. Ok then.