代码如下

1. interface Test
   
2. {
   
3. void func();
   
4. }
   
5. class Demo
   
6. {
   
7. public static void main(String[] args)
   
8. {
   
9. new Demo().show(new Test()//就是这一句不太明白
   
10. {
    
11. public void func(){}
    
12. });                                       //备注一下啊，这是一个语句，看清了啊
    
13. }
    
14. void show(Test t)
    
15. {
    
16. t.func;
    
17. }
    

复制代码

为了执行t.func，我知道因为主函数是静态的，show方法不是静态的，所以new Demo().show
后面的那些大概意思我也明白，能不能跟我具体的说一下为什么要那样写呢？

其实可以这样理解
Demo demo = new Demo()；
Test test = new test();
demo.show(test);
这样写使用可以简化代码啊，只要理解了。3行代码一句话就搞定。

1.Test是一个接口，假设使用类impTest来实现接口，并创建impTest类的对象，则impTest类必须实现接口Test中的所有方法。
2.new Demo()对象调用方法show时，需要传入实现Test接口的类的对象t。因此需要创建一个Test接口的实现类，并创建其对象。
void impTest implements Test
{
  public void func() {}
}
new Demo().show(new impTest());
也可以创建一个实现Test接口的匿名内部类。
3，对于那种只需要使用一次的类，匿名内部类的写法更加简洁。

1. interface Test
   
2. {
   
3.          void func();
   
4. }
   
5. 
   
6. class Demo
   
7. {
   
8.          public static void main(String[] args)
   
9.          {
   
10.                  //可以建立一个接口的引用指向其子类的对象
    
11.     Test t =new Test()//new Test(){};这是匿名内部类的书写格式  不是实例化接口哦。
    
12.                    //定义匿名内部类必须要实现一个接口或者继承一个类
    
13.                  {         //匿名内部类就是一个匿名子类对象,是把内部类和建立对象封装在一起
    
14.                                 
    
15.          public void func()
    
16.                          {
    
17.               System.out.println("run....");
    
18.                  }
    
19.          };
    
20. new Demo().show(t);//这样写是不是看着更清楚一些呢？
    
21.          
    
22.          }
    
23. 
    
24.          void show(Test t)
    
25.          {
    
26.          t.func();
    
27.          }
    
28. }
    
29. 
    

复制代码

new Demo().show(new Test()//就是这一句不太明白
{
public void func(){}
});                                       //备注一下啊，这是一个语句，看清了啊
想想如果Test()不是一个接口，而是一个简单的类， new Demo().show(new Test())。这样的代码应该可以理解吧，也可以理解成创建了一个匿名实例
而new Test()在这里行不通，因为Test是一个接口，要创建一个接口的实例，必须复写它的方法，所以才有了后面的代码：
new Test()//就是这一句不太明白
{
public void func(){}
}
而代码合起来也是创建一个接口Test的实例，然后show()方法需要的参数就是一个Test的实例。可以这样理解匿名内部类。

这其实就是一个链式的写法，和咱们先实例对象后调用是一回事，这样也是一种习惯。改回来就这样写：Demo do=new Demo();  do.show(new Test()   {public void func(){}}); 加油兄弟
01.interface Test
02.{
03.void func();
04.}
05.class Demo
06.{
07.public static void main(String[] args)
08.{
09.new Demo().show(new Test()//就是这一句不太明白
10.{
11.public void func(){}
12.});                                       //备注一下啊，这是一个语句，看清了啊
13.}
14.void show(Test t)
15.{
16.t.func;
17.}