（Java）抽象类的基本概念- 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();//定义抽象方法
}
910
11

此处由于定义了 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();//调用被子类覆写过的方法
    }
}
910
11
12

三、思考

（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();//实例化子类对象
    }
}
910
11
12
13
14
15

在这里插入图片描述
抽象类中定义了抽象方法，但是定义的抽象方法并不能被外部直接调用，在子类对象实例化前也同样会默认调用父类中的无参构造，即此时的子类实际上也隐含了一个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());
    }
}
910
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46