（Java）抽象类的基本概念

一、基本概念

在 java 中也可以创建一种类专门用来当做父类，这种类称为“抽象类”。

抽象类的作用类似“模板”，其目的是要设计者依据它的格式来修改并创建新的类，但是不能直接由抽象类创建对象，只能通过抽象类派生出新的类，再由它来创建对象。但是在抽象类的使用中同样存在单继承的局限，即一个子类只能继承一个抽象类

抽象类的定义及使用规则：
（1）包含一个抽象方法的类必须是抽象类
（2）抽象类和抽象方法都要使用 abstract 关键字声明
（3）抽象方法只需声明而不需要实现
（4）抽象类必须被子 继承，子类（如果不是抽象类）必须覆写抽象类中的全部抽象方法

抽象类的定义格式：

abstract class 抽象类名称{
	属性;
	访问权限 返回值类型 方法名称(参数){//普通方法
		return 返回值;
	}
	访问权限 abstract 返回值类型 方法名称(参数);//抽象方法
	//在抽象方法中是没有方法体的
}

可以看出抽象类的定义比普通类多了一些抽象方法，其他地方与普通类的组成基本都是一样的。

二、代码示例

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

此处由于定义了 print() 的抽象方法，所以此类的声明为 abstract class。
此时可以编写一个子类继承此抽象类，需要注意子类必须覆写抽象类中的全部抽象方法

class B extends A{//继承抽象类，覆写全部抽象方法
    public void print(){
        System.out.println("FLAG = " + FLAG);
        System.out.println("姓名：" + super.getName());
    }
}
public class Test{
    public static void main(String[] args) {
        B b = new B();//实例化子类对象
        b.print();//调用被子类覆写过的方法
    }
}

三、思考

（1）一个抽象类可以使用final关键字吗？
已知一个类如果使用了 final 关键字声明，则不能被子类继承，而抽象类又必须被子类覆写，所以，抽象类不能使用 final 关键字

此外使用 abstract 关键字修饰抽象方法时不能使用 private 修饰，因为抽象方法必须被子类覆写，而如果使用了 private 声明，则子类是无法覆写的

（2）一个抽象类可以定义构造方法吗？
在一个抽象类中是允许存在构造方法的，因为抽象类依然使用的是类的继承关系，而且抽象类也存在各个属性，所以子类在实例化之前必须先要对父类进行实例化

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

抽象类中定义了抽象方法，但是定义的抽象方法并不能被外部直接调用，在子类对象实例化前也同样会默认调用父类中的无参构造，即此时的子类实际上也隐含了一个super关键字调用构造方法的语句。

abstract class Person{
    private String name;
    private int age;
    public Person(String name,int age){
        this.setName(name);
        this.setAge(age);
    }
    public String getName(){
        return name;
    }
    public void setName(String name){
        this.name = name;
    }
    public int getAge(){
        return age;
    }
    public void setAge(int age){
        this.age = 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 String getSchool(){
        return school;
    }
    public void setSchool(String school){
        this.school = school;
    }
    public String getInfo(){//覆写抽象类中的抽象方法
        return "姓名：" + super.getName() + 
                "；年龄：" + super.getAge() + 
                "；学校：" + this.getSchool();
    }

}
public class Test{
    public static void main(String[] args) {
        Student stu = new Student("Java",20,"Jialidun");
        System.out.println(stu.getInfo());
    }
}

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

其实所谓的抽象类就是比普通类多定义了一个抽象方法，除了不能直接进行对象的实例化操作之外并没有任何的不同