1. abstract class jzl
   
2. {
   
3.         private jzl(){};
   
4.         public abstract void day();
   
5.         public abstract void day2();
   
6. 
   
7.         public  void day3()
   
8.         {
   
9.                 System.out.println("123456789");
   
10.         }
    
11.         public static jzl a=new jzl(){
    
12. 
    
13.                 public void day()
    
14.                 {
    
15.                         // TODO Auto-generated method stub
    
16.                        
    
17.                 }
    
18. 
    
19.                 public void day2()
    
20.                 {
    
21.                         // TODO Auto-generated method stub
    
22.                        
    
23.                 }
    
24.                
    
25.         };
    
26.        
    
27. 
    
28. }
    
29. public class Demo4
    
30. {
    
31. 
    
32.         /**
    
33.          * @param args
    
34.          */
    
35.         public static void main(String[] args)
    
36.         {
    
37.                 // TODO Auto-generated method stub
    
38.                
    
39.        
    
40.                 jzl.a.day3();
    
41.         }
    
42. 
    
43. }
    

复制代码

new出来的那个是什么？内部类吗？为什么还要覆写抽象类中的方法？

1.     public static jzl a=new jzl(){
   
2. 
   
3.                 public void day()
   
4.                 {
   
5.                         // TODO Auto-generated method stub
   
6.                         
   
7.                 }
   
8. 
   
9.                 public void day2()
   
10.                 {
    
11.                         // TODO Auto-generated method stub
    
12.                         
    
13.                 }
    
14.                
    
15.         };

复制代码

这是一个匿名内部类，也相当于jzl的一个子类，创建匿名内部类，父类中如果是抽象的话，就要覆盖父类中抽象的方法。
正如你上面的代码
jzl是个抽象类，有
public abstract void day();
        public abstract void day2();
两个抽象方法，要使用匿名内部类，必须覆盖父类抽象方法。酱紫

abstract class jzl{
        private jzl() {};
        public abstract void day();
        public abstract void day2();
        public void day3(){
                System.out.println("123456789");
        }
        /*
         * 1、下面这段代码的意思是创建一个内部类并将内部类的对象引用赋值给jzl这个抽象类类型的变量
         *   这个使用的是标准的多态特性。
         * 2、一个类要继承于一个抽象类，那么这个类就必须要实现抽象类中所有的抽象方法，也就是覆盖抽
         *   象类中的抽象方法
         */        public static jzl a = new jzl() {
                public void day(){
                }
                public void day2(){
                }
        };
}
public class Demo4{
        public static void main(String[] args){
                jzl.a.day3();
        }
}

1. abstract class jzl
   
2. {
   
3.         private jzl(){};
   
4.         public abstract void day();
   
5.         public abstract void day2();
   
6. 
   
7.         public  void day3()
   
8.         {
   
9.                 System.out.println("123456789");
   
10.         }
    
11.         public static jzl a=new jzl(){      
    
12. //[color=Red]因为抽象的类是不能建立对象，这里实际上是用匿名内部                                                                                    类的的方式指向了一个子类的对象。因为匿名内部类必须是有继承或实现才能用父类名建立对象。[/color]
    
13. 
    
14.                 public void day()
    
15.                 {
    
16.                         // TODO Auto-generated method stub
    
17.                         
    
18.                 }
    
19. 
    
20.                 public void day2()
    
21.                 {
    
22.                         // TODO Auto-generated method stub
    
23.                         
    
24.                 }
    
25.                
    
26.         };
    
27.         
    
28. 
    
29. }
    
30. public class Demo4
    
31. {
    
32. 
    
33.         /**
    
34.          * @param args
    
35.          */
    
36.         public static void main(String[] args)
    
37.         {
    
38.                 // TODO Auto-generated method stub
    
39.             
    
40.                jzl.a.day3();
    
41.         }
    
42. 
    
43. }
    

复制代码

能够复写jzl类的两个方法的就只有是它的子类了，所有new出来的是jzl的子类，这是匿名内部类。因为抽象类是不能直接建立对象的，它只有通过继承给子类并且覆盖里面的抽象方法才能建立对象。

abstract class jzl
{
        private jzl(){};
        public abstract void day();
        public abstract void day2();
        public  void day3()
        {
                System.out.println("123456789");
        }
        public static jzl a=new jzl(){          //这是jzl的匿名内部类，因为私有化了构造方法，外部类不能创建类的对象，所以在类的内部创建一个静态的匿名对象
                                                             //这样，就可以通过类名调用类的实例对象了。
                                                             // 因为day、day2方法是抽象的，所以在创建类的实例对象的时候必须实现抽象方法，所以这里将抽象方法的实现写在内部类中
                public void day()
                {
                        // TODO Auto-generated method stub
                        
                }
                public void day2()
                {
                        // TODO Auto-generated method stub
                        
                }
               
        };
        
}
public class Demo4
{
        /**
         * @param args
         */
        public static void main(String[] args)
        {
                // TODO Auto-generated method stub
               
        
                jzl.a.day3();
        }
}