java中的abstract

 abstract作为修饰符，可以修饰类和方法。

1>.抽象类: 不能手动创建对象(JVM可以创建抽象类的对象),但是可以声明抽象类型的引用.
     public class TestAbstract1{   
        public static void main(String[] args){ 
              //Animal a=new Animal();        //error
             
              Animal a=null;
              a=new Dog();
         } 
     }   
     abstract class Animal{
     }
     class Dog extends Animal{ 
     }    

 

2>.抽象方法:有方法名的定义，没有实现，（只定义了能做什么，没定义怎么做）    
                   抽象方法的好处是允许方法的定义和实现分开。 
     abstract class Animal{
       public abstract void eat();
     }
    
     抽象类和抽象方法的关系:含有抽象方法的类一定是抽象类，抽象类里不一定含有抽象方法
    
     抽象类存在的意义是用来被继承的。一个类继承了一个抽象类，必须实现抽象类里面所有的抽象方法，否则，此类也是抽象类。
     abstract class Animal{
        public void run(){}
        public abstract void sleep();
       public abstract void eat();
     }  
     class Dog extends Animal{
        public void sleep(){
          System.out.println("Dog sleep.");
        }
        public void eat(){
          System.out.println("Dog eat.");
        } 
     }    
     abstract class Cat extends Animal{
        public void eat(){
          System.out.println("Cat eat.");
        } 
     }      

     可以声明父类类型子类对象，利用多态调用抽象方法  
    public class TestAbstract1{   
     public static void main(String[] args){ 
          Animal a=null;  
          a=new Dog();
           a.sleep();
            a.eat();
      } 
    }        

     抽象类有构造方法，有父类的，也遵循单继承的规律   
     class E{}
     abstract class Animal extends E{
        public Animal(){
          super();
        }
     }    

3>.多种修饰符的连用问题: public  protected  default  private  static final  abstract
     可以连用： public static
                      private static
                      public final
                      public static final
     不可以连用：abstract final void eat(); 
                       private abstract void eat();
                      static abstract void eat();
     abstract不能和final，private，static连用