抽象类

1.1抽象类的概念：
包含一个抽象方法的类称为抽象类。
抽象方法：只声明而未实现的方法成为抽象方法，抽象方法必须使用abstract关键字声明。

1.2抽象类的定义及使用规则：

A包含一个抽象方法的类必须是抽象类；
B抽象类和抽象方法必须使用abstract关键字声明；
C抽象方法只需声明而不需要实现
D抽象类必须被子继承，子类必须覆写抽象类中全部抽象方法。

1.3抽象类的定义格式：

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

abstract class Person       //定义抽象类
{
    public static final String FLAG = "CHINA" ; //定义全局常量
    private String name = "IronMan";    //定义属性

    public void setName(String name)
    {
        this.name = name ;
    }
    public String getName()
    {
        return this.name ;
    }
    public abstract void String() ; //定义抽象方法
}

抽象类只是比普通类多了一个抽象方法而已 。

abstract class A        //定义抽象类
{
    public static final String FLAG = "CHINA" ; //定义全局常量
    private String name = "IronMan";    //定义属性

    public void setName(String name)
    {
        this.name = name ;
    }
    public String getName()
    {
        return this.name ;
    }
    public abstract void String() ; //定义抽象方法
}
class B extends A                   //继承抽象类，因为B是普通类，所以必须覆写抽象类的全部抽象方法
{
    public void String()        //覆写抽象类中抽象方法
    {
        System.out.println("FLAG = " + FLAG ) ;
        System.out.println("姓名 = " + super.getName()) ;
    }
}
public class AbstractDemo01
{
    public static void main(String[] args)
    {
        B b = new B() ;
        b.String() ;  //对象.方法()调用 输出内容
    }
}

抽象类思考：
1，一个抽象类可以使用final关键字声明吗？
答：final定义的类是不能有子类的
抽象类必须有子类继承。

final abstract class A

final和abstract 不可能同时出现的
2，一个抽象类中可以定义抽象方法吗？
答：抽象类中允许存在抽象方法的。因为抽象类使用的是类的继承关系，而且抽象类中存在各种属性，所以子类在实例化之前肯定要先对父类进行实例化。

abstract class A
{
    public A()  //构造方法
    {
        System.out.println("A ,父类中的构造方法") ;
    }
}
class B extends A
{
    public B()
    {
        super();  //通过super()先调用父类中构造方法
        System.out.println("B ,子类中的构造方法") ;
    }
}
public class AbstractDemo02
{
    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 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 void 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 this.school ;
    }
    public void getInfo()       //覆写抽象类中抽象方法
    {
        System.out.println("姓名："+super.getName()
                          +"，年龄："+super.getAge()
                          +"，学校："+this.getSchool()) ;
    }
}
public class AbstractDemo03
{
    public static void main(String[] args)
    {
        Student stu = new Student("张三",20,"北航") ;
        stu.getInfo() ;       //对象.方法()  取得信息
    }
}