zl程序教程

您现在的位置是:首页 >  其它

当前栏目

抽象类的基本概念

基本概念 抽象类
2023-09-14 08:58:42 时间

抽象类的基本概念:包含一个抽象方法的类就是抽象类

抽象方法:只声明而未实现的方法称为抽象方法,抽象方法必须使用abstract关键字声明。

一,使用规则:

1)包含一个抽象方法的类必须是抽象类。

2)抽象类和抽象方法都要使用abstract关键字声明。

3)抽象方法只声明不实现。

4)抽象类必须被子继承,子类(如果不是抽象类)必须覆写抽象类中全部抽象方法

二,抽象类定义格式

 

abstract class A{    // 是定义了一个抽象类
    public static final String FLAG = "CHINA" ;    // 全局常量
    private String name = "李兴华" ;    // 定义一个普通的属性
    public void setName(String name){  //普通方法
        this.name = name ;
    }
    public String getName(){
        return this.name ;
    }
    public abstract void print() ;        // 定义抽象方法
};

抽象类就比普通方法多了一个抽象方法而已,除此完全一样。

abstract class A{    // 是定义了一个抽象类
    public static final String FLAG = "CHINA" ;    // 全局常量
    private String name = "李兴华" ;    // 定义一个普通的属性
    public void setName(String name){
        this.name = name ;
    }
    public String getName(){
        return this.name ;
    }
    public abstract void print() ;        // 定义抽象方法
};public class AbstractDemo02{
    public static void main(String args[]){
        A a = new A() ;      //错误,不能直接实例化。
        a.print() ;
    }
};

抽象类虽然与普通类相似,但是不能直接实例化

所以抽象类必须有子类(由子类实例化),子类必须覆写抽象类中全部方法

abstract class A{    // 是定义了一个抽象类
    public static final String FLAG = "CHINA" ;    // 全局常量
    private String name = "李兴华" ;    // 定义一个普通的属性
    public void setName(String name){
        this.name = name ;
    }
    public String getName(){
        return this.name ;
    }
    public abstract void print() ;        // 定义抽象方法
};
class B extends A{    // 继承抽象类,因为B是普通类,所以必须覆写全部抽象方法
    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能不能定义抽象类?

因为final定义的类不能有子类,而抽象类必须有子类,所以不行!

final abstract class A{        //错误,final和abstract不能同时出现。
}    

2,一个抽象类能定义构造方法吗?

实际上抽象类是允许存在构造方法的,因为抽象类依然使用的是类的继承关系。而且抽象类也存在各个属性,

所以子类在实例化之前肯定要对父类进行实例化的。

package methoud;
abstract class A{    // 是定义了一个抽象类
    public A(){
        System.out.println("A、抽象类中的构造方法。") ;
    }
};
class B extends A{    // 继承抽象类,因为B是普通类,所以必须覆写全部抽象方法
    public B(){
        //super() ;    //默认的
        System.out.println("B、子类中的构造方法。") ;
    }
};
public class ThisDemo06{
    public static void main(String args[]){
        B b = new B() ;
    }
};
运行结果:

A、抽象类中的构造方法。
B、子类中的构造方法。

当然,也可以通过super明确指定要调用的方法。

abstract class Person{
    private String name ;        // 定义name属性
    private int age ;            // 定义age属性
    public Person(String name,int age){
        this.name = name ;
        this.age = age ;
    }
    public void setName(String name){
        this.name = name ;
    }
    public void setAge(int age){
        this.age = age ;
    }
    public String getName(){
        return this.name ;
    }
    public int getAge(){
        return this.age ;
    }
    public abstract String getInfo() ;    // 抽象方法
};
class Student extends Person{
    private String school ;
    public Student(String name,int age,String school){
        super(name,age) ;    // 指定要调用抽象类中有两个参数的构造方法
        this.school = school ;
    }
    public void setSchool(String school){
        this.school = school ;
    }
    public String getSchool(){
        return this.school ;
    }
    public String getInfo(){
        return    "姓名:" + super.getName()  + 
                ";年龄:" + super.getAge() + 
                ";学校:" + this.getSchool() ;
    }
};
public class AbstractDemo04{
    public static void main(String args[]){
        Student stu = new Student("张三",30,"清华大学") ;
        System.out.println(stu.getInfo()) ;
    }
};