1. public class Road {
   
2.         private  String name;
   
3.         private  LinkedList<String> vechicles = new LinkedList<String>();
   
4.         public Road(String name) {
   
5.                 super();
   
6.                 this.name = name;
   
7.         
   
8.         
   
9.                 new Thread(new Runnable(){
   
10.                         public void run(){
    
11.                                 try {
    
12.                                         Thread.sleep((new Random().nextInt(10)+1)*1000);
    
13.                                        
    
14.                                 } catch (Exception e) {
    
15.                                         // TODO: handle exception
    
16.                                 }
    
17.                                 vechicles.add(Road.this.name);
    
18.                         }
    
19.                 });
    
20.         }        

复制代码

内部类定义在局部时访问成员变量，成员变量必须是final修饰的，这个大家都知道
可是以上代码中最后一句vechicles.add(Road.this.name);该怎么理解。this指的是这个内部类吗，那这个内部类中也没有name这个成员啊。求详解

感觉这样更好理解：
this总是代表某一个类的对象
Road.this.name就是Road类下的某一个对象的name属性
而这个对象就是当前调用构造函数的那个

qhasilver 发表于 2012-10-15 20:42
哦对，这是个匿名内部类。我错了。你不加Road就指的是这个匿名内部类了。 ...

嗯我把定义在局部的内部类访问的局部变量必须被final修饰记错了
记成 访问的成员变量必须被final修饰。。

郭阳 发表于 2012-10-15 20:03
请问什么叫匿名内部类。。。。。

哦对，这是个匿名内部类:L。我错了。你不加Road就指的是这个匿名内部类了。

qhasilver 发表于 2012-10-15 18:38
如果它是个类，就有修饰符 class在前面，请参照一下三楼的样式，他就是写了个内部类RoadEntry ...

请问什么叫匿名内部类。。。。。

郭阳 发表于 2012-10-15 16:53
new的runnable不就是面向接口定义的内部类吗？

如果它是个类，就有修饰符 class在前面，（经指出，此言差矣，此乃匿名内部类）请参照一下三楼的样式，他就是写了个内部类RoadEntry

qhasilver 发表于 2012-10-15 08:38
public Road(String name) {}是你的构造方法(带了参数的)
this指的是当前类对象,你这段代码里就一个类,没有 ...

new的runnable不就是面向接口定义的内部类吗？

陈军 发表于 2012-10-15 15:01
这代码..，，阅读性不太好，，要想在本类内部搞多线程，直接用内部类实现Runnable接口，
然后再run()里面加 ...

我的代码是复制的张孝祥老师的代码呵呵
不过你这样写就好理解多了，只不过张老师是随着对象建立而跑线程，你的多一步要自己调用方法来启动
谢谢

这代码..，，阅读性不太好，，要想在本类内部搞多线程，直接用内部类实现Runnable接口，
然后再run()里面加入你要一直执行的方法或者监听器什么的。比如贪吃蛇，蛇的移动
其中Road.this.name 表示name用的Road类本类对象的name,而不是调用这个方法的对象的name,

代码我修改了。你可以看看
class Road {
    private  String name;
    private  LinkedList<String> vechicles = new LinkedList<String>();
    public Road(String name) {
            super();
            this.name = name;
    }
   private class RoadEntry implements Runnable{

                @Override
                public void run() {
                        // TODO Auto-generated method stub
                         try {
                 Thread.sleep((new Random().nextInt(10)+1)*1000);
                 
              } catch (Exception e) {
                 // TODO: handle exception
              }
         vechicles.add(Road.this.name);
                }        
    }
   
   public void start(){
           new Thread(new RoadEntry()).start();
   }
}
这样阅读性就提高了。以后修改也好改。 启动就调用start（）方法完成多线程了，

public Road(String name) {}是你的构造方法(带了参数的)
this指的是当前类对象,你这段代码里就一个类,没有内部类.而且这个线程都没启动,我改了一下你的代码.

1. import java.util.LinkedList;
   
2. import java.util.Random;
   
3. 
   
4. public class Road {
   
5.     private  String name;
   
6.     private  LinkedList<String> vechicles = new LinkedList<String>();
   
7.     public Road(String name) {
   
8.             super();
   
9.             this.name = name;
   
10.             new Thread(new Runnable(){               
    
11.                     public void run(){
    
12.                             try {
    
13.                                     Thread.sleep((new Random().nextInt(10)+1)*1000);
    
14.                                     
    
15.                             } catch (Exception e) {
    
16.                                     // TODO: handle exception
    
17.                             }
    
18.                             vechicles.add(Road.this.name);
    
19.                             System.out.println(vechicles.getLast());
    
20.                     }
    
21.             }).start();
    
22.     }
    
23.     public static void main(String[]args){
    
24.             new Road("ha");
    
25.     }
    
26. }

复制代码