JAVA基础（抽象类）

一，抽象类的定义
普通类前加上abstract关键字，
如果类中定义抽象方法（定义中加上abstract的方法，且没有方法体，只有方法的声明），该类一定要声明为抽象类。
二，抽象类的几点说明
1，一般情况下每一个抽象类要有子类，抽象类的子类可以为抽象类也可以为正常类，如果是正常类，抽象类中的所有抽象方法都要覆写
2，抽象类不能直接实例化对象，必须通过子类向上转型实例化对象
3，抽象类中的所有抽象方法都要在其继承的子类中实现覆写
4，从开发的角度讲，普通类一般要继承抽象类，而不是继承普通类
5，抽象类只比普通类多了抽象方法的定义，其他结构与普通类完全一样

package 抽象类;
abstract class A{
    //抽象方法
    public abstract void print();
    public abstract void fun();
}
class B extends A{
    //实现覆写
    public void print()
    {
        System.out.println("子类print()函数");
    }
    public void fun()
    {
        System.out.println("子类fun()函数");
    }
}
public class AbstractDemo {
    public static void main(String[] args) {
        //向上转型
        A b = new B();
        b.print();
    }
}

三，抽象类的一些限制
1，抽象类中有构造方法，实例化子类对象时，先调用父类构造，再调用子类构造，
2，抽象类不能由final定义，因为抽象类一定要有子类的存在，而final定义的类不存在子类
3，外部抽象类不能由static声明，内部抽象类可以由static声明，使用static声明的内部抽象类，相当于外部抽象类，继承的时候使用“外部类.内部类”的形式表示类名称

package 抽象类;
abstract class A{
     //static声明的内部抽象类
    static abstract class B {
        abstract public void print();
    }
}
class C extends A.B{
    public void print()
    {
        System.out.println("C类中的print()");
    }
}
public class AbstractDemo {
    public static void main(String[] args) {
        //向上转型
        A.B c = new C();
        c.print();
    }
}

4，当抽象类中定义static方法时，同样也不需要对象的产生，直接由抽象类调用，此时抽象类可以没有子类。即使有子类，该子类也不可覆写静态方法，只能继承静态方法

package 抽象类;
abstract class A{
         public static void print()
         {
             System.out.println("抽象类中的静态方法print()");
         }
}
public class AbstractDemo {
    public static void main(String[] args) {
        A.print();
    }
}

5.外部抽象类隐藏其子类的存在–>将抽象类子类定义在内部

package 抽象类;
abstract class A {
    public abstract void print();
   private static class B extends A {
        public void print() {
            System.out.println("内部 抽象类子类中的静态方法print()");
        }
    }
    public static A get()
    {
        return new B();
    }
}
public class AbstractDemo {
    public static void main(String[] args) {
        A a = A.get();
        a.print();
    }
}

6.解决遗留的问题，只有在构造完成后，为属性赋的初始值才真正给属性，构造没完成之前，属性的初始值只是该数据类型的默认值。

package 抽象类;
abstract class A {
    public A()//2.先执行父类构造-->3
    {
        this.print();//3.调用print()-->4
    }
    public abstract void print();
}
 class B extends A {
    private int num = 100;
    //4.执行print(),此时直接跳过来num的赋值，所以num=0;
    public void print() {
        System.out.println("num =  "+ num);
    }
}
public class AbstractDemo {
    public static void main(String[] args) {
        new B();//1.实例化对象，执行构造-->2
    }
}