Thread t1 = new Thread( new Runnable() {public void run() { myt3.m4t1(inner);} }, "t1");
谁能告诉我究竟是什么意思吗？

这是我认为比较完整的代码和一些解析。你可以借鉴着理解一下

1. class  ThreadTest
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 final Inner inner = new Inner();
   
6.                 /*
   
7.                 new Thread()是创建一个线程
   
8.                 new Runnable()是创建一个实现Runnable接口的子类
   
9.                 并让实现Runnable接口的子类重写父类的run方法
   
10.                 然后把把Runnable接口的子类对象当成参数传递给Thread类的构造函数
    
11.                 */
    
12.                 Thread t1 = new Thread(new Runnable()
    
13.                 {
    
14.                         public void run()
    
15.                         {
    
16.                                 myt3.m4t1(inner); //调用myt3类中的静态函数。并把Inner类的对象当成实参传递给m4t1函数
    
17.                         }
    
18.                 }, "t1");
    
19.                 t1.start(); //开启线程
    
20.         }
    
21.         
    
22. }
    
23. class myt3
    
24. {
    
25.         public static void m4t1(Inner i) //创建一个带类类型参数的函数
    
26.         {
    
27.                 for(int S = 0; S < 20; S++)
    
28.                 {
    
29.                         i.show(); //通过类对象调用类的函数               
    
30.                 }
    
31. 
    
32.         }
    
33. 
    
34. }
    
35. class Inner
    
36. {
    
37.         public void show()
    
38.         {
    
39.                 System.out.println("adfa");
    
40.         }
    
41. }

复制代码

awkflf11 发表于 2014-3-21 23:56
首先这是一个匿名内部类问题。
左边的new Thread( new Runnable() {public void run() { myt3.m4t1(inner); ...

感谢啊，，在接在理。。。。。。。。。。。。。。

首先这是一个匿名内部类问题。
左边的new Thread( new Runnable() {public void run() { myt3.m4t1(inner);} }, "t1");是子类对象，
Thread t1 是定义一个父类用于接收右边的类型。
new Runnable() {public void run() { myt3.m4t1(inner);}是覆盖了父类中的方法。
匿名内部类是内部类的简写方式，不需要知道内部类名的情况写出来的。
给你举个例子：
abstract class AbsDemo
{
        abstract void function();
        abstract void show();
}
class Outer
{
        int num = 4;
        /*
        class Inner extends AbsDemo
        {
                void function(){}
                void show(){}
        }
        */
        void method()
        {               
//                Inner in = new Inner();
//                in.function();
//                in.show();

                AbsDemo a = new AbsDemo() //多态的体现，new AbsDemo(){}--子类对象
                {
                        void function(){}
                        void show(){}
                };// 匿名类部类
                a.function();//  因为覆盖父类的两个方法，不出错
                a.show();

        }

首先这是一个匿名内部类问题。