抽象类的基本概念

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

抽象方法：只声明而未实现的方法称为抽象方法，抽象方法必须使用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()) ;
    }
};