黑马程序员技术交流社区

标题: 抽象类的问题，谢谢！！！ [打印本页]
作者: 你为谁归来    时间: 2014-4-25 21:10
标题: 抽象类的问题，谢谢！！！
  1. abstract class jzl
  2. {
  3.         private jzl(){};
  4.         public abstract void day();
  5.         public abstract void day2();

  7.         public  void day3()
  8.         {
  9.                 System.out.println("123456789");
  10.         }
  11.         public static jzl a=new jzl(){

  13.                 public void day()
  14.                 {
  15.                         // TODO Auto-generated method stub
  16.                        
  17.                 }

  19.                 public void day2()
  20.                 {
  21.                         // TODO Auto-generated method stub
  22.                        
  23.                 }
  24.                
  25.         };
  26.        

  28. }
  29. public class Demo4
  30. {

  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.         }

  43. }
复制代码


new出来的那个是什么？内部类吗？为什么还要覆写抽象类中的方法？
作者: 展展    时间: 2014-4-25 21:42
  1.     public static jzl a=new jzl(){

  3.                 public void day()
  4.                 {
  5.                         // TODO Auto-generated method stub
  6.                         
  7.                 }

  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();
两个抽象方法，要使用匿名内部类，必须覆盖父类抽象方法。酱紫
作者: 爱翚    时间: 2014-4-25 22:06
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();
        }
}
作者: skill20    时间: 2014-4-25 22:23
  1. abstract class jzl
  2. {
  3.         private jzl(){};
  4.         public abstract void day();
  5.         public abstract void day2();

  7.         public  void day3()
  8.         {
  9.                 System.out.println("123456789");
  10.         }
  11.         public static jzl a=new jzl(){      
  12. //[color=Red]因为抽象的类是不能建立对象，这里实际上是用匿名内部                                                                                    类的的方式指向了一个子类的对象。因为匿名内部类必须是有继承或实现才能用父类名建立对象。[/color]

  14.                 public void day()
  15.                 {
  16.                         // TODO Auto-generated method stub
  17.                         
  18.                 }

  20.                 public void day2()
  21.                 {
  22.                         // TODO Auto-generated method stub
  23.                         
  24.                 }
  25.                
  26.         };
  27.         

  29. }
  30. public class Demo4
  31. {

  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.         }

  43. }
复制代码
作者: 大恶魔先森~    时间: 2014-4-26 00:16
能够复写jzl类的两个方法的就只有是它的子类了，所有new出来的是jzl的子类，这是匿名内部类。因为抽象类是不能直接建立对象的，它只有通过继承给子类并且覆盖里面的抽象方法才能建立对象。
作者: 四川男人    时间: 2014-4-26 00:44
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();
        }
}





欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2