Converting Runnable into an array of runnable Workers

I am trying to create a runnable array that stores worker classes then use a Thread array to start the works.

public class SimpleThreads {
public static void main(String[] args) {
System.out.println("main starts.");
int num1 = 5;
int num2 = 7;
// create Workers
Runnable r1 = new Worker(num1, num2);
Runnable r2 = new Worker(num1 * 10, num2 * 10);
Runnable[] runs = new Worker(num1, num2);
// create Threads to run Workers
Thread[] threads = new Thread[args.length];
for (int i = 0; i < args.length; i++) {
threads[i] = new Thread(runs[i]);
}
Thread t1 = new Thread(r1);
Thread t2 = new Thread(r2);
// start threads
t1.start();
t2.start();
// Returns the adition to the main
System.out.println(((Worker) r1).doCalc());
System.out.println(((Worker) r2).doCalc());
int grandTotal = 0;
grandTotal = ((Worker) r1).doCalc() + ((Worker) r2).doCalc();
System.out.println("The Grand Total " + grandTotal);
System.out.println("main ends.");
}
}
/*
* the class that becomes a thread, can be named anything, must have
* "implements Runnable" which requires the public void run() method
*/
class Worker implements Runnable {
private int val1;
private int val2;
private long threadId;
// constructor
Worker(int val1, int val2) {
this.val1 = val1;
this.val2 = val2;
}
// required method
public void run() {
threadId = Thread.currentThread().getId();
doCalc();
}
// does the actual work
public int doCalc() {
return val1 + val2;
// System.out.printf("[%03d] %3d + %3d = %3d\n", threadId, val1, val2, result);
}
}

Basically, can someone help me figure out what I am doing wrong here? I get this error Type mismatch: cannot convert from Worker to Runnable[]Java(16777233)

My Expected results should be

Creating an array of runnable workers

Then using that array of runnable workers with my thread array and starting threads automatically, instead of hardcoding each thread 1 by 1.

It seems you are a little mixed up in concepts.

You store all your threads and runnables in arrays, but then you go ahead and create non-array instances and use those.
You declare runnables and threads, but then you go ahead and call the calculation method straight from your main thread.

Let's clean up the startup part first:

public class SimpleThreads {
public static void main(String[] args) {
System.out.println("main starts.");
int num1 = 5;
int num2 = 7;
// Build an array of workers.
Worker[] workers = new Worker[] {
new Worker(num1, num2),
new Worker(num1 * 10, num2 * 10)
};
// create Threads to run Workers and start them
Thread[] threads = new Thread[workers.length];
for (int i = 0; i < workers.length; i++) 
{
threads[i] = new Thread(workers[i]);
threads[i].start();
}

So, now we have an array of Workers and an array of Threads.
You could declare the workers array to be of type Runnable if you wish, but we want to use the worker's methods later.

Lets see if we can get data out of the workers. We'll add a getResult() method.

class Worker implements Runnable {
private int val1;
private int val2;
private int result;
// constructor
Worker(int val1, int val2) {
this.val1 = val1;
this.val2 = val2;
}
// required method
public void run() {
doCalc();
}
// does the actual work
private void doCalc() {
result = val1 + val2;
}
public int getResult() { return result; }
}

So, once our worker has completed, we can call getResult() to see what it's final answer is.

So, back to the main, let's wait for the threads to finish, and then add up their results.

int grandTotal = 0;
// Wait for threads to finish
for(int i=0;i<threads.length;i++)
{
threads[i].join();
}
// Read their results
for (int i=0; i<workers.length;i++)
{ 
grandTotal += workers[i].getResult();
}
System.out.println("The Grand Total " + grandTotal);