Java-面向对象（高级篇）--抽象类的基本概念

前面对类的继承进行了初步的讲解，通过继承可以从原来的类中派生出新的类。原有的类称为基类或父类，而新的类则称为子类或者派生类，通过继承机制，派生出的新类不仅可以保留原有类的功能，而且还可以拥有更多的功能。除了上述机制，在Java中也可以创建一种类专门用来作为父类，这种类称为“抽象类”。抽象类的作用类似“模板”，其目的是要设计者依据它的格式来修改并创建新的类，但是并不能直接由抽象类创建模板，只能通过抽象类派生出新的类，然后再由子类进行创建对象。但是抽象类的使用同样存在单继承的局限，即一个子类只能继承一个抽象类。
抽象类的定义及使用规则：
包含一个抽象方法的类必须是抽象类；
抽象类和抽象方法都要使用abstract关键字声明；
抽象方法只需声明而不需要实现；
抽象类必须被子类继承，子类（如果不是抽象类）必须覆写抽象类中的全部抽象方法。
【定义一个抽象类】

abstract class A {
    public static final String FLAG="zhao";
    private String name = "zhaoxe";
    public String getName(){
        return name;
        //取得姓名
    }
    public void setName(){
        this.name = name;//设置姓名
    }
    public abstract void print();//定义抽象方法
}

在A类中，以为定义类print()的抽样方法，所以此类必须声明为抽象类。子类必须覆写抽象类中所有的抽象方法：
【继承抽象类】

abstract class A {
    public static final String FLAG="zhao";
    private String name = "zhaoxe";
    public String getName(){
        return name;
        //取得姓名
    }
    public void setName(){
        this.name = name;//设置姓名
    }
    public abstract void print();//定义抽象方法
}

class B extends A{

    @Override
    public void print() {
        System.out.println("flag="+FLAG);
        System.out.println("姓名："+super.getName());
    }

}   

public class AbstractDemo02 {
    public static void main(String[] args) {
        B b=new B();//实例化子类对象
        b.print();//调用子类覆写过的方法
    }
}

运行结果为：

从上程序完成了抽象类的基本操作，子类覆写了抽象方法，然后在主方法中通过子类实例化的对象进行方法的调用。
抽象类的思考：
*1. 一个抽象类可以使用final关键字声明吗？
2. 一个抽象类中可以定义构造方法吗？*
对于第一个问题，从之前讲解的概念知道，一个类如果使用了final关键字声明，则此类不能被子类继承，而抽象类又必须被子类覆写，所以明显第一个问题的答案是一个抽象类不能用final关键字声明。抽象方法不要用private声明。
第二个问题我们用实例讲解：
【在抽象类中定义构造方法】

abstract class A
{
    public A(){
        System.out.println("A的构造方法");
    }
}
class B extends A
{
    public B(){
        System.out.println("B的构造方法");
    }
}
public class AbstractDemo03
{
    public static void main(String args[]){
        B b=new B(); //实例化子类对象
    }
}

运行结果为：

A的构造方法
B的构造方法

从上述程序可以看出抽象类中定义了构造方法，但是定义的构造方法不能被外部直接调用，必须由实例化的子类对象进行调用，在实例化子类对象时同样会默认调用父类中的构造方法，也就是说此时的子类实际上隐含了super关键字调用构造方法的语句。
既然子类可以通过super调用父类中的构造方法，那么可以在子类中指定调用父类中的指定参数的构造方法。
【调用指定参数的构造方法】

abstract class Person
{
    private String name;
    private int age;
    public Person(String name,int age){
        this.setName(name);
        this.setAge(age);
    }
    //设置姓名
    public void setName(String name){
        this.name=name;
    }
    //获取姓名
    public String getName(){
        return name;
    }

    //设置年龄
    public void setAge(int age){
        this.age=age;
    }
    //获得年龄
    public int getAge(){
        return age;
    }

    public abstract String getInfo();//取得信息的抽象方法 

}
class Student extends Person
{
    private String school;
    public Student(String name,int age,String school){
        super(name,age);//调用父类中的构造方法
        this.setSchool(school);
    }
    //设置学校
    public void setSchool(String school){
        this.school=school;
    }
    //取得学校
    public String getSchool(){
        return school;
    }
    //覆写父类中的抽象方法
    public String getInfo(){
        return "name:"+super.getName()+"age:"+super.getAge()+"school:"+school;
    }
}
public class AbstractDemo04
{
    public static void main(String args[]){
        Student s=new Student("张三",21,"ZZU");
        System.out.println(s.getInfo());
    }
}

运行结果为：

name:张三age:21school:ZZU

以上程序在实例化Student类时调用了抽象类中的构造方法，将姓名和年龄进行设置，然后再通过覆写getInfo()的抽象方法来输出信息。

通过代码可以清楚的发现，实际上抽象类就是比普通类多定义了一个抽象方法，除了不能直接进行对象的实例化之外没有任何的不同。