一段代码：

1. Thread th1 = new Thread(){
   
2. @Override
   
3. public void run() {
   
4. System.out.println("thread");
   
5. }
   
6. };

复制代码

上面这段代码是新起一个线程，用的是匿名内部类。
我不明白的是，这明明是new了一个Thread啊，怎么new的这个Thread就是Thread的子类了呢？
源码中Thread的构造方法的代码：

1. public Thread() {
   
2. init(null, null, "Thread-" + nextThreadNum(), 0);
   
3. }

复制代码

调用的init的代码：

1. private void init(ThreadGroup g, Runnable target, String name,
   
2. long stackSize) {
   
3. Thread parent = currentThread();

复制代码

下面还很长，就不贴了。这里倒是有个Thread，叫parent，但他获得的是当前线程，也不是新起的线程啊。

问题：
匿名内部类，怎么成为该类的子类了？这个用法很常见，但一直不懂。

1. class A
   
2. {
   
3.     Thread d = new myThread()
   
4.     {
   
5.         void show()
   
6.         {
   
7.             
   
8.         }
   
9.     }.show();
   
10. }
    
11. 
    
12. abstract class myThread extends Thread
    
13. {
    
14.     abstract void show() ;
    
15. }

复制代码

一段代码：

    Thread th1 = new Thread(){
    @Override
    public void run() {
    System.out.println("thread");
    }
    };

复制代码
上面这段代码是新起一个线程，用的是匿名内部类。
我不明白的是，这明明是new了一个Thread啊，怎么new的这个Thread就是Thread的子类了呢？
匿名内部类，怎么成为该类的子类了？这个用法很常见，但一直不懂。
解答：Thread是一个抽象类，是不能进行new产生对象的。这里用到用到的知识是，类的类型的向上转换，即把子类的实例对象的地址的引用赋值给了父类对象。
对象的多态性主要分为以下两种类型：
    1.向上转型 子类对象--->父类对象  格式： 父类 父类对象=子类实例；这个体中就是这样的例子
    2.向下转型  父类对象-->子类对象   格式： 子类 子类对象=（子类）父类实例
发生向上转型的调用后，调用的方法一定是被子类覆写过的方法，也就是说，如果对象发生了向上转型后，所有的方法一定是被子类覆写过的方法。

Thread th1 = new Thread(){//这一句体现多态

@Override

public void run() {

System.out.println("thread");

}

};
拆开就是这样的
ExtendThread extends Thread{
public void run(){
}
}
Thread th1 =new ExtendThread();
那个new Thread就是匿名的。

知道当时不想回答没动力了