Java抽象类

抽象类的定义与使用:
抽象类只是在普通类的基础上扩充了一些抽象方法而已，所谓的抽象方法指的是只声明而未实现的方法（即没有方法体）。所有抽象方法要求使用abstract关键字来定义，并且抽象方法所在的类也一定要使用abstract关键字来定义，表示抽象类

例如

abstract class Person{
    private String name;

    public String getName() {
        return this.name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public abstract void getPersonInfo();
}

通过上述代码我们会发现，抽象类就是比普通类多了一些抽象方法而已。
抽象类中包含有抽象方法，而抽象方法不包含方法体，即没有具体实现。因此抽象类不能直接产生实例化对象。

对于抽象类的使用原则：
1.所有的抽象类必须有子类。
2.抽象类的子类必须覆写抽象类的所有抽象方法（子类不是抽象类）【方法覆写一定要考虑权限问题，权限尽量都用public】
3.抽象类的对象可以通过对象多态性利用子类为其实例化
private与abstract不能同时使用。

范例:使用抽象类

package a.b.c;

public class Test{
    public static void main(String[] args) {
        Person per = new Student();//实例化子类,向上转型
        per.getPersonInfo();//被子类所覆写的方法

    }
}
abstract class Person{
    private String name;

    public String getName() {
        return this.name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public abstract void getPersonInfo();
}
class Student extends Person{
    public void getPersonInfo() {
        System.out.println("i am a student");
    }
}

抽象类相关规定
抽象类只是比普通类多了一些抽象方法而已
因此在抽象类中也允许提供构造方法，并且子类也照样遵循对象实例化流程。实例化子类时一定先调用父类构造方法。
范例：在抽象类中定义构造方法

package a.b.c;

abstract class Person{
    private String name ; // 属性
    public Person(){ //构造方法
        System.out.println("**********");
    }
    public String getName(){ // 普通方法
        return this.name;
    }
    public void setName(String name){
        this.name = name ;
    }
    // {}为方法体，所有抽象方法上不包含方法体
    public abstract void getPersonInfo() ; //抽象方法
}
class Student extends Person{
    public Student(){ //构造方法
        System.out.println("##########");
    }
    public void getPersonInfo(){
        //空实现。
    }
}
public class Test{
    public static void main(String[] args) {
        new Student();
    }
}

如果父类没有无参构造，那么子类构造必须使用super明确指出使用父类哪个构造方法。

package a.b.c;


abstract class A{
    public A(){ //3.调用父类构造
        this.print() ; //4.调用被子类覆写的方法
    }
    public abstract void print() ;
}
class B extends A{
    private int num = 100 ;
    public B(int num) { //2.调用子类实例化对象
        super() ; //3.隐含一行语句，实际要先调用父类构造
        this.num = num ; //7.为类中属性初始化
    }
    public void print() { //5.此时子类对象的属性还没有被初始化
        System.out.println(this.num) ; //6.对应其数据类型的默认值
    }
}
public class Test{
    public static void main(String[] args) {
        new B(30) ; //1.实例化子类对象
    }
}

结论：如果构造方法，那么对象中的属性一定都是其对应数据类型的默认值。

对象的实例化操作实际上需要以下几个核心步骤：
1.进行类加载
2.进行类对象的空间开辟
3.进行类对象中的属性初始化(构造方法)

抽象类中允许不定义任何的抽象方法，但是此时抽象类依然无法直接创建实例化对象

abstract class A{
public void print(){
//空实现，普通方法
 }
}
public class Test{
      public static void main(String[] args) {
           A a = new A() ; // 错误: A是抽象的; 无法实例化
  }
}

抽象类一定不能使用final声明，因为使用final声明的类不允许有子类；而抽象类必须有子类；相应的，抽象方法也不能使用private定义，因为抽象方法必须要能被覆写

抽象类也分为内部抽象类和外部抽象类。内部抽象类中也可以使用static定义来描述外部抽象类

如果现在外部抽象类中使用了static那么就是语法错误，但是内部抽象类允许使用static
示例:

abstract class A{ //此类结构出现几率很低
 public abstract void printA() ;
  static abstract class B {
   public abstract void printB() ;
  }
}
  class X extends A.B {
public void printB(){
   }
}