不知道怎么问，直接看题

Question

来个牛人解释一下吧，不解释的改改代码也好啊。public class test {
public static void main(String[] args) {
Thread t1 = new Thread() {
int a1 = 100; public int getA1() {
return a1;
} public void run() {
// 在这里怎么获得t2.a2
// t2.getA2();错误
};
};
Thread t2 = new Thread() {
int a2 = 200; public int getA2() {
return a2;
} public void run() {
// 在这里怎么获得t1.a1
// t1.getA1();错误
};
};
t1.start();
t2.start();
}}

Answer 1

通过匿名方法的形式new了2个没敢啥事情的线程
Thread t1 = new Thread() {
在这直接复写的run()
);
Thread t2 = new Thread() {
在这直接复写的run()
);
然后启动线程
t1.start();
t2.start();

Answer 2

汗，我是想问
// 在这里怎么获得t2.a2
// t2.getA2();错误

Answer 3

public class Test {
public static void main(String[] args) {
Thread1 t1 = new Thread1();
Thread2 t2 = new Thread2();
t1.start();
t2.start();
} static class Thread1 extends Thread {
static int a1 = 100; @Override
public void run() {
int a2 = Thread2.getA2();
super.run();
} public static int getA1() {
return a1;
}
} static class Thread2 extends Thread {
static int a2 = 100; @Override
public void run() {
int a1 = Thread1.getA1();
super.run();
} public static int getA2() {
return a2;
}
}}不知道这是不是你想要的

Answer 4

t1和t2都是匿名内部内，在外面是无法获取除了Thread外的其他的成员的

Answer 5

改成非匿名类,供借鉴.
public class Test
{
public static void main(String[] args)
        {
class Thread1 extends Thread
{
int a1 = 1;
public int getA1() 
{
return a1;
} public void run()
        {
//因Thread2是本类的内部类，可以进行实例化等操作。
System.out.println("a2 ="+new Thread2().getA2()); // 实例化一个Thread2对象。
// 
}
//把第二个线程类放在了第一个内部. 这样Thraed2是Thread1内部类，在Thread1可以
//对Thread2操作。
class Thread2 extends Thread
{
int a2 = 2;
public int getA2() 
{
return a2;
}
public void run()
        {
//内部类可以指向外围类，通过外围类对象调用其方法。
System.out.println("a1 ="+ Thread1.this.getA1()); //"Thread1.this"是Thread1对象。
}
}
} Thread1 t1 = new Thread1(); //实例化Thread1.
Thread1.Thread2 t2=t1.new Thread2(); //实例化Thread2.
t1.start();
t2.start();
}
}

Answer 6

不用static。还有其他方法吗。

Answer 7

在方法里用内部类,1和2 平行,一直没试成功. 放在方法外面,可以. 试试这个.(我改了几个数,怕混淆).public class CsdnTest1
{
public CsdnTest1()
{
Thread2 t2 = new Thread2();
Thread1 t1 = new Thread1();
t1.start();
t2.start();
}
class Thread1 extends Thread
{
int a1 = 10000;
public int getA1() 
{
return a1;
} public void run()
        {
System.out.println("thread t2 a2= "+new CsdnTest1.Thread2().getA2()); // 在这里怎么获得t2.a2
// // t2.getA2();错误
}
} class Thread2 extends Thread
{ int a2 = 30000;
public int getA2() 
{
return a2;
} public void run()
        {
// 在这里怎么获得t1.a1
  System.out.println("thread t1 a1= "+new CsdnTest1.Thread1().getA1()); //错误
}
} public static void main(String[] args)
        {
new CsdnTest1();
}}

Answer 8

这样的话好像就多new了一遍。