7.
interface Inter
{
        void show(int a,int b);
        void func();
}
class Demo
{
        public static void main(String[] args)
        {
                //补足代码；调用两个函数，要求用匿名内部类
                Inter in = new Inter()                                               //这块可以这么写吗？这不是有名了吗？还算匿名内部类了吗？
                {
                        public void show(int a,int b)
                        {
                        
                        }
                        public void func()
                        {
                        
                        }
                };

                in.show(4,5);
                in.func();
               
        }
}

老师不是说匿名内部类只适用于只有一两个方法的接口，不就是因为调用方法时每次都要：匿名内部类.方法()；吗？可以这样直接命名，然后引用.方法();吗？

及时更改问题状态，点编辑改为已解决

Inter in = new Inter() 这是父类引用指向子类
左边是接口的Inter类型右边是实现Inter的子类，所以子类还是没有名字

匿名内部类，不是说他就什么名字都没有，如果说，不像那样写的话，那是不是要创建一个内部类，然后继承或者实现Inter这个类？那代码不就多了好多么？

直接使用父类的名字，将方法实现，或者覆写那不就升很多事情？

当然，这个主要是理解，理解匿名类到底是怎么回事，然后用起来就非常happy了...真的，我不骗你哦，亲。

interface Inter
{
        void show(int a,int b);
        void func();
}
class Demo
{
        public static void main(String[] args)
        {
                //补足代码；调用两个函数，要求用匿名内部类
                Inter in = new Inter()     //虽然这多了个标示符in。但它并不是类的名字啊 。只是为了调用多个方法时方便一点而已。
                                       
                {
                        public void show(int a,int b)
                        {
                       
                        }
                        public void func()
                        {
                       
                        }
                };

                in.show(4,5);//在这就用上了。
                in.func();
               
        }
}

匿名内部类其实就是对接口方法的简化形式。但假如要复写的方法超过3个的话建议就不要用匿名了。还是给类取个名字为好。

问题解决请编辑改为已解决，有疑问可以继续追问

可以这样写， Inter in = new Inter()  {}是匿名内部类，匿名内部类是指没有类名，这里的in变量是匿名内部类的对象名，指向了匿名内部类的一个对象。
in变量时Inter接口的子类实例变量，可以直接调用Inter接口的方法: in.show(4,5);in.func();

可以new Inter()这是接口的一个实例，因为在其中有方法将接口中的方法覆盖啦！！
而这就相当于子类实例化，而这个实例是没有名字的，在我们调用的时候，可以个它添加一个名字
通过这个名字来去调用这个匿名内部类中的方法

这个在毕老师的视频里有讲过，跟LS们的答案差不多，复写成的匿名内部类变成的接口的子类对象，通过多态特性: 父类引用指向子类对象。
另外LZ说的“老师不是说匿名内部类只适用于只有一两个方法的接口”，是偏向匿名内部类的最原本的用法(直接调用匿名内部类的方法)而言。
至于LZ，你的这种做法是对的，只不过那个复写的匿名内部类(即使有更多方法的接口也行)可以独立成一个函数方法，然后再去调用那个方法；
区别在于这种写法会在主函数等中占用大量篇幅(特别是方法更多时)，所以不建议较多使用。（LS们可能也都知道了，呵呵，就当复习，O(∩_∩)O~）

ai，一心情不好就学不太进去...真烦..

1. interface Inter
   
2. {
   
3.         void show(int a,int b);
   
4.         void func();
   
5. }
   
6. class Demo
   
7. {
   
8.         public static void main(String[] args)
   
9.         {
   
10.                 //补足代码；调用两个函数，要求用匿名内部类
    
11.                 Inter in = new Inter()                                               //这块可以这么写吗？这不是有名了吗？还算匿名内部类了吗？
    
12.                 {
    
13.                         public void show(int a,int b)
    
14.                         {
    
15.                         
    
16.                         }
    
17.                         public void func()
    
18.                         {
    
19.                         
    
20.                         }
    
21.                 };
    
22. 
    
23.                 in.show(4,5);
    
24.                 in.func();
    
25.                
    
26.         }
    
27. }

复制代码

其实你就像你平时建立一个对象的时候 不都是              类名 对象名 = new 类名（）;
而这里是匿名的内部类，是没有名字的
所以就是类名 对象名 = new ｛代码块｝; 这么写
可以把他想成是一个对象的初始化吧   
多态的应用，就是那句 父类引用指向子类对象

这个就是对的，可以这么写的 ，匿名类就是没有通过classs声明，但是它还是被创建了。
内部类就是定义在另外一个类或者方法的内部的类。
所以这样写是没有错的，就是匿名内部类。

张迁 发表于 2013-5-6 22:18
可以这么写，new Inter(){};然后再重写接口的方法，就是匿名内部类。
Inter in = new Inter(){};这是多态 ...

哦，你说 new Inter(){}这整个是子类对象，然后把它给父类的引用Inter 类的in，那差不多明白了....

Inter in = new Inter() {  。。。。 }; 可以这么写 你可以把Inter的匿名内部类想成 一个子类实现了Inter接口 然后将in指向实现接口的子类实例

可以这么写，new Inter(){};然后再重写接口的方法，就是匿名内部类。
Inter in = new Inter(){};这是多态的用法，父类引用指向子类。

不懂帮顶。{:soso_e104:}