abstract class AbsDemo
{
        abstract void show();
}
class Outer
{
        int x=3;        
        
        public void function()
        {               
                //情况1
                AbsDemo d=new AbsDemo()
                {
                        int num=3;
                        void show()
                        {
                                System.out.println("num="+num);
                        }
                        void abc()
                        {
                                System.out.println("hello");
                        }
                };
                d.show();
                d.abc();//编译失败
               
                //情况2
                new AbsDemo()
                {
                        int num=3;
                        void show()
                        {
                                System.out.println("num="+num);
                        }
                        void abc()
                        {
                                System.out.println("hello");
                        }
                }.abc();               
        }        
}

class InnerClassDemo4
{
        public static void main(String[] args)
        {
                new Outer().function();
        }        
}

为什么情况1中的d.abc();不可以通过编译，情况2中的abc()方法就可以呢？

我觉得应该都不可以啊。

成员方法在多态调用时，编译看左边，运行看右边。

第一种情况是：自己调用父类
第二种情况是：自己调用自己

不管哪种情况，被调用者本身必须有此方法。

第一种情况下，父类中是没有方法abc()的，所以编译失败。
第二种情况下，匿名内部类本身有abc()方法，所以调用自己的方法是可以的。

abstract class AbsDemo
{
        abstract void show();
}
class Outer
{
        int x=3;        
        
        public void function()
        {               
                //情况1
                AbsDemo d=new AbsDemo()  //d是抽象类的对象  而不是抽象类的子类
                {
                        int num=3;
                        void show()
                        {
                                System.out.println("num="+num);
                        }
                        void abc()
                        {
                                System.out.println("hello");
                        }
                };
                d.show();
                d.abc(); //因为abc()不是抽象类Abstract的内部函数，所以编译失败
               
                //情况2
                new AbsDemo()  //这是匿名内部类的代码块  创建的是抽象类的子类
                {
                        int num=3;
                        void show()
                        {
                                System.out.println("num="+num);
                        }
                        void abc()     //1,在子类中定义了abc()方法 属于内部方法
                        {
                                System.out.println("hello");
                        }
                }.abc();   //2,所以在此处可以调用，编译成功            
        }        
}

class InnerClassDemo4
{
        public static void main(String[] args)
        {
                new Outer().function();
        }        
}

new AbsDemo()
                {
                        int num=3;
                        void show()
                        {
                                System.out.println("num="+num);
                        }
                        void abc()
                        {
                                System.out.println("hello");
                        }
                }.abc();               
        }        
}

abstract class AbsDemo
{
        abstract void show();
}
class Outer
{
        int x=3;        
        
        public void function()
        {               
                //情况1
                AbsDemo d=new AbsDemo()
                {
                        int num=3;
                        void show()
                        {
                                System.out.println("num="+num);
                        }
                        void abc()
                        {
                                System.out.println("hello");
                        }
                };
                d.show();
                d.abc();//编译失败      因为父类对象里没有这个方法，所以编译失败
               
                //情况2
                new AbsDemo()
                {
                        int num=3;
                        void show()
                        {
                                System.out.println("num="+num);
                        }
                        void abc()
                        {
                                System.out.println("hello");
                        }
                }.abc();               这里调用的本来对象，所以能编译通过
        }        
}

class InnerClassDemo4
{
        public static void main(String[] args)
        {
                new Outer().function();
        }        
}

这些在毕老师视频里都有讲到，楼主要好好看看啦

首先因为abc（）这个方法是AbsDemo子类中的方法
情况2
new AbsDemo()  //这里用的是匿名内部类，创建的是AbsDemo的子类对象
                 {
                         int num=3;
                         void show()
                         {
                                 System.out.println("num="+num);
                         }
                         void abc()
                         {
                                 System.out.println("hello");
                         }
                 }.abc(); //这里调用abc（）方法时用的就是AbsDemo的子类对象。                

情况1
AbsDemo d=new AbsDemo()   //这里=号的右边用的是内部类创建了一个子类对象，但是=左边是父类对象，这种父类对象指向子类引用实际是把=右边的对象向上转型。
                 {
                         int num=3;
                         void show()
                         {
                                 System.out.println("num="+num);
                         }
                         void abc()
                         {
                                 System.out.println("hello");
                         }
                 };
                 d.show();“”
                 d.abc(); //这里调用abc（）方法实际是父类对象在调用，但是父类中没有abc（）方法，所以报错“没有为类型 AbsDemo 定义方法 abc（）”